@1aboveio/skills 1.0.8 → 1.0.10

package/skills/engineering/test-quality/scripts/mock-policy-config.test.mjs

@@ -1,119 +0,0 @@
-// Tests for the mock-policy classifier (pure; one fs case via a temp dir).
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-
-import {
-  DEFAULT_MOCK_POLICY,
-  resolveMockPolicy,
-  loadMockPolicy,
-  loadMockPolicyFromFile,
-  extractMockTarget,
-  classifyMockTarget,
-} from './mock-policy-config.mjs'
-
-test('default policy is zero-tolerance: default-on, no waiver tag', () => {
-  assert.equal(DEFAULT_MOCK_POLICY.enabled, true)
-  // the inline-waiver escape hatch is gone
-  assert.equal(DEFAULT_MOCK_POLICY.waiverTag, undefined)
-})
-
-test('extractMockTarget pulls the specifier from vi/jest/vitest mock+doMock', () => {
-  assert.equal(extractMockTarget("vi." + "mock('@/lib/x')"), '@/lib/x')
-  assert.equal(extractMockTarget('jest.' + 'mock("pkg")'), 'pkg')
-  assert.equal(extractMockTarget('vi.' + 'doMock(`@/a/b`)'), '@/a/b')
-  assert.equal(extractMockTarget('vitest.' + 'mock("./rel")'), './rel')
-  assert.equal(extractMockTarget('const x = mockThing()'), null) // bare mock() is not a module mock
-  assert.equal(extractMockTarget('expect(x).toBe(1)'), null)
-})
-
-test('classify: first-party alias @/ and ~/ are internal seams (the incident case)', () => {
-  const p = resolveMockPolicy({})
-  assert.equal(classifyMockTarget('@/lib/org-allowlist-client', p).internal, true)
-  assert.equal(classifyMockTarget('~/services/cp', p).internal, true)
-})
-
-test('classify: stdlib and third-party packages are external (exempt)', () => {
-  const p = resolveMockPolicy({})
-  assert.equal(classifyMockTarget('node:fs', p).internal, false)
-  assert.equal(classifyMockTarget('react', p).internal, false)
-  assert.equal(classifyMockTarget('@playwright/test', p).internal, false)
-})
-
-test('classify: relative import into source is internal; into a test util/fixture is not', () => {
-  const p = resolveMockPolicy({})
-  assert.equal(classifyMockTarget('../services/payments', p).internal, true)
-  assert.equal(classifyMockTarget('./helpers/operator-session-store', p).internal, false)
-  assert.equal(classifyMockTarget('../__mocks__/cp', p).internal, false)
-  assert.equal(classifyMockTarget('../fixtures/data', p).internal, false)
-})
-
-test('classify: declared first-party workspace package is internal', () => {
-  const p = resolveMockPolicy({ firstPartyPackages: ['@acme/'] })
-  assert.equal(classifyMockTarget('@acme/db', p).internal, true)
-  assert.equal(classifyMockTarget('@acme', p).internal, true)
-  assert.equal(classifyMockTarget('@other/db', p).internal, false)
-})
-
-test('classify: declared externals allowlist exempts a first-party-looking target', () => {
-  const p = resolveMockPolicy({ externals: ['^@/generated/'] })
-  assert.equal(classifyMockTarget('@/generated/openapi', p).internal, false) // exempted
-  assert.equal(classifyMockTarget('@/lib/x', p).internal, true) // still flagged
-})
-
-test('compiled _externalsRe is non-enumerable: does not leak into JSON / enumeration', () => {
-  const p = resolveMockPolicy({ externals: ['^@/generated/'] })
-  // the compiled RegExp cache works...
-  assert.equal(classifyMockTarget('@/generated/openapi', p).internal, false)
-  // ...but is hidden from enumeration and serialization
-  assert.ok(!Object.keys(p).includes('_externalsRe'))
-  assert.equal(JSON.parse(JSON.stringify(p))._externalsRe, undefined)
-})
-
-test('loadMockPolicy reads coverage.config.json topology, defaults to on with no config', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mpc-'))
-  // no config → zero-tolerance default (on), conventional topology
-  assert.equal(loadMockPolicy(dir).enabled, true)
-  // with config → declared topology is merged in (config declares topology, not on/off)
-  fs.writeFileSync(
-    path.join(dir, 'coverage.config.json'),
-    JSON.stringify({ mockPolicy: { firstPartyPackages: ['@acme/'] } }),
-  )
-  const p = loadMockPolicy(dir)
-  assert.equal(p.enabled, true)
-  assert.deepEqual(p.firstPartyPackages, ['@acme/'])
-  // inherited default array still present
-  assert.ok(p.firstPartyAliasPrefixes.includes('@/'))
-})
-
-test('loadMockPolicy never throws on malformed config (and stays on)', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mpc-'))
-  fs.writeFileSync(path.join(dir, 'coverage.config.json'), '{ not json')
-  assert.equal(loadMockPolicy(dir).enabled, true)
-})
-
-test('loadMockPolicyFromFile reads the NAMED file (finding #1: not just its dirname)', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mpc-'))
-  const file = path.join(dir, 'team-coverage.json') // deliberately non-standard name
-  fs.writeFileSync(file, JSON.stringify({ mockPolicy: { enabled: true, externals: ['^@/generated/'] } }))
-  const p = loadMockPolicyFromFile(file)
-  assert.equal(p.enabled, true)
-  // the declared externals must actually apply (proof the file was read, not defaults)
-  assert.equal(classifyMockTarget('@/generated/openapi', p).internal, false)
-  assert.equal(classifyMockTarget('@/lib/auth', p).internal, true)
-})
-
-test('loadMockPolicyFromFile falls back to defaults when the named file is missing', () => {
-  // finding #1: a declared config that does not apply must not look like a clean pass.
-  // (It warns on stderr; here we assert the zero-tolerance default — gate stays ON.)
-  const p = loadMockPolicyFromFile(path.join(os.tmpdir(), 'definitely-absent-config-xyz.json'))
-  assert.equal(p.enabled, true)
-})
-
-test('loadMockPolicyFromFile with no argument discovers coverage.config.json in cwd', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mpc-'))
-  fs.writeFileSync(path.join(dir, 'coverage.config.json'), JSON.stringify({ mockPolicy: { enabled: true } }))
-  assert.equal(loadMockPolicyFromFile(undefined, dir).enabled, true)
-})

package/skills/engineering/test-quality/scripts/persist-conventions.test.mjs

@@ -1,104 +0,0 @@
-// Tests for persist-conventions: the real CLI against real files in a temp repo.
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import { existsSync, lstatSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { markers } from './persist-conventions-core.mjs'
-
-const CLI = fileURLToPath(new URL('./persist-conventions.mjs', import.meta.url))
-const SKILL = readFileSync(fileURLToPath(new URL('../SKILL.md', import.meta.url)), 'utf8')
-const TEMPLATE = readFileSync(fileURLToPath(new URL('../references/testing-conventions.md', import.meta.url)), 'utf8')
-const [START, END] = markers('testing')
-
-function withRepo(fn) {
-  const dir = mkdtempSync(join(tmpdir(), 'persist-conventions-'))
-  try {
-    return fn(dir, (name) => readFileSync(join(dir, name), 'utf8'))
-  } finally {
-    rmSync(dir, { recursive: true, force: true })
-  }
-}
-
-function run(dir, ...args) {
-  const res = spawnSync(process.execPath, [CLI, '--repo-root', dir, ...args], { encoding: 'utf8' })
-  return { code: res.status, out: res.stdout }
-}
-
-test('the persisted conventions carry one rule per SKILL.md principle, in order', () => {
-  const fromSkill = [...SKILL.matchAll(/^\| (\d) \| \[/gm)].map((m) => Number(m[1]))
-  const fromTemplate = [...TEMPLATE.matchAll(/^(\d+)\. /gm)].map((m) => Number(m[1]))
-  assert.ok(fromSkill.length >= 5, 'principle table not found in SKILL.md')
-  assert.deepEqual(fromTemplate, fromSkill)
-})
-
-test('without --write it previews and writes nothing', () => {
-  withRepo((dir) => {
-    const { code, out } = run(dir)
-    assert.equal(code, 0)
-    assert.match(out, /CONTRIBUTING\.md: would create/)
-    assert.match(out, /re-run with --write to write$/m)
-    assert.equal(existsSync(join(dir, 'CONTRIBUTING.md')), false)
-    assert.equal(existsSync(join(dir, 'AGENTS.md')), false)
-  })
-})
-
-test('--write creates CONTRIBUTING.md and AGENTS.md, links CLAUDE.md to it, and a re-run changes nothing', () => {
-  withRepo((dir, read) => {
-    const first = run(dir, '--write')
-    assert.equal(first.code, 0)
-    assert.match(first.out, /CONTRIBUTING\.md: created/)
-    assert.match(first.out, /AGENTS\.md: created/)
-    assert.match(first.out, /CLAUDE\.md: linked to AGENTS\.md/)
-    const conventions = read('CONTRIBUTING.md')
-    assert.ok(conventions.startsWith(`# Contributing\n\n${START}`))
-    assert.ok(conventions.includes('## Testing conventions'))
-    assert.ok(conventions.includes("6. Don't test config files"))
-    assert.match(read('AGENTS.md'), /\[CONTRIBUTING\.md\]\(CONTRIBUTING\.md\)/)
-
-    assert.ok(lstatSync(join(dir, 'CLAUDE.md')).isSymbolicLink())
-
-    const before = [conventions, read('AGENTS.md'), read('CLAUDE.md')]
-    assert.match(run(dir, '--write').out, /0 file\(s\) written, 3 unchanged$/m)
-    assert.deepEqual([read('CONTRIBUTING.md'), read('AGENTS.md'), read('CLAUDE.md')], before)
-  })
-})
-
-test('a stale section is replaced and the rest of each file is kept', () => {
-  withRepo((dir, read) => {
-    writeFileSync(join(dir, 'CONTRIBUTING.md'), `# Contributing\n\nUse tabs.\n\n${START}\nold principles\n${END}\n\n## Naming\n\ncamelCase.\n`)
-    writeFileSync(join(dir, 'AGENTS.md'), '# Agents\n\nRun `pnpm test`.\n')
-    run(dir, '--write')
-    const conventions = read('CONTRIBUTING.md')
-    assert.ok(conventions.startsWith('# Contributing\n\nUse tabs.\n\n'))
-    assert.ok(conventions.endsWith(`${END}\n\n## Naming\n\ncamelCase.\n`))
-    assert.ok(!conventions.includes('old principles'))
-    assert.equal(conventions.split(START).length, 2) // exactly one section
-    assert.ok(read('AGENTS.md').startsWith('# Agents\n\nRun `pnpm test`.\n\n## Contributing'))
-  })
-})
-
-test('an AGENTS.md that already names CONTRIBUTING.md is left alone; OLD_CONTRIBUTING.md is not a mention', () => {
-  withRepo((dir, read) => {
-    const agents = '# Agents\n\nSee CONTRIBUTING.md.\n'
-    writeFileSync(join(dir, 'AGENTS.md'), agents)
-    assert.match(run(dir, '--write').out, /AGENTS\.md: unchanged/)
-    assert.equal(read('AGENTS.md'), agents)
-  })
-  withRepo((dir, read) => {
-    writeFileSync(join(dir, 'AGENTS.md'), '# Agents\n\nSee OLD_CONTRIBUTING.md.\n')
-    assert.match(run(dir, '--write').out, /AGENTS\.md: updated/)
-    assert.match(read('AGENTS.md'), /\[CONTRIBUTING\.md\]\(CONTRIBUTING\.md\)/)
-  })
-})
-
-test('an unknown argument or a missing repo root is a usage error', () => {
-  withRepo((dir) => {
-    assert.equal(run(dir, '--force').code, 2)
-    assert.equal(run(join(dir, 'missing')).code, 2)
-    assert.equal(existsSync(join(dir, 'CONTRIBUTING.md')), false)
-  })
-})

package/skills/risk-compliance/compliance-audit/scripts/compliance-audit.test.mjs

@@ -1,14 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import test from 'node:test';
-
-const scriptsDir = dirname(fileURLToPath(import.meta.url));
-
-for (const suite of ['test_validate_tracker.py', 'test_export_tracker_xlsx.py']) {
-  test(`compliance-audit ${suite}`, () => {
-    const result = spawnSync('python3', [join(scriptsDir, suite)], { encoding: 'utf8' });
-    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-  });
-}

package/skills/risk-compliance/doc-authenticity/manual-invocation.test.mjs

@@ -1,12 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { manualOnlyPolicyFindings } from '../../engineering/engineering-runtime/scripts/invocation-policy.mjs';
-
-const SKILL_ROOT = dirname(fileURLToPath(import.meta.url));
-
-test('doc-authenticity remains explicit-invocation only across supported harnesses', () => {
-  assert.deepEqual(manualOnlyPolicyFindings(SKILL_ROOT), []);
-});

package/skills/risk-compliance/doc-authenticity/scripts/validate_verdict.test.mjs

@@ -1,212 +0,0 @@
-// @covers doc-authenticity:routed-verdict-contract
-// @level integration
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, 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 SCRIPTS = dirname(fileURLToPath(import.meta.url));
-const VALIDATOR = join(SCRIPTS, 'validate_verdict.py');
-const VALIDITY_IDS = {
-  bank_statement: [...Array.from({ length: 5 }, (_, i) => `C${i + 1}`), ...Array.from({ length: 5 }, (_, i) => `D${i + 1}`)],
-  invoice: Array.from({ length: 8 }, (_, i) => `N${i + 1}`),
-  agreement: Array.from({ length: 8 }, (_, i) => `A${i + 1}`),
-  conversation_log: [],
-  other: [],
-};
-const CONTENT_IDS = new Set([
-  ...Array.from({ length: 5 }, (_, i) => `C${i + 1}`),
-  'N2', 'N3', 'N4', 'N7',
-  'A2', 'A4', 'A5', 'A7',
-]);
-
-function check(id) {
-  const authenticity = id.startsWith('F') || id.startsWith('I');
-  return {
-    id,
-    name: `Check ${id}`,
-    axis: authenticity ? 'authenticity' : 'validity',
-    dimension: authenticity ? 'file_forensics' : CONTENT_IDS.has(id) ? 'content' : 'domain',
-    result: 'PASS',
-    decisive: false,
-    evidence: `Concrete evidence for ${id}.`,
-  };
-}
-
-function verdict(fileType, docType) {
-  const prefix = fileType === 'pdf' ? 'F' : 'I';
-  const authIds = Array.from({ length: 9 }, (_, i) => `${prefix}${i + 1}`);
-  const validityIds = VALIDITY_IDS[docType];
-  return {
-    schema_version: '2.2',
-    artifact: {
-      path: `/tmp/${fileType}-${docType}`,
-      file_type: fileType,
-      media_type: fileType === 'pdf' ? 'application/pdf' : 'image/jpeg',
-      size_bytes: 1234,
-      sha256: 'a'.repeat(64),
-      extension_magic_match: true,
-      doc_type: docType,
-      detail: 'route fixture',
-      claimed_issuer: null,
-      supplied_claim: 'Test document.',
-    },
-    authenticity: {
-      verdict: 'NO_EVIDENCE_OF_MODIFICATION',
-      confidence: 'MEDIUM',
-      summary: 'No modification evidence.',
-    },
-    validity: {
-      verdict: validityIds.length ? 'VALID' : 'INCONCLUSIVE',
-      confidence: 'LOW',
-      summary: 'Validity route result.',
-    },
-    checks: [...authIds, ...validityIds].map(check),
-    summary: 'Route test.',
-    checked_at: '2026-09-03T13:30:00+08:00',
-  };
-}
-
-function runValidator(directory, name, value) {
-  const path = join(directory, `${name}.json`);
-  writeFileSync(path, `${JSON.stringify(value)}\n`);
-  return spawnSync('python3', [VALIDATOR, path], { encoding: 'utf8' });
-}
-
-test('all file-type and document-type routes require the correct check set', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'doc-auth-routes-'));
-  try {
-    for (const fileType of ['pdf', 'image']) {
-      for (const docType of Object.keys(VALIDITY_IDS)) {
-        const result = runValidator(directory, `${fileType}-${docType}`, verdict(fileType, docType));
-        assert.equal(result.status, 0, `${fileType}/${docType}: ${result.stdout}${result.stderr}`);
-        assert.match(result.stdout, new RegExp(`valid: ${fileType}/${docType} route`));
-      }
-    }
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-test('conversation logs and other documents cannot claim specialized validity', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'doc-auth-no-validity-'));
-  try {
-    for (const docType of ['conversation_log', 'other']) {
-      const value = verdict('image', docType);
-      value.validity.verdict = 'VALID';
-      const result = runValidator(directory, docType, value);
-      assert.notEqual(result.status, 0);
-      assert.match(result.stdout, /validity verdict must be INCONCLUSIVE/);
-    }
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-test('missing and cross-profile validity checks fail closed', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'doc-auth-invalid-route-'));
-  try {
-    const missing = verdict('pdf', 'invoice');
-    missing.checks = missing.checks.filter(({ id }) => id !== 'N8');
-    const missingResult = runValidator(directory, 'missing-invoice-check', missing);
-    assert.notEqual(missingResult.status, 0);
-    assert.match(missingResult.stdout, /missing checks: \['N8'\]/);
-
-    const mixed = verdict('image', 'agreement');
-    mixed.checks.push(check('N1'));
-    const mixedResult = runValidator(directory, 'mixed-agreement-check', mixed);
-    assert.notEqual(mixedResult.status, 0);
-    assert.match(mixedResult.stdout, /checks do not belong to the selected route: \['N1'\]/);
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-test('artifact audit fields and checked_at timezone are mandatory', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'doc-auth-artifact-'));
-  try {
-    const missingAudit = verdict('pdf', 'invoice');
-    delete missingAudit.artifact.sha256;
-    const missingResult = runValidator(directory, 'missing-hash', missingAudit);
-    assert.notEqual(missingResult.status, 0);
-    assert.match(missingResult.stdout, /artifact missing keys: \['sha256'\]/);
-
-    const badTimestamp = verdict('pdf', 'invoice');
-    badTimestamp.checked_at = '2026-99-99T13:30:00';
-    const timestampResult = runValidator(directory, 'bad-timestamp', badTimestamp);
-    assert.notEqual(timestampResult.status, 0);
-    assert.match(timestampResult.stdout, /valid ISO 8601 timestamp with timezone/);
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-test('authenticity verdict must match decisive, FAIL, FLAG, and NA thresholds', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'doc-auth-rubric-'));
-  try {
-    const tooManyFlags = verdict('pdf', 'other');
-    for (const id of ['F1', 'F2', 'F3']) tooManyFlags.checks.find((item) => item.id === id).result = 'FLAG';
-    const flagsResult = runValidator(directory, 'flags', tooManyFlags);
-    assert.notEqual(flagsResult.status, 0);
-    assert.match(flagsResult.stdout, /authenticity verdict must be SUSPICIOUS/);
-
-    const unavailable = verdict('pdf', 'other');
-    for (const id of ['F1', 'F2', 'F3', 'F4', 'F5']) unavailable.checks.find((item) => item.id === id).result = 'NA';
-    const unavailableResult = runValidator(directory, 'unavailable', unavailable);
-    assert.notEqual(unavailableResult.status, 0);
-    assert.match(unavailableResult.stdout, /authenticity verdict must be INCONCLUSIVE/);
-
-    const decisive = verdict('image', 'other');
-    decisive.authenticity.verdict = 'LIKELY_MODIFIED';
-    const splice = decisive.checks.find((item) => item.id === 'I7');
-    splice.result = 'FAIL';
-    splice.decisive = true;
-    const decisiveResult = runValidator(directory, 'decisive', decisive);
-    assert.equal(decisiveResult.status, 0, decisiveResult.stdout);
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-test('validity verdict must match decisive, FAIL, FLAG, and NA thresholds', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'doc-validity-rubric-'));
-  try {
-    const unavailable = verdict('pdf', 'invoice');
-    unavailable.validity.verdict = 'INCONCLUSIVE';
-    for (const id of ['N1', 'N2', 'N3', 'N4']) unavailable.checks.find((item) => item.id === id).result = 'NA';
-    const unavailableResult = runValidator(directory, 'unavailable-validity', unavailable);
-    assert.equal(unavailableResult.status, 0, unavailableResult.stdout);
-
-    const decisive = verdict('pdf', 'agreement');
-    decisive.validity.verdict = 'INVALID';
-    const conflict = decisive.checks.find((item) => item.id === 'A4');
-    conflict.result = 'FAIL';
-    conflict.decisive = true;
-    const decisiveResult = runValidator(directory, 'decisive-validity', decisive);
-    assert.equal(decisiveResult.status, 0, decisiveResult.stdout);
-
-    const invalidDecisive = verdict('pdf', 'invoice');
-    invalidDecisive.checks.find((item) => item.id === 'N1').decisive = true;
-    const invalidResult = runValidator(directory, 'decisive-pass', invalidDecisive);
-    assert.notEqual(invalidResult.status, 0);
-    assert.match(invalidResult.stdout, /only a FAIL can be decisive/);
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-test('the schema advertises every routed document type and check family', () => {
-  const schema = JSON.parse(readFileSync(join(SCRIPTS, '..', 'references', 'verdict.schema.json'), 'utf8'));
-  assert.deepEqual(
-    schema.properties.artifact.properties.doc_type.enum,
-    ['bank_statement', 'conversation_log', 'invoice', 'agreement', 'other'],
-  );
-  assert.equal(schema.properties.schema_version.const, '2.2');
-  assert.ok(schema.properties.artifact.required.includes('sha256'));
-  assert.ok(schema.$defs.check.required.includes('decisive'));
-  assert.match(schema.$defs.check.properties.id.pattern, /N\[1-8\]/);
-  assert.match(schema.$defs.check.properties.id.pattern, /A\[1-8\]/);
-});

package/skills/risk-compliance/tld-detection/scripts/detect_ladders.test.mjs

@@ -1,14 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import test from 'node:test';
-
-const skillDir = join(dirname(fileURLToPath(import.meta.url)), '..');
-
-test('TLD ladder detector Python contract', () => {
-  const result = spawnSync('python3', [join(skillDir, 'tests', 'test_detect_ladders.py'), '-v'], {
-    encoding: 'utf8',
-  });
-  assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-});

package/skills/risk-compliance/tld-detection/scripts/detect_streams.test.mjs

@@ -1,14 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import test from 'node:test';
-
-const skillDir = join(dirname(fileURLToPath(import.meta.url)), '..');
-
-test('TLD stream inference Python contract', () => {
-  const result = spawnSync('python3', [join(skillDir, 'tests', 'test_detect_streams.py'), '-v'], {
-    encoding: 'utf8',
-  });
-  assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-});

package/skills/risk-compliance/tld-detection/tests/test_detect_ladders.py

@@ -1,134 +0,0 @@
-from collections import Counter
-import csv
-from decimal import Decimal
-import importlib.util
-import json
-from pathlib import Path
-import subprocess
-import sys
-import tempfile
-import unittest
-
-
-sys.dont_write_bytecode = True
-SCRIPT = Path(__file__).parents[1] / "scripts" / "detect_ladders.py"
-SPEC = importlib.util.spec_from_file_location("detect_ladders", SCRIPT)
-MODULE = importlib.util.module_from_spec(SPEC)
-assert SPEC.loader is not None
-sys.modules[SPEC.name] = MODULE
-SPEC.loader.exec_module(MODULE)
-
-
-def pair(amount: str) -> tuple[str, Decimal]:
-    return "USD", Decimal(amount)
-
-
-class DetectLaddersTest(unittest.TestCase):
-    def detect(self, values: dict[str, int], cap: str = "0.15"):
-        counts = Counter({pair(amount): count for amount, count in values.items()})
-        return MODULE.detect_ladders(
-            counts,
-            sum(counts.values()),
-            MODULE.LadderConfig({"USD": Decimal(cap)}),
-        )[0]
-
-    def test_detects_tight_exact_ladder(self):
-        ladders = self.detect({"28.03": 131, "56.04": 117, "112.09": 65, "224.19": 27, "70.00": 100})
-        amounts = {amount for _, amount in ladders[0]["pairs"]}
-        self.assertEqual(amounts, {Decimal("28.03"), Decimal("56.04"), Decimal("112.09"), Decimal("224.19")})
-
-    def test_keeps_multiple_exact_anchors_at_one_level(self):
-        ladders = self.detect({"14.41": 34, "14.52": 25, "28.94": 43, "57.96": 29, "80.00": 100})
-        levels = next(ladder["levels"] for ladder in ladders if pair("28.94") in ladder["pairs"])
-        self.assertEqual(levels[-1], {pair("14.41"), pair("14.52")})
-
-    def test_rejects_upper_amount_outside_absolute_cap(self):
-        ladders = self.detect({"14.41": 34, "28.94": 43, "57.96": 29, "116.85": 29, "80.00": 100})
-        ladder = next(ladder for ladder in ladders if pair("14.41") in ladder["pairs"])
-        self.assertNotIn(pair("116.85"), ladder["pairs"])
-
-    def test_requires_explicit_currency_cap(self):
-        with self.assertRaisesRegex(ValueError, "missing absolute residual cap"):
-            MODULE.detect_ladders(Counter({pair("10"): 10}), 10, MODULE.LadderConfig({}))
-
-    def test_ignores_currency_below_rung_pool_threshold(self):
-        counts = Counter({pair("10"): 1000, ("EUR", Decimal("9.99")): 1})
-        ladders, _ = MODULE.detect_ladders(counts, 1001, MODULE.LadderConfig({"USD": Decimal("0.15")}))
-        self.assertEqual(ladders, [])
-
-    def test_sensitivity_reports_coverage_by_cap(self):
-        counts = Counter({pair("14.41"): 34, pair("28.94"): 43, pair("57.96"): 29})
-        rows = MODULE.sensitivity_analysis(
-            counts,
-            sum(counts.values()),
-            MODULE.LadderConfig({"USD": Decimal("0.15")}),
-            "USD",
-            [Decimal("0.10"), Decimal("0.15")],
-        )
-        self.assertEqual([row["ladder_count"] for row in rows], [0, 1])
-
-    def test_keeps_below_threshold_family_out_of_clusters(self):
-        counts = Counter({pair("10"): 32, pair("20"): 32, pair("40"): 32})
-        ladders, metadata = MODULE.detect_ladders(
-            counts,
-            96,
-            MODULE.LadderConfig({"USD": Decimal("0.15")}),
-        )
-        self.assertEqual(ladders, [])
-        self.assertEqual(metadata["below_threshold"][0]["attempts"], 96)
-
-    def test_same_pair_can_belong_to_different_partitions(self):
-        entries = []
-        amounts = (("10", 40), ("20", 40), ("40", 40))
-        for partition in ("alpha", "beta"):
-            for amount, count in amounts:
-                entries.extend([(partition, pair(amount))] * count)
-        _, ladders, _ = MODULE.detect_partitioned_ladders(
-            entries,
-            MODULE.LadderConfig({"USD": Decimal("0.15")}),
-        )
-        self.assertEqual(len(ladders), 2)
-        self.assertEqual({ladder["partition"] for ladder in ladders}, {"alpha", "beta"})
-
-    def test_requires_at_least_three_levels(self):
-        self.assertEqual(self.detect({"10": 60, "20": 60, "70": 100}), [])
-
-    def test_rejects_non_two_x_relationships(self):
-        self.assertEqual(self.detect({"10": 40, "30": 40, "90": 40}), [])
-
-    def test_cli_keeps_whole_descriptor_despite_country_and_pattern_labels(self):
-        with tempfile.TemporaryDirectory() as directory:
-            csv_path = Path(directory) / "clean.csv"
-            with csv_path.open("w", encoding="utf-8", newline="") as handle:
-                writer = csv.DictWriter(handle, fieldnames=["descriptor", "country", "currency", "amount", "payment_pattern"])
-                writer.writeheader()
-                for country in ("US", "GB"):
-                    for amount in ("10", "20", "40"):
-                        writer.writerows(
-                            {"descriptor": "ACME", "country": country, "currency": "USD", "amount": amount,
-                             "payment_pattern": "Direct top-up pattern" if country == "US" else "E-commerce pattern"}
-                            for _ in range(20)
-                        )
-            result = subprocess.run(
-                [
-                    sys.executable,
-                    str(SCRIPT),
-                    str(csv_path),
-                    "--descriptor-column", "descriptor",
-                    "--bin-country-column", "country",
-                    "--currency-column", "currency",
-                    "--amount-column", "amount",
-                    "--cap", "USD=0.15",
-                ],
-                check=True,
-                capture_output=True,
-                text=True,
-            )
-        payload = json.loads(result.stdout)
-        self.assertEqual(len(payload["ladders"]), 1)
-        self.assertEqual(payload["ladders"][0]["partition_attempts"], 120)
-        self.assertEqual(payload["ladders"][0]["bin_country_components"], {"US": 60, "GB": 60})
-
-
-if __name__ == "__main__":
-    unittest.main()