@devrik-tools/claude-gates 0.2.0 → 0.3.0

package/plugins/gates/hooks/gates/test-matrix/test.mjs

@@ -1,114 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-function runGate(payload, { config } = {}) {
-  const project = mkdtempSync(join(tmpdir(), 'test-matrix-'));
-  mkdirSync(join(project, '.git'));
-  if (config) {
-    mkdirSync(join(project, '.ai'));
-    writeFileSync(join(project, '.ai', 'config.json'), JSON.stringify(config));
-  }
-  const out = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    // Isolate from the user's real global config: point homedir() at the temp
-    // project so the global-config fallback finds nothing (registry default).
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return out.trim() ? JSON.parse(out.trim()) : null;
-}
-
-function delegate(prompt, subagentType = 'backend') {
-  return {
-    tool_name: 'Agent',
-    tool_input: { prompt, subagent_type: subagentType },
-  };
-}
-
-function isDeny(result) {
-  return result?.hookSpecificOutput?.permissionDecision === 'deny';
-}
-
-function enabledConfig(extraParameters) {
-  return {
-    gates: {
-      requireTestMatrixWhenImplementing: extraParameters
-        ? { enabled: true, ...extraParameters }
-        : true,
-    },
-  };
-}
-
-test('disabled by default: a money-touching brief with no test matrix is allowed', () => {
-  const prompt = 'Nivel: STANDARD\nImplementá el cobro de la cuota.';
-  assert.equal(runGate(delegate(prompt)), null);
-});
-
-test('denies missing unit/mutation on a plain brief with no test type declared', () => {
-  const prompt = 'Nivel: STANDARD\nImplementá el checkout.';
-  assert.ok(isDeny(runGate(delegate(prompt), { config: enabledConfig() })));
-});
-
-test('denies missing E2E when the brief touches money and only declares unit tests', () => {
-  const prompt =
-    'Nivel: STANDARD\nImplementá el cobro de la cuota. Verificación: vitest cubre el cálculo.';
-  assert.ok(isDeny(runGate(delegate(prompt), { config: enabledConfig() })));
-});
-
-test('allows a brief that declares unit, E2E and negative cases for a money domain', () => {
-  const prompt =
-    'Nivel: STANDARD\nImplementá el cobro de la cuota. ' +
-    'Verificación: vitest cubre el cálculo. E2E: flujo completo de cobro. ' +
-    'Casos negativos: monto cero, sin saldo, error de red.';
-  assert.equal(runGate(delegate(prompt), { config: enabledConfig() }), null);
-});
-
-test('exempt subagent type (qa) is never held to the matrix requirement', () => {
-  const prompt = 'Nivel: STANDARD\nImplementá el cobro de la cuota.';
-  assert.equal(
-    runGate(delegate(prompt, 'qa'), { config: enabledConfig() }),
-    null,
-  );
-});
-
-test('denies missing E2E for a Spanish money brief (cobro/saldo/cuota), not just its English equivalent', () => {
-  const prompt =
-    'Nivel: STANDARD\nImplementá el cobro de la cuota. Verificación: vitest cubre el cálculo.';
-  const result = runGate(delegate(prompt), { config: enabledConfig() });
-  assert.ok(isDeny(result));
-  assert.ok(result.hookSpecificOutput.permissionDecisionReason.includes('E2E'));
-});
-
-test('bilingual control: an EN money brief with only unit coverage denies for the same reason as its ES equivalent', () => {
-  const es = 'Nivel: STANDARD\nImplementá el cobro de la cuota. Verificación: vitest cubre el cálculo.';
-  const en = 'Level: STANDARD\nImplement the fee charge. Verification: vitest covers the calculation.';
-  const resultEs = runGate(delegate(es), { config: enabledConfig() });
-  const resultEn = runGate(delegate(en), { config: enabledConfig() });
-  assert.ok(isDeny(resultEs));
-  assert.ok(isDeny(resultEn));
-  assert.ok(resultEs.hookSpecificOutput.permissionDecisionReason.includes('E2E'));
-  assert.ok(resultEn.hookSpecificOutput.permissionDecisionReason.includes('E2E'));
-});
-
-test('allows a Spanish brief that declares unit, E2E and negative cases with Spanish wording', () => {
-  const prompt =
-    'Nivel: STANDARD\nImplementá el cobro de la cuota. ' +
-    'Verificación: pruebas unitarias cubren el calculo. E2E: flujo completo de cobro. ' +
-    'Casos negativos: monto cero, sin saldo, entrada invalida.';
-  assert.equal(runGate(delegate(prompt), { config: enabledConfig() }), null);
-});
-
-test('e2eSignals param override makes a domain word mandatory that the default list omits', () => {
-  const prompt =
-    'Nivel: STANDARD\nImplementá el módulo de inventario. Verificación: vitest cubre el cálculo.';
-  const config = enabledConfig({ e2eSignals: ['inventario|inventory'] });
-  assert.ok(isDeny(runGate(delegate(prompt), { config })));
-});

package/plugins/gates/hooks/gates/tool-map/edge.edge.test.mjs

@@ -1,62 +0,0 @@
-// Edge-case probe for tool-map. Previously the same Edit/new_string content-field gap
-// as feature-catalog/sdd-specs meant a legitimately-audited tool created/edited via
-// Edit's `new_string` was never recorded in .ai/tool-map.json, so reuse-before-build
-// kept re-blocking a tool that was already cleared once. Migrated to
-// writtenContentOf()/writtenPathOf() (hook-io.mjs), which read new_string, so this is
-// now recorded the same as a Write.
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-function runGate(payload) {
-  const project = mkdtempSync(join(tmpdir(), 'tool-map-edge-'));
-  mkdirSync(join(project, '.git'));
-  mkdirSync(join(project, '.ai'));
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify({ gates: { maintainToolMap: true } }),
-  );
-  execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return { mapPath: join(project, '.ai', 'tool-map.json') };
-}
-
-test('FIXED: an audited tool written via Edit (new_string) is now recorded', () => {
-  const payload = {
-    tool_name: 'Edit',
-    tool_input: {
-      file_path: 'scripts/new-tool.mjs',
-      old_string: '',
-      new_string: '// audited: nothing does this\nexport function parse(){}',
-    },
-  };
-  const { mapPath } = runGate(payload);
-  assert.ok(
-    existsSync(mapPath),
-    'writtenContentOf must read new_string so an Edit-created tool is persisted',
-  );
-  const map = JSON.parse(readFileSync(mapPath, 'utf8'));
-  assert.equal(map.tools[0].path, 'scripts/new-tool.mjs');
-});
-
-test('OK: the equivalent Write-tool payload IS recorded (control)', () => {
-  const payload = {
-    tool_name: 'Write',
-    tool_input: {
-      file_path: 'scripts/new-tool.mjs',
-      content: '// audited: nothing does this\nexport function parse(){}',
-    },
-  };
-  const { mapPath } = runGate(payload);
-  assert.ok(existsSync(mapPath), 'control failed');
-});

package/plugins/gates/hooks/gates/tool-map/test.mjs

@@ -1,87 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import {
-  mkdtempSync,
-  mkdirSync,
-  writeFileSync,
-  existsSync,
-  readFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-// Runs the gate in a temp project (with .git). The gate is off by default, so config
-// enables it. Returns { output, mapPath, project } so a test can inspect the written map.
-function runGate(payload, { config } = {}) {
-  const project = mkdtempSync(join(tmpdir(), 'tool-map-'));
-  mkdirSync(join(project, '.git'));
-  mkdirSync(join(project, '.ai'));
-  const effectiveConfig = config ?? { gates: { maintainToolMap: true } };
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify(effectiveConfig),
-  );
-  const output = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    // Isolate from the user's real global config: point homedir() at the temp
-    // project so the global-config fallback finds nothing (registry default).
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return {
-    output: output.trim(),
-    mapPath: join(project, '.ai', 'tool-map.json'),
-  };
-}
-
-function writeTool(filePath, content) {
-  return { tool_name: 'Write', tool_input: { file_path: filePath, content } };
-}
-
-test('records a new tool that declares its audit', () => {
-  const { mapPath } = runGate(
-    writeTool(
-      'scripts/csv-parser.mjs',
-      '// Justification: no existing tool covers this.\nexport {}',
-    ),
-  );
-  assert.ok(existsSync(mapPath));
-  const map = JSON.parse(readFileSync(mapPath, 'utf8'));
-  assert.equal(map.tools.length, 1);
-  assert.equal(map.tools[0].path, 'scripts/csv-parser.mjs');
-  assert.match(map.tools[0].audit, /no existing tool/i);
-});
-
-test('does not record a tool without an audit line', () => {
-  const { mapPath } = runGate(
-    writeTool('scripts/thing.mjs', 'export function thing() {}'),
-  );
-  assert.ok(!existsSync(mapPath));
-});
-
-test('ignores a non-tool write', () => {
-  const { mapPath } = runGate(writeTool('docs/readme.md', 'audited: hi'));
-  assert.ok(!existsSync(mapPath));
-});
-
-test('does not duplicate an already-recorded tool', () => {
-  // Two writes of the same tool path record it once.
-  const first = runGate(
-    writeTool('scripts/x.mjs', '// audited: nothing does this\nexport {}'),
-  );
-  const map = JSON.parse(readFileSync(first.mapPath, 'utf8'));
-  assert.equal(map.tools.length, 1);
-});
-
-test('disabled by config: does not record', () => {
-  const { mapPath } = runGate(
-    writeTool('scripts/y.mjs', '// audited: none\nexport {}'),
-    { config: { gates: { maintainToolMap: false } } },
-  );
-  assert.ok(!existsSync(mapPath));
-});

package/plugins/gates/hooks/lib/__tests__/config.test.mjs

@@ -1,173 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { test } from 'node:test';
-import { isGateEnabled, gateParameters } from '../config.mjs';
-
-const GATE_KEY = 'blockDestructiveShellCommands';
-
-function temporaryDirectory() {
-  return mkdtempSync(join(tmpdir(), 'claude-gates-config-'));
-}
-
-/** A project directory with a .git marker so config.mjs finds a project root. */
-function projectDirectory() {
-  const root = temporaryDirectory();
-  mkdirSync(join(root, '.git'));
-  return root;
-}
-
-function writeProjectConfig(root, config) {
-  mkdirSync(join(root, '.ai'), { recursive: true });
-  writeFileSync(join(root, '.ai', 'config.json'), JSON.stringify(config));
-}
-
-function writeGlobalConfig(home, config) {
-  const directory = join(home, '.claude', 'claude-gates');
-  mkdirSync(directory, { recursive: true });
-  writeFileSync(join(directory, 'config.json'), JSON.stringify(config));
-}
-
-test('isGateEnabled falls back to the registry default when no config exists anywhere', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), true);
-  assert.equal(isGateEnabled(GATE_KEY, false, project, { home }), false);
-});
-
-test('isGateEnabled reads a bool shorthand entry from the project config', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeProjectConfig(project, { gates: { [GATE_KEY]: false } });
-  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), false);
-
-  const projectTrue = projectDirectory();
-  writeProjectConfig(projectTrue, { gates: { [GATE_KEY]: true } });
-  assert.equal(isGateEnabled(GATE_KEY, false, projectTrue, { home }), true);
-});
-
-test('isGateEnabled reads an object entry with an explicit enabled flag', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeProjectConfig(project, {
-    gates: { [GATE_KEY]: { enabled: false, someParam: 'x' } },
-  });
-  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), false);
-});
-
-test('isGateEnabled treats an object entry with no enabled field as silent (uses registry default)', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeProjectConfig(project, {
-    gates: { [GATE_KEY]: { someParam: 'x' } },
-  });
-  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), true);
-  assert.equal(isGateEnabled(GATE_KEY, false, project, { home }), false);
-});
-
-test('isGateEnabled falls back to the global config when the project declares nothing', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeGlobalConfig(home, { gates: { [GATE_KEY]: false } });
-  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), false);
-});
-
-test('isGateEnabled: an existing project config wins over the global config even if silent about this gate', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeGlobalConfig(home, { gates: { [GATE_KEY]: false } });
-  writeProjectConfig(project, { gates: {} });
-  // Project config exists (even without this gate declared): registry default wins,
-  // global's false must NOT leak through.
-  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), true);
-});
-
-test('isGateEnabled: corrupt project config is treated as absent and falls through to global', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  mkdirSync(join(project, '.ai'), { recursive: true });
-  writeFileSync(join(project, '.ai', 'config.json'), '{not valid json');
-  writeGlobalConfig(home, { gates: { [GATE_KEY]: false } });
-  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), false);
-});
-
-test('isGateEnabled: a malformed entry (string/number) is ignored, falls back to registry default', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeProjectConfig(project, { gates: { [GATE_KEY]: 'yes' } });
-  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), true);
-  assert.equal(isGateEnabled(GATE_KEY, false, project, { home }), false);
-
-  const projectNumber = projectDirectory();
-  writeProjectConfig(projectNumber, { gates: { [GATE_KEY]: 1 } });
-  assert.equal(isGateEnabled(GATE_KEY, false, projectNumber, { home }), false);
-});
-
-test('gateParameters returns {} when nothing is declared for the gate', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeProjectConfig(project, { gates: {} });
-  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {});
-});
-
-test('gateParameters returns {} for a bool shorthand entry (no params, just enabled)', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeProjectConfig(project, { gates: { [GATE_KEY]: true } });
-  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {});
-});
-
-test('gateParameters strips enabled and returns the remaining params from the project config', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeProjectConfig(project, {
-    gates: {
-      [GATE_KEY]: { enabled: true, protectedPaths: ['a', 'b'] },
-    },
-  });
-  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {
-    protectedPaths: ['a', 'b'],
-  });
-});
-
-test('gateParameters: project params replace (do not merge with) global params', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  writeGlobalConfig(home, {
-    gates: {
-      [GATE_KEY]: { protectedPaths: ['global-a'], extra: 'g' },
-    },
-  });
-  writeProjectConfig(project, {
-    gates: { [GATE_KEY]: { protectedPaths: ['project-a'] } },
-  });
-  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {
-    protectedPaths: ['project-a'],
-  });
-});
-
-test('gateParameters returns {} when no config exists anywhere', () => {
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {});
-});
-
-test('a project config saved WITH a UTF-8 BOM is still read (not silently dropped)', () => {
-  // A BOM is what a Windows editor or PowerShell 5.1 `Set-Content -Encoding utf8` prepends.
-  // Before the fix, JSON.parse threw on the leading BOM, the project config was treated as
-  // absent, and its gate disables were silently ignored (falling through to global/registry).
-  // Here the project disables the gate; the BOM must not resurrect it.
-  const project = projectDirectory();
-  const home = temporaryDirectory();
-  mkdirSync(join(project, '.ai'), { recursive: true });
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    '' + JSON.stringify({ gates: { [GATE_KEY]: { enabled: false } } }),
-  );
-  assert.equal(
-    isGateEnabled(GATE_KEY, true, project, { home }),
-    false,
-    'the BOM-prefixed project disable must take effect',
-  );
-});

package/plugins/gates/hooks/lib/__tests__/hook-io.test.mjs

@@ -1,210 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { test } from 'node:test';
-import { pathToFileURL } from 'node:url';
-import {
-  toolNamesFor,
-  matcherFor,
-  toolNameOf,
-  sessionIdOf,
-  toolInputOf,
-  toolInGroups,
-  writtenContentOf,
-  writtenPathOf,
-  delegationPromptOf,
-} from '../hook-io.mjs';
-
-// deny/warn/allow/runGate call process.exit and cannot be invoked in-process without
-// killing the test runner. They are exercised here as a child process instead; each
-// gate's own tests additionally cover runGate's wiring through its real check function.
-
-test('toolNamesFor expands a single group', () => {
-  assert.deepEqual(toolNamesFor(['question']), ['AskUserQuestion']);
-});
-
-test('toolNamesFor expands multiple groups and de-duplicates overlapping names', () => {
-  const names = toolNamesFor(['write', 'execution']);
-  // 'execution' repeats every 'write' tool plus Bash/run_command/mcp__ide__executeCode.
-  assert.equal(names.filter((name) => name === 'Write').length, 1);
-  assert.ok(names.includes('Write'));
-  assert.ok(names.includes('Bash'));
-  assert.ok(names.includes('mcp__ide__executeCode'));
-});
-
-test('toolNamesFor returns an empty list for an empty group set', () => {
-  assert.deepEqual(toolNamesFor([]), []);
-});
-
-test('toolNamesFor ignores an unknown group name', () => {
-  assert.deepEqual(toolNamesFor(['not-a-real-group']), []);
-});
-
-test('matcherFor joins native tool names with a pipe and always appends the mcp__.* clause', () => {
-  // The trailing `mcp__.*` makes Claude Code route EVERY MCP tool call to the hook, so the
-  // gate can classify it at runtime with toolInGroups. Without it, the hook is never even
-  // invoked for an MCP tool — the deepest layer of the MCP blind spot.
-  assert.equal(matcherFor(['question']), 'AskUserQuestion|mcp__.*');
-  assert.equal(matcherFor(['shell']), 'Bash|run_command|mcp__.*');
-});
-
-test('matcherFor still matches MCP tools even for an empty native group set', () => {
-  // An empty group means "no native names", but MCP tools must still reach the hook.
-  assert.equal(matcherFor([]), 'mcp__.*');
-});
-
-test('toolInGroups matches native names exactly and case-insensitively', () => {
-  assert.equal(toolInGroups('Write', ['write']), true);
-  assert.equal(toolInGroups('write', ['write']), true); // case-insensitive
-  assert.equal(toolInGroups('AskUserQuestion', ['question']), true);
-  assert.equal(toolInGroups('Bash', ['write']), false); // wrong group
-  assert.equal(toolInGroups('', ['write']), false); // empty tool name
-});
-
-test('toolInGroups classifies MCP tools by their action segment', () => {
-  assert.equal(toolInGroups('mcp__filesystem__write_file', ['write']), true);
-  assert.equal(toolInGroups('mcp__fs__edit_file', ['write']), true);
-  assert.equal(toolInGroups('mcp__shell__exec', ['shell']), true);
-  assert.equal(toolInGroups('mcp__x__ask_user_confirmation', ['question']), true);
-  assert.equal(toolInGroups('mcp__orchestrator__spawn_agent', ['delegation']), true);
-  // A read-only MCP tool must NOT match a write/shell group.
-  assert.equal(toolInGroups('mcp__fs__read_file', ['write', 'shell']), false);
-  // Malformed mcp name (no action segment) does not match.
-  assert.equal(toolInGroups('mcp__server', ['write']), false);
-});
-
-test('writtenContentOf reads content across native and MCP field shapes', () => {
-  assert.equal(writtenContentOf({ content: 'a' }), 'a'); // Write
-  assert.equal(writtenContentOf({ new_string: 'b' }), 'b'); // Edit
-  assert.equal(writtenContentOf({ new_source: 'c' }), 'c'); // NotebookEdit
-  assert.equal(writtenContentOf({ new_content: 'd' }), 'd'); // replace_file_content
-  assert.equal(writtenContentOf({ text: 'e' }), 'e'); // an MCP shape
-  assert.equal(
-    writtenContentOf({ edits: [{ new_string: 'x' }, { new_string: 'y' }] }),
-    'x\ny',
-  ); // MultiEdit
-  assert.equal(writtenContentOf({}), '');
-  assert.equal(writtenContentOf(null), '');
-});
-
-test('writtenPathOf reads the target path across field shapes', () => {
-  assert.equal(writtenPathOf({ file_path: 'a.js' }), 'a.js');
-  assert.equal(writtenPathOf({ path: 'b.js' }), 'b.js');
-  assert.equal(writtenPathOf({ notebook_path: 'n.ipynb' }), 'n.ipynb');
-  assert.equal(writtenPathOf({}), '');
-});
-
-test('delegationPromptOf reads the brief across field shapes', () => {
-  assert.equal(delegationPromptOf({ prompt: 'a' }), 'a');
-  assert.equal(delegationPromptOf({ description: 'b' }), 'b'); // Task
-  assert.equal(delegationPromptOf({ instructions: 'c' }), 'c'); // an MCP shape
-  assert.equal(delegationPromptOf({}), '');
-});
-
-test('toolNameOf reads tool_name, falls back to name, defaults to empty string', () => {
-  assert.equal(toolNameOf(JSON.stringify({ tool_name: 'Bash' })), 'Bash');
-  assert.equal(toolNameOf(JSON.stringify({ name: 'Edit' })), 'Edit');
-  assert.equal(
-    toolNameOf(JSON.stringify({ tool_name: 'Bash', name: 'Edit' })),
-    'Bash',
-  );
-  assert.equal(toolNameOf(JSON.stringify({})), '');
-});
-
-test('toolNameOf returns null for unparseable payloads', () => {
-  assert.equal(toolNameOf('{not json'), null);
-  assert.equal(toolNameOf(undefined), null);
-});
-
-test('sessionIdOf reads session_id or returns null when absent/unparseable', () => {
-  assert.equal(sessionIdOf(JSON.stringify({ session_id: 'abc123' })), 'abc123');
-  assert.equal(sessionIdOf(JSON.stringify({})), null);
-  assert.equal(sessionIdOf('{not json'), null);
-});
-
-test('toolInputOf reads tool_input, falls back to input, defaults to {}', () => {
-  assert.deepEqual(
-    toolInputOf(JSON.stringify({ tool_input: { command: 'ls' } })),
-    { command: 'ls' },
-  );
-  assert.deepEqual(toolInputOf(JSON.stringify({ input: { file: 'a' } })), {
-    file: 'a',
-  });
-  assert.deepEqual(
-    toolInputOf(JSON.stringify({ tool_input: { a: 1 }, input: { b: 2 } })),
-    { a: 1 },
-  );
-  assert.deepEqual(toolInputOf(JSON.stringify({})), {});
-});
-
-test('toolInputOf returns {} for unparseable payloads', () => {
-  assert.deepEqual(toolInputOf('{not json'), {});
-  assert.deepEqual(toolInputOf(undefined), {});
-});
-
-const hookIoModuleUrl = pathToFileURL(
-  new URL('../hook-io.mjs', import.meta.url).pathname.replace(
-    /^\/([A-Za-z]:)/,
-    '$1',
-  ),
-).href;
-
-/** Runs `body` (a callback expression referencing `mod`) in a child process after
- *  dynamically importing hook-io.mjs there, so process.exit-calling exports can be
- *  exercised without killing the test runner. */
-function runInChildProcess(body, execOptions) {
-  const script = `import('${hookIoModuleUrl}').then((mod) => { ${body} });`;
-  return execFileSync(process.execPath, ['--input-type=module', '-e', script], {
-    encoding: 'utf8',
-    ...execOptions,
-  });
-}
-
-test('readHookPayload reads whatever is piped on stdin, including empty input', () => {
-  const output = runInChildProcess(
-    'process.stdout.write(JSON.stringify(mod.readHookPayload()))',
-    { input: '{"tool_name":"Bash"}' },
-  );
-  assert.equal(output, JSON.stringify('{"tool_name":"Bash"}'));
-
-  const emptyOutput = runInChildProcess(
-    'process.stdout.write(JSON.stringify(mod.readHookPayload()))',
-    { stdio: ['ignore', 'pipe', 'pipe'] },
-  );
-  // With no stdin available, readFileSync(0) resolves to an empty string rather than
-  // throwing on this platform, so readHookPayload returns '' — not null. The null
-  // path (an unreadable fd 0) is exercised indirectly by every gate's own tests via
-  // runGate, since forcing an EBADF/EAGAIN on fd 0 portably from node:test is not
-  // reliable across platforms.
-  assert.equal(emptyOutput, JSON.stringify(''));
-});
-
-test('deny writes a permissionDecision:deny hookSpecificOutput and exits 0', () => {
-  const output = runInChildProcess("mod.deny('my-gate', 'because reasons')", {
-    input: '',
-  });
-  const parsed = JSON.parse(output);
-  assert.equal(parsed.hookSpecificOutput.hookEventName, 'PreToolUse');
-  assert.equal(parsed.hookSpecificOutput.permissionDecision, 'deny');
-  assert.equal(
-    parsed.hookSpecificOutput.permissionDecisionReason,
-    '[my-gate] because reasons',
-  );
-});
-
-test('warn writes additionalContext and exits 0', () => {
-  const output = runInChildProcess("mod.warn('my-gate', 'consider this')", {
-    input: '',
-  });
-  const parsed = JSON.parse(output);
-  assert.equal(parsed.hookSpecificOutput.hookEventName, 'PreToolUse');
-  assert.equal(
-    parsed.hookSpecificOutput.additionalContext,
-    '[my-gate] consider this',
-  );
-  assert.equal(parsed.hookSpecificOutput.permissionDecision, undefined);
-});
-
-test('allow exits 0 with no stdout', () => {
-  const output = runInChildProcess('mod.allow()', { input: '' });
-  assert.equal(output, '');
-});