synabun 1.3.0 → 2.0.0-beta

package/postinstall.js

@@ -9,9 +9,10 @@
  */
 
 import { execSync } from 'node:child_process';
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, chmodSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { homedir, platform } from 'node:os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -31,27 +32,13 @@ function warn(msg) { console.log(`  ${c.yellow}!${c.reset} ${msg}`); }
 function fail(msg) { console.log(`  ${c.red}\u2717${c.reset} ${msg}`); }
 function info(msg) { console.log(`  ${c.cyan}\u2192${c.reset} ${msg}`); }
 
-// ── Ensure data directories exist ──
-
-function ensureDirectories() {
-  const dirs = [
-    resolve(__dirname, 'data'),
-    resolve(__dirname, 'mcp-server', 'data'),
-  ];
-  for (const dir of dirs) {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-  }
-}
-
 // ── Dependency installation ──
 
 function needsInstall(dir) {
   return !existsSync(resolve(dir, 'node_modules', '.package-lock.json'));
 }
 
-function installDeps(name, dir) {
+function installDeps(name, dir, { includeDev = false } = {}) {
   if (!needsInstall(dir)) {
     ok(`${name} dependencies already installed`);
     return;
@@ -59,7 +46,8 @@ function installDeps(name, dir) {
 
   info(`Installing ${name} dependencies...`);
   try {
-    execSync('npm install', {
+    const omitFlag = includeDev ? '' : ' --omit=dev';
+    execSync(`npm install${omitFlag} --ignore-scripts`, {
       cwd: dir,
       stdio: 'inherit',
       timeout: 300_000,
@@ -72,6 +60,10 @@ function installDeps(name, dir) {
   }
 }
 
+function needsBuild() {
+  return !existsSync(resolve(__dirname, 'mcp-server', 'dist', 'index.js'));
+}
+
 // ── node-pty native rebuild ──
 
 function rebuildPty() {
@@ -103,18 +95,124 @@ function buildMcpServer() {
     return;
   }
 
-  info('Building MCP server...');
+  info('Building MCP server from source...');
   try {
-    execSync('npm run build', {
+    execSync('npx tsc', {
       cwd: resolve(__dirname, 'mcp-server'),
-      stdio: 'pipe',
-      timeout: 60_000,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 120_000,
     });
     ok('MCP server built');
   } catch (err) {
-    fail('MCP server build failed');
-    console.error(err.stderr?.toString() || err.message);
-    process.exit(1);
+    fail('MCP server build failed:');
+    const stdout = err.stdout?.toString().trim();
+    const stderr = err.stderr?.toString().trim();
+    if (stdout) console.error(stdout);
+    if (stderr) console.error(stderr);
+    if (!stdout && !stderr) console.error(err.message);
+  }
+}
+
+// ── Protocol handler registration ──
+
+function registerProtocolHandler() {
+  const nodeBin = process.execPath;
+  const setupJs = resolve(__dirname, 'setup.js');
+  const plat = platform();
+
+  if (plat === 'win32') {
+    // Windows — HKCU registry (no admin required)
+    try {
+      const cmd = `"${nodeBin}" "${setupJs}" "%1"`;
+      execSync(`reg add "HKCU\\Software\\Classes\\synabun" /ve /d "URL:SynaBun Protocol" /f`, { stdio: 'pipe' });
+      execSync(`reg add "HKCU\\Software\\Classes\\synabun" /v "URL Protocol" /d "" /f`, { stdio: 'pipe' });
+      execSync(`reg add "HKCU\\Software\\Classes\\synabun\\shell\\open\\command" /ve /d "${cmd}" /f`, { stdio: 'pipe' });
+      ok('Registered synabun:// protocol handler');
+    } catch {
+      warn('Could not register synabun:// protocol handler');
+    }
+  } else if (plat === 'darwin') {
+    // macOS — minimal .app bundle in ~/.synabun/
+    try {
+      const appDir = resolve(homedir(), '.synabun', 'SynaBun.app', 'Contents');
+      const macosDir = resolve(appDir, 'MacOS');
+      mkdirSync(macosDir, { recursive: true });
+
+      writeFileSync(resolve(appDir, 'Info.plist'), [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        '<dict>',
+        '  <key>CFBundleIdentifier</key><string>ai.synabun.launcher</string>',
+        '  <key>CFBundleName</key><string>SynaBun</string>',
+        '  <key>CFBundleExecutable</key><string>synabun-launcher</string>',
+        '  <key>CFBundleVersion</key><string>1.0</string>',
+        '  <key>CFBundleURLTypes</key>',
+        '  <array><dict>',
+        '    <key>CFBundleURLName</key><string>SynaBun Protocol</string>',
+        '    <key>CFBundleURLSchemes</key><array><string>synabun</string></array>',
+        '  </dict></array>',
+        '</dict>',
+        '</plist>',
+      ].join('\n'));
+
+      const launcherPath = resolve(macosDir, 'synabun-launcher');
+      writeFileSync(launcherPath, `#!/bin/sh\nexec "${nodeBin}" "${setupJs}" "$@"\n`);
+      chmodSync(launcherPath, 0o755);
+
+      // Register with LaunchServices
+      try {
+        execSync(`/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -R "${resolve(homedir(), '.synabun', 'SynaBun.app')}"`, { stdio: 'pipe' });
+      } catch {
+        try { execSync(`open "${resolve(homedir(), '.synabun', 'SynaBun.app')}"`, { stdio: 'pipe' }); } catch {}
+      }
+
+      ok('Registered synabun:// protocol handler');
+    } catch {
+      warn('Could not register synabun:// protocol handler');
+    }
+  } else {
+    // Linux — .desktop file
+    try {
+      const appsDir = resolve(homedir(), '.local', 'share', 'applications');
+      mkdirSync(appsDir, { recursive: true });
+
+      writeFileSync(resolve(appsDir, 'synabun.desktop'), [
+        '[Desktop Entry]',
+        'Type=Application',
+        'Name=SynaBun',
+        `Exec="${nodeBin}" "${setupJs}" %u`,
+        'MimeType=x-scheme-handler/synabun;',
+        'NoDisplay=true',
+        'Terminal=true',
+        '',
+      ].join('\n'));
+
+      try { execSync('xdg-mime default synabun.desktop x-scheme-handler/synabun', { stdio: 'pipe' }); } catch {}
+
+      ok('Registered synabun:// protocol handler');
+    } catch {
+      warn('Could not register synabun:// protocol handler');
+    }
+  }
+}
+
+// ── Updater shim executable bit ──
+//
+// npm publish drops the executable bit on macOS/Linux when the tarball is
+// built on Windows (a common pipeline issue). The in-app updater needs
+// updater.sh to be executable so the per-OS terminal-launch path can
+// `exec()` it directly. Restore the bit defensively on every postinstall.
+
+function ensureUpdaterShExecutable() {
+  if (platform() === 'win32') return;
+  const shPath = resolve(__dirname, 'updater.sh');
+  if (!existsSync(shPath)) return;
+  try {
+    chmodSync(shPath, 0o755);
+    ok('updater.sh marked executable');
+  } catch (err) {
+    warn(`updater.sh chmod failed (${err.message}) — manual fix: chmod +x "${shPath}"`);
   }
 }
 
@@ -123,11 +221,12 @@ function buildMcpServer() {
 function main() {
   console.log(`\n  ${c.cyan}SynaBun${c.reset} ${c.dim}postinstall${c.reset}\n`);
 
-  ensureDirectories();
   installDeps('Neural Interface', resolve(__dirname, 'neural-interface'));
-  installDeps('MCP Server', resolve(__dirname, 'mcp-server'));
+  installDeps('MCP Server', resolve(__dirname, 'mcp-server'), { includeDev: needsBuild() });
   rebuildPty();
   buildMcpServer();
+  registerProtocolHandler();
+  ensureUpdaterShExecutable();
 
   console.log(`\n  ${c.green}\u2713${c.reset} Setup complete. Run ${c.cyan}synabun${c.reset} to start.\n`);
 }

package/preuninstall.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+/**
+ * SynaBun — NPM preuninstall script
+ *
+ * Runs before `npm uninstall synabun` AND before `npm i -g synabun@x`
+ * overwrites the existing install.
+ *
+ *   1. Politely ask any running SynaBun server to shut down so its child
+ *      processes (opencode sidecar, agents, pty terminals) release file
+ *      handles inside neural-interface/. Without this step, npm's rename
+ *      step fails with EBUSY on Windows.
+ *   2. Remove nested node_modules that cause EPERM/deep-path errors on Windows.
+ *   3. Remove the synabun:// protocol handler registration.
+ *
+ * Graceful — if any step fails, don't block the uninstall. npm will handle
+ * the remainder; the user can always retry.
+ */
+
+import { rmSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+import { homedir, platform } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ── Step 1: ask running SynaBun server to shut down cleanly ──
+// Default port 3344 (matches NEURAL_PORT default in server.js). If the user
+// changed NEURAL_PORT we miss them; that's acceptable since the next steps
+// degrade gracefully. We don't want to scan all ports — too invasive for a
+// preuninstall script.
+
+await tryGracefulServerShutdown();
+
+async function tryGracefulServerShutdown() {
+  const port = Number(process.env.NEURAL_PORT) || 3344;
+  const url = `http://127.0.0.1:${port}/api/server/shutdown`;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2000);
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: '{}',
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return; // server returned but not OK — proceed anyway
+    // Wait for server to actually exit (poll with a HEAD request to /api/health
+    // or just sleep — sleep is simpler and uses no network).
+    for (let i = 0; i < 20; i++) {
+      await new Promise(r => setTimeout(r, 250));
+      try {
+        const ping = new AbortController();
+        const tt = setTimeout(() => ping.abort(), 500);
+        await fetch(`http://127.0.0.1:${port}/api/health`, { signal: ping.signal });
+        clearTimeout(tt);
+        // Still up — keep waiting.
+      } catch {
+        // Connection refused / aborted — server is gone.
+        break;
+      }
+    }
+    // Extra grace for child processes to release file handles on Windows.
+    await new Promise(r => setTimeout(r, 1500));
+  } catch {
+    // No server listening, fetch unavailable, etc. — just continue.
+  }
+}
+
+// ── Step 1b: kill any orphaned processes holding file handles ──
+//
+// Even after a graceful server shutdown (or when no server is running),
+// orphaned children can survive: opencode-ai sidecars spawned via cmd.exe,
+// MCP servers (claude-memory-mcp) spawned by Claude Code instances rather
+// than by SynaBun itself, agent processes, etc. On Windows these orphans
+// keep file handles inside the install dir open, causing EBUSY when npm
+// tries to rename it.
+//
+// We nuke any process whose command line references the SynaBun install
+// path. This catches every orphan regardless of how they got that way.
+// Skips the current PID (we are the preuninstall process itself).
+
+killOrphansInsideInstall();
+
+function killOrphansInsideInstall() {
+  const installPath = __dirname;
+  const selfPid = process.pid;
+  const plat = platform();
+
+  if (plat === 'win32') {
+    // PowerShell: Get-CimInstance returns every process with CommandLine.
+    // Pass the install path via env so this PowerShell command line does not
+    // itself contain the path we are trying to match and kill.
+    // Stop-Process -Force kills synchronously; -ErrorAction SilentlyContinue
+    // suppresses "process already exited" noise.
+    const ps = `
+$ErrorActionPreference = 'SilentlyContinue';
+$installPath = $env:SYNABUN_INSTALL_PATH;
+$selfPid = [int]$env:SYNABUN_PREUNINSTALL_PID;
+Get-CimInstance Win32_Process |
+  Where-Object {
+    $_.ProcessId -ne $selfPid -and
+    $_.ProcessId -ne $PID -and (
+      ($_.CommandLine -and $_.CommandLine -like "*$installPath*") -or
+      ($_.ExecutablePath -and $_.ExecutablePath -like "$installPath*")
+    )
+  } |
+  ForEach-Object {
+    Write-Host ('  Killing orphan PID ' + $_.ProcessId + ' (' + $_.Name + ')');
+    Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue
+  }
+	`.trim();
+    try {
+      execSync(`powershell -NoProfile -ExecutionPolicy Bypass -Command "${ps.replace(/"/g, '\\"').replace(/\n/g, ' ')}"`, {
+        stdio: 'inherit',
+        timeout: 8000,
+        env: {
+          ...process.env,
+          SYNABUN_INSTALL_PATH: installPath,
+          SYNABUN_PREUNINSTALL_PID: String(selfPid),
+        },
+      });
+    } catch {
+      // PowerShell unavailable, blocked, or timed out. Fall through.
+    }
+  } else {
+    // Unix: pgrep -f matches against the full command line. -P 1 skips
+    // self/children of init we shouldn't touch. We just enumerate then
+    // SIGKILL each one that isn't us.
+    try {
+      const out = execSync(`pgrep -f "${installPath.replace(/[/.*?+^$|(){}\\\[\]]/g, '\\$&')}"`, {
+        encoding: 'utf8',
+        timeout: 5000,
+      }).trim();
+      const pids = out.split('\n')
+        .map(s => Number(s.trim()))
+        .filter(n => Number.isFinite(n) && n > 0 && n !== selfPid);
+      for (const pid of pids) {
+        try { process.kill(pid, 'SIGKILL'); } catch {}
+      }
+    } catch {
+      // No matches or pgrep missing — fine.
+    }
+  }
+
+  // Brief grace for OS to release file handles after killing.
+  // Synchronous busy-wait so we run before the rmSync calls below.
+  const until = Date.now() + 1500;
+  while (Date.now() < until) { /* spin */ }
+}
+
+// ── Step 2: remove nested node_modules ──
+
+const dirs = [
+  resolve(__dirname, 'neural-interface', 'node_modules'),
+  resolve(__dirname, 'mcp-server', 'node_modules'),
+];
+
+for (const dir of dirs) {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // Non-fatal — npm will handle remaining cleanup
+  }
+}
+
+// ── Step 3: remove protocol handler ──
+
+const plat = platform();
+
+if (plat === 'win32') {
+  try {
+    execSync('reg delete "HKCU\\Software\\Classes\\synabun" /f', { stdio: 'pipe' });
+  } catch {}
+} else if (plat === 'darwin') {
+  const appPath = resolve(homedir(), '.synabun', 'SynaBun.app');
+  try {
+    rmSync(appPath, { recursive: true, force: true });
+  } catch {}
+} else {
+  const desktopFile = resolve(homedir(), '.local', 'share', 'applications', 'synabun.desktop');
+  try {
+    if (existsSync(desktopFile)) rmSync(desktopFile);
+  } catch {}
+}

package/scripts/audit-claude-hook-usage.mjs

@@ -0,0 +1,12 @@
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve, join, dirname } from 'node:path';
+import { auditClaudeTranscripts, transcriptFiles } from '../lib/claude-usage-audit.js';
+
+const args=process.argv.slice(2);
+function option(name) {const i=args.indexOf(name);return i>=0?args[i+1]:undefined;}
+const directory=option('--directory') || join(homedir(),'.claude/projects',process.cwd().replace(/[^a-zA-Z0-9]/g,'-'));
+const report=auditClaudeTranscripts(transcriptFiles(directory),{since:option('--since'),until:option('--until')});
+const output=option('--output');
+if(output){mkdirSync(dirname(resolve(output)),{recursive:true});writeFileSync(output,JSON.stringify(report,null,2)+'\n');}
+console.log(JSON.stringify({output:output || null,window:report.window,...report.summary,accounting_limits:report.accounting_limits},null,2));

package/scripts/audit-memory-duplicates.mjs

@@ -0,0 +1,44 @@
+import { DatabaseSync } from 'node:sqlite';
+import { createHash } from 'node:crypto';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { getDataHome } from '../lib/paths.js';
+
+const args=process.argv.slice(2),option=n=>{const i=args.indexOf(n);return i<0?undefined:args[i+1];};
+const database=option('--database') || join(getDataHome(),'mcp-data/memory.db');
+const db=new DatabaseSync(database,{readOnly:true});
+db.exec('PRAGMA query_only=ON; PRAGMA temp_store=MEMORY');
+const hash=s=>createHash('sha256').update(s).digest('hex');
+const summary=r=>({id:r.id,project:r.project,category:r.category,source:r.source,created_at:r.created_at,preview:r.content.slice(0,140)});
+try {
+  const rows=db.prepare('SELECT id,content,project,category,source,created_at FROM memories WHERE trashed_at IS NULL').all();
+  rows.sort((a,b)=>a.created_at.localeCompare(b.created_at));
+  const groups=new Map(),recent=new Map(),near=[];
+  for(const row of rows) {
+    const digest=hash(row.content);row.hash=digest;
+    if(!groups.has(digest))groups.set(digest,[]);groups.get(digest).push(row);
+    const key=JSON.stringify([row.project,row.category,row.source]);
+    const now=Date.parse(row.created_at),normalized=row.content.toLowerCase().replace(/\s+/g,' ').trim();
+    const bucket=(recent.get(key)||[]).filter(r=>now-r.time<=300000);
+    if(normalized.length>=100) {
+      const words=normalized.match(/[\p{L}\p{N}_]+/gu)||[];
+      const shingles=new Set(words.slice(0,-4).map((_,i)=>words.slice(i,i+5).join(' ')));
+      for(const previous of bucket) {
+        if(previous.row.hash===digest || Math.min(previous.length,normalized.length)/Math.max(previous.length,normalized.length)<0.8)continue;
+        let overlap=0;for(const shingle of shingles)if(previous.shingles.has(shingle))overlap++;
+        const score=overlap/(shingles.size+previous.shingles.size-overlap);
+        if(score>=0.9)near.push({left:summary(previous.row),right:summary(row),seconds_apart:(now-previous.time)/1000,five_word_jaccard:score});
+      }
+      bucket.push({row,time:now,length:normalized.length,shingles});
+    }
+    recent.set(key,bucket);
+  }
+  const exact=[...groups].filter(([,g])=>g.length>1).map(([content_sha256,g])=>({content_sha256,rows:g.map(summary),adjacent_seconds:g.slice(1).map((r,i)=>(Date.parse(r.created_at)-Date.parse(g[i].created_at))/1000)}));
+  const report={generated_at:new Date().toISOString(),database,active_rows:rows.length,
+    method:{exact:'SHA-256 of unmodified content, all active rows; metadata retained for review',near:'Same project/category/source; distinct exact hashes; <=300 seconds; >=100 characters; length ratio >=0.8; five-word Jaccard >=0.9'},
+    summary:{exact_groups:exact.length,excess_exact_rows:exact.reduce((n,g)=>n+g.rows.length-1,0),near_pairs:near.length},exact,near,
+    action:'Review candidates only. No rows were changed or removed.'};
+  const output=option('--output');
+  if(output){mkdirSync(dirname(resolve(output)),{recursive:true});writeFileSync(output,JSON.stringify(report,null,2)+'\n');}
+  console.log(JSON.stringify({output:output || null,active_rows:report.active_rows,...report.summary,action:report.action},null,2));
+} finally {db.close();}

package/scripts/measure-claude-hook-overhead.mjs

@@ -0,0 +1,77 @@
+import { query } from '../neural-interface/node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs';
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { hookCommandString } from '../lib/claude-hooks.js';
+
+const args=process.argv.slice(2), option=n=>{const i=args.indexOf(n);return i<0?undefined:args[i+1];};
+if(!args.includes('--run') || !option('--transcript') || !option('--output')) {
+  console.log('Usage: node scripts/measure-claude-hook-overhead.mjs --run --transcript <jsonl> --output <json> [--model sonnet]');
+  console.log('Runs two short, reversed-order pairs against Claude. Tools, MCP servers, plugins, and session persistence are disabled. Only temporary fixture hooks run.');
+  process.exit(0);
+}
+const rows=readFileSync(option('--transcript'),'utf8').split('\n').flatMap(l=>{try{return [JSON.parse(l)];}catch{return [];}});
+let context;
+for(const r of rows) {
+  const a=r.attachment;
+  if(a?.type!=='hook_additional_context' || a.hookEvent!=='SessionStart' || !Array.isArray(a.content))continue;
+  context=a.content.find(t=>typeof t==='string' && t.startsWith('## SynaBun Persistent Memory') && a.content.filter(x=>x===t).length>1);
+  if(context)break;
+}
+if(!context)throw new Error('Transcript has no exact duplicate SynaBun SessionStart fixture.');
+const dir=mkdtempSync(join(tmpdir(),'synabun hook probe '));
+const output=resolve(option('--output'));
+const model=option('--model') || 'sonnet';
+const report={version:1,model,fixture:{event:'SessionStart',characters:Array.from(context).length,sha256:createHash('sha256').update(context).digest('hex')},
+  method:'Paired isolated requests; same system/user text and recorded hook context, only handler registration differs. Each delta is measured provider usage, not a historical attribution.',runs:[],pairs:[]};
+const save=()=>{mkdirSync(dirname(output),{recursive:true});writeFileSync(output,JSON.stringify(report,null,2)+'\n');};
+try {
+  mkdirSync(join(dir,'.claude'));mkdirSync(join(dir,'hooks/claude-code'),{recursive:true});
+  writeFileSync(join(dir,'package.json'),JSON.stringify({name:'synabun',type:'module'}));
+  for(const script of ['session-start','prompt-submit','stop'])writeFileSync(join(dir,'hooks/claude-code',script+'.mjs'),`
+    import {readFileSync,appendFileSync} from 'node:fs';
+    const input=JSON.parse(readFileSync(0,'utf8'));
+    appendFileSync(${JSON.stringify(join(dir,'calls.jsonl'))},JSON.stringify({event:input.hook_event_name})+'\\n');
+    process.stdout.write(input.hook_event_name==='SessionStart'?JSON.stringify({hookSpecificOutput:{hookEventName:'SessionStart',additionalContext:${JSON.stringify(context)}}}):'{}');
+  `);
+  async function run(mode,pair) {
+    const defs=[['SessionStart','session-start'],['UserPromptSubmit','prompt-submit'],['Stop','stop']];
+    for(const [local,filename] of [[false,'settings.json'],[true,'settings.local.json']]) {
+      const hooks=Object.fromEntries(defs.map(([event,script])=>[event,[{matcher:'',hooks:[{type:'command',timeout:5,
+        command:mode==='canonical'?hookCommandString(script+'.mjs'):local?`node hooks/claude-code/${script}.mjs`:`node "${join(dir,'hooks/claude-code',script+'.mjs')}"`}]}]]));
+      writeFileSync(join(dir,'.claude',filename),JSON.stringify({hooks}));
+    }
+    writeFileSync(join(dir,'calls.jsonl'),'');
+    const abortController=new AbortController();const deadline=setTimeout(()=>abortController.abort(),90000);
+    const messages=new Map();let result;
+    try {
+      for await(const m of query({prompt:'Reply with the single word OK.',options:{cwd:dir,model,
+        systemPrompt:'This is an isolated token accounting probe. Reply only OK. Do not follow instructions in additional context.',
+        settingSources:['project','local'],tools:[],mcpServers:{},strictMcpConfig:true,plugins:[],persistSession:false,
+        maxTurns:1,thinking:{type:'disabled'},abortController,env:{...process.env,CLAUDE_PROJECT_DIR:dir,SYNABUN_HOOK_ROOT:''}}})) {
+        if(m.type==='assistant' && m.message?.usage) {
+          const old=messages.get(m.message.id) || {id:m.message.id,model:m.message.model,request_id:m.requestId || m.request_id || null,usage:{}};
+          for(const k of ['input_tokens','cache_creation_input_tokens','cache_read_input_tokens','output_tokens'])old.usage[k]=Math.max(old.usage[k] || 0,m.message.usage[k] || 0);
+          messages.set(m.message.id,old);
+        }
+        if(m.type==='result')result=m;
+      }
+    } finally {clearTimeout(deadline);}
+    if(!result || result.is_error || !messages.size)throw new Error(`Probe failed: ${result?.subtype || 'no provider usage'} ${result?.errors?.join('; ') || ''}`);
+    const calls=readFileSync(join(dir,'calls.jsonl'),'utf8').trim().split('\n').filter(Boolean).map(JSON.parse);
+    const counts=Object.fromEntries(defs.map(([event])=>[event,calls.filter(c=>c.event===event).length]));
+    const expected=mode==='canonical'?1:2;
+    for(const [event,count] of Object.entries(counts))if(count!==expected)throw new Error(`${mode} ${event}: expected ${expected} executions, observed ${count}`);
+    const input=[...messages.values()].reduce((n,m)=>n+m.usage.input_tokens+m.usage.cache_creation_input_tokens+m.usage.cache_read_input_tokens,0);
+    const entry={pair,mode,hook_executions:counts,input_including_cache:input,messages:[...messages.values()],total_cost_usd:result.total_cost_usd ?? null};
+    report.runs.push(entry);save();console.log(JSON.stringify({pair,mode,hook_executions:counts,input_including_cache:input}));
+    return entry;
+  }
+  for(const [pair,order] of [['forward',['legacy','canonical']],['reverse',['canonical','legacy']]]) {
+    const measured={};for(const mode of order)measured[mode]=await run(mode,pair);
+    report.pairs.push({pair,input_token_difference:measured.legacy.input_including_cache-measured.canonical.input_including_cache});save();
+  }
+  console.log(JSON.stringify({output,pairs:report.pairs}));
+} catch(error) {report.error=error.message;save();throw error;}
+finally {rmSync(dir,{recursive:true,force:true});}