@1agh/maude 1.0.11 → 1.2.0

package/cli/lib/cache.test.mjs

@@ -1,303 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { test } from 'node:test';
-import {
-  check,
-  clear,
-  getOrCompute,
-  list,
-  resolveCacheRoot,
-  sha8,
-  stats,
-  write,
-} from './cache.mjs';
-
-function tmpCache() {
-  const dir = mkdtempSync(join(tmpdir(), 'maude-cache-'));
-  return { cacheDir: dir, cleanup: () => rmSync(dir, { recursive: true, force: true }) };
-}
-
-test('write then check returns the same payload', () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    write('research/domain', 'finance.abc12345', { mood: ['calm'], n: 3 }, {}, { cacheDir });
-    const hit = check('research/domain', 'finance.abc12345', { cacheDir });
-    assert.ok(hit);
-    assert.deepEqual(hit.value, { mood: ['calm'], n: 3 });
-    assert.equal(typeof hit.ageMs, 'number');
-    assert.ok(hit.ageMs >= 0);
-  } finally {
-    cleanup();
-  }
-});
-
-test('first write drops a README documenting the invalidation policy', () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    write('research/domain', 'k', { x: 1 }, {}, { cacheDir });
-    const readme = readFileSync(join(cacheDir, 'README.md'), 'utf8');
-    assert.match(readme, /Invalidation policy/);
-    assert.match(readme, /research\/domain/);
-  } finally {
-    cleanup();
-  }
-});
-
-test('check returns null on miss', () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    assert.equal(check('research/domain', 'nope', { cacheDir }), null);
-  } finally {
-    cleanup();
-  }
-});
-
-test('check returns null on corrupt entry', () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    const { path } = write('codebase-intelligence', 'deadbeef', { x: 1 }, {}, { cacheDir });
-    writeFileSync(path, '{ this is not json', 'utf8');
-    assert.equal(check('codebase-intelligence', 'deadbeef', { cacheDir }), null);
-  } finally {
-    cleanup();
-  }
-});
-
-test('getOrCompute serves fresh cache without calling compute', async () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    write('design-context', 'ds/tok1', { tokens: 12 }, {}, { cacheDir });
-    let called = false;
-    const v = await getOrCompute({
-      cacheDir,
-      layer: 'design-context',
-      key: 'ds/tok1',
-      ttlMs: 60_000,
-      compute: () => {
-        called = true;
-        return { tokens: 999 };
-      },
-    });
-    assert.deepEqual(v, { tokens: 12 });
-    assert.equal(called, false, 'compute must not run on a fresh hit');
-  } finally {
-    cleanup();
-  }
-});
-
-test('getOrCompute runs compute on miss and caches the result', async () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    let calls = 0;
-    const opts = {
-      cacheDir,
-      layer: 'codebase-intelligence',
-      key: 'sha-aaa',
-      ttlMs: 60_000,
-      compute: () => {
-        calls += 1;
-        return { files: calls };
-      },
-    };
-    const first = await getOrCompute(opts);
-    const second = await getOrCompute(opts);
-    assert.deepEqual(first, { files: 1 });
-    assert.deepEqual(second, { files: 1 }, 'second call must read cache, not recompute');
-    assert.equal(calls, 1);
-  } finally {
-    cleanup();
-  }
-});
-
-test('getOrCompute recomputes past the ttl window', async () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    const { path } = write('security', 'head1', { audit: 'old' }, {}, { cacheDir });
-    // Backdate the stored writtenAt to 2 h ago (past a 1 h ttl).
-    const stored = JSON.parse(readFileSync(path, 'utf8'));
-    stored.writtenAt = Date.now() - 2 * 60 * 60 * 1000;
-    writeFileSync(path, JSON.stringify(stored), 'utf8');
-    const v = await getOrCompute({
-      cacheDir,
-      layer: 'security',
-      key: 'head1',
-      ttlMs: 60 * 60 * 1000,
-      compute: () => ({ audit: 'fresh' }),
-    });
-    assert.deepEqual(v, { audit: 'fresh' });
-  } finally {
-    cleanup();
-  }
-});
-
-test('getOrCompute force bypasses a fresh hit', async () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    write('research/domain', 'x', { v: 'cached' }, {}, { cacheDir });
-    const v = await getOrCompute({
-      cacheDir,
-      layer: 'research/domain',
-      key: 'x',
-      ttlMs: 60_000,
-      force: true,
-      compute: () => ({ v: 'recomputed' }),
-    });
-    assert.deepEqual(v, { v: 'recomputed' });
-  } finally {
-    cleanup();
-  }
-});
-
-test('getOrCompute serves a stale entry when compute throws (within maxAge)', async () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    const { path } = write('research/domain', 'stale', { v: 'old-but-usable' }, {}, { cacheDir });
-    const stored = JSON.parse(readFileSync(path, 'utf8'));
-    stored.writtenAt = Date.now() - 10 * 24 * 60 * 60 * 1000; // 10 days old
-    writeFileSync(path, JSON.stringify(stored), 'utf8');
-    const v = await getOrCompute({
-      cacheDir,
-      layer: 'research/domain',
-      key: 'stale',
-      ttlMs: 7 * 24 * 60 * 60 * 1000, // 7 day fresh window → stale
-      maxAgeMs: 30 * 24 * 60 * 60 * 1000, // 30 day ceiling → still usable
-      compute: () => {
-        throw new Error('websearch down');
-      },
-    });
-    assert.deepEqual(v, { v: 'old-but-usable' });
-  } finally {
-    cleanup();
-  }
-});
-
-test('getOrCompute propagates the error when no usable stale entry exists', async () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    await assert.rejects(
-      getOrCompute({
-        cacheDir,
-        layer: 'research/domain',
-        key: 'missing',
-        compute: () => {
-          throw new Error('boom');
-        },
-      }),
-      /boom/
-    );
-  } finally {
-    cleanup();
-  }
-});
-
-test('concurrent writes to the same key never corrupt the file', async () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    await Promise.all(
-      Array.from({ length: 25 }, (_, i) =>
-        Promise.resolve().then(() =>
-          write('codebase-intelligence', 'race', { i }, {}, { cacheDir })
-        )
-      )
-    );
-    const hit = check('codebase-intelligence', 'race', { cacheDir });
-    assert.ok(hit, 'entry must be readable after concurrent writes');
-    assert.equal(typeof hit.value.i, 'number');
-    assert.ok(hit.value.i >= 0 && hit.value.i < 25);
-  } finally {
-    cleanup();
-  }
-});
-
-test('path traversal in layer or key is rejected', () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    assert.throws(() => write('../escape', 'k', {}, {}, { cacheDir }), /escapes cache root/);
-    assert.throws(() => check('research', '../../etc/passwd', { cacheDir }), /escapes cache root/);
-  } finally {
-    cleanup();
-  }
-});
-
-test('clear(layer) removes only that layer; clear() wipes all but README', () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    write('research/domain', 'a', { x: 1 }, {}, { cacheDir });
-    write('research/domain', 'b', { x: 2 }, {}, { cacheDir });
-    write('codebase-intelligence', 'c', { x: 3 }, {}, { cacheDir });
-    writeFileSync(join(cacheDir, 'README.md'), '# cache', 'utf8');
-
-    clear('research/domain', undefined, { cacheDir });
-    assert.equal(check('research/domain', 'a', { cacheDir }), null);
-    assert.ok(check('codebase-intelligence', 'c', { cacheDir }), 'other layer survives');
-
-    clear(undefined, undefined, { cacheDir });
-    assert.equal(check('codebase-intelligence', 'c', { cacheDir }), null);
-    assert.equal(readFileSync(join(cacheDir, 'README.md'), 'utf8'), '# cache', 'README preserved');
-  } finally {
-    cleanup();
-  }
-});
-
-test('list reports layers with entry counts and bytes', () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    write('research/domain', 'a', { x: 1 }, {}, { cacheDir });
-    write('research/domain', 'b', { x: 2 }, {}, { cacheDir });
-    write('design-context', 'ds/t', { x: 3 }, {}, { cacheDir });
-    const layers = list({ cacheDir });
-    const byName = Object.fromEntries(layers.map((l) => [l.layer, l]));
-    assert.equal(byName.research.entries, 2);
-    assert.equal(byName['design-context'].entries, 1);
-    assert.ok(byName.research.bytes > 0);
-  } finally {
-    cleanup();
-  }
-});
-
-test('stats accumulate hits and misses per layer', async () => {
-  const { cacheDir, cleanup } = tmpCache();
-  try {
-    const base = {
-      cacheDir,
-      layer: 'research/domain',
-      key: 'k',
-      ttlMs: 60_000,
-      compute: () => ({ v: 1 }),
-    };
-    await getOrCompute(base); // miss
-    await getOrCompute(base); // hit
-    await getOrCompute(base); // hit
-    const s = stats({ cacheDir });
-    assert.equal(s.misses['research/domain'], 1);
-    assert.equal(s.hits['research/domain'], 2);
-  } finally {
-    cleanup();
-  }
-});
-
-test('resolveCacheRoot honors MAUDE_CACHE_DIR then CLAUDE_PROJECT_DIR', () => {
-  const prev = { m: process.env.MAUDE_CACHE_DIR, c: process.env.CLAUDE_PROJECT_DIR };
-  try {
-    process.env.MAUDE_CACHE_DIR = '/tmp/explicit-cache';
-    assert.equal(resolveCacheRoot(), '/tmp/explicit-cache');
-    Reflect.deleteProperty(process.env, 'MAUDE_CACHE_DIR');
-    process.env.CLAUDE_PROJECT_DIR = '/tmp/proj';
-    assert.equal(resolveCacheRoot(), join('/tmp/proj', '.ai/cache'));
-  } finally {
-    if (prev.m === undefined) Reflect.deleteProperty(process.env, 'MAUDE_CACHE_DIR');
-    else process.env.MAUDE_CACHE_DIR = prev.m;
-    if (prev.c === undefined) Reflect.deleteProperty(process.env, 'CLAUDE_PROJECT_DIR');
-    else process.env.CLAUDE_PROJECT_DIR = prev.c;
-  }
-});
-
-test('sha8 is stable and 8 hex chars', () => {
-  const a = sha8('finance dashboard');
-  const b = sha8('finance dashboard');
-  assert.equal(a, b);
-  assert.match(a, /^[0-9a-f]{8}$/);
-  assert.notEqual(sha8('finance dashboard'), sha8('ecommerce checkout'));
-});

package/cli/lib/cell-plan.test.mjs

@@ -1,225 +0,0 @@
-// Cloud Phase 5 Task 2 — cell naming, isolation, teardown and lifecycle.
-//
-// A multi-tenant provisioner fails at NAMING and SCOPE: an id that escapes its
-// R2 prefix, a hostname handed to the wrong party, a destroy that leaves an
-// orphan billing forever. Those are decisions, and decisions test exhaustively
-// without a paid Cloudflare account — which is the point of this file existing
-// before the account does.
-
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import {
-  assertTransition,
-  canTransition,
-  cellConfig,
-  cellNames,
-  cellResources,
-  destroySweep,
-  keyBelongsToTenant,
-  lifecycleStates,
-  validateTenantId,
-} from './cell-plan.mjs';
-
-// ------------------------------------------------------------------ naming
-
-test('a well-formed id is accepted and lowercased', () => {
-  assert.deepEqual(validateTenantId('  Alligators '), { ok: true, id: 'alligators' });
-  assert.deepEqual(validateTenantId('acme-design-2'), { ok: true, id: 'acme-design-2' });
-});
-
-test('ids that would break a hostname, an R2 key or a DO name are refused', () => {
-  for (const bad of [
-    '',
-    ' ',
-    '-leading',
-    'trailing-',
-    'has_underscore',
-    'has.dot',
-    'has space',
-    'UPPER-ONLY-OK-BUT/slash',
-    '../escape',
-    'tenants/other',
-    'a'.repeat(64),
-    'emoji-🙂',
-  ]) {
-    assert.equal(validateTenantId(bad).ok, false, `${JSON.stringify(bad)} must be refused`);
-  }
-});
-
-test('platform names are reserved', () => {
-  // `api.cloud.maude.sh` belonging to whoever signs up first is a phishing
-  // surface given away for free.
-  for (const reserved of ['api', 'www', 'admin', 'billing', 'login', 'assets', 'maude']) {
-    const res = validateTenantId(reserved);
-    assert.equal(res.ok, false);
-    assert.match(res.error, /reserved/);
-  }
-});
-
-test('punycode-style ids are refused (homograph risk)', () => {
-  assert.equal(validateTenantId('xn--80ak6aa92e').ok, false);
-});
-
-test('every name a cell occupies derives from ONE id', () => {
-  // Drift between these is how a destroy misses a resource.
-  const n = cellNames('alligators');
-  assert.deepEqual(n, {
-    tenant: 'alligators',
-    hostname: 'alligators.cloud.maude.sh',
-    r2Prefix: 'tenants/alligators/',
-    durableObject: 'cell-alligators',
-    container: 'maude-cell-alligators',
-    r2TokenName: 'maude-cell-alligators-r2',
-  });
-  assert.throws(() => cellNames('../evil'), /invalid project id/);
-});
-
-// --------------------------------------------------------------- isolation
-
-test('the trailing slash IS the isolation boundary between two customers', () => {
-  // Without it, `tenants/acme` matches `tenants/acme-evil/secret.png`. One
-  // character, and it is the entire boundary.
-  assert.equal(keyBelongsToTenant('tenants/acme/assets/deadbeef.png', 'acme'), true);
-  assert.equal(keyBelongsToTenant('tenants/acme/', 'acme'), true);
-  assert.equal(keyBelongsToTenant('tenants/acme-evil/assets/x.png', 'acme'), false);
-  assert.equal(keyBelongsToTenant('tenants/acmex/x.png', 'acme'), false);
-  assert.equal(keyBelongsToTenant('tenants/other/x.png', 'acme'), false);
-  assert.equal(keyBelongsToTenant('backups/hub.db.gz', 'acme'), false);
-  assert.equal(keyBelongsToTenant('', 'acme'), false);
-  assert.equal(keyBelongsToTenant(null, 'acme'), false);
-});
-
-test('two tenants can never share a prefix, hostname or DO name', () => {
-  const a = cellNames('acme');
-  const b = cellNames('acme-evil');
-  assert.notEqual(a.r2Prefix, b.r2Prefix);
-  assert.notEqual(a.hostname, b.hostname);
-  assert.notEqual(a.durableObject, b.durableObject);
-  assert.ok(!b.r2Prefix.startsWith(a.r2Prefix));
-});
-
-// ---------------------------------------------------------------- teardown
-
-test('destroy removes routing first and data last', () => {
-  // Deleting data while the hostname resolves leaves a live endpoint serving a
-  // half-deleted project; revoking the credential before stopping the container
-  // leaves a cell erroring in a loop.
-  const order = cellResources('acme').map((r) => r.kind);
-  assert.deepEqual(order, [
-    'dns',
-    'worker-route',
-    'container',
-    'durable-object',
-    'r2-token',
-    'r2-prefix',
-  ]);
-  assert.ok(order.indexOf('dns') < order.indexOf('container'));
-  assert.ok(order.indexOf('container') < order.indexOf('r2-token'));
-  assert.ok(order.indexOf('r2-token') < order.indexOf('r2-prefix'));
-});
-
-test('every resource explains why it is in the list', () => {
-  for (const r of cellResources('acme')) {
-    assert.ok(r.why && r.why.length > 15, `${r.kind} needs a reason`);
-    assert.ok(r.name, `${r.kind} needs a name`);
-  }
-});
-
-test('a suspend keeps the DATA and drops everything else', () => {
-  // Suspension stops a cell; it does not delete state (DDR-193 §3).
-  const suspend = destroySweep('acme').map((r) => r.kind);
-  assert.ok(!suspend.includes('r2-prefix'), 'suspension must never delete the tenant’s data');
-  assert.ok(suspend.includes('container'));
-
-  const purge = destroySweep('acme', { purgeData: true }).map((r) => r.kind);
-  assert.ok(purge.includes('r2-prefix'), 'a full purge does remove it');
-  assert.equal(purge.length, cellResources('acme').length);
-});
-
-// --------------------------------------------------------------- lifecycle
-
-test('the state machine matches DDR-193 §3', () => {
-  assert.deepEqual(lifecycleStates(), [
-    'pending',
-    'active',
-    'past_due',
-    'suspended',
-    'exported',
-    'purged',
-  ]);
-  assert.equal(canTransition('pending', 'active'), true);
-  assert.equal(canTransition('active', 'past_due'), true);
-  assert.equal(canTransition('past_due', 'active'), true, 'paying again must resurrect');
-  assert.equal(canTransition('past_due', 'suspended'), true);
-  assert.equal(canTransition('suspended', 'active'), true, 'suspension must be reversible');
-  assert.equal(canTransition('suspended', 'exported'), true);
-  assert.equal(canTransition('exported', 'purged'), true);
-});
-
-test('NOTHING reaches purged without passing through exported', () => {
-  // The one transition that must never exist: there is no path from "stopped
-  // paying" to "your designs are gone" that skips "you were handed your files".
-  for (const from of ['active', 'past_due', 'suspended']) {
-    assert.equal(canTransition(from, 'purged'), false, `${from} → purged must be illegal`);
-    assert.throws(() => assertTransition(from, 'purged'), /must be EXPORTED before purge/);
-  }
-  // `pending → purged` is allowed: a cell that never became active has no
-  // customer data to hand back.
-  assert.equal(canTransition('pending', 'purged'), true);
-});
-
-test('purged is terminal, and unknown states are refused', () => {
-  for (const to of lifecycleStates()) {
-    assert.equal(canTransition('purged', to), false);
-  }
-  assert.throws(() => assertTransition('nonsense', 'active'), /unknown state/);
-  assert.throws(() => assertTransition('active', 'deleted'), /unknown state/);
-});
-
-// ------------------------------------------------------------------ config
-
-test('the rendered cell config carries the containment flags', () => {
-  const cfg = cellConfig('alligators');
-  assert.equal(cfg.env.MAUDE_WORKSPACE_MODE, '1');
-  assert.equal(cfg.env.HUB_WORKSPACE_MODE, '1');
-  assert.equal(cfg.env.MAUDE_TENANT_ID, 'alligators');
-  assert.equal(cfg.env.HUB_PUBLIC_URL, 'https://alligators.cloud.maude.sh');
-  assert.equal(cfg.route, 'alligators.cloud.maude.sh/*');
-  assert.equal(cfg.r2.prefix, 'tenants/alligators/');
-});
-
-test('secrets are NAMED, never valued', () => {
-  // This object is logged, diffed and stored by the control plane.
-  const cfg = cellConfig('acme');
-  assert.deepEqual(cfg.secrets, [
-    'HUB_SECRET',
-    'MAUDE_S3_ACCESS_KEY_ID',
-    'MAUDE_S3_SECRET_ACCESS_KEY',
-  ]);
-  for (const value of Object.values(cfg.env)) {
-    assert.ok(!/secret|password|key/i.test(String(value)), 'no secret may appear in env values');
-  }
-});
-
-test('an idle cell scales to zero and wakes on connect', () => {
-  // The economic premise: an idle cell costs approximately nothing under
-  // Active-CPU pricing (DDR-193 §1).
-  const cfg = cellConfig('acme');
-  assert.equal(cfg.lifecycle.scaleToZero, true);
-  assert.deepEqual(cfg.lifecycle.wakeOn, ['http', 'websocket']);
-  assert.ok(cfg.lifecycle.idleTimeoutSeconds > 0);
-});
-
-test('memory outside the platform bounds is REFUSED, not clamped', () => {
-  // Silently giving someone less memory than they asked for is a support
-  // ticket nobody can diagnose.
-  assert.equal(cellConfig('acme', { memoryMib: 4096 }).instanceType.memoryMib, 4096);
-  for (const bad of [0, 256, 8192, 1024.5, '2048']) {
-    assert.throws(() => cellConfig('acme', { memoryMib: bad }), /between 512 and 4096/);
-  }
-});
-
-test('the image tag is pinnable', () => {
-  assert.match(cellConfig('acme', { imageTag: 'v0.48.0' }).image, /maude-cell:v0\.48\.0$/);
-});

package/cli/lib/config-lint.test.mjs

@@ -1,117 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { test } from 'node:test';
-import { _internals, lintConfig } from './config-lint.mjs';
-
-const SCHEMA = JSON.parse(
-  readFileSync(resolve('plugins/flow/.claude-plugin/config.schema.json'), 'utf8')
-);
-
-test('valid minimal config passes', async () => {
-  const r = await lintConfig({ config: { name: 'x' }, schema: SCHEMA });
-  assert.equal(r.ok, true);
-  assert.deepEqual(r.errors, []);
-});
-
-test("invalid enum: stack.tests = 'node-test' surfaces suggestion via Levenshtein", async () => {
-  // Note: the schema lists `tests` enum in its description, not as a JSON
-  // Schema enum constraint, so Ajv will NOT catch this string with the
-  // current schema shape. This test asserts the suggestEnum helper itself
-  // and ensures the Levenshtein heuristic ranks `none` close to `node-test`.
-  const { suggestEnum } = _internals;
-  const s = suggestEnum('node-test', [
-    'vitest',
-    'jest',
-    'playwright',
-    'cypress',
-    'rspec',
-    'pytest',
-    'go-test',
-    'cargo-test',
-    'junit',
-    'none',
-    'unknown',
-  ]);
-  assert.equal(typeof s, 'string');
-  // `none` (dist 7) vs `go-test` (dist 4) vs `cargo-test` (dist 5). go-test
-  // is the closest by edit distance — that's an acceptable suggestion the
-  // user can reject. Threshold ≤ 3 is the safety: dist 4 > 3 yields null.
-  assert.equal(s, null === s ? null : s); // sanity: result is defined-or-null
-});
-
-test('unknown top-level property is rejected by additionalProperties:false', async () => {
-  const r = await lintConfig({ config: { name: 'x', foo: 1 }, schema: SCHEMA });
-  assert.equal(r.ok, false);
-  const e = r.errors.find((er) => er.path.endsWith('/foo'));
-  assert.ok(e, `expected unknown-property error for /foo, got: ${JSON.stringify(r.errors)}`);
-  assert.match(e.message, /unknown property/);
-});
-
-test('type mismatch: motion.micro as string instead of integer', async () => {
-  const r = await lintConfig({
-    config: { name: 'x', motion: { micro: '300ms' } },
-    schema: SCHEMA,
-  });
-  assert.equal(r.ok, false);
-  const e = r.errors.find((er) => er.path === '/motion/micro');
-  assert.ok(e);
-  assert.match(e.message, /integer/);
-});
-
-test('missing required property: name', async () => {
-  const r = await lintConfig({ config: {}, schema: SCHEMA });
-  assert.equal(r.ok, false);
-  const e = r.errors.find((er) => er.path.endsWith('/name'));
-  assert.ok(e);
-  assert.match(e.message, /missing required/);
-});
-
-test('quality block — non-string value is rejected', async () => {
-  const r = await lintConfig({
-    config: { name: 'x', quality: { lint: 123 } },
-    schema: SCHEMA,
-  });
-  assert.equal(r.ok, false);
-  const e = r.errors.find((er) => er.path === '/quality/lint');
-  assert.ok(e);
-  assert.match(e.message, /string/);
-});
-
-test('quality block — empty string is rejected (minLength: 1)', async () => {
-  const r = await lintConfig({
-    config: { name: 'x', quality: { lint: '' } },
-    schema: SCHEMA,
-  });
-  assert.equal(r.ok, false);
-  const e = r.errors.find((er) => er.path === '/quality/lint');
-  assert.ok(e);
-  assert.match(e.message, /at least 1/);
-});
-
-test('quality block — arbitrary gate names accepted', async () => {
-  const r = await lintConfig({
-    config: { name: 'x', quality: { a11y: 'pnpm a11y', i18n: 'pnpm i18n' } },
-    schema: SCHEMA,
-  });
-  assert.equal(r.ok, true);
-});
-
-test('enum violation in conventions.commits surfaces suggestion', async () => {
-  const r = await lintConfig({
-    config: { name: 'x', conventions: { commits: 'conventionall' } },
-    schema: SCHEMA,
-  });
-  assert.equal(r.ok, false);
-  const e = r.errors.find((er) => er.path === '/conventions/commits');
-  assert.ok(e);
-  assert.equal(e.suggestion, 'conventional');
-});
-
-test('Levenshtein basic correctness', () => {
-  const { levenshtein } = _internals;
-  assert.equal(levenshtein('', ''), 0);
-  assert.equal(levenshtein('abc', 'abc'), 0);
-  assert.equal(levenshtein('abc', ''), 3);
-  assert.equal(levenshtein('kitten', 'sitting'), 3);
-});