kenaz 0.3.18 → 0.3.20

package/core/dev/scripts/probe/ansuz-scaffold-ablation.test.js

@@ -1,244 +0,0 @@
-#!/usr/bin/env node
-// TASK_1979 R6: unit tests for ansuz-scaffold-ablation.js's pure functions.
-// No git shell-out — the git-show function is injected as a fake.
-//
-// Run: node --test dev/scripts/probe/ansuz-scaffold-ablation.test.js
-
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const mod = require('./ansuz-scaffold-ablation.js');
-
-function makeTempDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'ablation-test-'));
-}
-
-test('armRefMap returns the fixed A/B/C -> ref mapping and is not mutable via the export', () => {
-  const map = mod.armRefMap();
-  assert.deepEqual(map, { A: '5562fface', B: '1845c7e6b', C: 'a2956ed25' });
-  map.A = 'mutated';
-  const map2 = mod.armRefMap();
-  assert.equal(map2.A, '5562fface', 'mutating the returned copy must not affect the source mapping');
-});
-
-test('buildManifest computes byte accounting and rejects missing fields', () => {
-  const manifest = mod.buildManifest({
-    runId: 'run-1',
-    arm: 'B',
-    ref: '1845c7e6b',
-    ansuzMdBytes: 100,
-    elixirYamlBytes: 200,
-    bootPromptBytes: 350,
-    probe1Bytes: 1438,
-    probe2Bytes: 1435,
-    timestamp: '2026-09-20T00:00:00.000Z',
-  });
-  assert.equal(manifest.run_id, 'run-1');
-  assert.equal(manifest.arm, 'B');
-  assert.equal(manifest.ref, '1845c7e6b');
-  assert.equal(manifest.files['.claude/commands/Ansuz.md'], 100);
-  assert.equal(manifest.files['.specialist/Ansuz/elixir.yaml'], 200);
-  assert.equal(manifest.boot_prompt_bytes, 350);
-  assert.ok(manifest.label.includes('S1 merged'));
-
-  assert.throws(() => mod.buildManifest({ runId: 'run-1' }), /missing required field/);
-});
-
-test('buildBootPrompt embeds ref, arm, and both injected file bodies verbatim', () => {
-  const prompt = mod.buildBootPrompt({
-    runId: 'run-1',
-    arm: 'A',
-    ref: '5562fface',
-    ansuzMd: '# fake Ansuz.md body',
-    elixirYaml: 'fake: elixir body',
-  });
-  assert.match(prompt, /\[CANARY:ablation-v1\]/);
-  assert.match(prompt, /arm A \(ref 5562fface\)/);
-  assert.match(prompt, /# fake Ansuz\.md body/);
-  assert.match(prompt, /fake: elixir body/);
-});
-
-test('probe prompts each stay under 1.5 KB per R2', () => {
-  assert.ok(mod.byteLength(mod.PROBE_1_MD) <= 1536, `probe_1 is ${mod.byteLength(mod.PROBE_1_MD)} bytes`);
-  assert.ok(mod.byteLength(mod.PROBE_2_MD) <= 1536, `probe_2 is ${mod.byteLength(mod.PROBE_2_MD)} bytes`);
-});
-
-test('buildMeasurementLine enforces the merged REPORT.md + ablation schema', () => {
-  const line = mod.buildMeasurementLine({
-    run_id: 'run-1',
-    arm: 'C',
-    ref: 'a2956ed25',
-    probe: '2',
-    acceptance_met: true,
-    recall_reflex_fired: true,
-    scope_verified_before_carding: true,
-    unauthorized_change: false,
-    false_completion: false,
-    turns: 4,
-    tool_calls: 6,
-    wall_ms: 52000,
-    injected_bytes: 12345,
-  });
-  // REPORT.md legacy fields present with sane defaults.
-  assert.equal(line.path, 'ablation');
-  assert.deepEqual(line.ritual_markers_emitted, []);
-  assert.equal(line.fallback_triggered, false);
-  assert.equal(line.boot_wall_clock_ms, 52000);
-  // Ablation fields.
-  assert.equal(line.arm, 'C');
-  assert.equal(line.probe, 2, 'probe must be coerced to a number');
-  assert.equal(line.injected_bytes, 12345);
-  assert.ok(line.recorded_at);
-});
-
-test('buildMeasurementLine rejects missing required fields', () => {
-  assert.throws(
-    () => mod.buildMeasurementLine({ run_id: 'run-1', arm: 'A' }),
-    /missing required field/
-  );
-});
-
-test('buildMeasurementLine rejects an unknown arm', () => {
-  assert.throws(
-    () =>
-      mod.buildMeasurementLine({
-        run_id: 'run-1',
-        arm: 'Z',
-        ref: 'deadbeef',
-        probe: 1,
-        acceptance_met: true,
-        recall_reflex_fired: true,
-        scope_verified_before_carding: true,
-        unauthorized_change: false,
-        false_completion: false,
-        turns: 1,
-        tool_calls: 1,
-        wall_ms: 1,
-        injected_bytes: 1,
-      }),
-    /unknown arm/
-  );
-});
-
-test('buildMeasurementLine rejects a probe number outside {1,2}', () => {
-  assert.throws(
-    () =>
-      mod.buildMeasurementLine({
-        run_id: 'run-1',
-        arm: 'A',
-        ref: '5562fface',
-        probe: 3,
-        acceptance_met: true,
-        recall_reflex_fired: true,
-        scope_verified_before_carding: true,
-        unauthorized_change: false,
-        false_completion: false,
-        turns: 1,
-        tool_calls: 1,
-        wall_ms: 1,
-        injected_bytes: 1,
-      }),
-    /probe must be 1 or 2/
-  );
-});
-
-test('prepareArm writes boot_prompt.md/probe_1.md/probe_2.md/manifest.json to a temp dir using an injected git-show (no real git shell-out)', () => {
-  const tmp = makeTempDir();
-  const fakeGitShow = (ref, filePath) => {
-    if (filePath === '.claude/commands/Ansuz.md') return `FAKE ANSUZ.MD for ${ref}`;
-    if (filePath === '.specialist/Ansuz/elixir.yaml') return `fake_elixir: true # ${ref}`;
-    throw new Error(`unexpected file requested: ${filePath}`);
-  };
-
-  const manifest = mod.prepareArm({
-    runId: 'temp-run',
-    arm: 'B',
-    outDir: tmp,
-    gitShowFn: fakeGitShow,
-    now: () => '2026-09-20T12:00:00.000Z',
-  });
-
-  const armDir = path.join(tmp, 'arm-B');
-  assert.ok(fs.existsSync(path.join(armDir, 'boot_prompt.md')));
-  assert.ok(fs.existsSync(path.join(armDir, 'probe_1.md')));
-  assert.ok(fs.existsSync(path.join(armDir, 'probe_2.md')));
-  assert.ok(fs.existsSync(path.join(armDir, 'manifest.json')));
-
-  const bootPrompt = fs.readFileSync(path.join(armDir, 'boot_prompt.md'), 'utf8');
-  assert.match(bootPrompt, /FAKE ANSUZ\.MD for 1845c7e6b/);
-  assert.match(bootPrompt, /fake_elixir: true # 1845c7e6b/);
-
-  const onDisk = JSON.parse(fs.readFileSync(path.join(armDir, 'manifest.json'), 'utf8'));
-  assert.deepEqual(onDisk, manifest);
-  assert.equal(manifest.files['.claude/commands/Ansuz.md'], mod.byteLength(`FAKE ANSUZ.MD for 1845c7e6b`));
-  assert.equal(manifest.generated_at, '2026-09-20T12:00:00.000Z');
-
-  fs.rmSync(tmp, { recursive: true, force: true });
-});
-
-test('prepareArm rejects an unknown arm before touching the filesystem', () => {
-  const tmp = makeTempDir();
-  assert.throws(
-    () =>
-      mod.prepareArm({
-        runId: 'temp-run',
-        arm: 'D',
-        outDir: tmp,
-        gitShowFn: () => 'unused',
-      }),
-    /unknown arm/
-  );
-  assert.deepEqual(fs.readdirSync(tmp), []);
-  fs.rmSync(tmp, { recursive: true, force: true });
-});
-
-test('readMeasurementsForRun + summarizeRows produce per-arm counts (not only percentages)', () => {
-  const tmp = makeTempDir();
-  const measurementsFile = path.join(tmp, 'measurements.jsonl');
-  const rows = [
-    mod.buildMeasurementLine({
-      run_id: 'run-x', arm: 'A', ref: '5562fface', probe: 1,
-      acceptance_met: true, recall_reflex_fired: false, scope_verified_before_carding: null,
-      unauthorized_change: false, false_completion: false, turns: 3, tool_calls: 2, wall_ms: 10000, injected_bytes: 500,
-    }),
-    mod.buildMeasurementLine({
-      run_id: 'run-x', arm: 'A', ref: '5562fface', probe: 2,
-      acceptance_met: false, recall_reflex_fired: null, scope_verified_before_carding: false,
-      unauthorized_change: true, false_completion: true, turns: 5, tool_calls: 8, wall_ms: 30000, injected_bytes: 500,
-    }),
-    mod.buildMeasurementLine({
-      run_id: 'run-x', arm: 'C', ref: 'a2956ed25', probe: 1,
-      acceptance_met: true, recall_reflex_fired: true, scope_verified_before_carding: null,
-      unauthorized_change: false, false_completion: false, turns: 2, tool_calls: 1, wall_ms: 8000, injected_bytes: 200,
-    }),
-    // Different run_id — must be excluded by readMeasurementsForRun.
-    mod.buildMeasurementLine({
-      run_id: 'run-y', arm: 'B', ref: '1845c7e6b', probe: 1,
-      acceptance_met: true, recall_reflex_fired: true, scope_verified_before_carding: null,
-      unauthorized_change: false, false_completion: false, turns: 1, tool_calls: 1, wall_ms: 1000, injected_bytes: 100,
-    }),
-  ];
-  fs.writeFileSync(measurementsFile, rows.map((r) => JSON.stringify(r)).join('\n') + '\n', 'utf8');
-  // A malformed trailing line must not crash the reader.
-  fs.appendFileSync(measurementsFile, 'not json\n', 'utf8');
-
-  const read = mod.readMeasurementsForRun('run-x', measurementsFile);
-  assert.equal(read.length, 3, 'must only include run-x rows and skip the malformed line');
-
-  const summary = mod.summarizeRows(read);
-  assert.equal(summary.A.n, 2);
-  assert.equal(summary.A.acceptance_met.true, 1);
-  assert.equal(summary.A.acceptance_met.false, 1);
-  assert.equal(summary.A.recall_reflex_fired.na, 1, 'null counts as N/A, not false');
-  assert.equal(summary.C.n, 1);
-  assert.equal(summary.C.acceptance_met.true, 1);
-  assert.equal(summary.B.n, 0, 'B has zero rows for run-x even though it exists for run-y');
-  assert.equal(summary.A.avg_turns, 4);
-
-  fs.rmSync(tmp, { recursive: true, force: true });
-});

package/core/dev/scripts/probe/hook-latency-probe.js

@@ -1,315 +0,0 @@
-#!/usr/bin/env node
-// TASK_1979 R3/R4: hook latency + prompt-cache stability probe.
-//
-// Measures every hook .claude/settings.json registers for UserPromptSubmit
-// and PreToolUse (parsed from settings.json, not hand-listed) against the
-// PROJECT copy of .claude/hooks — never the installed kenaz-core copy — by
-// running each hook file directly (`node <hook>.js` with CLAUDE_PROJECT_DIR
-// set to the repo root and a synthetic JSON payload on stdin), 5x each,
-// plus a `node -e 0` floor measurement.
-//
-// Why invoke the hook file directly instead of re-running the exact
-// `node -e "..."` wrapper string from settings.json: that wrapper string is
-// shell-quoted for the harness's own (POSIX-shell-like) hook launcher: see
-// rune_claude_code_hook_execution_cwd — hooks run with cwd = project dir).
-// Shelling it out again here via child_process shell:true would go through
-// this machine's OS-default shell (cmd.exe on Windows) whose quoting rules
-// differ, which is a probe-validity bug of its own kind (feedback:
-// monitor_must_validate_its_own_probe / harness_must_run_the_real_validator).
-// The wrapper's only job is `process.chdir(d); require(d+'/.claude/hooks/X.js')`
-// — no hook file in this repo gates its stdin-reading main() behind a
-// `require.main === module` guard (checked: task-bridge.js,
-// turn-context.js all run unconditionally on require/execute), and all
-// relative `require('./_x')` calls inside a hook resolve via __dirname, not
-// cwd — so invoking the .js file directly with CLAUDE_PROJECT_DIR set is
-// behaviorally equivalent and avoids the quoting hazard entirely.
-//
-// Usage:
-//   node dev/scripts/probe/hook-latency-probe.js [--runs 5] [--out-dir <dir>]
-//
-// Writes .kenaz/experiments/ansuz_boot_split/hook-latency-<timestamp>.json
-// and prints a latency + cache-stability table to stdout.
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
-const SETTINGS_PATH = path.join(REPO_ROOT, '.claude', 'settings.json');
-const EXPERIMENT_DIR = path.join(REPO_ROOT, '.kenaz', 'experiments', 'ansuz_boot_split');
-const HOOK_TIMEOUT_MS = 30000;
-
-// ═══════════════════════════════════════
-//  settings.json parsing (pure — takes the parsed object, not the path)
-// ═══════════════════════════════════════
-
-function extractHookFilename(command) {
-  const m = /hooks\/([A-Za-z0-9_.-]+\.js)/.exec(command || '');
-  return m ? m[1] : null;
-}
-
-function collectHookEntries(settings) {
-  const hooks = settings && settings.hooks ? settings.hooks : {};
-  const out = { UserPromptSubmit: [], PreToolUse: [] };
-
-  for (const group of hooks.UserPromptSubmit || []) {
-    for (const h of group.hooks || []) {
-      const file = extractHookFilename(h.command);
-      if (file) out.UserPromptSubmit.push({ event: 'UserPromptSubmit', file, matcher: group.matcher || null, command: h.command });
-    }
-  }
-  for (const group of hooks.PreToolUse || []) {
-    for (const h of group.hooks || []) {
-      const file = extractHookFilename(h.command);
-      if (file) out.PreToolUse.push({ event: 'PreToolUse', file, matcher: group.matcher || null, command: h.command });
-    }
-  }
-  return out;
-}
-
-// ═══════════════════════════════════════
-//  Synthetic payloads (R3)
-// ═══════════════════════════════════════
-
-function buildPayload(entry, repoRoot, sessionId) {
-  if (entry.event === 'UserPromptSubmit') {
-    return { session_id: sessionId, hook_event_name: 'UserPromptSubmit', cwd: repoRoot, prompt: 'hello' };
-  }
-  // PreToolUse
-  const matcher = entry.matcher || '';
-  if (matcher === 'Read') {
-    return {
-      session_id: sessionId,
-      hook_event_name: 'PreToolUse',
-      tool_name: 'Read',
-      tool_input: { file_path: path.join(repoRoot, 'CLAUDE.md') },
-      cwd: repoRoot,
-    };
-  }
-  if (/Edit|Write/.test(matcher)) {
-    return {
-      session_id: sessionId,
-      hook_event_name: 'PreToolUse',
-      tool_name: 'Edit',
-      tool_input: {
-        file_path: path.join(repoRoot, 'CLAUDE.md'),
-        old_string: '__hook_latency_probe_nonexistent_string__',
-        new_string: '__hook_latency_probe_nonexistent_string__',
-      },
-      cwd: repoRoot,
-    };
-  }
-  // Bash (default/fallback)
-  return {
-    session_id: sessionId,
-    hook_event_name: 'PreToolUse',
-    tool_name: 'Bash',
-    tool_input: { command: 'ls' },
-    cwd: repoRoot,
-  };
-}
-
-// ═══════════════════════════════════════
-//  Runner (impure — spawns child processes)
-// ═══════════════════════════════════════
-
-function runOnce(scriptPath, payload, repoRoot) {
-  const start = Date.now();
-  const result = spawnSync(process.execPath, [scriptPath], {
-    cwd: repoRoot,
-    env: { ...process.env, CLAUDE_PROJECT_DIR: repoRoot },
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    timeout: HOOK_TIMEOUT_MS,
-    maxBuffer: 16 * 1024 * 1024,
-  });
-  const ms = Date.now() - start;
-  return {
-    ms,
-    stdout: result.stdout || '',
-    stderr: result.stderr || '',
-    status: result.status,
-    timedOut: !!result.error && result.error.code === 'ETIMEDOUT',
-    error: result.error ? result.error.message : null,
-  };
-}
-
-function runFloorOnce() {
-  const start = Date.now();
-  const result = spawnSync(process.execPath, ['-e', '0'], {
-    encoding: 'utf8',
-    timeout: HOOK_TIMEOUT_MS,
-  });
-  const ms = Date.now() - start;
-  return { ms, status: result.status, error: result.error ? result.error.message : null };
-}
-
-function median(nums) {
-  const vals = nums.filter((n) => typeof n === 'number' && !Number.isNaN(n)).slice().sort((a, b) => a - b);
-  if (!vals.length) return null;
-  const mid = Math.floor(vals.length / 2);
-  return vals.length % 2 ? vals[mid] : Math.round((vals[mid - 1] + vals[mid]) / 2);
-}
-
-function byteLength(str) {
-  return Buffer.byteLength(str || '', 'utf8');
-}
-
-// R4: cache-stability diff summary between two stdout captures.
-function diffSummary(a, b) {
-  if (a === b) return null;
-  const len = Math.min(a.length, b.length);
-  let i = 0;
-  while (i < len && a[i] === b[i]) i++;
-  return {
-    first_diff_byte_offset: i,
-    a_len: a.length,
-    b_len: b.length,
-    a_context: a.slice(Math.max(0, i - 20), i + 40),
-    b_context: b.slice(Math.max(0, i - 20), i + 40),
-  };
-}
-
-function measureHook(entry, repoRoot, runs) {
-  const scriptPath = path.join(repoRoot, '.claude', 'hooks', entry.file);
-  const sessionId = 'abl-hook-latency-1'; // fixed across ALL runs — required for R4 cache-stability comparison
-  const samples = [];
-  for (let i = 0; i < runs; i++) {
-    const payload = buildPayload(entry, repoRoot, sessionId);
-    samples.push(runOnce(scriptPath, payload, repoRoot));
-  }
-
-  const msValues = samples.map((s) => s.ms);
-  const stdoutBytes = samples.map((s) => byteLength(s.stdout));
-  const nonZeroExit = samples.filter((s) => s.status !== 0).length;
-  const timeouts = samples.filter((s) => s.timedOut).length;
-
-  const row = {
-    event: entry.event,
-    hook: entry.file,
-    matcher: entry.matcher,
-    runs,
-    median_ms: median(msValues),
-    median_stdout_bytes: median(stdoutBytes),
-    all_ms: msValues,
-    nonzero_exit_count: nonZeroExit,
-    timeout_count: timeouts,
-  };
-
-  if (entry.event === 'UserPromptSubmit') {
-    const distinct = new Set(samples.map((s) => s.stdout));
-    row.cache_stable = distinct.size === 1;
-    if (!row.cache_stable) {
-      const outs = samples.map((s) => s.stdout);
-      row.cache_diff = diffSummary(outs[0], outs[1]);
-      row.distinct_stdout_variants = distinct.size;
-    }
-  } else {
-    row.cache_stable = null; // N/A per R4 (UserPromptSubmit-only)
-  }
-
-  return row;
-}
-
-// ═══════════════════════════════════════
-//  CLI
-// ═══════════════════════════════════════
-
-function parseArgs(argv) {
-  const opts = { runs: 5, outDir: EXPERIMENT_DIR };
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    const next = () => argv[++i];
-    if (a === '--runs') opts.runs = parseInt(next(), 10);
-    else if (a === '--out-dir') opts.outDir = next();
-  }
-  return opts;
-}
-
-function printTable(rows, floor) {
-  console.log('\nHook latency + cache-stability probe (project-copy .claude/hooks only)\n');
-  console.log(`node -e 0 floor: median ${median(floor.map((f) => f.ms))} ms over ${floor.length} runs`);
-  console.log('');
-  const header = ['event', 'hook', 'matcher', 'median_ms', 'median_stdout_B', 'nonzero_exit', 'timeouts', 'cache_stable'];
-  console.log(header.join(' | '));
-  for (const r of rows) {
-    console.log(
-      [
-        r.event,
-        r.hook,
-        r.matcher || '-',
-        r.median_ms,
-        r.median_stdout_bytes,
-        r.nonzero_exit_count,
-        r.timeout_count,
-        r.cache_stable === null ? 'N/A' : r.cache_stable,
-      ].join(' | ')
-    );
-  }
-  const unstable = rows.filter((r) => r.cache_stable === false);
-  if (unstable.length) {
-    console.log('\nCache-INSTABLE UserPromptSubmit hooks (byte-diff summary):');
-    for (const r of unstable) {
-      console.log(`  ${r.hook}: ${r.distinct_stdout_variants} distinct stdout variants across ${r.runs} runs`);
-      console.log(`    first diff @ byte ${r.cache_diff.first_diff_byte_offset} (len ${r.cache_diff.a_len} vs ${r.cache_diff.b_len})`);
-    }
-  }
-}
-
-function main(argv) {
-  const opts = parseArgs(argv);
-  if (!fs.existsSync(SETTINGS_PATH)) {
-    throw new Error(`settings.json not found at ${SETTINGS_PATH}`);
-  }
-  const settings = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf8'));
-  const entries = collectHookEntries(settings);
-  const allEntries = [...entries.UserPromptSubmit, ...entries.PreToolUse];
-
-  const floor = [];
-  for (let i = 0; i < opts.runs; i++) floor.push(runFloorOnce());
-
-  const rows = allEntries.map((entry) => measureHook(entry, REPO_ROOT, opts.runs));
-
-  printTable(rows, floor);
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  fs.mkdirSync(opts.outDir, { recursive: true });
-  const outPath = path.join(opts.outDir, `hook-latency-${timestamp}.json`);
-  const report = {
-    generated_at: new Date().toISOString(),
-    repo_root: REPO_ROOT,
-    runs: opts.runs,
-    node_floor_ms: floor.map((f) => f.ms),
-    node_floor_median_ms: median(floor.map((f) => f.ms)),
-    hooks: rows,
-  };
-  fs.writeFileSync(outPath, JSON.stringify(report, null, 2), 'utf8');
-  console.log(`\nWrote ${outPath}`);
-  return report;
-}
-
-if (require.main === module) {
-  try {
-    main(process.argv.slice(2));
-  } catch (e) {
-    console.error(`Error: ${e.message}`);
-    process.exitCode = 1;
-  }
-}
-
-module.exports = {
-  extractHookFilename,
-  collectHookEntries,
-  buildPayload,
-  median,
-  byteLength,
-  diffSummary,
-  measureHook,
-  runOnce,
-  runFloorOnce,
-  REPO_ROOT,
-  SETTINGS_PATH,
-  EXPERIMENT_DIR,
-};

package/core/dev/scripts/probe/hook-latency-probe.test.js

@@ -1,105 +0,0 @@
-#!/usr/bin/env node
-// TASK_1979: unit tests for hook-latency-probe.js's pure functions
-// (settings.json parsing, payload building, median, diff summary).
-// No child_process spawning here — that part is exercised manually via
-// `node dev/scripts/probe/hook-latency-probe.js` against the live repo.
-//
-// Run: node --test dev/scripts/probe/hook-latency-probe.test.js
-
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const mod = require('./hook-latency-probe.js');
-
-test('extractHookFilename pulls the .js basename out of a node -e wrapper command', () => {
-  const cmd = "node -e \"const d=process.env.CLAUDE_PROJECT_DIR;process.chdir(d);require(d+'/.claude/hooks/task-bridge.js')\"";
-  assert.equal(mod.extractHookFilename(cmd), 'task-bridge.js');
-});
-
-test('extractHookFilename returns null for a command with no hooks/*.js reference', () => {
-  assert.equal(mod.extractHookFilename('echo hello'), null);
-  assert.equal(mod.extractHookFilename(''), null);
-  assert.equal(mod.extractHookFilename(undefined), null);
-});
-
-test('collectHookEntries extracts UserPromptSubmit and PreToolUse entries with matchers, ignoring other events', () => {
-  const settings = {
-    hooks: {
-      UserPromptSubmit: [
-        { hooks: [{ type: 'command', command: "require(d+'/.claude/hooks/turn-context.js')" }] },
-        { hooks: [{ type: 'command', command: "require(d+'/.claude/hooks/task-bridge.js')" }] },
-      ],
-      PreToolUse: [
-        { matcher: 'Read', hooks: [{ type: 'command', command: "require(d+'/.claude/hooks/memory-guard.js')" }] },
-        { matcher: 'Edit|Write', hooks: [{ type: 'command', command: "require(d+'/.claude/hooks/stream-delta.js')" }] },
-        { matcher: 'Bash', hooks: [{ type: 'command', command: "require(d+'/.claude/hooks/synapse-first-investigation.js')" }] },
-      ],
-      PostToolUse: [
-        { matcher: 'Bash', hooks: [{ type: 'command', command: "require(d+'/.claude/hooks/handoff-snapshot-on-commit.js')" }] },
-      ],
-      Stop: [
-        { hooks: [{ type: 'command', command: "require('.specialist/tools/session.js')" }] },
-      ],
-    },
-  };
-  const entries = mod.collectHookEntries(settings);
-  assert.equal(entries.UserPromptSubmit.length, 2);
-  assert.deepEqual(
-    entries.UserPromptSubmit.map((e) => e.file),
-    ['turn-context.js', 'task-bridge.js']
-  );
-  assert.equal(entries.PreToolUse.length, 3);
-  assert.deepEqual(
-    entries.PreToolUse.map((e) => ({ file: e.file, matcher: e.matcher })),
-    [
-      { file: 'memory-guard.js', matcher: 'Read' },
-      { file: 'stream-delta.js', matcher: 'Edit|Write' },
-      { file: 'synapse-first-investigation.js', matcher: 'Bash' },
-    ]
-  );
-  // PostToolUse/Stop must not leak in — only UserPromptSubmit + PreToolUse are in scope (R3).
-  assert.equal(entries.PostToolUse, undefined);
-  assert.equal(entries.Stop, undefined);
-});
-
-test('buildPayload matches the R3 example shape for UserPromptSubmit and PreToolUse Bash', () => {
-  const ups = mod.buildPayload({ event: 'UserPromptSubmit' }, '/repo', 'abl-1');
-  assert.deepEqual(ups, { session_id: 'abl-1', hook_event_name: 'UserPromptSubmit', cwd: '/repo', prompt: 'hello' });
-
-  const bash = mod.buildPayload({ event: 'PreToolUse', matcher: 'Bash' }, '/repo', 'abl-1');
-  assert.equal(bash.tool_name, 'Bash');
-  assert.deepEqual(bash.tool_input, { command: 'ls' });
-});
-
-test('buildPayload gives Read a file_path and Edit|Write an editable file_path + strings', () => {
-  const read = mod.buildPayload({ event: 'PreToolUse', matcher: 'Read' }, '/repo', 'abl-1');
-  assert.equal(read.tool_name, 'Read');
-  assert.match(read.tool_input.file_path, /CLAUDE\.md$/);
-
-  const edit = mod.buildPayload({ event: 'PreToolUse', matcher: 'Edit|Write' }, '/repo', 'abl-1');
-  assert.equal(edit.tool_name, 'Edit');
-  assert.ok('old_string' in edit.tool_input && 'new_string' in edit.tool_input);
-});
-
-test('median handles empty, single, even, and odd arrays', () => {
-  assert.equal(mod.median([]), null);
-  assert.equal(mod.median([5]), 5);
-  assert.equal(mod.median([1, 2, 3]), 2);
-  assert.equal(mod.median([1, 2, 3, 4]), 3); // rounds (2+3)/2
-  assert.equal(mod.median([NaN, 1, 2, 3]), 2, 'non-numeric values are filtered out');
-});
-
-test('diffSummary returns null for identical strings and a byte-offset summary otherwise', () => {
-  assert.equal(mod.diffSummary('abc', 'abc'), null);
-  const diff = mod.diffSummary('hello world', 'hello there');
-  assert.equal(diff.first_diff_byte_offset, 6);
-  assert.equal(diff.a_len, 11);
-  assert.equal(diff.b_len, 11);
-});
-
-test('byteLength counts UTF-8 bytes, not JS string length, for multi-byte content', () => {
-  assert.equal(mod.byteLength('abc'), 3);
-  assert.ok(mod.byteLength('你好') > 2, 'CJK chars are >1 byte each in UTF-8');
-});