audrey 1.0.1 → 1.0.2

package/benchmarks/reference-results.js

@@ -44,27 +44,32 @@ export const PUBLISHED_LEADERBOARD = [
 export const MEMORY_TRENDS = [
   {
     title: 'Memory is moving from flat retrieval to typed systems',
-    summary: 'Recent work treats episodic, semantic, procedural, and graph memory as separate but cooperating layers.',
+    summary:
+      'Recent work treats episodic, semantic, procedural, and graph memory as separate but cooperating layers.',
     source: 'https://arxiv.org/abs/2507.03724',
   },
   {
     title: 'Benchmarks now emphasize multi-session realism',
-    summary: 'LongMemEval and LoCoMo push memory systems toward temporal updates, abstraction, and cross-session reasoning instead of single-turn fact recall.',
+    summary:
+      'LongMemEval and LoCoMo push memory systems toward temporal updates, abstraction, and cross-session reasoning instead of single-turn fact recall.',
     source: 'https://arxiv.org/abs/2410.10813',
   },
   {
     title: 'Context engineering is now competing with retrieval-first designs',
-    summary: 'Letta argues filesystem and memory-block approaches can outperform simpler retrieval-only memory on realistic long-horizon tasks.',
+    summary:
+      'Letta argues filesystem and memory-block approaches can outperform simpler retrieval-only memory on realistic long-horizon tasks.',
     source: 'https://www.letta.com/blog/memory-blocks',
   },
   {
     title: 'Production teams care about latency and token footprint, not just recall quality',
-    summary: 'Mem0 frames memory as a cost and latency optimization surface in addition to a personalization surface.',
+    summary:
+      'Mem0 frames memory as a cost and latency optimization surface in addition to a personalization surface.',
     source: 'https://arxiv.org/abs/2504.19413',
   },
   {
     title: 'Temporal and multimodal memory are becoming table stakes',
-    summary: 'MIRIX and Graphiti both model time and state change explicitly instead of assuming memories stay forever true.',
+    summary:
+      'MIRIX and Graphiti both model time and state change explicitly instead of assuming memories stay forever true.',
     source: 'https://arxiv.org/abs/2507.07957',
   },
 ];

package/benchmarks/report.js

@@ -38,25 +38,29 @@ function renderBarChart({ title, rows, valueSuffix = '%', maxValue = 100 }) {
   const barWidth = Math.max(32, Math.floor(plotWidth / Math.max(rows.length, 1)) - 18);
   const gap = rows.length > 1 ? (plotWidth - barWidth * rows.length) / (rows.length - 1) : 0;
 
-  const bars = rows.map((row, index) => {
-    const value = Math.max(0, Math.min(maxValue, row.value));
-    const barHeight = (value / maxValue) * plotHeight;
-    const x = margin.left + index * (barWidth + gap);
-    const y = margin.top + plotHeight - barHeight;
-    return `
+  const bars = rows
+    .map((row, index) => {
+      const value = Math.max(0, Math.min(maxValue, row.value));
+      const barHeight = (value / maxValue) * plotHeight;
+      const x = margin.left + index * (barWidth + gap);
+      const y = margin.top + plotHeight - barHeight;
+      return `
       <rect x="${x}" y="${y}" width="${barWidth}" height="${barHeight}" rx="8" fill="${chartBarColor(row.label)}" />
       <text x="${x + barWidth / 2}" y="${y - 10}" text-anchor="middle" font-size="15" fill="${PALETTE.accent}">${value.toFixed(1)}${valueSuffix}</text>
       <text x="${x + barWidth / 2}" y="${height - 42}" text-anchor="middle" font-size="14" fill="${PALETTE.muted}">${escapeHtml(row.label)}</text>
     `;
-  }).join('\n');
+    })
+    .join('\n');
 
-  const grid = [0, 25, 50, 75, 100].map(tick => {
-    const y = margin.top + plotHeight - (tick / maxValue) * plotHeight;
-    return `
+  const grid = [0, 25, 50, 75, 100]
+    .map(tick => {
+      const y = margin.top + plotHeight - (tick / maxValue) * plotHeight;
+      return `
       <line x1="${margin.left}" y1="${y}" x2="${width - margin.right}" y2="${y}" stroke="${PALETTE.border}" stroke-dasharray="4 4" />
       <text x="${margin.left - 10}" y="${y + 5}" text-anchor="end" font-size="13" fill="${PALETTE.muted}">${tick}${valueSuffix}</text>
     `;
-  }).join('\n');
+    })
+    .join('\n');
 
   return `<?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeHtml(title)}">
@@ -68,39 +72,53 @@ function renderBarChart({ title, rows, valueSuffix = '%', maxValue = 100 }) {
 }
 
 function renderTrendList(trends) {
-  return trends.map(trend => `
+  return trends
+    .map(
+      trend => `
     <li>
       <strong>${escapeHtml(trend.title)}</strong><br />
       ${escapeHtml(trend.summary)}<br />
       <a href="${trend.source}">${escapeHtml(trend.source)}</a>
     </li>
-  `).join('\n');
+  `,
+    )
+    .join('\n');
 }
 
 function renderCaseRows(localCases) {
-  return localCases.map(caseResult => `
+  return localCases
+    .map(
+      caseResult => `
     <tr>
       <td>${escapeHtml(caseResult.title)}</td>
       <td>${escapeHtml(caseResult.suite)}</td>
       <td>${escapeHtml(caseResult.family)}</td>
-      ${caseResult.results.map(result => {
-        const bg = result.passed ? '#ecfdf5' : result.score >= 0.5 ? '#fff7ed' : '#fef2f2';
-        const fg = result.passed ? '#065f46' : result.score >= 0.5 ? '#9a3412' : '#991b1b';
-        return `<td style="background:${bg};color:${fg}">${result.score.toFixed(2)}<br /><span style="font-size:12px">${escapeHtml(result.summary)}</span></td>`;
-      }).join('')}
+      ${caseResult.results
+        .map(result => {
+          const bg = result.passed ? '#ecfdf5' : result.score >= 0.5 ? '#fff7ed' : '#fef2f2';
+          const fg = result.passed ? '#065f46' : result.score >= 0.5 ? '#9a3412' : '#991b1b';
+          return `<td style="background:${bg};color:${fg}">${result.score.toFixed(2)}<br /><span style="font-size:12px">${escapeHtml(result.summary)}</span></td>`;
+        })
+        .join('')}
     </tr>
-  `).join('\n');
+  `,
+    )
+    .join('\n');
 }
 
 function renderSuiteSections(suiteCharts) {
   if (suiteCharts.length === 0) return '';
-  return suiteCharts.map(chart => `
+  return suiteCharts
+    .map(
+      chart => `
     <section class="callout">
       <h2>${escapeHtml(chart.title)}</h2>
       <p>${escapeHtml(chart.description)}</p>
       <img src="./${escapeHtml(chart.fileName)}" alt="${escapeHtml(chart.title)} chart" />
     </section>
-  `).join('\n');
+  `,
+    )
+    .join('\n');
 }
 
 export function writeBenchmarkArtifacts({
@@ -114,9 +132,10 @@ export function writeBenchmarkArtifacts({
 }) {
   mkdirSync(outputDir, { recursive: true });
 
-  const localChartTitle = summary.local?.overall_scope === 'comparable_suites'
-    ? 'Audrey vs Comparable Local Memory Baselines'
-    : 'Selected Audrey Regression Suite';
+  const localChartTitle =
+    summary.local?.overall_scope === 'comparable_suites'
+      ? 'Audrey vs Comparable Local Memory Baselines'
+      : 'Selected Audrey Regression Suite';
   const localChart = renderBarChart({
     title: localChartTitle,
     rows: localOverall.map(row => ({ label: row.system, value: row.scorePercent })),
@@ -162,8 +181,10 @@ export function writeBenchmarkArtifacts({
         operationsReadmeChart,
         renderBarChart({
           title: 'Audrey Memory Operations Benchmark',
-          rows: (localSuites.find(suite => suite.id === 'operations')?.overall || [])
-            .map(row => ({ label: row.system, value: row.scorePercent })),
+          rows: (localSuites.find(suite => suite.id === 'operations')?.overall || []).map(row => ({
+            label: row.system,
+            value: row.scorePercent,
+          })),
         }),
         'utf8',
       );

package/benchmarks/run-external-guardbench.mjs

@@ -3,31 +3,46 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { writeGuardBenchConformanceCard } from './create-conformance-card.mjs';
-import { computeGuardBenchArtifactHashes, validateGuardBenchArtifacts } from './validate-guardbench-artifacts.mjs';
+import {
+  computeGuardBenchArtifactHashes,
+  validateGuardBenchArtifacts,
+} from './validate-guardbench-artifacts.mjs';
 import { publicArtifactValue } from './public-paths.mjs';
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const KNOWN_ADAPTERS = new Map([
-  ['mem0', {
-    name: 'mem0-platform',
-    path: 'benchmarks/adapters/mem0-platform.mjs',
-    requiredEnv: ['MEM0_API_KEY'],
-  }],
-  ['mem0-platform', {
-    name: 'mem0-platform',
-    path: 'benchmarks/adapters/mem0-platform.mjs',
-    requiredEnv: ['MEM0_API_KEY'],
-  }],
-  ['zep', {
-    name: 'zep-cloud',
-    path: 'benchmarks/adapters/zep-cloud.mjs',
-    requiredEnv: ['ZEP_API_KEY'],
-  }],
-  ['zep-cloud', {
-    name: 'zep-cloud',
-    path: 'benchmarks/adapters/zep-cloud.mjs',
-    requiredEnv: ['ZEP_API_KEY'],
-  }],
+  [
+    'mem0',
+    {
+      name: 'mem0-platform',
+      path: 'benchmarks/adapters/mem0-platform.mjs',
+      requiredEnv: ['MEM0_API_KEY'],
+    },
+  ],
+  [
+    'mem0-platform',
+    {
+      name: 'mem0-platform',
+      path: 'benchmarks/adapters/mem0-platform.mjs',
+      requiredEnv: ['MEM0_API_KEY'],
+    },
+  ],
+  [
+    'zep',
+    {
+      name: 'zep-cloud',
+      path: 'benchmarks/adapters/zep-cloud.mjs',
+      requiredEnv: ['ZEP_API_KEY'],
+    },
+  ],
+  [
+    'zep-cloud',
+    {
+      name: 'zep-cloud',
+      path: 'benchmarks/adapters/zep-cloud.mjs',
+      requiredEnv: ['ZEP_API_KEY'],
+    },
+  ],
 ]);
 
 export function parseExternalArgs(argv = process.argv.slice(2)) {
@@ -127,13 +142,19 @@ export function evaluateAdapterConformance(summary, adapterName) {
     .filter(row => row.system === resolvedAdapterName);
 
   if (adapterRows.length !== expectedScenarios) {
-    failures.push(`Adapter ${resolvedAdapterName} returned ${adapterRows.length}/${expectedScenarios} scenario rows`);
+    failures.push(
+      `Adapter ${resolvedAdapterName} returned ${adapterRows.length}/${expectedScenarios} scenario rows`,
+    );
   }
   if (systemSummary && systemSummary.scenarios !== expectedScenarios) {
-    failures.push(`Adapter ${resolvedAdapterName} system summary has ${systemSummary.scenarios}/${expectedScenarios} scenarios`);
+    failures.push(
+      `Adapter ${resolvedAdapterName} system summary has ${systemSummary.scenarios}/${expectedScenarios} scenarios`,
+    );
   }
   if (systemSummary && systemSummary.redactionLeaks !== 0) {
-    failures.push(`Adapter ${resolvedAdapterName} leaked ${systemSummary.redactionLeaks} seeded secret(s) in decision output`);
+    failures.push(
+      `Adapter ${resolvedAdapterName} leaked ${systemSummary.redactionLeaks} seeded secret(s) in decision output`,
+    );
   }
   if (adapterRows.some(row => row.external !== true)) {
     failures.push(`Adapter ${resolvedAdapterName} rows are not marked external`);
@@ -270,7 +291,8 @@ async function main() {
   const card = child.status === 0 ? writeGuardBenchConformanceCard({ dir: run.outDir }) : null;
   console.log(`External GuardBench metadata: ${metadataPath}`);
   if (card) console.log(`External GuardBench conformance card: ${card.path}`);
-  process.exitCode = child.status === 0 && validation.ok && adapterConformance.ok ? 0 : (child.status ?? 1);
+  process.exitCode =
+    child.status === 0 && validation.ok && adapterConformance.ok ? 0 : (child.status ?? 1);
 }
 
 if (process.argv[1] && process.argv[1].endsWith('run-external-guardbench.mjs')) {

package/benchmarks/run.js

@@ -68,7 +68,9 @@ function normalizeSuiteSelection(value = 'all') {
 
   const invalid = selected.filter(token => !ALL_SUITE_IDS.includes(token));
   if (invalid.length > 0) {
-    throw new Error(`Unknown benchmark suite(s): ${invalid.join(', ')}. Valid: all, ${ALL_SUITE_IDS.join(', ')}`);
+    throw new Error(
+      `Unknown benchmark suite(s): ${invalid.join(', ')}. Valid: all, ${ALL_SUITE_IDS.join(', ')}`,
+    );
   }
   return [...new Set(selected)];
 }
@@ -94,12 +96,19 @@ function evaluateCase(benchmarkCase, results) {
   const expected = (benchmarkCase.expectAny || []).map(normalize);
   const required = (benchmarkCase.expectAll || []).map(normalize);
   const forbidden = (benchmarkCase.forbid || []).map(normalize);
-  const firstMatchIndex = expected.length === 0
-    ? -1
-    : normalizedContents.findIndex(content => expected.some(expectation => content.includes(expectation)));
-  const firstForbiddenIndex = normalizedContents.findIndex(content => forbidden.some(blocked => content.includes(blocked)));
+  const firstMatchIndex =
+    expected.length === 0
+      ? -1
+      : normalizedContents.findIndex(content =>
+          expected.some(expectation => content.includes(expectation)),
+        );
+  const firstForbiddenIndex = normalizedContents.findIndex(content =>
+    forbidden.some(blocked => content.includes(blocked)),
+  );
   const matched = firstMatchIndex !== -1;
-  const requiredMatches = required.filter(expectation => normalizedContents.some(content => content.includes(expectation)));
+  const requiredMatches = required.filter(expectation =>
+    normalizedContents.some(content => content.includes(expectation)),
+  );
   const matchedRequired = required.length > 0 && requiredMatches.length === required.length;
   const leakedForbidden = firstForbiddenIndex !== -1;
 
@@ -108,16 +117,21 @@ function evaluateCase(benchmarkCase, results) {
     return {
       passed: score === 1,
       score,
-      summary: leakedForbidden ? 'leaked restricted content' : results.length === 0 ? 'correct abstention' : 'no leak, but retrieved tangential context',
+      summary: leakedForbidden
+        ? 'leaked restricted content'
+        : results.length === 0
+          ? 'correct abstention'
+          : 'no leak, but retrieved tangential context',
     };
   }
 
   if (required.length > 0) {
-    const score = matchedRequired && !leakedForbidden
-      ? 1
-      : leakedForbidden
-        ? 0
-        : Math.min(0.5, requiredMatches.length / required.length);
+    const score =
+      matchedRequired && !leakedForbidden
+        ? 1
+        : leakedForbidden
+          ? 0
+          : Math.min(0.5, requiredMatches.length / required.length);
     const missing = required.filter(expectation => !requiredMatches.includes(expectation));
     return {
       passed: score === 1,
@@ -154,7 +168,9 @@ async function seedRetrievalCase(brain, benchmarkCase) {
   const ids = [];
   for (let index = 0; index < benchmarkCase.memory.length; index++) {
     const memory = benchmarkCase.memory[index];
-    const supersedes = Number.isInteger(memory.supersedesIndex) ? ids[memory.supersedesIndex] : undefined;
+    const supersedes = Number.isInteger(memory.supersedesIndex)
+      ? ids[memory.supersedesIndex]
+      : undefined;
     const id = await brain.encode({
       content: memory.content,
       source: memory.source,
@@ -264,7 +280,9 @@ async function executeGuardStep(brain, step, refs) {
   if (step.type === 'expectGuardAfterError') {
     const receiptId = step.receiptRef ? refs.get(step.receiptRef) : step.receiptId;
     if (!receiptId) {
-      throw new Error(`Missing guard benchmark receipt reference: ${step.receiptRef || step.receiptId}`);
+      throw new Error(
+        `Missing guard benchmark receipt reference: ${step.receiptRef || step.receiptId}`,
+      );
     }
 
     try {
@@ -278,15 +296,19 @@ async function executeGuardStep(brain, step, refs) {
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       if (step.errorIncludes && !message.includes(step.errorIncludes)) {
-        throw new Error(`Guard hardening expected "${step.errorIncludes}" but got "${message}"`);
+        throw new Error(`Guard hardening expected "${step.errorIncludes}" but got "${message}"`, {
+          cause: err,
+        });
       }
       const label = step.label ?? 'after_error_rejected';
-      return [{
-        id: `${receiptId}:${label}`,
-        content: `guard_hardened:${label} error:${message}`,
-        type: 'guard_hardening',
-        score: 1,
-      }];
+      return [
+        {
+          id: `${receiptId}:${label}`,
+          content: `guard_hardened:${label} error:${message}`,
+          type: 'guard_hardening',
+          score: 1,
+        },
+      ];
     }
 
     throw new Error(`Guard hardening expected an error for receipt ${receiptId}`);
@@ -299,18 +321,20 @@ async function seedGuardCase(brain, benchmarkCase) {
   const refs = new Map();
   const diagnostics = [];
   for (const step of benchmarkCase.steps || []) {
-    diagnostics.push(...await executeGuardStep(brain, step, refs));
+    diagnostics.push(...(await executeGuardStep(brain, step, refs)));
   }
   return diagnostics;
 }
 
 function guardDecisionRows(decision) {
-  const rows = [{
-    id: decision.receipt_id,
-    content: `decision:${decision.decision} verdict:${decision.verdict} risk:${decision.risk_score} ${decision.summary}`,
-    type: 'guard_decision',
-    score: 1,
-  }];
+  const rows = [
+    {
+      id: decision.receipt_id,
+      content: `decision:${decision.decision} verdict:${decision.verdict} risk:${decision.risk_score} ${decision.summary}`,
+      type: 'guard_decision',
+      score: 1,
+    },
+  ];
 
   for (const [index, warning] of decision.warnings.entries()) {
     rows.push({
@@ -380,12 +404,15 @@ async function runAudreyCase(benchmarkCase, providerConfig) {
 
 async function runBaselineCase(system, benchmarkCase, providerConfig) {
   if (benchmarkCase.kind === 'guard') {
-    return [{
-      id: `${system.toLowerCase().replace(/[^a-z0-9]+/g, '-')}-guard-baseline`,
-      content: 'decision:go verdict:clear summary:retrieval-only baseline has no before-action guard controller',
-      type: 'guard_decision',
-      score: 0,
-    }];
+    return [
+      {
+        id: `${system.toLowerCase().replace(/[^a-z0-9]+/g, '-')}-guard-baseline`,
+        content:
+          'decision:go verdict:clear summary:retrieval-only baseline has no before-action guard controller',
+        type: 'guard_decision',
+        score: 0,
+      },
+    ];
   }
 
   return runBaselineScenario(system, benchmarkCase, providerConfig, 5);
@@ -394,9 +421,18 @@ async function runBaselineCase(system, benchmarkCase, providerConfig) {
 async function runSystemsForCase(benchmarkCase, providerConfig) {
   const systems = [
     { system: 'Audrey', run: () => runAudreyCase(benchmarkCase, providerConfig) },
-    { system: 'Vector Only', run: () => runBaselineCase('Vector Only', benchmarkCase, providerConfig) },
-    { system: 'Keyword + Recency', run: () => runBaselineCase('Keyword + Recency', benchmarkCase, providerConfig) },
-    { system: 'Recent Window', run: () => runBaselineCase('Recent Window', benchmarkCase, providerConfig) },
+    {
+      system: 'Vector Only',
+      run: () => runBaselineCase('Vector Only', benchmarkCase, providerConfig),
+    },
+    {
+      system: 'Keyword + Recency',
+      run: () => runBaselineCase('Keyword + Recency', benchmarkCase, providerConfig),
+    },
+    {
+      system: 'Recent Window',
+      run: () => runBaselineCase('Recent Window', benchmarkCase, providerConfig),
+    },
   ];
 
   const results = [];
@@ -504,13 +540,13 @@ export function assertBenchmarkGuardrails(summary, options = {}) {
 
   if (audrey.scorePercent < settings.minAudreyScore) {
     failures.push(
-      `Audrey score ${audrey.scorePercent.toFixed(1)}% fell below ${settings.minAudreyScore.toFixed(1)}%.`
+      `Audrey score ${audrey.scorePercent.toFixed(1)}% fell below ${settings.minAudreyScore.toFixed(1)}%.`,
     );
   }
 
   if (audrey.passRate < settings.minAudreyPassRate) {
     failures.push(
-      `Audrey pass rate ${audrey.passRate.toFixed(1)}% fell below ${settings.minAudreyPassRate.toFixed(1)}%.`
+      `Audrey pass rate ${audrey.passRate.toFixed(1)}% fell below ${settings.minAudreyPassRate.toFixed(1)}%.`,
     );
   }
 
@@ -518,8 +554,8 @@ export function assertBenchmarkGuardrails(summary, options = {}) {
     const margin = audrey.scorePercent - strongestBaseline.scorePercent;
     if (margin < settings.minMarginOverBaseline) {
       failures.push(
-        `Audrey beat ${strongestBaseline.system} by ${margin.toFixed(1)} points, below the required `
-        + `${settings.minMarginOverBaseline.toFixed(1)}-point margin.`
+        `Audrey beat ${strongestBaseline.system} by ${margin.toFixed(1)} points, below the required ` +
+          `${settings.minMarginOverBaseline.toFixed(1)}-point margin.`,
       );
     }
   }
@@ -531,7 +567,9 @@ export function assertBenchmarkGuardrails(summary, options = {}) {
   return {
     audrey,
     strongestBaseline,
-    marginOverBaseline: strongestBaseline ? audrey.scorePercent - strongestBaseline.scorePercent : null,
+    marginOverBaseline: strongestBaseline
+      ? audrey.scorePercent - strongestBaseline.scorePercent
+      : null,
     thresholds: settings,
   };
 }
@@ -563,7 +601,9 @@ export async function runBenchmarkSuite(options = {}) {
     }
   }
 
-  const comparableCaseResults = caseResults.filter(caseResult => caseResult.comparable_to_baselines);
+  const comparableCaseResults = caseResults.filter(
+    caseResult => caseResult.comparable_to_baselines,
+  );
   const overallCaseResults = comparableCaseResults.length > 0 ? comparableCaseResults : caseResults;
   const overallScope = comparableCaseResults.length > 0 ? 'comparable_suites' : 'selected_suites';
   const overallSuiteIds = [...new Set(overallCaseResults.map(caseResult => caseResult.suite))];
@@ -579,10 +619,14 @@ export async function runBenchmarkSuite(options = {}) {
       suites: suiteIds,
     },
     methodology: {
-      localBenchmark: 'Local regression suite inspired by LongMemEval-style retrieval, operation-level lifecycle, and agent guard-loop benchmarks',
-      retrievalBenchmark: 'Information extraction, updates, reasoning, procedural learning, privacy, abstention, and conflict handling',
-      operationsBenchmark: 'Update, overwrite, delete, merge, and abstention behavior after lifecycle operations',
-      guardBenchmark: 'Memory-before-action controller behavior: receipts, learned tool-failure cautions, strict blocking reflexes, and guard-after hardening',
+      localBenchmark:
+        'Local regression suite inspired by LongMemEval-style retrieval, operation-level lifecycle, and agent guard-loop benchmarks',
+      retrievalBenchmark:
+        'Information extraction, updates, reasoning, procedural learning, privacy, abstention, and conflict handling',
+      operationsBenchmark:
+        'Update, overwrite, delete, merge, and abstention behavior after lifecycle operations',
+      guardBenchmark:
+        'Memory-before-action controller behavior: receipts, learned tool-failure cautions, strict blocking reflexes, and guard-after hardening',
       externalLeaderboard: 'Published LoCoMo scores from official papers and project blogs',
     },
     local: {
@@ -615,10 +659,10 @@ export async function runBenchmarkCli({ argv = process.argv.slice(2), out = cons
   });
   const gate = args.check
     ? assertBenchmarkGuardrails(summary, {
-      minAudreyScore: args.minAudreyScore,
-      minAudreyPassRate: args.minAudreyPassRate,
-      minMarginOverBaseline: args.minMarginOverBaseline,
-    })
+        minAudreyScore: args.minAudreyScore,
+        minAudreyPassRate: args.minAudreyPassRate,
+        minMarginOverBaseline: args.minMarginOverBaseline,
+      })
     : null;
 
   if (args.jsonOnly) {
@@ -629,15 +673,22 @@ export async function runBenchmarkCli({ argv = process.argv.slice(2), out = cons
   const lines = [];
   lines.push('Audrey benchmark complete.');
   lines.push('');
-  lines.push(`Suites: ${summary.config.suites.map(suiteId => SUITE_LABELS.get(suiteId) || suiteId).join(', ')}`);
-  lines.push(`Scope: ${summary.local.overall_scope} (${summary.local.overall_suite_ids.join(', ')})`);
-  const comparableCaseCount = summary.local.cases
-    .filter(testCase => summary.local.overall_suite_ids.includes(testCase.suite)).length;
-  lines.push(`Cases: ${summary.local.cases.length} total; ${comparableCaseCount} in combined local chart`);
+  lines.push(
+    `Suites: ${summary.config.suites.map(suiteId => SUITE_LABELS.get(suiteId) || suiteId).join(', ')}`,
+  );
+  lines.push(
+    `Scope: ${summary.local.overall_scope} (${summary.local.overall_suite_ids.join(', ')})`,
+  );
+  const comparableCaseCount = summary.local.cases.filter(testCase =>
+    summary.local.overall_suite_ids.includes(testCase.suite),
+  ).length;
+  lines.push(
+    `Cases: ${summary.local.cases.length} total; ${comparableCaseCount} in combined local chart`,
+  );
   for (const row of summary.local.overall) {
     lines.push(
-      `${row.system}: ${row.scorePercent.toFixed(1)}% score, ${row.passRate.toFixed(1)}% pass rate, `
-      + `${row.avgDurationMs.toFixed(1)} ms avg/case`
+      `${row.system}: ${row.scorePercent.toFixed(1)}% score, ${row.passRate.toFixed(1)}% pass rate, ` +
+        `${row.avgDurationMs.toFixed(1)} ms avg/case`,
     );
   }
   lines.push('');
@@ -667,7 +718,9 @@ export async function runBenchmarkCli({ argv = process.argv.slice(2), out = cons
       ? `${gate.strongestBaseline.system} by ${gate.marginOverBaseline.toFixed(1)} points`
       : 'all local baselines';
     lines.push('');
-    lines.push(`Regression gate passed: Audrey stayed above ${gate.thresholds.minAudreyScore.toFixed(1)}% and ahead of ${baselineLabel}.`);
+    lines.push(
+      `Regression gate passed: Audrey stayed above ${gate.thresholds.minAudreyScore.toFixed(1)}% and ahead of ${baselineLabel}.`,
+    );
   }
 
   out(lines.join('\n'));

package/benchmarks/validate-adapter-module.mjs

@@ -42,9 +42,10 @@ export async function validateAdapterModuleFile(options = {}) {
   } else {
     try {
       const mod = await import(pathToFileURL(adapterPath).href);
-      const candidate = typeof mod.createGuardBenchAdapter === 'function'
-        ? await mod.createGuardBenchAdapter()
-        : mod.default ?? mod.adapter;
+      const candidate =
+        typeof mod.createGuardBenchAdapter === 'function'
+          ? await mod.createGuardBenchAdapter()
+          : (mod.default ?? mod.adapter);
       adapter = validateGuardBenchAdapter(candidate, adapterPath);
     } catch (error) {
       failures.push(error.message);
@@ -57,12 +58,12 @@ export async function validateAdapterModuleFile(options = {}) {
     moduleFile: basename(adapterPath),
     adapter: adapter
       ? {
-        name: adapter.name,
-        description: adapter.description ?? null,
-        hasSetup: typeof adapter.setup === 'function',
-        hasDecide: typeof adapter.decide === 'function',
-        hasCleanup: typeof adapter.cleanup === 'function',
-      }
+          name: adapter.name,
+          description: adapter.description ?? null,
+          hasSetup: typeof adapter.setup === 'function',
+          hasDecide: typeof adapter.decide === 'function',
+          hasCleanup: typeof adapter.cleanup === 'function',
+        }
       : null,
     contract: {
       moduleFormat: 'ESM',
@@ -87,7 +88,9 @@ async function main() {
   } else if (validation.ok) {
     console.log(`GuardBench adapter module validation passed: ${validation.adapterPath}`);
     console.log(`Adapter: ${validation.adapter.name}`);
-    console.log(`Methods: setup=${validation.adapter.hasSetup}, decide=${validation.adapter.hasDecide}, cleanup=${validation.adapter.hasCleanup}`);
+    console.log(
+      `Methods: setup=${validation.adapter.hasSetup}, decide=${validation.adapter.hasDecide}, cleanup=${validation.adapter.hasCleanup}`,
+    );
   } else {
     console.error('GuardBench adapter module validation failed:');
     for (const failure of validation.failures) console.error(`- ${failure}`);