audrey 1.0.0 → 1.0.2

package/examples/ollama-memory-agent.js

@@ -6,8 +6,9 @@ const OLLAMA_MODEL = process.env.OLLAMA_MODEL || 'qwen3';
 const AUDREY_API_KEY = process.env.AUDREY_API_KEY || '';
 const MAX_TOOL_LOOPS = Number.parseInt(process.env.MAX_TOOL_LOOPS || '4', 10);
 
-const userPrompt = process.argv.slice(2).join(' ').trim()
-  || 'Use Audrey memory to explain how this local Ollama agent should remember useful facts.';
+const userPrompt =
+  process.argv.slice(2).join(' ').trim() ||
+  'Use Audrey memory to explain how this local Ollama agent should remember useful facts.';
 
 function usage() {
   console.log(`
@@ -112,15 +113,22 @@ const tools = [
     type: 'function',
     function: {
       name: 'memory_preflight',
-      description: 'Check Audrey memory before taking an action, so prior failures and rules are not repeated.',
+      description:
+        'Check Audrey memory before taking an action, so prior failures and rules are not repeated.',
       parameters: {
         type: 'object',
         required: ['action'],
         properties: {
           action: { type: 'string', description: 'Action the agent is considering.' },
           tool: { type: 'string', description: 'Optional tool or command family.' },
-          strict: { type: 'boolean', description: 'If true, high-severity warnings can block the action.' },
-          include_capsule: { type: 'boolean', description: 'Include full capsule context in the result.' },
+          strict: {
+            type: 'boolean',
+            description: 'If true, high-severity warnings can block the action.',
+          },
+          include_capsule: {
+            type: 'boolean',
+            description: 'Include full capsule context in the result.',
+          },
         },
       },
     },
@@ -129,15 +137,22 @@ const tools = [
     type: 'function',
     function: {
       name: 'memory_reflexes',
-      description: 'Return Audrey Memory Reflexes: trigger-response rules for the action the agent is considering.',
+      description:
+        'Return Audrey Memory Reflexes: trigger-response rules for the action the agent is considering.',
       parameters: {
         type: 'object',
         required: ['action'],
         properties: {
           action: { type: 'string', description: 'Action the agent is considering.' },
           tool: { type: 'string', description: 'Optional tool or command family.' },
-          strict: { type: 'boolean', description: 'If true, high-severity warnings can become blocking reflexes.' },
-          include_preflight: { type: 'boolean', description: 'Include the full underlying preflight report.' },
+          strict: {
+            type: 'boolean',
+            description: 'If true, high-severity warnings can become blocking reflexes.',
+          },
+          include_preflight: {
+            type: 'boolean',
+            description: 'Include the full underlying preflight report.',
+          },
         },
       },
     },
@@ -176,7 +191,8 @@ const tools = [
     type: 'function',
     function: {
       name: 'memory_encode',
-      description: 'Store a useful lasting observation, decision, preference, or procedure in Audrey.',
+      description:
+        'Store a useful lasting observation, decision, preference, or procedure in Audrey.',
       parameters: {
         type: 'object',
         required: ['content'],
@@ -184,7 +200,13 @@ const tools = [
           content: { type: 'string', description: 'Memory content to store.' },
           source: {
             type: 'string',
-            enum: ['direct-observation', 'told-by-user', 'tool-result', 'inference', 'model-generated'],
+            enum: [
+              'direct-observation',
+              'told-by-user',
+              'tool-result',
+              'inference',
+              'model-generated',
+            ],
             description: 'Source reliability category.',
           },
           tags: {
@@ -270,7 +292,9 @@ async function main() {
     try {
       response = await ollamaChat(messages);
     } catch (err) {
-      console.error(`Ollama is not reachable at ${OLLAMA_URL}, or model "${OLLAMA_MODEL}" is not available.`);
+      console.error(
+        `Ollama is not reachable at ${OLLAMA_URL}, or model "${OLLAMA_MODEL}" is not available.`,
+      );
       console.error(`Try: ollama pull ${OLLAMA_MODEL}`);
       console.error(`Details: ${err.message}`);
       process.exit(1);
@@ -294,7 +318,11 @@ async function main() {
       const name = call.function?.name;
       const executor = toolExecutors[name];
       if (!executor) {
-        messages.push({ role: 'tool', tool_name: name || 'unknown', content: 'Unknown Audrey tool' });
+        messages.push({
+          role: 'tool',
+          tool_name: name || 'unknown',
+          content: 'Unknown Audrey tool',
+        });
         continue;
       }
 
@@ -320,7 +348,7 @@ async function main() {
   console.log('Stopped after MAX_TOOL_LOOPS without a final model answer.');
 }
 
-main().catch((err) => {
+main().catch(err => {
   console.error(err);
   process.exit(1);
 });

package/examples/stripe-demo.js

@@ -21,11 +21,15 @@ async function demo() {
   });
 
   brain.on('consolidation', ({ principlesExtracted, clustersFound }) => {
-    console.log(`  [CONSOLIDATE] Found ${clustersFound} clusters, extracted ${principlesExtracted} principles`);
+    console.log(
+      `  [CONSOLIDATE] Found ${clustersFound} clusters, extracted ${principlesExtracted} principles`,
+    );
   });
 
   brain.on('reinforcement', ({ episodeId, similarity }) => {
-    console.log(`  [REINFORCE] Episode ${episodeId.slice(0, 8)}... reinforced existing knowledge (sim: ${similarity?.toFixed(2) || 'N/A'})`);
+    console.log(
+      `  [REINFORCE] Episode ${episodeId.slice(0, 8)}... reinforced existing knowledge (sim: ${similarity?.toFixed(2) || 'N/A'})`,
+    );
   });
 
   // --- Scenario: Agent encounters Stripe rate limits ---
@@ -41,7 +45,8 @@ async function demo() {
 
   console.log('\n--- Episode 2: Second hit from different code path ---');
   await brain.encode({
-    content: 'Stripe webhook verification endpoint returned 429 Too Many Requests during high traffic',
+    content:
+      'Stripe webhook verification endpoint returned 429 Too Many Requests during high traffic',
     source: 'tool-result',
     salience: 0.7,
     causal: { trigger: 'webhook-flood', consequence: 'missed-webhook-events' },
@@ -65,7 +70,7 @@ async function demo() {
     // (e.g. OpenAI text-embedding-3-small), a threshold of 0.80+ works well.
     // We drop it here so the demo pipeline runs end-to-end.
     similarityThreshold: -0.3,
-    extractPrinciple: (episodes) => ({
+    extractPrinciple: () => ({
       content: `Stripe enforces ~100 req/s rate limit across all endpoints. Exceeding this causes 429 errors that can stall payment queues and cause missed webhooks. Implement request throttling.`,
       type: 'semantic',
     }),
@@ -80,7 +85,9 @@ async function demo() {
 
   console.log(`\nRecalled ${memories.length} memories:`);
   for (const mem of memories) {
-    console.log(`  [${mem.type.toUpperCase()}] (conf: ${mem.confidence.toFixed(2)}, score: ${mem.score.toFixed(3)}) ${mem.content.slice(0, 80)}${mem.content.length > 80 ? '...' : ''}`);
+    console.log(
+      `  [${mem.type.toUpperCase()}] (conf: ${mem.confidence.toFixed(2)}, score: ${mem.score.toFixed(3)}) ${mem.content.slice(0, 80)}${mem.content.length > 80 ? '...' : ''}`,
+    );
   }
 
   // --- Introspection ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "audrey",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Local-first memory runtime for AI agents with recall, consolidation, memory reflexes, contradiction detection, and tool-trace learning",
   "type": "module",
   "main": "dist/src/index.js",
@@ -71,10 +71,10 @@
     "pretest": "npm run build && npm run test:artifacts",
     "test": "node scripts/run-vitest.mjs",
     "test:watch": "node scripts/run-vitest.mjs watch",
-    "test:artifacts": "npm run bench:perf && npm run bench:memory:check && npm run bench:guard:check && npm run bench:guard:card && npm run bench:guard:bundle && npm run bench:guard:bundle:verify && npm run bench:guard:leaderboard && npm run bench:guard:adapter-self-test && npm run bench:guard:adapter-self-test:validate && npm run bench:guard:external:dry-run && npm run bench:guard:external:evidence && npm run paper:arxiv && npm run paper:arxiv:verify && npm run paper:arxiv:compile && npm run paper:bundle && npm run paper:bundle:verify",
-    "release:gate": "npm run typecheck && npm test && npm run bench:memory:check && npm run bench:guard:check && npm run bench:guard:card && npm run bench:guard:bundle && npm run bench:guard:bundle:verify && npm run bench:guard:leaderboard && npm run bench:guard:adapter-registry:validate && npm run bench:guard:external:dry-run && npm run bench:guard:external:evidence && npm run bench:guard:adapter-module:validate && npm run bench:guard:adapter-self-test && npm run bench:guard:adapter-self-test:validate && npm run bench:guard:validate && npm run bench:guard:publication:verify && npm run python:release:check && npm run smoke:cli && npm run security:audit && npm run pack:check",
-    "release:gate:sandbox": "npm run build && npm run typecheck && npm run bench:perf && npm run bench:memory:check && npm run bench:guard:check && npm run bench:guard:card && npm run bench:guard:bundle && npm run bench:guard:bundle:verify && npm run bench:guard:leaderboard && npm run bench:guard:adapter-registry:validate && npm run bench:guard:external:dry-run && npm run bench:guard:external:evidence && npm run bench:guard:adapter-module:validate && npm run bench:guard:adapter-self-test && npm run bench:guard:adapter-self-test:validate && npm run bench:guard:validate && npm run bench:guard:publication:verify && npm run python:release:check && npm run smoke:cli && npm run security:audit && npm run pack:check",
-    "release:gate:paper": "npm run build && npm run typecheck && npm run bench:perf && npm run bench:memory:check && npm run bench:guard:check && npm run bench:guard:card && npm run bench:guard:bundle && npm run bench:guard:bundle:verify && npm run bench:guard:leaderboard && npm run bench:guard:adapter-registry:validate && npm run bench:guard:external:dry-run && npm run bench:guard:external:evidence && npm run bench:guard:adapter-module:validate && npm run bench:guard:adapter-self-test && npm run bench:guard:adapter-self-test:validate && npm run bench:guard:validate && npm run bench:guard:publication:verify && npm run python:release:check && npm run paper:sync && npm run paper:arxiv && npm run paper:arxiv:verify && npm run paper:arxiv:compile && npm run paper:launch-plan && npm run paper:launch-results && npm run paper:bundle && npm run paper:bundle:verify && npm run paper:verify && npm run release:readiness && npm run smoke:cli && npm run security:audit && npm run pack:check",
+    "test:artifacts": "npm run bench:perf && npm run bench:memory:check && npm run bench:guard:check && npm run bench:guard:card && npm run bench:guard:bundle && npm run bench:guard:bundle:verify && npm run bench:guard:leaderboard && npm run bench:guard:adapter-self-test && npm run bench:guard:adapter-self-test:validate && npm run bench:guard:external:dry-run && npm run bench:guard:external:evidence && npm run paper:sync && npm run paper:arxiv && npm run paper:arxiv:verify && npm run paper:arxiv:compile && npm run paper:bundle && npm run paper:bundle:verify && npm run paper:verify",
+    "release:gate": "npm run typecheck && npm run lint && npm run format:check && npm test && npm run bench:memory:check && npm run bench:guard:check && npm run bench:guard:card && npm run bench:guard:bundle && npm run bench:guard:bundle:verify && npm run bench:guard:leaderboard && npm run bench:guard:adapter-registry:validate && npm run bench:guard:external:dry-run && npm run bench:guard:external:evidence && npm run bench:guard:adapter-module:validate && npm run bench:guard:adapter-self-test && npm run bench:guard:adapter-self-test:validate && npm run bench:guard:validate && npm run bench:guard:publication:verify && npm run python:release:check && npm run smoke:cli && npm run security:audit && npm run pack:check",
+    "release:gate:sandbox": "npm run build && npm run typecheck && npm run lint && npm run format:check && npm run bench:perf && npm run bench:memory:check && npm run bench:guard:check && npm run bench:guard:card && npm run bench:guard:bundle && npm run bench:guard:bundle:verify && npm run bench:guard:leaderboard && npm run bench:guard:adapter-registry:validate && npm run bench:guard:external:dry-run && npm run bench:guard:external:evidence && npm run bench:guard:adapter-module:validate && npm run bench:guard:adapter-self-test && npm run bench:guard:adapter-self-test:validate && npm run bench:guard:validate && npm run bench:guard:publication:verify && npm run python:release:check && npm run smoke:cli && npm run security:audit && npm run pack:check",
+    "release:gate:paper": "npm run build && npm run typecheck && npm run lint && npm run format:check && npm run bench:perf && npm run bench:memory:check && npm run bench:guard:check && npm run bench:guard:card && npm run bench:guard:bundle && npm run bench:guard:bundle:verify && npm run bench:guard:leaderboard && npm run bench:guard:adapter-registry:validate && npm run bench:guard:external:dry-run && npm run bench:guard:external:evidence && npm run bench:guard:adapter-module:validate && npm run bench:guard:adapter-self-test && npm run bench:guard:adapter-self-test:validate && npm run bench:guard:validate && npm run bench:guard:publication:verify && npm run python:release:check && npm run paper:sync && npm run paper:arxiv && npm run paper:arxiv:verify && npm run paper:arxiv:compile && npm run paper:launch-plan && npm run paper:launch-results && npm run paper:bundle && npm run paper:bundle:verify && npm run paper:verify && npm run release:readiness && npm run smoke:cli && npm run security:audit && npm run pack:check",
     "release:cut:plan": "node scripts/prepare-release-cut.mjs --json",
     "release:cut:apply": "node scripts/prepare-release-cut.mjs --apply",
     "release:readiness": "node scripts/verify-release-readiness.mjs --allow-pending",
@@ -135,6 +135,10 @@
     "paper:sync": "node scripts/sync-paper-artifacts.mjs",
     "paper:verify": "node scripts/verify-paper-artifacts.mjs",
     "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"mcp-server/**/*.ts\" \"tests/**/*.js\" \"benchmarks/**/*.{js,mjs}\" \"scripts/**/*.{js,mjs}\" \"examples/**/*.js\" \"*.{js,mjs}\" \".prettierrc.json\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"mcp-server/**/*.ts\" \"tests/**/*.js\" \"benchmarks/**/*.{js,mjs}\" \"scripts/**/*.{js,mjs}\" \"examples/**/*.js\" \"*.{js,mjs}\" \".prettierrc.json\"",
     "serve": "node dist/mcp-server/index.js serve",
     "docker:build": "docker build -t audrey:local .",
     "docker:up": "docker compose up -d --build",
@@ -200,11 +204,20 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.6.2",
+    "eslint": "^10.4.0",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.6.0",
+    "prettier": "^3.8.3",
     "typescript": "^6.0.3",
+    "typescript-eslint": "^8.60.0",
     "vitest": "^4.1.5"
   },
+  "overrides": {
+    "qs": "^6.15.2"
+  },
   "directories": {
     "example": "examples",
     "test": "tests"

package/scripts/audit-release-completion.mjs

@@ -3,7 +3,7 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { verifyExternalGuardBenchEvidence } from '../benchmarks/verify-external-evidence.mjs';
 import { verifyBrowserLaunchResults } from './verify-browser-launch-results.mjs';
@@ -35,7 +35,8 @@ function parseArgs(argv = process.argv.slice(2)) {
 
   for (let i = 0; i < argv.length; i++) {
     const token = argv[i];
-    if ((token === '--version' || token === '--target-version') && argv[i + 1]) args.version = argv[++i];
+    if ((token === '--version' || token === '--target-version') && argv[i + 1])
+      args.version = argv[++i];
     else if (token === '--out' && argv[i + 1]) args.out = argv[++i];
     else if (token === '--json') args.json = true;
     else if (token === '--help' || token === '-h') args.help = true;
@@ -81,7 +82,9 @@ function run(command, args, options = {}) {
 }
 
 function sha256(path) {
-  return createHash('sha256').update(readFileSync(fromRoot(path))).digest('hex');
+  return createHash('sha256')
+    .update(readFileSync(fromRoot(path)))
+    .digest('hex');
 }
 
 function artifactEvidence(path) {
@@ -104,7 +107,10 @@ function statusFromGaps(gaps, passed = true) {
 }
 
 function commandEvidence(result) {
-  const firstLine = `${result.stderr}\n${result.stdout}`.split(/\r?\n/).map(line => line.trim()).find(Boolean);
+  const firstLine = `${result.stderr}\n${result.stdout}`
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .find(Boolean);
   return `${result.command}: ${result.ok ? 'ok' : `exit ${result.status ?? 'unknown'}`}${firstLine ? ` (${firstLine})` : ''}`;
 }
 
@@ -137,10 +143,16 @@ function localPathSweep(paths) {
   for (const path of paths) {
     const absolute = fromRoot(path);
     if (!existsSync(absolute)) continue;
-    const scan = run('rg', ['-n', '-F', '-e', 'B:\\Projects', '-e', 'C:\\Users', '-e', '\\\\?\\', '-e', 'file://', path], { timeout: 30_000 });
+    const scan = run(
+      'rg',
+      ['-n', '-F', '-e', 'B:\\Projects', '-e', 'C:\\Users', '-e', '\\\\?\\', '-e', 'file://', path],
+      { timeout: 30_000 },
+    );
     if (scan.status === 0) failures.push(`${path}: local path match found`);
-    if (scan.status !== 0 && scan.status !== 1) failures.push(`${path}: local path sweep failed (${scan.stderr || scan.stdout})`);
-    if (scan.stdout && localPathPattern.test(scan.stdout)) failures.push(`${path}: local path sweep output contains local path`);
+    if (scan.status !== 0 && scan.status !== 1)
+      failures.push(`${path}: local path sweep failed (${scan.stderr || scan.stdout})`);
+    if (scan.stdout && localPathPattern.test(scan.stdout))
+      failures.push(`${path}: local path sweep output contains local path`);
   }
   return failures;
 }
@@ -150,16 +162,41 @@ export async function auditReleaseCompletion(options = {}) {
   const out = options.out ?? DEFAULT_OUT;
   const pkg = readJson('package.json');
   const readiness = await verifyReleaseReadiness({ targetVersion: version, allowPending: true });
-  const strictReadiness = await verifyReleaseReadiness({ targetVersion: version, allowPending: false });
+  const strictReadiness = await verifyReleaseReadiness({
+    targetVersion: version,
+    allowPending: false,
+  });
   const browserResults = await verifyBrowserLaunchResults();
-  const externalEvidence = await verifyExternalGuardBenchEvidence({ allowPending: true, write: false });
+  const externalEvidence = await verifyExternalGuardBenchEvidence({
+    allowPending: true,
+    write: false,
+  });
   const paperVerify = run('node', ['scripts/verify-paper-artifacts.mjs'], { timeout: 180_000 });
-  const paperBundleVerify = run('node', ['scripts/verify-paper-submission-bundle.mjs'], { timeout: 120_000 });
+  const paperBundleVerify = run('node', ['scripts/verify-paper-submission-bundle.mjs'], {
+    timeout: 120_000,
+  });
   const audit = run('npm', ['audit', '--omit=dev', '--audit-level=moderate'], { timeout: 120_000 });
   const diffCheck = run('git', ['diff', '--check'], { timeout: 60_000 });
-  const bundleVerify = run('git', ['bundle', 'verify', `.tmp/release-artifacts/audrey-${version}.git.bundle`], { timeout: 60_000 });
-  const remoteRefsResult = run('git', ['-c', 'http.sslBackend=openssl', 'ls-remote', 'origin', 'refs/heads/master', `refs/tags/v${version}`], { timeout: 60_000 });
-  const npmView = run('npm', ['view', `audrey@${version}`, 'version', '--registry', NPM_REGISTRY], { timeout: 60_000 });
+  const bundleVerify = run(
+    'git',
+    ['bundle', 'verify', `.tmp/release-artifacts/audrey-${version}.git.bundle`],
+    { timeout: 60_000 },
+  );
+  const remoteRefsResult = run(
+    'git',
+    [
+      '-c',
+      'http.sslBackend=openssl',
+      'ls-remote',
+      'origin',
+      'refs/heads/master',
+      `refs/tags/v${version}`,
+    ],
+    { timeout: 60_000 },
+  );
+  const npmView = run('npm', ['view', `audrey@${version}`, 'version', '--registry', NPM_REGISTRY], {
+    timeout: 60_000,
+  });
   const pypi = await checkPypi(version);
   const gitObjects = latestGitObjectReport();
   const remoteRefs = extractRemoteRefs(remoteRefsResult.stdout);
@@ -170,130 +207,166 @@ export async function auditReleaseCompletion(options = {}) {
 
   const checklist = [];
   const versionGaps = [];
-  if (pkg.version !== version) versionGaps.push(`package.json is ${pkg.version}, expected ${version}`);
-  if (!readiness.ok) versionGaps.push(...readiness.failures.map(failure => `readiness failure: ${failure}`));
-  checklist.push(checklistItem(
-    'code-release-local-readiness',
-    'Audrey codebase is cut to 1.0.0 and local release gates are coherent.',
-    statusFromGaps(versionGaps, readiness.ok),
-    [
-      `package.json version=${pkg.version}`,
-      `readiness ok=${readiness.ok}`,
-      `strict readiness ok=${strictReadiness.ok}`,
-      `pending blockers=${readiness.blockers.length}`,
-    ],
-    versionGaps,
-  ));
+  if (pkg.version !== version)
+    versionGaps.push(`package.json is ${pkg.version}, expected ${version}`);
+  if (!readiness.ok)
+    versionGaps.push(...readiness.failures.map(failure => `readiness failure: ${failure}`));
+  checklist.push(
+    checklistItem(
+      'code-release-local-readiness',
+      'Audrey codebase is cut to 1.0.0 and local release gates are coherent.',
+      statusFromGaps(versionGaps, readiness.ok),
+      [
+        `package.json version=${pkg.version}`,
+        `readiness ok=${readiness.ok}`,
+        `strict readiness ok=${strictReadiness.ok}`,
+        `pending blockers=${readiness.blockers.length}`,
+      ],
+      versionGaps,
+    ),
+  );
 
   const sourceGaps = [];
   const remoteMaster = remoteRefs.get('refs/heads/master');
-  const remoteTag = remoteRefs.get(`refs/tags/v${version}`) ?? remoteRefs.get(`refs/tags/v${version}^{}`);
+  const remoteTag =
+    remoteRefs.get(`refs/tags/v${version}`) ?? remoteRefs.get(`refs/tags/v${version}^{}`);
   if (!bundleVerify.ok) sourceGaps.push('release Git bundle does not verify');
   if (!gitObjects?.commit) sourceGaps.push('missing external release commit object report');
   if (gitObjects?.commit && remoteMaster !== gitObjects.commit) {
-    sourceGaps.push(`remote master is ${remoteMaster ?? 'missing'}, not release commit ${gitObjects.commit}`);
+    sourceGaps.push(
+      `remote master is ${remoteMaster ?? 'missing'}, not release commit ${gitObjects.commit}`,
+    );
   }
   if (!remoteTag) sourceGaps.push(`remote tag v${version} is missing`);
-  checklist.push(checklistItem(
-    'source-control-release-state',
-    'Final release commit and v1.0.0 tag are present on the public repository.',
-    statusFromGaps(sourceGaps, bundleVerify.ok && remoteRefsResult.ok),
-    [
-      commandEvidence(bundleVerify),
-      `external commit=${gitObjects?.commit ?? 'missing'}`,
-      `external tag object=${gitObjects?.tag ?? 'missing'}`,
-      `remote master=${remoteMaster ?? 'missing'}`,
-      `remote tag=${remoteTag ?? 'missing'}`,
-    ],
-    sourceGaps,
-  ));
+  checklist.push(
+    checklistItem(
+      'source-control-release-state',
+      'Final release commit and v1.0.0 tag are present on the public repository.',
+      statusFromGaps(sourceGaps, bundleVerify.ok && remoteRefsResult.ok),
+      [
+        commandEvidence(bundleVerify),
+        `external commit=${gitObjects?.commit ?? 'missing'}`,
+        `external tag object=${gitObjects?.tag ?? 'missing'}`,
+        `remote master=${remoteMaster ?? 'missing'}`,
+        `remote tag=${remoteTag ?? 'missing'}`,
+      ],
+      sourceGaps,
+    ),
+  );
 
   const npmArtifact = artifactEvidence(`.tmp/release-artifacts/audrey-${version}.tgz`);
   const npmGaps = [];
   if (!npmArtifact.exists) npmGaps.push('npm tarball missing');
-  if (!npmView.ok) npmGaps.push(`audrey@${version} is not published on npm or npm registry check failed`);
-  checklist.push(checklistItem(
-    'npm-package-publication',
-    'audrey@1.0.0 npm package is packaged and published.',
-    statusFromGaps(npmGaps),
-    [JSON.stringify(npmArtifact), commandEvidence(npmView)],
-    npmGaps,
-  ));
+  if (!npmView.ok)
+    npmGaps.push(`audrey@${version} is not published on npm or npm registry check failed`);
+  checklist.push(
+    checklistItem(
+      'npm-package-publication',
+      'audrey@1.0.0 npm package is packaged and published.',
+      statusFromGaps(npmGaps),
+      [JSON.stringify(npmArtifact), commandEvidence(npmView)],
+      npmGaps,
+    ),
+  );
 
   const wheel = artifactEvidence(`python/dist/audrey_memory-${version}-py3-none-any.whl`);
   const sdist = artifactEvidence(`python/dist/audrey_memory-${version}.tar.gz`);
   const pypiGaps = [];
   if (!wheel.exists) pypiGaps.push('Python wheel missing');
   if (!sdist.exists) pypiGaps.push('Python sdist missing');
-  if (!pypi.ok) pypiGaps.push(`audrey-memory ${version} is not published on PyPI (status=${pypi.status})`);
-  checklist.push(checklistItem(
-    'python-package-publication',
-    'audrey-memory 1.0.0 Python package is built and published.',
-    statusFromGaps(pypiGaps),
-    [JSON.stringify(wheel), JSON.stringify(sdist), `PyPI status=${pypi.status}`],
-    pypiGaps,
-  ));
+  if (!pypi.ok)
+    pypiGaps.push(`audrey-memory ${version} is not published on PyPI (status=${pypi.status})`);
+  checklist.push(
+    checklistItem(
+      'python-package-publication',
+      'audrey-memory 1.0.0 Python package is built and published.',
+      statusFromGaps(pypiGaps),
+      [JSON.stringify(wheel), JSON.stringify(sdist), `PyPI status=${pypi.status}`],
+      pypiGaps,
+    ),
+  );
 
   const paperGaps = [];
   if (!paperVerify.ok) paperGaps.push('paper artifact verifier failed');
   if (!paperBundleVerify.ok) paperGaps.push('paper submission bundle verifier failed');
-  checklist.push(checklistItem(
-    'paper-local-quality',
-    'Research paper, claim register, bibliography, evidence ledger, arXiv source, and submission bundle verify locally.',
-    statusFromGaps(paperGaps, paperVerify.ok && paperBundleVerify.ok),
-    [commandEvidence(paperVerify), commandEvidence(paperBundleVerify)],
-    paperGaps,
-  ));
+  checklist.push(
+    checklistItem(
+      'paper-local-quality',
+      'Research paper, claim register, bibliography, evidence ledger, arXiv source, and submission bundle verify locally.',
+      statusFromGaps(paperGaps, paperVerify.ok && paperBundleVerify.ok),
+      [commandEvidence(paperVerify), commandEvidence(paperBundleVerify)],
+      paperGaps,
+    ),
+  );
 
   const publicationGaps = [];
   if (!browserResults.ok) publicationGaps.push(...browserResults.failures);
   if (!browserResults.ready) publicationGaps.push(...browserResults.blockers);
-  checklist.push(checklistItem(
-    'paper-publication',
-    'Paper is publicly submitted/published across the launch targets recorded by the browser launch ledger.',
-    statusFromGaps(publicationGaps, browserResults.ok),
-    [
-      `browser results ok=${browserResults.ok}`,
-      `browser results ready=${browserResults.ready}`,
-      `submitted=${browserResults.targets.filter(target => target.status === 'submitted').length}/${browserResults.targets.length}`,
-    ],
-    publicationGaps,
-  ));
+  checklist.push(
+    checklistItem(
+      'paper-publication',
+      'Paper is publicly submitted/published across the launch targets recorded by the browser launch ledger.',
+      statusFromGaps(publicationGaps, browserResults.ok),
+      [
+        `browser results ok=${browserResults.ok}`,
+        `browser results ready=${browserResults.ready}`,
+        `submitted=${browserResults.targets.filter(target => target.status === 'submitted').length}/${browserResults.targets.length}`,
+      ],
+      publicationGaps,
+    ),
+  );
 
   const guardGaps = [];
   if (!externalEvidence.ok) guardGaps.push(...externalEvidence.failures);
-  for (const adapter of externalEvidence.adapters.filter(adapter => adapter.status !== 'verified')) {
-    guardGaps.push(`${adapter.id}: ${adapter.missingEnv?.length ? `missing ${adapter.missingEnv.join(', ')}` : adapter.evidenceKind}`);
+  for (const adapter of externalEvidence.adapters.filter(
+    adapter => adapter.status !== 'verified',
+  )) {
+    guardGaps.push(
+      `${adapter.id}: ${adapter.missingEnv?.length ? `missing ${adapter.missingEnv.join(', ')}` : adapter.evidenceKind}`,
+    );
   }
-  checklist.push(checklistItem(
-    'external-guardbench-evidence',
-    'External GuardBench adapters are live-verified, not only dry-run verified.',
-    statusFromGaps(guardGaps, externalEvidence.ok),
-    externalEvidence.adapters.map(adapter => `${adapter.id}: ${adapter.status}/${adapter.evidenceKind}`),
-    guardGaps,
-  ));
+  checklist.push(
+    checklistItem(
+      'external-guardbench-evidence',
+      'External GuardBench adapters are live-verified, not only dry-run verified.',
+      statusFromGaps(guardGaps, externalEvidence.ok),
+      externalEvidence.adapters.map(
+        adapter => `${adapter.id}: ${adapter.status}/${adapter.evidenceKind}`,
+      ),
+      guardGaps,
+    ),
+  );
 
   const safetyGaps = [];
   if (!audit.ok) safetyGaps.push('production dependency audit failed');
   if (!diffCheck.ok) safetyGaps.push('git diff --check failed');
   safetyGaps.push(...localPathFailures);
-  checklist.push(checklistItem(
-    'release-safety-hygiene',
-    'Release artifacts pass dependency audit, whitespace checks, and local-path leak sweeps.',
-    statusFromGaps(safetyGaps, audit.ok && diffCheck.ok),
-    [commandEvidence(audit), commandEvidence(diffCheck), `local path sweep failures=${localPathFailures.length}`],
-    safetyGaps,
-  ));
+  checklist.push(
+    checklistItem(
+      'release-safety-hygiene',
+      'Release artifacts pass dependency audit, whitespace checks, and local-path leak sweeps.',
+      statusFromGaps(safetyGaps, audit.ok && diffCheck.ok),
+      [
+        commandEvidence(audit),
+        commandEvidence(diffCheck),
+        `local path sweep failures=${localPathFailures.length}`,
+      ],
+      safetyGaps,
+    ),
+  );
 
   const finalizerGaps = [];
   if (!artifactReport) finalizerGaps.push('missing release-finalize-report.json');
-  checklist.push(checklistItem(
-    'release-finalizer-artifacts',
-    'Finalization report records packaged npm/Python artifacts and source-control handoff artifacts.',
-    statusFromGaps(finalizerGaps),
-    artifactReport?.artifacts?.map(artifact => `${artifact.path} sha256=${artifact.sha256}`) ?? [],
-    finalizerGaps,
-  ));
+  checklist.push(
+    checklistItem(
+      'release-finalizer-artifacts',
+      'Finalization report records packaged npm/Python artifacts and source-control handoff artifacts.',
+      statusFromGaps(finalizerGaps),
+      artifactReport?.artifacts?.map(artifact => `${artifact.path} sha256=${artifact.sha256}`) ??
+        [],
+      finalizerGaps,
+    ),
+  );
 
   const complete = checklist.every(item => item.status === 'passed');
   const report = {
@@ -343,7 +416,9 @@ async function main() {
   } else {
     console.log(`Audrey release completion audit: complete=${report.complete}`);
     for (const item of report.checklist) {
-      console.log(`- ${item.id}: ${item.status}${item.gaps.length ? ` (${item.gaps.length} gap(s))` : ''}`);
+      console.log(
+        `- ${item.id}: ${item.status}${item.gaps.length ? ` (${item.gaps.length} gap(s))` : ''}`,
+      );
     }
   }
 
@@ -351,7 +426,10 @@ async function main() {
 }
 
 function isDirectRun() {
-  return Boolean(process.argv[1]) && resolve(process.argv[1]).toLowerCase() === fileURLToPath(import.meta.url).toLowerCase();
+  return (
+    Boolean(process.argv[1]) &&
+    resolve(process.argv[1]).toLowerCase() === fileURLToPath(import.meta.url).toLowerCase()
+  );
 }
 
 if (isDirectRun()) {