@ikon85/agent-workflow-kit 0.43.0 → 0.44.0

package/scripts/build-kit.test.mjs

@@ -1,207 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { access, mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createHash } from 'node:crypto';
-import { execFileSync } from 'node:child_process';
-import { buildKit } from './build-kit.mjs';
-import { init } from '../src/commands/init.mjs';
-import { HELPER_FILES, STUB_TARGETS } from '../src/lib/bundle.mjs';
-import { CONSUMER_MANIFEST_NAME, readManifest } from '../src/lib/manifest.mjs';
-
-const REPO = join(dirname(fileURLToPath(import.meta.url)), '..');
-const PUBLIC_CENSUS_UNIT = JSON.parse(await readFile(
-  join(REPO, 'test/fixtures/census-consumers/public-unit.json'), 'utf8',
-)).paths;
-const WAVE_152_HELPERS = [
-  { path: 'scripts/marker_lib.py', kind: 'script', mode: 0o644 },
-  { path: 'scripts/find-by-marker.py', kind: 'script', mode: 0o755 },
-  { path: 'scripts/codex-exec.sh', kind: 'script', mode: 0o755 },
-  { path: 'scripts/codex_proc.py', kind: 'script', mode: 0o644 },
-  { path: 'scripts/render-anchor.py', kind: 'script', mode: 0o755 },
-];
-async function withBuild(fn) {
-  const dist = await mkdtemp(join(tmpdir(), 'awkit-build-'));
-  try { return await fn(dist, await buildKit({ repoRoot: REPO, distDir: dist })); }
-  finally { await rm(dist, { recursive: true, force: true }); }
-}
-const exists = (path) => access(path).then(() => true, () => false);
-
-test('historical v0.9.0 manifest remains an immutable golden fixture', async () => {
-  const fixture = await readFile(join(REPO, 'test/fixtures/v0.9.0-agent-workflow-kit.package.json'));
-  assert.equal(createHash('sha256').update(fixture).digest('hex'),
-    'a209e14b1a2e5b3bba63c16ee6a7d713b6acd9a1d11379bb07fdd1e3e4ca8b6c');
-  const manifest = JSON.parse(fixture);
-  assert.equal(manifest.kitVersion, '0.9.0');
-  assert.equal(manifest.files.length, 215);
-});
-
-test('current public SSOT builds deterministically', async () => {
-  const first = await withBuild(async (dist) => readFile(join(dist, 'agent-workflow-kit.package.json'), 'utf8'));
-  const second = await withBuild(async (dist) => readFile(join(dist, 'agent-workflow-kit.package.json'), 'utf8'));
-  assert.equal(first, second);
-});
-
-test('current build assigns every file an explicit install role', async () => {
-  await withBuild(async (dist) => {
-    const manifest = JSON.parse(await readFile(join(dist, 'agent-workflow-kit.package.json'), 'utf8'));
-    assert.ok(manifest.files.every(({ installRole }) => ['consumer', 'maintainer'].includes(installRole)));
-    assert.deepEqual(
-      manifest.files.filter(({ installRole }) => installRole === 'maintainer').map(({ path }) => path),
-      [
-        '.agents/skills/kit-release/SKILL.md',
-        '.claude/skills/kit-release/SKILL.md',
-        'scripts/kit-release.mjs',
-        'scripts/release-delta-guard.mjs',
-      ],
-    );
-  });
-});
-
-test('a built kit installs no maintainer-only release surface into a consumer', async () => {
-  await withBuild(async (dist) => {
-    const consumer = await mkdtemp(join(tmpdir(), 'awkit-role-consumer-'));
-    try {
-      await init({ kitRoot: dist, consumerRoot: consumer });
-      const maintainerPaths = [
-        '.agents/skills/kit-release/SKILL.md',
-        '.claude/skills/kit-release/SKILL.md',
-        'scripts/kit-release.mjs',
-        'scripts/release-delta-guard.mjs',
-      ];
-      assert.deepEqual(
-        await Promise.all(maintainerPaths.map((path) => exists(join(consumer, path)))),
-        [false, false, false, false],
-      );
-      const manifest = await readManifest(join(consumer, CONSUMER_MANIFEST_NAME));
-      assert.equal(manifest.installRole, 'consumer');
-      assert.ok(manifest.installed.every(({ installRole }) => installRole === 'consumer'));
-    } finally {
-      await rm(consumer, { recursive: true, force: true });
-    }
-  });
-});
-
-test('current build contains post-tag public files and repository metadata', async () => {
-  await withBuild(async (dist) => {
-    await readFile(join(dist, '.agents/skills/codex-adapter-sync/SKILL.md'));
-    await readFile(join(dist, 'scripts/program_graph.py'));
-    const pkg = JSON.parse(await readFile(join(dist, 'package.json'), 'utf8'));
-    assert.equal(pkg.name, '@ikon85/agent-workflow-kit');
-    assert.equal(pkg.repository.url, 'git+https://github.com/iKon85/agent-workflow-kit.git');
-    assert.equal(pkg.bin['agent-workflow-kit'], 'src/cli.mjs');
-    assert.equal(pkg.bin['agent-workflow-kit-update-pr'], 'scripts/kit-update-pr.mjs');
-    await readFile(join(dist, 'scripts/kit-update-pr.mjs'));
-  });
-});
-
-test('Wave 152 helpers keep their bundle and built-manifest modes', async () => {
-  assert.deepEqual(
-    WAVE_152_HELPERS.map(({ path }) => HELPER_FILES.find((entry) => entry.path === path)),
-    WAVE_152_HELPERS,
-  );
-  await withBuild(async (dist) => {
-    const manifest = JSON.parse(await readFile(join(dist, 'agent-workflow-kit.package.json'), 'utf8'));
-    const byPath = new Map(manifest.files.map((entry) => [entry.path, entry]));
-    assert.deepEqual(
-      WAVE_152_HELPERS.map(({ path }) => {
-        const { kind, mode, installRole } = byPath.get(path);
-        return { path, kind, mode, installRole };
-      }),
-      WAVE_152_HELPERS.map((entry) => ({ ...entry, installRole: 'consumer' })),
-    );
-  });
-});
-
-test('current build contains the complete dual-surface census consumer unit', async () => {
-  await withBuild(async (dist, report) => {
-    const manifest = JSON.parse(await readFile(join(dist, 'agent-workflow-kit.package.json'), 'utf8'));
-    const paths = new Set(manifest.files.map(({ path }) => path));
-    assert.deepEqual(PUBLIC_CENSUS_UNIT.filter((path) => !paths.has(path)), []);
-    assert.equal(report.fileCount, manifest.files.length);
-    assert.equal(
-      await readFile(join(dist, '.claude/skills/census-update/SKILL.md'), 'utf8'),
-      await readFile(join(dist, '.agents/skills/census-update/SKILL.md'), 'utf8'),
-    );
-  });
-});
-
-test('current build is self-contained and never reaches into a consumer checkout', async () => {
-  const source = await readFile(join(REPO, 'scripts/build-kit.mjs'), 'utf8');
-  assert.doesNotMatch(source, /testreporter|tools\/agent-workflow-kit/);
-});
-
-test('npm pack keeps product files but excludes runtime residue', async () => {
-  const logsDir = join(REPO, '.claude/logs');
-  await mkdir(logsDir, { recursive: true });
-  const ownedLogDir = await mkdtemp(join(logsDir, 'pack-runtime-'));
-  const runtimeLog = join(ownedLogDir, 'drift-guard.log');
-  const sentinelLog = join(ownedLogDir, 'preexisting.log');
-  const sentinelBytes = 'preexisting runtime log bytes\n';
-  await writeFile(sentinelLog, sentinelBytes);
-  await writeFile(runtimeLog, `${new Date().toISOString()} runtime-only\n`);
-  try {
-    const output = execFileSync('npm', ['pack', '--dry-run', '--json'], {
-      cwd: REPO, encoding: 'utf8',
-    });
-    const files = JSON.parse(output)[0].files.map((file) => file.path);
-    assert.ok(files.includes('scripts/build-kit.mjs'));
-    assert.ok(files.includes('scripts/board-sync.py'));
-    assert.ok(files.includes('scripts/kit-update-pr.mjs'));
-    assert.ok(files.includes('.claude/hooks/drift-guard.py'));
-    assert.ok(files.includes('.claude/skills/tdd/SKILL.md'));
-    for (const path of PUBLIC_CENSUS_UNIT) {
-      assert.ok(files.includes(path), `pack missing ${path}`);
-    }
-    for (const path of STUB_TARGETS) {
-      assert.ok(!files.includes(path), `pack must exclude init stub target ${path}`);
-    }
-    const packedByPath = new Map(JSON.parse(output)[0].files.map((file) => [file.path, file]));
-    assert.deepEqual(
-      WAVE_152_HELPERS.map(({ path, mode }) => ({ path, mode: packedByPath.get(path)?.mode })),
-      WAVE_152_HELPERS.map(({ path, mode }) => ({ path, mode })),
-    );
-    assert.ok(files.every((path) => !path.startsWith('.claude/logs/')));
-    assert.ok(files.every((path) => !path.includes('__pycache__') && !path.endsWith('.pyc')));
-    const pkg = JSON.parse(execFileSync('node', ['-p', 'JSON.stringify(require("./package.json"))'], {
-      cwd: REPO, encoding: 'utf8',
-    }));
-    assert.ok(pkg.files.includes('scripts/'), 'package must ship future script file types');
-    assert.equal(await readFile(sentinelLog, 'utf8'), sentinelBytes);
-  } finally {
-    await rm(ownedLogDir, { recursive: true, force: true });
-  }
-});
-
-test('packed scoped artifact keeps the existing npx default-bin inference', async () => {
-  const destination = await mkdtemp(join(tmpdir(), 'awkit-pack-'));
-  try {
-    const packed = JSON.parse(execFileSync('npm', [
-      'pack', '--pack-destination', destination, '--json',
-    ], { cwd: REPO, encoding: 'utf8' }));
-    const packedByPath = new Map(packed[0].files.map((file) => [file.path, file]));
-    execFileSync('tar', ['-xzf', join(destination, packed[0].filename), '-C', destination]);
-    for (const { path, mode } of WAVE_152_HELPERS) {
-      assert.equal(packedByPath.get(path)?.mode, mode, `packed mode mismatch: ${path}`);
-      assert.equal(
-        (await stat(join(destination, 'package', path))).mode & 0o777,
-        mode,
-        `extracted mode mismatch: ${path}`,
-      );
-    }
-    const output = execFileSync('npx', [
-      '--yes', '--offline', `./${packed[0].filename}`,
-    ], { cwd: destination, encoding: 'utf8' });
-    assert.match(output, /Usage: agent-workflow-kit/);
-
-    const updater = execFileSync('npm', [
-      'exec', '--yes', '--offline', `--package=./${packed[0].filename}`,
-      '--', 'agent-workflow-kit-update-pr', 'help',
-    ], { cwd: destination, encoding: 'utf8' });
-    assert.match(updater, /Usage: agent-workflow-kit-update-pr/);
-  } finally {
-    await rm(destination, { recursive: true, force: true });
-  }
-});

package/scripts/census/census.test.mjs

@@ -1,252 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { cp, mkdtemp, mkdir, rm, symlink, writeFile } from 'node:fs/promises';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-  CENSUS_VERDICTS,
-  diffCensus,
-  scanCensus,
-  serializeCensus,
-} from './index.mjs';
-
-const exec = promisify(execFile);
-const FIXTURE = new URL('../../test/fixtures/census-recipes/known/', import.meta.url);
-
-async function makeRepository() {
-  const root = await mkdtemp(join(tmpdir(), 'awk-census-'));
-  await cp(FIXTURE, root, { recursive: true });
-  await exec('git', ['init', '--quiet'], { cwd: root });
-  await exec('git', ['add', '.'], { cwd: root });
-  await exec('git', ['add', '-f', 'ignored/src/ignored.mjs'], { cwd: root });
-  return root;
-}
-
-test('known recipe scans are byte-identical and separate denominator from evidence', async () => {
-  const root = await makeRepository();
-  try {
-    const first = await scanCensus({ repoRoot: root });
-    const second = await scanCensus({ repoRoot: root });
-
-    assert.equal(serializeCensus(first), serializeCensus(second));
-    assert.deepEqual(first.denominator.map(({ path }) => path), [
-      'package.json',
-      'src/index.mjs',
-    ]);
-    assert.deepEqual(first.evidence.map(({ path }) => path), [
-      'docs/architecture.md',
-      'test/index.test.mjs',
-    ]);
-    assert.equal(first.fingerprints.builder.length, 64);
-    assert.equal(first.fingerprints.topology.length, 64);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('scan state reflects explicit activation and active-census facts', async () => {
-  const root = await makeRepository();
-  try {
-    assert.equal((await scanCensus({ repoRoot: root })).state, 'disabled');
-    assert.equal((await scanCensus({ repoRoot: root, enabled: true })).state, 'bootstrap');
-    assert.equal((await scanCensus({ repoRoot: root, enabled: true, hasActive: true })).state, 'current');
-
-    await mkdir(join(root, 'new-service', 'src'), { recursive: true });
-    await writeFile(join(root, 'new-service', 'src', 'index.mjs'), 'export const newService = true;\n');
-    assert.equal(
-      (await scanCensus({ repoRoot: root, enabled: true, hasActive: true })).state,
-      'refresh_required',
-    );
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('secret, ignored, generated, and vendor paths are never read or counted', async () => {
-  const root = await makeRepository();
-  try {
-    const reads = [];
-    const result = await scanCensus({
-      repoRoot: root,
-      readText: async (path) => {
-        reads.push(path);
-        return (await import('node:fs/promises')).readFile(path, 'utf8');
-      },
-    });
-    const output = serializeCensus(result);
-
-    assert.ok(!reads.some((path) => path.includes('secrets')));
-    assert.ok(!reads.some((path) => path.includes('credentials')));
-    assert.ok(!output.includes('CENSUS_SECRET_CANARY'));
-    assert.ok(!output.includes('secrets/'));
-    assert.ok(!output.includes('credentials.txt'));
-    assert.ok(!output.includes('vendor/src'));
-    assert.ok(!output.includes('dist/src'));
-    assert.ok(!output.includes('ignored/src'));
-    assert.equal(result.denominator.length, 2);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('tracked product symlinks stay unread and force an open refresh', async () => {
-  const root = await makeRepository();
-  const external = await mkdtemp(join(tmpdir(), 'awk-census-external-'));
-  const externalPath = join(external, 'canary.mjs');
-  await writeFile(externalPath, 'CENSUS_EXTERNAL_SECRET_CANARY\n');
-  await symlink(externalPath, join(root, 'src', 'external.mjs'));
-  await exec('git', ['add', 'src/external.mjs'], { cwd: root });
-  try {
-    const reads = [];
-    const result = await scanCensus({
-      repoRoot: root,
-      enabled: true,
-      hasActive: true,
-      readText: async (path) => {
-        reads.push(path);
-        return (await import('node:fs/promises')).readFile(path, 'utf8');
-      },
-    });
-
-    assert.ok(!reads.includes(join(root, 'src', 'external.mjs')));
-    assert.ok(!reads.includes(externalPath));
-    assert.ok(!serializeCensus(result).includes('CENSUS_EXTERNAL_SECRET_CANARY'));
-    assert.ok(!result.denominator.some(({ path }) => path === 'src/external.mjs'));
-    assert.deepEqual(result.families.surfaces, [
-      { name: 'production-config', status: 'abgedeckt', type: 'surface' },
-      { name: 'src', status: 'offen', type: 'surface' },
-    ]);
-    assert.equal(result.state, 'refresh_required');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-    await rm(external, { recursive: true, force: true });
-  }
-});
-
-test('a tracked product file missing from the working tree forces an open refresh', async () => {
-  const root = await makeRepository();
-  try {
-    await rm(join(root, 'src', 'index.mjs'));
-
-    const result = await scanCensus({ repoRoot: root, enabled: true, hasActive: true });
-
-    assert.deepEqual(result.denominator.map(({ path }) => path), ['package.json']);
-    assert.deepEqual(result.families.surfaces, [
-      { name: 'production-config', status: 'abgedeckt', type: 'surface' },
-      { name: 'src', status: 'offen', type: 'surface' },
-    ]);
-    assert.equal(result.state, 'refresh_required');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('an unreadable tracked product file makes its family open without a duplicate covered verdict', async () => {
-  const root = await makeRepository();
-  try {
-    const result = await scanCensus({
-      repoRoot: root,
-      enabled: true,
-      hasActive: true,
-      readText: async (path) => {
-        if (path === join(root, 'src', 'index.mjs')) throw new Error('simulated unreadable product file');
-        return (await import('node:fs/promises')).readFile(path, 'utf8');
-      },
-    });
-
-    assert.deepEqual(result.families.surfaces, [
-      { name: 'production-config', status: 'abgedeckt', type: 'surface' },
-      { name: 'src', status: 'offen', type: 'surface' },
-    ]);
-    assert.equal(result.state, 'refresh_required');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('an untracked source root is open and prevents current', async () => {
-  const root = await makeRepository();
-  try {
-    await mkdir(join(root, 'new-service', 'src'), { recursive: true });
-    await writeFile(join(root, 'new-service', 'src', 'index.mjs'), 'export const newService = true;\n');
-
-    const result = await scanCensus({ repoRoot: root, enabled: true, hasActive: true });
-
-    assert.equal(result.state, 'refresh_required');
-    assert.deepEqual(result.families.surfaces.filter(({ status }) => status === 'offen'), [
-      { name: 'new-service/src', status: 'offen', type: 'surface' },
-    ]);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('delta reports compact path changes and open families', async () => {
-  const root = await makeRepository();
-  try {
-    const previous = await scanCensus({ repoRoot: root });
-    await writeFile(join(root, 'src', 'index.mjs'), 'export const answer = 43;\n');
-    await mkdir(join(root, 'new-service', 'src'), { recursive: true });
-    await writeFile(join(root, 'new-service', 'src', 'index.mjs'), 'export const newService = true;\n');
-    const next = await scanCensus({ repoRoot: root });
-
-    assert.deepEqual(diffCensus(previous, next), {
-      added: [],
-      changed: ['src/index.mjs'],
-      open: ['new-service/src'],
-      removed: [],
-    });
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('content-only edits do not change the topology fingerprint', async () => {
-  const root = await makeRepository();
-  try {
-    const previous = await scanCensus({ repoRoot: root });
-    await writeFile(join(root, 'src', 'index.mjs'), 'export const answer = 99;\n');
-    const next = await scanCensus({ repoRoot: root });
-
-    assert.equal(previous.fingerprints.topology, next.fingerprints.topology);
-    assert.deepEqual(diffCensus(previous, next).changed, ['src/index.mjs']);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('family verdicts expose every machine-readable contract value', () => {
-  assert.deepEqual(CENSUS_VERDICTS, {
-    covered: 'abgedeckt',
-    notRelevant: 'nicht relevant',
-    open: 'offen',
-  });
-});
-
-test('behavior families represent covered, not-relevant, and open verdicts separately', async () => {
-  const root = await makeRepository();
-  try {
-    const result = await scanCensus({
-      repoRoot: root,
-      enabled: true,
-      hasActive: true,
-      behaviorFamilies: [
-        { name: 'auth-session', status: CENSUS_VERDICTS.covered },
-        { name: 'billing', status: CENSUS_VERDICTS.notRelevant },
-        { name: 'email-delivery', status: CENSUS_VERDICTS.open },
-      ],
-    });
-
-    assert.deepEqual(result.families.behaviors, [
-      { name: 'auth-session', status: 'abgedeckt', type: 'behavior' },
-      { name: 'billing', status: 'nicht relevant', type: 'behavior' },
-      { name: 'email-delivery', status: 'offen', type: 'behavior' },
-    ]);
-    assert.ok(result.families.surfaces.every(({ type }) => type === 'surface'));
-    assert.equal(result.state, 'refresh_required');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});

package/scripts/census/state.test.mjs

@@ -1,15 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { CENSUS_STATES, resolveCensusState } from './index.mjs';
-
-test('state resolver implements the complete census state contract', () => {
-  assert.deepEqual(CENSUS_STATES, [
-    'disabled', 'bootstrap', 'current', 'refresh_required', 'updating', 'failed',
-  ]);
-  assert.equal(resolveCensusState({ enabled: false }), 'disabled');
-  assert.equal(resolveCensusState({ enabled: true, hasActive: false }), 'bootstrap');
-  assert.equal(resolveCensusState({ enabled: true, hasActive: true }), 'current');
-  assert.equal(resolveCensusState({ enabled: true, hasActive: true, hasOpen: true }), 'refresh_required');
-  assert.equal(resolveCensusState({ enabled: true, hasActive: true, updating: true }), 'updating');
-  assert.equal(resolveCensusState({ enabled: true, hasActive: true, failed: true }), 'failed');
-});

package/scripts/census/transaction.test.mjs

@@ -1,103 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { activateCensus } from './index.mjs';
-
-test('activation requires a callable verifier before staging or swapping', async () => {
-  for (const verify of [undefined, 'not-callable']) {
-    const root = await mkdtemp(join(tmpdir(), 'awk-census-transaction-'));
-    const activePath = join(root, 'active.json');
-    const previous = '{"generation":"previous"}\n';
-    await writeFile(activePath, previous);
-    let swapped = false;
-    try {
-      await assert.rejects(
-        activateCensus({
-          activePath,
-          candidate: { generation: 'next' },
-          renameCandidate: async () => { swapped = true; },
-          verify,
-        }),
-        /callable verifier/,
-      );
-      assert.equal(await readFile(activePath, 'utf8'), previous);
-      await assert.rejects(readFile(`${activePath}.candidate`), { code: 'ENOENT' });
-      await assert.rejects(readFile(`${activePath}.lock`), { code: 'ENOENT' });
-      assert.equal(swapped, false);
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  }
-});
-
-test('verify failure preserves active bytes and a second run can succeed', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'awk-census-transaction-'));
-  const activePath = join(root, 'active.json');
-  const previous = '{"generation":"previous"}\n';
-  await writeFile(activePath, previous);
-  try {
-    await assert.rejects(
-      activateCensus({
-        activePath,
-        candidate: { generation: 'next' },
-        verify: async () => { throw new Error('fixture verify failure'); },
-      }),
-      (error) => error.state === 'failed',
-    );
-    assert.equal(await readFile(activePath, 'utf8'), previous);
-
-    const result = await activateCensus({
-      activePath,
-      candidate: { generation: 'next' },
-      verify: async ({ generation }) => generation === 'next',
-    });
-    assert.equal(result.state, 'current');
-    assert.equal(await readFile(activePath, 'utf8'), '{"generation":"next"}\n');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('swap failure preserves active bytes', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'awk-census-transaction-'));
-  const activePath = join(root, 'active.json');
-  const previous = '{"generation":"previous"}\n';
-  await writeFile(activePath, previous);
-  try {
-    await assert.rejects(
-      activateCensus({
-        activePath,
-        candidate: { generation: 'next' },
-        renameCandidate: async () => { throw new Error('fixture swap failure'); },
-        verify: async () => true,
-      }),
-      (error) => error.state === 'failed',
-    );
-    assert.equal(await readFile(activePath, 'utf8'), previous);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('an existing local lock reports updating without touching active bytes', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'awk-census-transaction-'));
-  const activePath = join(root, 'active.json');
-  const previous = '{"generation":"previous"}\n';
-  await writeFile(activePath, previous);
-  await writeFile(`${activePath}.lock`, 'held\n');
-  try {
-    await assert.rejects(
-      activateCensus({
-        activePath,
-        candidate: { generation: 'next' },
-        verify: async () => true,
-      }),
-      (error) => error.state === 'updating',
-    );
-    assert.equal(await readFile(activePath, 'utf8'), previous);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});