@jantstack/adonis-authz 1.1.0 → 2.4.0-alpha.1

package/build/src/testing/contract.js

@@ -2,32 +2,400 @@ import '@japa/assert';
 import { test } from '@japa/runner';
 import { v7 as uuidv7 } from 'uuid';
 import { APP_SCOPE } from '../types.js';
-/** Catálogo de prueba: roles a nivel app y a nivel organization. */
+import { AuthorizationManager } from '../manager.js';
+import db from '@adonisjs/lucid/services/db';
+import { CatalogCache, GLOBAL_OWNER_KEY, withAuthzCatalogWrite } from '../catalog/catalog_cache.js';
+import { scopeKey } from '../identity.js';
+import { descendantsFrom, memoryScopeTree, resolveChainFrom } from './scope_tree.js';
+/**
+ * Catálogo de prueba: roles a nivel app y a nivel organization. Los dos
+ * últimos existen solo para el invariante 8: `rank` es metadata y el motor no
+ * lo evalúa (un rol de rango alto no concede lo que no tiene).
+ */
 const CONTRACT_CATALOG = {
-    permissions: [{ slug: 'docs:read' }, { slug: 'docs:write' }, { slug: 'billing:read' }],
+    permissions: [
+        { slug: 'docs:read' },
+        { slug: 'docs:write' },
+        { slug: 'billing:read' },
+        // 3B · B5: solo los roles de app y organization pueden llevarlo (composición).
+        { slug: 'org:settings', assignableAt: ['app', 'organization'] },
+    ],
     roles: [
         { slug: 'editor', scopeType: 'app', permissions: ['docs:read', 'docs:write'] },
+        // 3B: el administrador de una organization (rank 50) es quien delega roles locales.
+        { slug: 'org-admin', scopeType: 'organization', rank: 50, permissions: ['docs:read', 'docs:write', 'billing:read', 'org:settings'] },
         { slug: 'viewer', scopeType: 'app', permissions: ['docs:read'] },
         { slug: 'org-editor', scopeType: 'organization', permissions: ['docs:read', 'docs:write'] },
+        { slug: 'unit-editor', scopeType: 'unit', permissions: ['docs:write'] },
+        { slug: 'auditor-senior', scopeType: 'app', rank: 100, permissions: ['billing:read'] },
+        { slug: 'scribe', scopeType: 'app', rank: 0, permissions: ['docs:write'] },
+        // Mismo slug en dos niveles: `hasRole` con string no debe confundirlos (L0.6).
+        { slug: 'owner', scopeType: 'app', permissions: ['billing:read'] },
+        { slug: 'owner', scopeType: 'organization', permissions: ['docs:read'] },
     ],
 };
+/**
+ * El mismo driver con OTRO memo del catálogo (2D · F1): una vista por
+ * prototipo cuyo `catalog` es un `CatalogCache` nuevo. Todo lo demás
+ * (cliente, conexión, resolutor) es el del original. Para un driver sin
+ * `catalog` no hay memo que separar: se devuelve tal cual.
+ */
+function twinOf(driver) {
+    const catalog = driver.catalog;
+    if (!(catalog instanceof CatalogCache))
+        return driver;
+    const twin = Object.create(driver);
+    Object.defineProperty(twin, 'catalog', { value: new CatalogCache(), enumerable: true });
+    return twin;
+}
+/**
+ * Lo que un sync de otro proceso deja en la base al quitar un permiso de un
+ * rol: el vínculo ya no está y la versión compartida subió, en UNA
+ * transacción con el bump como última sentencia (`withAuthzCatalogWrite`, 2E
+ * · H2). Ninguna señal en memoria: es exactamente lo que cruza procesos.
+ */
+async function removeLinkRow(role, scopeType, permission) {
+    let roleUuid = '';
+    await withAuthzCatalogWrite(async (trx) => {
+        const roleRow = (await trx.from('authz_roles').where('slug', role).where('scope_type', scopeType).where('owner_scope_key', GLOBAL_OWNER_KEY).select('uuid'))[0];
+        const permRow = (await trx.from('authz_permissions').where('slug', permission).select('uuid'))[0];
+        roleUuid = String(roleRow.uuid);
+        await trx.from('authz_role_permissions').where('role_uuid', roleRow.uuid).where('permission_uuid', permRow.uuid).delete();
+    });
+    return roleUuid;
+}
+/**
+ * Un rol LOCAL a `owner` escrito directamente en `authz_*` (3B · B2), como
+ * lo dejaría `defineScopedRole` en otro proceso: fila con
+ * `owner_scope_key = scopeKey(owner)` y sus vínculos, en una transacción con
+ * la versión subida al final. Sirve para juzgar al DRIVER (visibilidad por
+ * owner) sin pasar por la policy del manager (que se juzga aparte, con
+ * `defineScopedRole`). Devuelve el uuid del rol.
+ */
+async function insertLocalRole(owner, spec) {
+    const uuid = uuidv7();
+    await withAuthzCatalogWrite(async (trx) => {
+        const now = new Date();
+        await trx.table('authz_roles').insert({
+            uuid,
+            slug: spec.slug,
+            name: spec.slug,
+            scope_type: spec.scopeType,
+            rank: spec.rank ?? 0,
+            owner_scope_key: scopeKey(owner),
+            created_at: now,
+            updated_at: now,
+        });
+        for (const permission of spec.permissions) {
+            const permRow = (await trx.from('authz_permissions').where('slug', permission).select('uuid'))[0];
+            await trx.table('authz_role_permissions').insert({ uuid: uuidv7(), role_uuid: uuid, permission_uuid: permRow.uuid, created_at: now });
+        }
+    });
+    return uuid;
+}
+/**
+ * Cambia a mano el NIVEL declarado de un rol (`authz_roles.scope_type`), con
+ * la versión subida (3D · N1). Es la forma de observar en LOS DOS drivers la
+ * paridad «una asignación cuenta si su rol está declarado para el nivel de
+ * ESE scope»: el catálogo siempre es SQL, así que una asignación creada
+ * legalmente queda apuntando a un rol de otro nivel sin escribir hechos a
+ * mano (que en `openfga` no serían escribibles por el puerto).
+ */
+async function retypeRoleRow(roleUuid, scopeType) {
+    await withAuthzCatalogWrite(async (trx) => {
+        await trx.from('authz_roles').where('uuid', roleUuid).update({ scope_type: scopeType, updated_at: new Date() });
+    });
+}
+/**
+ * Los vínculos rol→permiso que quedan en `authz_role_permissions` para ese
+ * rol. El catálogo siempre es SQL, en los dos drivers, así que mirarlo aquí
+ * no acopla a ninguno.
+ *
+ * **Aviso honesto (3F · U2, tester 3E · R7)**: esta cuenta DOCUMENTA la
+ * promesa, no la falsa. El «todo o nada» del borrado de vínculos lo garantiza
+ * el ESQUEMA —`authz_role_permissions.role_uuid ON DELETE CASCADE`, y
+ * `authz_assignments.role_uuid ON DELETE RESTRICT` para las asignaciones—,
+ * vigilado por el guard stub↔espejo (K11, `delete_rule` a `delete_rule`). Un
+ * driver que borrase la fila del rol y se olvidara de los vínculos pasa este
+ * caso igual en SQLite, PostgreSQL y MySQL: el motor los borra por él
+ * (mutante EQUIVALENTE bajo este esquema, medido). Un driver de terceros
+ * sobre un esquema sin esas acciones —o con las FK desactivadas— tiene que
+ * borrarlos ÉL, y ningún caso de esta suite se lo va a decir.
+ */
+async function linksOf(roleUuid) {
+    const rows = await db.from('authz_role_permissions').where('role_uuid', roleUuid).select('uuid');
+    return rows.length;
+}
+/**
+ * Un rol local escrito SIN subir la versión del catálogo (3E · R2): es lo que
+ * ve un escritor cuya foto del memo se tomó antes de que otro proceso
+ * confirmara el suyo. Solo la relectura de la BASE dentro de la transacción
+ * serializada (3D · M2 b) puede pararlo; el chequeo barato contra el memo no.
+ */
+async function insertRoleUnseen(spec) {
+    const uuid = uuidv7();
+    const now = new Date();
+    await db.table('authz_roles').insert({
+        uuid,
+        slug: spec.slug,
+        name: spec.slug,
+        scope_type: spec.scopeType,
+        rank: 1,
+        owner_scope_key: spec.owner,
+        created_at: now,
+        updated_at: now,
+    });
+    return uuid;
+}
+/** Las filas de `authz_roles` con ese `(slug, nivel)`, leídas de la base (sin pasar por el memo). */
+async function rowsNamed(slug, scopeType) {
+    return db.from('authz_roles').where('slug', slug).where('scope_type', scopeType).select('uuid');
+}
+/** El rol local `roleUuid` borrado A MANO (lo que la plataforma tiene que hacer sin `purgeRole`), con la versión subida. */
+async function forgetRoleByHand(roleUuid) {
+    await withAuthzCatalogWrite(async (trx) => {
+        await trx.from('authz_role_permissions').where('role_uuid', roleUuid).delete();
+        await trx.from('authz_roles').where('uuid', roleUuid).delete();
+    });
+}
+/** Un vínculo rol→permiso escrito a mano (lo que un sync rechazaría), con la versión subida. */
+async function insertLinkRow(roleUuid, permission) {
+    await withAuthzCatalogWrite(async (trx) => {
+        const permRow = (await trx.from('authz_permissions').where('slug', permission).select('uuid'))[0];
+        await trx.table('authz_role_permissions').insert({ uuid: uuidv7(), role_uuid: roleUuid, permission_uuid: permRow.uuid, created_at: new Date() });
+    });
+}
 function subject(type = 'users') {
     return { type, uuid: uuidv7() };
 }
+/**
+ * Reloj controlado del juez (2.5 · J1): un instante fijo que solo se mueve
+ * cuando el caso lo dice. Es lo que se inyecta con `driver.withClock(now)` y
+ * en `config.clock`: cada pregunta ve exactamente este `Date`.
+ */
+function fixedClock(start) {
+    let current = new Date(start.getTime());
+    return {
+        now: () => new Date(current.getTime()),
+        set: (at) => {
+            current = new Date(at.getTime());
+        },
+        advance: (ms) => {
+            current = new Date(current.getTime() + ms);
+        },
+    };
+}
 function orgScope(uuid = uuidv7()) {
     return { type: 'organization', uuid };
 }
+function unitScope(uuid = uuidv7()) {
+    return { type: 'unit', uuid };
+}
+/** Una organization nueva, ya colgada del padre en el árbol del harness. */
+async function orgUnder(tree, parent) {
+    const org = orgScope();
+    await tree.attach(org, parent);
+    return org;
+}
+/** Una unit nueva, ya colgada del padre en el árbol del harness. */
+async function unitUnder(tree, parent) {
+    const unit = unitScope();
+    await tree.attach(unit, parent);
+    return unit;
+}
+function scopeKeys(scopes) {
+    return scopes.map((s) => `${s.type}:${s.uuid ?? ''}`).sort();
+}
+const LEVEL_RANK = { core: 0, '2.0': 1, '2.1': 2, '2.2': 3 };
+/**
+ * La llamada rechaza con el `status` y el `code` esperados. `assert.rejects`
+ * a secas aceptaría cualquier error —un `SqliteError` sin status, un 503 por
+ * un 422— y el contrato distingue precisamente esos tres estados.
+ */
+async function rejectsWith(assert, fn, expected) {
+    try {
+        await fn();
+    }
+    catch (error) {
+        assert.equal(error?.status, expected.status, `status de ${error?.message ?? error}`);
+        assert.equal(error?.code, expected.code, `code de ${error?.message ?? error}`);
+        return error;
+    }
+    assert.fail('debería haber rechazado');
+}
 export function runAuthorizationDriverContract(harness) {
-    test.group(`authorization contract [${harness.name}]`, (group) => {
+    return registerAuthorizationDriverContract(harness, {
+        group: (title, define) => test.group(title, define),
+        test: (title, fn) => test(title, fn),
+    });
+}
+export function registerAuthorizationDriverContract(harness, api) {
+    const { test } = api;
+    const level = harness.level ?? 'core';
+    /** Capacidades con par registrado en esta ejecución (ver `caseFor`). */
+    const covered = new Set();
+    api.group(`authorization contract [${harness.name} · ${level}]`, (group) => {
         let driver;
+        let tree;
+        /** Registra el caso solo si el harness pidió ese nivel o uno superior. */
+        let registered = 0;
+        const test = (title, fn) => {
+            registered += 1;
+            return api.test(title, fn);
+        };
+        function since(minLevel, title, fn) {
+            if (LEVEL_RANK[level] >= LEVEL_RANK[minLevel])
+                return test(title, fn) ?? undefined;
+        }
+        /**
+         * Par de casos de una capacidad: se registra la cara que el harness
+         * declara y se anota como cubierta. Una capacidad declarada `true` sin
+         * cara `whenTrue` queda sin cubrir y la suite lanza al cerrar el grupo.
+         */
+        function caseFor(capability, pair) {
+            const side = harness.capabilities[capability] ? pair.whenTrue : pair.whenFalse;
+            if (!side)
+                return;
+            // Una capacidad solo cuenta como juzgada si su lado registró al menos
+            // un caso: un par que se registra bajo un `since` de nivel superior no
+            // cubre nada en un harness `core`, y no debe parecer que sí.
+            const before = registered;
+            side();
+            if (registered > before)
+                covered.add(capability);
+        }
         group.each.setup(async () => {
             await harness.cleanup();
             await harness.seedCatalog(CONTRACT_CATALOG);
-            driver = await harness.makeDriver();
+            tree = harness.makeTree ? await harness.makeTree() : memoryScopeTree();
+            driver = await harness.makeDriver(tree);
+            // `tree.detach` es lo que el consumidor hace al borrar un scope, y el
+            // contrato exige que los hechos se purguen (N7/N8): el harness purga
+            // PRIMERO (el driver demuestra cero) y quita la arista DESPUÉS (S6).
+            // Se parchea el objeto en sitio (no se envuelve) para que el driver,
+            // que ya lo tiene, y los casos que parchean `chainOf` vean el mismo.
+            const detachEdge = tree.detach.bind(tree);
+            tree.detach = async (child) => {
+                await driver.purgeScope(child);
+                // El árbol del BACKEND, si el driver lo materializa (3b-2e · E6):
+                // la arista se va DESPUÉS de que la purga demuestre cero (S6), igual
+                // que hace `manager.scopes.detached`.
+                await driver.onScopeDetached?.(child);
+                await detachEdge(child);
+            };
+            // **El espejo del árbol** (3b-2e · E6). Un driver que declara
+            // `hierarchyFacts` NO lee el árbol del consumidor para decidir: lo tiene
+            // como hechos propios, y quien se los cuenta es el consumidor con
+            // `authorization.scopes.*`. La suite mueve el árbol con `tree.attach` /
+            // `tree.move` directamente (decenas de sitios), así que aquí se espeja:
+            // primero la fila del consumidor, después la notificación al driver —
+            // que es el orden en el que el paquete valida (el padre tiene que
+            // existir para el resolutor).
+            if (harness.capabilities.hierarchyFacts) {
+                /**
+                 * El juez cuelga a propósito scopes que el PAQUETE considera
+                 * identidad inválida (el uuid centinela de la raíz) para comprobar
+                 * que ninguna escritura los acepta. El espejo no puede tumbar ese
+                 * caso: si el driver rechaza el nodo por identidad, el store
+                 * simplemente no se entera —y las escrituras siguen siendo 422, que
+                 * es lo que el caso mide—. Cualquier otro error SÍ se propaga (un
+                 * ciclo, un padre desconocido, el backend caído).
+                 */
+                const mirror = async (notify) => {
+                    try {
+                        await notify();
+                    }
+                    catch (error) {
+                        if (error?.code !== 'E_AUTHZ_INVALID_IDENTITY')
+                            throw error;
+                    }
+                };
+                const attachEdge = tree.attach.bind(tree);
+                tree.attach = async (child, parent) => {
+                    await attachEdge(child, parent);
+                    await mirror(() => driver.onScopeAttached?.(child, parent));
+                };
+                const moveEdge = tree.move.bind(tree);
+                tree.move = async (child, parent) => {
+                    await moveEdge(child, parent);
+                    await mirror(() => driver.onScopeMoved?.(child, parent));
+                };
+            }
         });
         group.teardown(async () => {
             await harness.cleanup();
         });
+        /**
+         * Las primitivas de 2.1 (`within`, `authorizedScopes`, `effectivePermissions`,
+         * `authorizeMany`) son COMPOSICIÓN del manager sobre el puerto: el juez
+         * las observa a través de un manager construido sobre el driver del
+         * harness y el árbol del juez. Un driver que solo implemente el puerto
+         * 2.0 pasa por aquí igual; lo que le falte (`listDenies`) se ve como
+         * 500 `E_AUTHZ_UNSUPPORTED` en el caso que lo necesita, nunca como skip.
+         */
+        /**
+         * Un rol LOCAL escrito directamente en `authz_*`, como haría otro proceso
+         * —y, desde 3b-2e · E6, con la **proyección derivada** del driver puesta
+         * al día: en un driver donde lo que un rol concede son tuplas (modo
+         * `facts`), un rol escrito sin proyectar no concedería nada y el caso
+         * mediría el espejo en vez del invariante.
+         */
+        /**
+         * Los dos escritores «a mano» del catálogo, con la **proyección derivada**
+         * del driver al día (3b-2e · E6). Un proceso que escribe `authz_*` por
+         * fuera del sync ya tenía el deber de invalidar el memo (2A); en un driver
+         * que mantiene un espejo del catálogo en el backend (modo `facts`) también
+         * tiene que rehacer ese espejo — es lo que hace `syncAuthzCatalog` cuando
+         * se le pasa la proyección, y lo que `authz:reconcile` repara si se pierde.
+         */
+        async function withoutLink(role, scopeType, permission) {
+            const uuid = await removeLinkRow(role, scopeType, permission);
+            await driver.projectCatalogRole?.(uuid);
+        }
+        async function linkByHand(roleUuid, permission) {
+            await insertLinkRow(roleUuid, permission);
+            await driver.projectCatalogRole?.(roleUuid);
+        }
+        async function localRole(owner, spec) {
+            const uuid = await insertLocalRole(owner, spec);
+            await driver.projectCatalogRole?.(uuid);
+            return uuid;
+        }
+        /**
+         * El TERCER escritor a mano: el NIVEL declarado de un rol (3b-2g · R1).
+         * Misma regla que los otros dos —quien escribe `authz_*` por fuera del
+         * sync rehace la proyección derivada del driver—, y aquí no es un detalle
+         * del harness: en `facts` la visibilidad de un rol también está
+         * materializada (la arista `scope#binding` significa «el rol es visible
+         * aquí»), así que un `scope_type` cambiado sin proyectar deja concediendo
+         * lo que el catálogo ya no declara en ese nivel. En `database`
+         * `projectCatalogRole` no existe y esto es un no-op: la regla se evalúa en
+         * cada pregunta.
+         */
+        async function retypeRole(roleUuid, scopeType) {
+            await retypeRoleRow(roleUuid, scopeType);
+            await driver.projectCatalogRole?.(roleUuid);
+        }
+        function managerOver(overrides = {}, over = driver) {
+            return new AuthorizationManager({
+                default: harness.name,
+                drivers: { [harness.name]: () => over },
+                warnOnOptInSecurity: false,
+                ...overrides,
+                // `scopes` va DESPUÉS de los overrides y los respeta enteros (hay
+                // casos que quitan `descendantsOf` a propósito): lo único que se
+                // añade siempre es la firma del riesgo de deriva. El juez juzga el
+                // DRIVER; la outbox es una mitigación del CONFIG (3b-2e · E3) y aquí
+                // el árbol lo mueve la propia suite, no una transacción de consumidor.
+                scopes: {
+                    ...(overrides.scopes ?? {
+                        resolveChain: resolveChainFrom(tree),
+                        descendantsOf: descendantsFrom(tree),
+                    }),
+                    acceptScopeDriftRisk: true,
+                },
+            });
+        }
         test('grant de un rol concede sus permisos (authorize true)', async ({ assert }) => {
             const alice = subject();
             await driver.grant(alice, 'editor', APP_SCOPE);
@@ -82,22 +450,24 @@ export function runAuthorizationDriverContract(harness) {
         });
         test('scope aislado: grant en una org NO autoriza en app ni en otra org', async ({ assert, }) => {
             const alice = subject();
-            const orgA = orgScope();
-            const orgB = orgScope();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
             await driver.grant(alice, 'org-editor', orgA);
             assert.isTrue(await driver.authorize(alice, 'docs:write', orgA));
+            // orgB EXISTE en el árbol: el false es por aislamiento, no por scope desconocido.
             assert.isFalse(await driver.authorize(alice, 'docs:write', orgB));
             assert.isFalse(await driver.authorize(alice, 'docs:write', APP_SCOPE));
         });
         test('herencia hacia abajo: grant a nivel app autoriza dentro de una org', async ({ assert, }) => {
             const alice = subject();
+            const org = await orgUnder(tree, APP_SCOPE);
             await driver.grant(alice, 'editor', APP_SCOPE);
-            assert.isTrue(await driver.authorize(alice, 'docs:write', orgScope()));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', org));
         });
         test('deny en el scope cercano bloquea el grant heredado, solo ahí', async ({ assert }) => {
             const alice = subject();
-            const orgA = orgScope();
-            const orgB = orgScope();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
             await driver.grant(alice, 'editor', APP_SCOPE);
             await driver.deny(alice, 'docs:write', orgA);
             assert.isFalse(await driver.authorize(alice, 'docs:write', orgA));
@@ -112,9 +482,9 @@ export function runAuthorizationDriverContract(harness) {
             assert.isTrue(await driver.authorize(asUser, 'docs:read', APP_SCOPE));
             assert.isFalse(await driver.authorize(asAdmin, 'docs:read', APP_SCOPE));
         });
-        test('grant duplicado es idempotente (y refresca expiresAt)', async ({ assert }) => {
+        test('grant duplicado es idempotente (y revive una asignación expirada)', async ({ assert }) => {
             const alice = subject();
-            // Primera vez expirada, re-grant sin expiración: debe quedar vigente y única.
+            // Primera vez expirada, re-grant sin opciones: debe quedar vigente y única.
             await driver.grant(alice, 'editor', APP_SCOPE, {
                 expiresAt: new Date(Date.now() - 60_000),
             });
@@ -124,12 +494,235 @@ export function runAuthorizationDriverContract(harness) {
             const holders = await driver.listSubjects('editor', APP_SCOPE);
             assert.lengthOf(holders.filter((h) => h.uuid === alice.uuid), 1);
         });
+        // ── Par de capacidad `injectableClock` (2.5 · J1) ────────────────────
+        // L0.4, los tres estados de `expiresAt`: "asegúrate de que tiene el rol"
+        // (un seeder, un onboarding) es un grant SIN opciones, y convertía un
+        // acceso temporal en permanente: `expiresAt` omitido se guardaba como
+        // NULL. Ahora omitido = no tocar una caducidad vigente; `null` = quitarla
+        // explícitamente; y sobre una asignación YA expirada el re-grant revive
+        // sin caducidad (es un grant nuevo a todos los efectos). El driver
+        // devuelve lo que hizo (`GrantOutcome`), pero lo que se juzga es el
+        // hecho: la caducidad preservada vence, la quitada no. La cara `true`
+        // lo observa con el reloj inyectado (sin dormir y con igualdad EXACTA de
+        // instantes); la cara `false` solo puede observarlo en tiempo real.
+        caseFor('injectableClock', {
+            whenTrue: () => {
+                test('expiresAt en tres estados con el reloj inyectado: omitido preserva la caducidad vigente, null la quita, expirada revive; el instante que vence es exacto', async ({ assert, }) => {
+                    assert.typeOf(driver.withClock, 'function', 'injectableClock: true exige withClock en el puerto');
+                    // Relativo a hoy (2.5-B · K7): al final se observa el driver SIN
+                    // reloj, para el que `soon` tiene que seguir siendo futuro — un
+                    // instante fijo (2030) sería una bomba de relojería en el juez.
+                    const clock = fixedClock(new Date(Date.now() + 365 * 24 * 3_600_000));
+                    const clocked = driver.withClock(clock.now);
+                    const keep = subject();
+                    const lift = subject();
+                    const revive = subject();
+                    const soon = new Date(clock.now().getTime() + 1_500);
+                    await clocked.grant(keep, 'editor', APP_SCOPE, { expiresAt: soon });
+                    const kept = await clocked.grant(keep, 'editor', APP_SCOPE);
+                    await clocked.grant(lift, 'editor', APP_SCOPE, { expiresAt: soon });
+                    const lifted = await clocked.grant(lift, 'editor', APP_SCOPE, { expiresAt: null });
+                    const past = new Date(clock.now().getTime() - 60_000);
+                    await clocked.grant(revive, 'editor', APP_SCOPE, { expiresAt: past });
+                    assert.isFalse(await clocked.authorize(revive, 'docs:read', APP_SCOPE));
+                    const revived = await clocked.grant(revive, 'editor', APP_SCOPE);
+                    assert.isTrue(kept.existed);
+                    assert.equal(kept.expiresAt.getTime(), soon.getTime());
+                    assert.isTrue(lifted.existed);
+                    assert.isNull(lifted.expiresAt);
+                    assert.equal(lifted.previousExpiresAt.getTime(), soon.getTime());
+                    assert.isTrue(revived.existed);
+                    assert.isNull(revived.expiresAt);
+                    assert.equal(revived.previousExpiresAt.getTime(), past.getTime());
+                    assert.isTrue(await clocked.authorize(revive, 'docs:read', APP_SCOPE));
+                    assert.isTrue(await clocked.authorize(keep, 'docs:read', APP_SCOPE));
+                    assert.isTrue(await clocked.authorize(lift, 'docs:read', APP_SCOPE));
+                    // Un milisegundo antes de vencer sigue vigente; en el instante exacto, no.
+                    clock.set(new Date(soon.getTime() - 1));
+                    assert.isTrue(await clocked.authorize(keep, 'docs:read', APP_SCOPE));
+                    clock.set(soon);
+                    assert.isFalse(await clocked.authorize(keep, 'docs:read', APP_SCOPE));
+                    assert.isTrue(await clocked.authorize(lift, 'docs:read', APP_SCOPE));
+                    assert.isTrue(await clocked.authorize(revive, 'docs:read', APP_SCOPE));
+                    // El driver sin reloj inyectado no se ha tocado: para él (hoy) `soon` —dentro de un año— es futuro.
+                    assert.isTrue(await driver.authorize(keep, 'docs:read', APP_SCOPE));
+                });
+                since('2.1', 'caducidad exacta con el reloj inyectado: en T−1 ms concede, en T no, en T+1 ms no —authorize, hasRole y los list*—; la renovación y el revivir se observan sin dormir', async ({ assert, }) => {
+                    // 2.5 · J1. Antes `whereActive` (SQL) y `checkContext` (FGA) leían
+                    // `new Date()`: la frontera exacta de la caducidad no era observable
+                    // sin una ventana de tiempo real. `T` lleva milisegundos a propósito
+                    // (J3): un motor que trunque a segundos falla aquí.
+                    const T = new Date('2030-06-15T12:34:56.789Z');
+                    const clock = fixedClock(new Date(T.getTime() - 60_000));
+                    const clocked = driver.withClock(clock.now);
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    await clocked.grant(alice, 'editor', APP_SCOPE, { expiresAt: T });
+                    const observe = async () => ({
+                        authorize: await clocked.authorize(alice, 'docs:read', org),
+                        hasRole: await clocked.hasRole(alice, 'editor', org),
+                        listSubjects: (await clocked.listSubjects('editor', APP_SCOPE)).some((h) => h.uuid === alice.uuid),
+                        listRoles: await clocked.listRoles(alice, APP_SCOPE),
+                        listRoleScopes: (await clocked.listRoleScopes(alice, 'app')).length,
+                        listScopes: (await clocked.listScopes(alice, 'docs:read')).length,
+                    });
+                    const alive = { authorize: true, hasRole: true, listSubjects: true, listRoles: ['editor'], listRoleScopes: 1, listScopes: 1 };
+                    const gone = { authorize: false, hasRole: false, listSubjects: false, listRoles: [], listRoleScopes: 0, listScopes: 0 };
+                    clock.set(new Date(T.getTime() - 1));
+                    assert.deepEqual(await observe(), alive, 'T−1 ms');
+                    clock.set(T);
+                    assert.deepEqual(await observe(), gone, 'T: el que expira ahora ya no cuenta');
+                    clock.set(new Date(T.getTime() + 1));
+                    assert.deepEqual(await observe(), gone, 'T+1 ms');
+                    // Renovación: un re-grant con caducidad posterior vuelve a conceder hasta ESE instante.
+                    const T2 = new Date(T.getTime() + 1_000);
+                    const renewed = await clocked.grant(alice, 'editor', APP_SCOPE, { expiresAt: T2 });
+                    assert.isTrue(renewed.existed);
+                    assert.equal(renewed.previousExpiresAt.getTime(), T.getTime());
+                    assert.equal(renewed.expiresAt.getTime(), T2.getTime());
+                    assert.deepEqual(await observe(), alive, 'renovada en T+1 ms');
+                    clock.set(new Date(T2.getTime() - 1));
+                    assert.deepEqual(await observe(), alive, 'T2−1 ms');
+                    clock.set(T2);
+                    assert.deepEqual(await observe(), gone, 'T2');
+                    // Revivir: el re-grant sin opciones sobre una asignación expirada queda sin caducidad.
+                    const revived = await clocked.grant(alice, 'editor', APP_SCOPE);
+                    assert.isTrue(revived.existed);
+                    assert.isNull(revived.expiresAt);
+                    clock.set(new Date('2099-12-31T23:59:59.999Z'));
+                    assert.deepEqual(await observe(), alive, 'revivida, sin caducidad');
+                });
+                since('2.1', 'la caducidad guarda milisegundos: una que vence dentro de 600 ms no se redondea al segundo y lo que se lee es lo que se escribió, al milisegundo', async ({ assert, }) => {
+                    // 2.5 · J3 (`subSecondExpiry`). En MySQL la columna `timestamp` de
+                    // knex es TIMESTAMP(0): REDONDEA al segundo (una caducidad de
+                    // +600 ms se guardaba como +1 s y concedía medio segundo de más).
+                    // `DATETIME(3)` en el stub y el espejo. Un caso, una afirmación
+                    // (2.5-B · K15): la de 2040 va aparte para que un motor que falle
+                    // aquí no la enmascare.
+                    const T0 = new Date('2030-01-01T00:00:00.000Z');
+                    const clock = fixedClock(T0);
+                    const clocked = driver.withClock(clock.now);
+                    const alice = subject();
+                    const soon = new Date(T0.getTime() + 600);
+                    const first = await clocked.grant(alice, 'editor', APP_SCOPE, { expiresAt: soon });
+                    assert.equal(first.expiresAt.getTime(), soon.getTime());
+                    const reread = await clocked.grant(alice, 'editor', APP_SCOPE);
+                    assert.equal(reread.previousExpiresAt.getTime(), soon.getTime(), 'lo que se lee es lo que se escribió, al milisegundo');
+                    assert.equal(reread.expiresAt.getTime(), soon.getTime());
+                    clock.set(new Date(soon.getTime() - 1));
+                    assert.isTrue(await clocked.authorize(alice, 'docs:read', APP_SCOPE));
+                    clock.set(soon);
+                    assert.isFalse(await clocked.authorize(alice, 'docs:read', APP_SCOPE), 'vence a los 600 ms, no al segundo');
+                    clock.set(new Date(T0.getTime() + 999));
+                    assert.isFalse(await clocked.authorize(alice, 'docs:read', APP_SCOPE));
+                    assert.deepEqual(await clocked.listSubjects('editor', APP_SCOPE), []);
+                });
+                since('2.1', 'la caducidad admite fechas más allá de 2038 (2040) y se escribe estando el reloj en 2040: los sellos de auditoría no son decisiones y no llevan el reloj inyectado', async ({ assert, }) => {
+                    // 2.5 · J3: MySQL `TIMESTAMP` no admite fechas más allá de
+                    // 2038-01-19 (un grant hasta 2040 era un 503) ⇒ `expires_at` es
+                    // `DATETIME(3)`. Y 2.5-B · K5 (CR#4): `created_at` se sellaba con
+                    // el reloj INYECTADO, así que un `grant` con el reloj en 2040
+                    // reventaba igual (`TIMESTAMP` sigue siendo `TIMESTAMP` para los
+                    // sellos). Los sellos son auditoría, no decisiones: llevan el reloj
+                    // del sistema; lo que decide (`expires_at`) lleva el inyectado.
+                    const T0 = new Date('2030-01-01T00:00:00.000Z');
+                    const clock = fixedClock(T0);
+                    const clocked = driver.withClock(clock.now);
+                    const bob = subject();
+                    const carol = subject();
+                    const far = new Date('2040-01-01T00:00:00.000Z');
+                    const long = await clocked.grant(bob, 'editor', APP_SCOPE, { expiresAt: far });
+                    assert.equal(long.expiresAt.getTime(), far.getTime());
+                    assert.isTrue(await clocked.authorize(bob, 'docs:read', APP_SCOPE));
+                    assert.equal((await clocked.grant(bob, 'editor', APP_SCOPE)).previousExpiresAt.getTime(), far.getTime());
+                    clock.set(new Date('2039-12-31T23:59:59.999Z'));
+                    assert.isTrue(await clocked.authorize(bob, 'docs:read', APP_SCOPE));
+                    clock.set(far);
+                    assert.isFalse(await clocked.authorize(bob, 'docs:read', APP_SCOPE));
+                    // Escribir con el reloj más allá de 2038: grant y deny se sellan igual.
+                    const later = new Date('2041-06-01T00:00:00.000Z');
+                    const written = await clocked.grant(carol, 'editor', APP_SCOPE, { expiresAt: later });
+                    assert.equal(written.expiresAt.getTime(), later.getTime());
+                    await clocked.deny(carol, 'docs:write', APP_SCOPE);
+                    assert.isTrue(await clocked.authorize(carol, 'docs:read', APP_SCOPE));
+                    assert.isFalse(await clocked.authorize(carol, 'docs:write', APP_SCOPE));
+                    assert.deepEqual(await clocked.listRoles(carol, APP_SCOPE), ['editor']);
+                    clock.set(later);
+                    assert.isFalse(await clocked.authorize(carol, 'docs:read', APP_SCOPE));
+                });
+                since('2.1', 'el manager expone el reloj (config.clock) y lo comparten sus vistas de forRequest: la misma pregunta cambia de respuesta al mover el reloj, sin escribir nada', async ({ assert, }) => {
+                    // 2.5 · J1. El consumidor fija el reloj UNA vez (config) y todo lo
+                    // que pasa por el manager —lecturas directas, vistas por request,
+                    // `effectivePermissions`, `authorizeMany`— lo usa. El memo de la
+                    // vista es de ANCESTROS, nunca de decisiones: mover el reloj cambia
+                    // la respuesta de la misma vista.
+                    // Relativo a hoy (K7): al final se observa el driver del harness (reloj real), para el que T es futuro.
+                    const T = new Date(Date.now() + 400 * 24 * 3_600_000 + 3_003);
+                    const clock = fixedClock(new Date(T.getTime() - 60_000));
+                    const authz = managerOver({ clock: clock.now });
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    await authz.grant(alice, 'editor', APP_SCOPE, { expiresAt: T });
+                    const view = authz.forRequest();
+                    clock.set(new Date(T.getTime() - 1));
+                    assert.isTrue(await authz.authorize(alice, 'docs:read', org));
+                    assert.isTrue(await view.authorize(alice, 'docs:read', org));
+                    assert.isTrue(await view.hasRole(alice, 'editor', org));
+                    assert.deepEqual(await view.listRoles(alice, APP_SCOPE), ['editor']);
+                    assert.deepEqual(await view.authorizeMany(alice, 'docs:read', [org, APP_SCOPE]), [true, true]);
+                    assert.lengthOf(await view.listSubjects('editor', APP_SCOPE), 1);
+                    clock.set(T);
+                    assert.isFalse(await authz.authorize(alice, 'docs:read', org));
+                    assert.isFalse(await view.authorize(alice, 'docs:read', org));
+                    assert.isFalse(await view.hasRole(alice, 'editor', org));
+                    assert.deepEqual(await view.listRoles(alice, APP_SCOPE), []);
+                    assert.deepEqual(await view.authorizeMany(alice, 'docs:read', [org, APP_SCOPE]), [false, false]);
+                    assert.deepEqual(await view.listSubjects('editor', APP_SCOPE), []);
+                    // El driver del harness (reloj real) no se ve afectado: para él T es futuro.
+                    assert.isTrue(await driver.authorize(alice, 'docs:read', org));
+                });
+            },
+            whenFalse: () => {
+                test('expiresAt en tres estados: omitido preserva la caducidad vigente, null la quita, expirada revive (observado en tiempo real: sin reloj inyectable)', async ({ assert, }) => {
+                    assert.notTypeOf(driver.withClock, 'function', 'el harness declara injectableClock: false y el driver trae withClock: declara lo observable');
+                    const keep = subject();
+                    const lift = subject();
+                    const revive = subject();
+                    const soon = new Date(Date.now() + 1_500);
+                    await driver.grant(keep, 'editor', APP_SCOPE, { expiresAt: soon });
+                    const kept = await driver.grant(keep, 'editor', APP_SCOPE);
+                    await driver.grant(lift, 'editor', APP_SCOPE, { expiresAt: soon });
+                    const lifted = await driver.grant(lift, 'editor', APP_SCOPE, { expiresAt: null });
+                    const past = new Date(Date.now() - 60_000);
+                    await driver.grant(revive, 'editor', APP_SCOPE, { expiresAt: past });
+                    assert.isFalse(await driver.authorize(revive, 'docs:read', APP_SCOPE));
+                    const revived = await driver.grant(revive, 'editor', APP_SCOPE);
+                    assert.isTrue(kept.existed);
+                    assert.closeTo(kept.expiresAt.getTime(), soon.getTime(), 1_000);
+                    assert.isTrue(lifted.existed);
+                    assert.isNull(lifted.expiresAt);
+                    assert.closeTo(lifted.previousExpiresAt.getTime(), soon.getTime(), 1_000);
+                    assert.isTrue(revived.existed);
+                    assert.isNull(revived.expiresAt);
+                    assert.closeTo(revived.previousExpiresAt.getTime(), past.getTime(), 1_000);
+                    assert.isTrue(await driver.authorize(revive, 'docs:read', APP_SCOPE));
+                    assert.isTrue(await driver.authorize(keep, 'docs:read', APP_SCOPE));
+                    assert.isTrue(await driver.authorize(lift, 'docs:read', APP_SCOPE));
+                    await new Promise((resolve) => setTimeout(resolve, Math.max(0, soon.getTime() - Date.now()) + 300));
+                    // La caducidad preservada venció; la quitada ya no existe.
+                    assert.isFalse(await driver.authorize(keep, 'docs:read', APP_SCOPE));
+                    assert.isTrue(await driver.authorize(lift, 'docs:read', APP_SCOPE));
+                    assert.isTrue(await driver.authorize(revive, 'docs:read', APP_SCOPE));
+                })?.timeout(15_000);
+            },
+        });
         test('hasRole respeta scope, herencia y expiración', async ({ assert }) => {
             const alice = subject();
+            const org = await orgUnder(tree, APP_SCOPE);
             await driver.grant(alice, 'editor', APP_SCOPE);
             assert.isTrue(await driver.hasRole(alice, 'editor', APP_SCOPE));
             // Herencia hacia abajo: el rol de app "vale" dentro de una org.
-            assert.isTrue(await driver.hasRole(alice, 'editor', orgScope()));
+            assert.isTrue(await driver.hasRole(alice, 'editor', org));
             assert.isFalse(await driver.hasRole(alice, 'viewer', APP_SCOPE));
             await driver.revoke(alice, 'editor', APP_SCOPE);
             assert.isFalse(await driver.hasRole(alice, 'editor', APP_SCOPE));
@@ -139,34 +732,65 @@ export function runAuthorizationDriverContract(harness) {
             });
             assert.isFalse(await driver.hasRole(expired, 'editor', APP_SCOPE));
         });
+        test('hasRole con el mismo slug en dos niveles: string hereda por cadena; { slug, scopeType } acota el nivel', async ({ assert, }) => {
+            // L0.6. `owner` existe a nivel app y a nivel organization. Con string,
+            // en cada nivel de la cadena solo cuenta el rol de ESE nivel: el owner
+            // de app casa en app y hereda hacia abajo; un owner de organization
+            // jamás casa en app. Con `{ slug, scopeType }` se pregunta por el rol
+            // de un nivel concreto, y el heredado de otro nivel no vale.
+            const bob = subject();
+            const carol = subject();
+            const org = await orgUnder(tree, APP_SCOPE);
+            await driver.grant(bob, 'owner', APP_SCOPE);
+            await driver.grant(carol, 'owner', org);
+            assert.isTrue(await driver.hasRole(bob, 'owner', org));
+            assert.isTrue(await driver.hasRole(bob, { slug: 'owner', scopeType: 'app' }, org));
+            assert.isFalse(await driver.hasRole(bob, { slug: 'owner', scopeType: 'organization' }, org));
+            assert.isTrue(await driver.hasRole(carol, 'owner', org));
+            assert.isTrue(await driver.hasRole(carol, { slug: 'owner', scopeType: 'organization' }, org));
+            assert.isFalse(await driver.hasRole(carol, { slug: 'owner', scopeType: 'app' }, org));
+            assert.isFalse(await driver.hasRole(carol, 'owner', APP_SCOPE));
+            assert.isFalse(await driver.hasRole(carol, { slug: 'owner', scopeType: 'organization' }, APP_SCOPE));
+        });
+        test('un deny NO afecta a hasRole: es membresía, no acceso', async ({ assert }) => {
+            // L0.6, fijado a propósito. `hasRole` responde "¿tiene el rol?", un hecho;
+            // el deny gobierna `authorize`, la decisión. Por eso ningún PEP del
+            // paquete acepta `role`: un middleware sobre `hasRole` sería indenegable.
+            const alice = subject();
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            await driver.deny(alice, 'docs:read', APP_SCOPE);
+            await driver.deny(alice, 'docs:write', APP_SCOPE);
+            assert.isFalse(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+            assert.isFalse(await driver.authorize(alice, 'docs:write', APP_SCOPE));
+            assert.isTrue(await driver.hasRole(alice, 'editor', APP_SCOPE));
+        });
         test('listSubjects: holders vigentes del rol en el scope exacto', async ({ assert }) => {
             const alice = subject();
             const bob = subject();
             const expired = subject();
-            const otherScope = orgScope();
+            const otherScope = await orgUnder(tree, APP_SCOPE);
             await driver.grant(alice, 'editor', APP_SCOPE);
             await driver.grant(bob, 'editor', APP_SCOPE);
             await driver.grant(expired, 'editor', APP_SCOPE, {
                 expiresAt: new Date(Date.now() - 60_000),
             });
             await driver.grant(subject(), 'org-editor', otherScope);
+            // Igualdad de CONJUNTO, no inclusión: un driver que devolviera de más
+            // (el expirado, el holder de la otra org) pasaría con `includeMembers`.
             const holders = await driver.listSubjects('editor', APP_SCOPE);
-            const uuids = holders.map((h) => h.uuid);
-            assert.includeMembers(uuids, [alice.uuid, bob.uuid]);
-            assert.notInclude(uuids, expired.uuid);
+            assert.deepEqual(holders.map((h) => h.uuid).sort(), [alice.uuid, bob.uuid].sort());
         });
         test('listScopes: scopes directos que conceden el permiso, sin los denegados', async ({ assert, }) => {
             const alice = subject();
-            const orgA = orgScope();
-            const orgB = orgScope();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
             await driver.grant(alice, 'editor', APP_SCOPE);
             await driver.grant(alice, 'org-editor', orgA);
             await driver.grant(alice, 'org-editor', orgB);
             await driver.deny(alice, 'docs:write', orgB);
+            // Conjunto exacto: ni orgB (denegada) ni nada heredado.
             const scopes = await driver.listScopes(alice, 'docs:write');
-            const keys = scopes.map((s) => `${s.type}:${s.uuid ?? ''}`);
-            assert.includeMembers(keys, ['app:', `organization:${orgA.uuid}`]);
-            assert.notInclude(keys, `organization:${orgB.uuid}`);
+            assert.deepEqual(scopeKeys(scopes), scopeKeys([APP_SCOPE, orgA]));
         });
         test('revoke/removeDeny inexistentes son no-ops seguros', async ({ assert }) => {
             const ghost = subject();
@@ -174,9 +798,37 @@ export function runAuthorizationDriverContract(harness) {
             await driver.removeDeny(ghost, 'docs:read', APP_SCOPE);
             assert.isFalse(await driver.authorize(ghost, 'docs:read', APP_SCOPE));
         });
+        test('revoke/removeDeny con rol o permiso fuera del catálogo ⇒ 422, como grant/deny', async ({ assert, }) => {
+            // D10 (auditor H9/N4). Un rol que no existe para ese nivel no es "nada
+            // que quitar": es una pregunta mal formada, igual que en `grant`. El
+            // no-op silencioso escondía el caso real (el `scope_type` de un rol
+            // cambió en el catálogo y el revoke no quitaba nada) y además
+            // divergía entre drivers. El no-op sigue siendo para una ASIGNACIÓN
+            // inexistente de un rol válido ("revoke/removeDeny inexistentes son
+            // no-ops seguros").
+            const alice = subject();
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            await driver.deny(alice, 'docs:read', APP_SCOPE);
+            await rejectsWith(assert, () => driver.revoke(alice, 'no-existe', APP_SCOPE), {
+                status: 422,
+                code: 'E_AUTHZ_UNKNOWN_ROLE',
+            });
+            // `org-editor` existe, pero no a nivel app.
+            await rejectsWith(assert, () => driver.revoke(alice, 'org-editor', APP_SCOPE), {
+                status: 422,
+                code: 'E_AUTHZ_UNKNOWN_ROLE',
+            });
+            await rejectsWith(assert, () => driver.removeDeny(alice, 'no:existe', APP_SCOPE), {
+                status: 422,
+                code: 'E_AUTHZ_UNKNOWN_PERMISSION',
+            });
+            // Nada de lo anterior tocó los hechos.
+            assert.isTrue(await driver.hasRole(alice, 'editor', APP_SCOPE));
+            assert.isFalse(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+        });
         test('listRoles: roles directos vigentes en el scope exacto', async ({ assert }) => {
             const alice = subject();
-            const orgA = orgScope();
+            const orgA = await orgUnder(tree, APP_SCOPE);
             await driver.grant(alice, 'editor', APP_SCOPE);
             await driver.grant(alice, 'viewer', APP_SCOPE, {
                 expiresAt: new Date(Date.now() - 60_000), // expirado: no cuenta
@@ -192,8 +844,8 @@ export function runAuthorizationDriverContract(harness) {
         });
         test('listRoleScopes: scopes del tipo con algún rol directo vigente', async ({ assert }) => {
             const alice = subject();
-            const orgA = orgScope();
-            const orgB = orgScope();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
             await driver.grant(alice, 'org-editor', orgA);
             await driver.grant(alice, 'org-editor', orgB, {
                 expiresAt: new Date(Date.now() - 60_000), // expirado: fuera
@@ -206,6 +858,2779 @@ export function runAuthorizationDriverContract(harness) {
             assert.lengthOf(apps, 1);
             assert.isNull(apps[0].uuid);
         });
+        test('rank es metadata: un rol de rango alto no concede lo que no tiene', async ({ assert, }) => {
+            // Invariante 8 (core). La policy "no puedes dar un rol de rango ≥ al
+            // tuyo" es del consumidor; el motor jamás usa `rank` para decidir.
+            const senior = subject();
+            await driver.grant(senior, 'auditor-senior', APP_SCOPE); // rank 100, sin docs:write
+            assert.isFalse(await driver.authorize(senior, 'docs:write', APP_SCOPE));
+            const junior = subject();
+            await driver.grant(junior, 'scribe', APP_SCOPE); // rank 0, con docs:write
+            assert.isTrue(await driver.authorize(junior, 'docs:write', APP_SCOPE));
+        });
+        test('deny repetido no se duplica: un solo removeDeny lo levanta', async ({ assert }) => {
+            // Invariante 6 (core). Un deny duplicado que necesitara dos removeDeny
+            // dejaría al holder bloqueado "sin motivo" tras levantarlo una vez.
+            const alice = subject();
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            await driver.deny(alice, 'docs:write', APP_SCOPE);
+            await driver.deny(alice, 'docs:write', APP_SCOPE);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', APP_SCOPE));
+            await driver.removeDeny(alice, 'docs:write', APP_SCOPE);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', APP_SCOPE));
+        });
+        test('deny antes del grant también bloquea: el orden de escritura no importa', async ({ assert, }) => {
+            const alice = subject();
+            await driver.deny(alice, 'docs:write', APP_SCOPE);
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', APP_SCOPE));
+            assert.isTrue(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+        });
+        test('identidad inválida ⇒ 422 E_AUTHZ_INVALID_IDENTITY, en lecturas y escrituras', async ({ assert, }) => {
+            // Invariante 5 (core, L0.5). Un uuid ausente, vacío o con sintaxis de
+            // otro sistema (`#` fabrica un userset en FGA; la comilla es SQL) no es
+            // "un holder sin permisos": es una pregunta mal formada. Se rechaza
+            // ANTES de tocar catálogo o backend, con el mismo status en todo driver
+            // — hoy openfga escribía `user:undefined` y database persistía la comilla.
+            const invalidUuids = ['', undefined, 'x#y', "x' OR '1'='1", 'a b', 'u|v', 'w*'];
+            for (const uuid of invalidUuids) {
+                const holder = { type: 'users', uuid };
+                const expected = { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' };
+                await rejectsWith(assert, () => driver.grant(holder, 'editor', APP_SCOPE), expected);
+                await rejectsWith(assert, () => driver.authorize(holder, 'docs:read', APP_SCOPE), expected);
+                await rejectsWith(assert, () => driver.deny(holder, 'docs:read', APP_SCOPE), expected);
+            }
+            // El tipo también es identidad, y va en minúsculas: en un motor SQL con
+            // collation `*_ci` `Users` y `users` serían la misma fila y en FGA dos
+            // holders distintos (E4, auditor H14).
+            for (const type of ['users#x', 'Users', 'USERS']) {
+                await rejectsWith(assert, () => driver.grant({ type, uuid: uuidv7() }, 'editor', APP_SCOPE), { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' });
+            }
+            await rejectsWith(assert, () => driver.authorize(subject(), 'docs:read', { type: 'Organization', uuid: uuidv7() }), { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' });
+            // Caso negativo: el ':' de un permiso es gramática válida, no identidad rota.
+            assert.isFalse(await driver.authorize(subject(), 'docs:read', APP_SCOPE));
+        });
+        test('expiresAt que no es Date válida, null ni omitido ⇒ 422 E_AUTHZ_INVALID_IDENTITY, sin escribir', async ({ assert, }) => {
+            // D7 (CR7). Una cadena ('2026-12-31'), un `Invalid Date` o un número no
+            // son una caducidad: un driver lanzaba un TypeError crudo al serializar
+            // y el otro persistía basura (una fecha inválida que nunca "vence" o que
+            // vence siempre). Es una pregunta mal formada: 422 antes de tocar nada.
+            const alice = subject();
+            const expected = { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' };
+            for (const expiresAt of ['2026-12-31', new Date('x'), 123, {}]) {
+                await rejectsWith(assert, () => driver.grant(alice, 'editor', APP_SCOPE, { expiresAt: expiresAt }), expected);
+            }
+            assert.deepEqual(await driver.listRoles(alice, APP_SCOPE), []);
+            assert.isFalse(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+            // Los tres estados legales siguen siéndolo.
+            await driver.grant(alice, 'editor', APP_SCOPE, { expiresAt: new Date(Date.now() + 60_000) });
+            await driver.grant(alice, 'editor', APP_SCOPE, { expiresAt: null });
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            assert.isTrue(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+        });
+        test('un RoleQuery mal formado ⇒ 422 antes de tocar nada; las tres formas legales (slug, {slug,scopeType}, {uuid}) valen en grant/revoke/hasRole/listSubjects', async ({ assert, }) => {
+            // D11 (auditor H4) reescrito en 3D · M1: desde que `RoleQuery` admite
+            // `{ uuid }` en las cuatro rutas, el objeto ya no es «lo que no va
+            // aquí» — lo que sigue sin ir es un objeto MAL FORMADO (un body sin
+            // tipar, un job). Antes acababa en un 503 en un driver y en un
+            // TypeError crudo en el otro; sigue siendo 422, antes de tocar nada.
+            const alice = subject();
+            const slugError = { status: 422, code: 'E_AUTHZ_INVALID_SLUG' };
+            const identityError = { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' };
+            const malformed = [
+                [{}, slugError],
+                [{ slug: 'Editor', scopeType: 'app' }, slugError],
+                [{ slug: 'editor' }, identityError],
+                [{ uuid: 'no-es-un-uuid' }, identityError],
+                [{ uuid: '01a04dd8-095b-7208-827b-cb90aeee2936', slug: 'editor' }, identityError],
+                [42, identityError],
+                [null, identityError],
+            ];
+            for (const [query, expected] of malformed) {
+                await rejectsWith(assert, () => driver.grant(alice, query, APP_SCOPE), expected);
+                await rejectsWith(assert, () => driver.revoke(alice, query, APP_SCOPE), expected);
+                await rejectsWith(assert, () => driver.listSubjects(query, APP_SCOPE), expected);
+                await rejectsWith(assert, () => driver.hasRole(alice, query, APP_SCOPE), expected);
+            }
+            assert.deepEqual(await driver.listRoles(alice, APP_SCOPE), []);
+            // Y las tres formas legales apuntan al MISMO rol.
+            const editor = (await new CatalogCache().view()).role('editor', 'app');
+            await driver.grant(alice, { uuid: editor.uuid }, APP_SCOPE);
+            assert.isTrue(await driver.hasRole(alice, 'editor', APP_SCOPE));
+            assert.isTrue(await driver.hasRole(alice, { slug: 'editor', scopeType: 'app' }, APP_SCOPE));
+            assert.isTrue(await driver.hasRole(alice, { uuid: editor.uuid }, APP_SCOPE));
+            assert.deepEqual((await driver.listSubjects({ uuid: editor.uuid }, APP_SCOPE)).map((h) => h.uuid), [alice.uuid]);
+            assert.deepEqual((await driver.listSubjects({ slug: 'editor', scopeType: 'app' }, APP_SCOPE)).map((h) => h.uuid), [alice.uuid]);
+            // Un uuid del catálogo que no es de un rol de ESE nivel no existe ahí.
+            const orgEditor = (await new CatalogCache().view()).role('org-editor', 'organization');
+            await rejectsWith(assert, () => driver.grant(alice, { uuid: orgEditor.uuid }, APP_SCOPE), {
+                status: 422,
+                code: 'E_AUTHZ_ROLE_NOT_VISIBLE',
+            });
+            assert.deepEqual(await driver.listSubjects({ uuid: orgEditor.uuid }, APP_SCOPE), []);
+            await driver.revoke(alice, { uuid: editor.uuid }, APP_SCOPE);
+            assert.isFalse(await driver.hasRole(alice, 'editor', APP_SCOPE));
+        });
+        test('scope app con uuid ⇒ 422; no concede nada ni en la raíz', async ({ assert }) => {
+            // L0.10. `app` es la raíz: `{ app, 'X' }` no es "otro app". Un driver lo
+            // colapsaba a la raíz global (escalada de tenant a plataforma) y el otro
+            // respondía false: la divergencia es peor que cualquiera de las dos.
+            const alice = subject();
+            const fakeApp = { type: 'app', uuid: uuidv7() };
+            const expected = { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' };
+            await rejectsWith(assert, () => driver.grant(alice, 'editor', fakeApp), expected);
+            await rejectsWith(assert, () => driver.authorize(alice, 'docs:read', fakeApp), expected);
+            await rejectsWith(assert, () => driver.deny(alice, 'docs:read', fakeApp), expected);
+            await rejectsWith(assert, () => driver.listRoles(alice, fakeApp), expected);
+            assert.isFalse(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+            assert.deepEqual(await driver.listRoles(alice, APP_SCOPE), []);
+        });
+        test('uuid centinela de la raíz en un scope que no es app ⇒ 422', async ({ assert }) => {
+            // L0.15. `00000000-…` es cómo el driver database almacena la raíz; como
+            // identidad de una organization colisionaría con ella.
+            const alice = subject();
+            const sentinel = { type: 'organization', uuid: '00000000-0000-0000-0000-000000000000' };
+            const expected = { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' };
+            await rejectsWith(assert, () => driver.grant(alice, 'org-editor', sentinel), expected);
+            await rejectsWith(assert, () => driver.authorize(alice, 'docs:read', sentinel), expected);
+        });
+        test('uuid centinela en un scope que el árbol SÍ conoce ⇒ 422 E_AUTHZ_INVALID_IDENTITY, y la raíz sigue limpia', async ({ assert, }) => {
+            // Tester H1 (E3). El caso anterior no discrimina por sí solo: sin la
+            // regla, el árbol del harness no conoce ese scope y B1 lo rechazaría
+            // igual con `E_AUTHZ_UNKNOWN_SCOPE`. El peligro real es un centinela
+            // que el árbol conoce: en `database` colisionaría con la fila de la
+            // raíz (un grant ahí concedería en `app`). Aquí se cuelga del árbol y
+            // debe seguir siendo identidad inválida, no un scope válido.
+            const alice = subject();
+            const sentinel = { type: 'organization', uuid: '00000000-0000-0000-0000-000000000000' };
+            await tree.attach(sentinel, APP_SCOPE);
+            const expected = { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' };
+            await rejectsWith(assert, () => driver.grant(alice, 'org-editor', sentinel), expected);
+            await rejectsWith(assert, () => driver.deny(alice, 'docs:read', sentinel), expected);
+            await rejectsWith(assert, () => driver.authorize(alice, 'docs:read', sentinel), expected);
+            await rejectsWith(assert, () => driver.listRoles(alice, sentinel), expected);
+            assert.isFalse(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+            assert.deepEqual(await driver.listRoles(alice, APP_SCOPE), []);
+            assert.deepEqual(await driver.listRoleScopes(alice, 'app'), []);
+        });
+        test('slug mal formado o reservado ⇒ 422 E_AUTHZ_INVALID_SLUG; nunca alcanza otro permiso', async ({ assert, }) => {
+            // L0.8a. Hasta 2.1 openfga codificaba `docs:read` como `docs~read` en el
+            // id del binding: un slug que llegara YA codificado apuntaba al binding
+            // del permiso real, y `removeDeny(…, 'docs~read')` levantaba el deny de
+            // `docs:read`. Desde 3A (2.2) los ids llevan el uuid del catálogo y no
+            // hay escape, pero la gramática sigue rechazando `~`: el caso fija que
+            // un slug así nunca alcanza otro permiso, en ningún driver. Los
+            // reservados (`parent`…) y las familias (`can_`…) son nombres del modelo
+            // FGA del modo facts: un permiso así invalidaría el modelo entero.
+            const alice = subject();
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            await driver.deny(alice, 'docs:read', APP_SCOPE);
+            const expected = { status: 422, code: 'E_AUTHZ_INVALID_SLUG' };
+            await rejectsWith(assert, () => driver.removeDeny(alice, 'docs~read', APP_SCOPE), expected);
+            await rejectsWith(assert, () => driver.deny(alice, 'docs~read', APP_SCOPE), expected);
+            // El deny real sigue en pie: nada lo tocó.
+            assert.isFalse(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+            for (const slug of ['parent', 'assignee', 'can_docs', 'denied_docs', 'permits_x', 'a'.repeat(101), 'Docs', 'x|y', 'x y', '']) {
+                await rejectsWith(assert, () => driver.grant(alice, slug, APP_SCOPE), expected);
+                await rejectsWith(assert, () => driver.deny(alice, slug, APP_SCOPE), expected);
+                await rejectsWith(assert, () => driver.authorize(alice, slug, APP_SCOPE), expected);
+            }
+            // Un rol no lleva ':'; un permiso sí (una vez).
+            await rejectsWith(assert, () => driver.grant(alice, 'org:editor', APP_SCOPE), expected);
+            await rejectsWith(assert, () => driver.authorize(alice, 'a:b:c', APP_SCOPE), expected);
+        });
+        since('2.1', 'la identidad es una cadena validada por la gramática, no un UUID del motor: ids que no son UUID se aceptan; un uuid con MAYÚSCULAS (holder o scope) es 422 E_AUTHZ_INVALID_IDENTITY antes de tocar nada', async ({ assert, }) => {
+            // 2.5 · J3 + 2.5-B · K1. La gramática admite `[a-z0-9._-]{1,36}` y el
+            // uuid es del consumidor. PostgreSQL con columnas `uuid` rechazaba
+            // 'user-42' con un error de tipo (503) ⇒ columnas `varchar(64)`. MySQL
+            // con la collation por defecto (`*_ci`) fundía 'abc' y 'ABC' en la
+            // MISMA fila ⇒ `utf8mb4_bin`; y el árbol del consumidor (tipo `uuid`,
+            // `*_ci`) seguía fundiéndolos (auditor 🔴 1) ⇒ las mayúsculas en un
+            // uuid ya no son identidad: 422 en la puerta, en lecturas y escrituras,
+            // para holders y scopes. Un alias por mayúsculas no llega al árbol.
+            const lower = { type: 'users', uuid: 'abc.def_42' };
+            const upper = { type: 'users', uuid: 'ABC.DEF_42' };
+            const longest = { type: 'users', uuid: 'x'.repeat(36) };
+            const org = await orgUnder(tree, APP_SCOPE);
+            const orgUpper = { type: 'organization', uuid: org.uuid.toUpperCase() };
+            const invalid = { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' };
+            await driver.grant(lower, 'viewer', APP_SCOPE);
+            await driver.grant(longest, 'editor', APP_SCOPE);
+            await driver.grant(lower, 'org-editor', org);
+            await driver.deny(lower, 'docs:read', org);
+            assert.isTrue(await driver.authorize(lower, 'docs:read', APP_SCOPE));
+            assert.isFalse(await driver.authorize(lower, 'docs:read', org), 'el deny en la org gana');
+            assert.isTrue(await driver.authorize(lower, 'docs:write', org));
+            assert.isTrue(await driver.authorize(longest, 'docs:write', APP_SCOPE));
+            assert.deepEqual((await driver.listSubjects('viewer', APP_SCOPE)).map((h) => h.uuid), [lower.uuid], 'el holder, con su uuid exacto');
+            assert.deepEqual(await driver.listRoles(lower, org), ['org-editor']);
+            assert.deepEqual(scopeKeys(await driver.listRoleScopes(lower, 'organization')), scopeKeys([org]));
+            // Mayúsculas en el uuid del HOLDER: 422 en lecturas y escrituras, y nada escrito.
+            await rejectsWith(assert, () => driver.grant(upper, 'viewer', APP_SCOPE), invalid);
+            await rejectsWith(assert, () => driver.authorize(upper, 'docs:read', APP_SCOPE), invalid);
+            await rejectsWith(assert, () => driver.deny(upper, 'docs:read', APP_SCOPE), invalid);
+            await rejectsWith(assert, () => driver.hasRole(upper, 'viewer', APP_SCOPE), invalid);
+            await rejectsWith(assert, () => driver.listRoles(upper, APP_SCOPE), invalid);
+            await rejectsWith(assert, () => driver.revoke(upper, 'viewer', APP_SCOPE), invalid);
+            // Mayúsculas en el uuid del SCOPE: lo mismo, aunque el árbol fundiera el alias con la fila.
+            await rejectsWith(assert, () => driver.authorize(lower, 'docs:write', orgUpper), invalid);
+            await rejectsWith(assert, () => driver.grant(lower, 'org-editor', orgUpper), invalid);
+            await rejectsWith(assert, () => driver.deny(lower, 'docs:write', orgUpper), invalid);
+            await rejectsWith(assert, () => driver.removeDeny(lower, 'docs:read', orgUpper), invalid);
+            await rejectsWith(assert, () => driver.listRoles(lower, orgUpper), invalid);
+            await rejectsWith(assert, () => driver.listSubjects('org-editor', orgUpper), invalid);
+            await rejectsWith(assert, () => driver.purgeScope(orgUpper), invalid);
+            // Nada de lo anterior tocó los hechos.
+            assert.isFalse(await driver.authorize(lower, 'docs:read', org));
+            assert.deepEqual(await driver.listRoles(lower, org), ['org-editor']);
+            assert.deepEqual((await driver.listSubjects('viewer', APP_SCOPE)).map((h) => h.uuid), [lower.uuid]);
+        });
+        since('2.1', 'un alias del uuid del scope (mayúsculas, guiones quitados) jamás evade un deny: o el árbol no lo conoce (false, nada, 422 al escribir) o resuelve al scope canónico (el deny casa y los hechos se escriben bajo la forma canónica)', async ({ assert, }) => {
+            // 2.5-B · K1 (auditor 🔴 1). El árbol del consumidor puede fundir formas
+            // distintas del mismo id (tipo `uuid` de PG: `BBBB…` = `bbbb…` =
+            // `bbbb…` sin guiones; `char(36) *_ci` de MySQL: mayúsculas), pero
+            // `authz_*` compara por bytes (J3): la cadena resolvía con el alias, el
+            // grant del ancestro aplicaba y el deny —escrito canónico— no casaba.
+            // Con el árbol en memoria el alias es simplemente desconocido; con el
+            // árbol SQL del harness (`sqlScopeTree`, PG/MySQL) es donde estaba el
+            // agujero. Lo que NUNCA puede pasar, con cualquier árbol: `true`.
+            const mallory = subject();
+            const eve = subject();
+            const org = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, org);
+            await driver.grant(mallory, 'org-editor', org);
+            await driver.deny(mallory, 'docs:read', unit);
+            assert.isFalse(await driver.authorize(mallory, 'docs:read', unit), 'precondición: el deny gana con la forma canónica');
+            assert.isTrue(await driver.authorize(mallory, 'docs:write', unit));
+            // Mayúsculas: identidad inválida en la puerta (K1, defensa en profundidad): ni árbol ni hechos.
+            const invalid = { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' };
+            for (const uuid of [unit.uuid.toUpperCase(), unit.uuid.replaceAll('-', '').toUpperCase()]) {
+                const alias = { type: 'unit', uuid };
+                await rejectsWith(assert, () => driver.authorize(mallory, 'docs:read', alias), invalid);
+                await rejectsWith(assert, () => driver.grant(eve, 'unit-editor', alias), invalid);
+                await rejectsWith(assert, () => driver.deny(eve, 'docs:read', alias), invalid);
+            }
+            // Sin guiones: gramática válida. O el árbol no lo conoce, o resuelve a
+            // la fila canónica (tipo `uuid` de PG); nunca una cadena con el alias.
+            const alias = { type: 'unit', uuid: unit.uuid.replaceAll('-', '') };
+            assert.isFalse(await driver.authorize(mallory, 'docs:read', alias), 'sin guiones: el deny se evade');
+            const known = (await tree.chainOf(alias)) !== null;
+            if (known) {
+                // El árbol lo funde con la fila real: la cadena es la canónica y las
+                // ESCRITURAS caen sobre los hechos canónicos. Si además la DECISIÓN
+                // sobre el alias encuentra esos hechos es la capacidad
+                // `canonicalScopeReads`, con su par (3b-2k · K1 · R2 (c)): aquí no se
+                // afirma, porque `openfga` en modo `facts` responde `false` —
+                // fail-closed, pero no la misma respuesta que `database`.
+                assert.deepEqual(await driver.listRoles(mallory, alias), [], 'sin guiones: los roles directos se leen bajo la forma canónica');
+                await driver.grant(eve, 'unit-editor', alias);
+                assert.deepEqual(await driver.listRoles(eve, unit), ['unit-editor'], 'sin guiones: el grant sobre el alias queda bajo la forma canónica');
+                assert.deepEqual(scopeKeys(await driver.listRoleScopes(eve, 'unit')), scopeKeys([unit]), 'sin guiones: ningún hecho con la forma del alias');
+                await driver.revoke(eve, 'unit-editor', alias);
+                assert.deepEqual(await driver.listRoles(eve, unit), [], 'sin guiones: revoke sobre el alias quita el hecho canónico');
+                // 3b-1 · M13: `purgeScope` canoniza igual que el resto (invariante
+                // 17). Sin esto, la canonización que hace el DRIVER dentro de
+                // `purgeScope` no la observaba ningún caso en ningún motor: un
+                // `detached` notificado con el alias dejaría vivos los hechos.
+                await driver.grant(eve, 'unit-editor', alias);
+                await driver.purgeScope(alias);
+                assert.deepEqual(await driver.listRoles(eve, unit), [], 'sin guiones: purgeScope sobre el alias purga los hechos CANÓNICOS');
+                assert.isTrue(await driver.authorize(mallory, 'docs:read', unit), 'y también el deny canónico (era lo único que bloqueaba)');
+            }
+            else {
+                assert.isFalse(await driver.authorize(mallory, 'docs:write', alias), 'sin guiones: desconocido: nada concede');
+                assert.deepEqual(await driver.listRoles(mallory, alias), [], 'sin guiones: desconocido');
+                await rejectsWith(assert, () => driver.grant(eve, 'unit-editor', alias), { status: 422, code: 'E_AUTHZ_UNKNOWN_SCOPE' });
+                // 3b-1 · M13, la otra cara: un scope que el árbol no conoce se purga
+                // TAL CUAL (`canonicalScope`), así que un alias desconocido no puede
+                // llevarse por delante los hechos de la forma canónica.
+                await driver.purgeScope(alias);
+                assert.isFalse(await driver.authorize(mallory, 'docs:read', unit), 'el deny canónico sigue en pie');
+                assert.isTrue(await driver.authorize(mallory, 'docs:write', unit), 'y lo concedido sigue concedido');
+            }
+        });
+        test('scope que el árbol no conoce: authorize/hasRole false; grant/deny 422 E_AUTHZ_UNKNOWN_SCOPE', async ({ assert, }) => {
+            // L0.3. Un scope que el consumidor no reconoce (borrado, inventado, o
+            // no encontrado por un fallo) no es "un scope que cuelga de app": el
+            // fallback plano `[APP_SCOPE]` hacía que un grant de app concediera en
+            // un scope inventado y que borrar la unit tirase el deny de su org. Se
+            // deniega por defecto y se rechaza escribir sobre él; las operaciones
+            // idempotentes (revoke/removeDeny) no lanzan: no hay nada que quitar.
+            const alice = subject();
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            const ghost = orgScope(); // nunca colgado del árbol
+            assert.isFalse(await driver.authorize(alice, 'docs:read', ghost));
+            assert.isFalse(await driver.hasRole(alice, 'editor', ghost));
+            const expected = { status: 422, code: 'E_AUTHZ_UNKNOWN_SCOPE' };
+            await rejectsWith(assert, () => driver.grant(alice, 'org-editor', ghost), expected);
+            await rejectsWith(assert, () => driver.deny(alice, 'docs:read', ghost), expected);
+            await driver.revoke(alice, 'org-editor', ghost);
+            await driver.removeDeny(alice, 'docs:read', ghost);
+            assert.deepEqual(await driver.listRoles(alice, ghost), []);
+            // Nada de lo anterior tocó la raíz.
+            assert.isTrue(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+        });
+        // ── Nivel 2.0 (Fase 0) ──────────────────────────────────────────────
+        // Los casos que siguen se registran solo con `level: '2.0'`. Un harness
+        // de tercero escrito para 1.x sigue corriendo los 19 de arriba tal cual.
+        //
+        // N7/N8 (`detach` purga) están abajo; N9 (un ciclo lanza 422 EN EL
+        // PAQUETE) vive en el manager (`scopes.attached/moved`) y se prueba en
+        // `tests/manager.spec.ts`: el juez habla con el driver, que no ve aristas.
+        // Diferido: A1–A6 / B1–B2 — anexo de `hierarchyFacts: true` (Fase 3b).
+        since('2.0', 'herencia de dos niveles: grant en app autoriza en una unit bajo una org', async ({ assert, }) => {
+            // N1. El resolutor plano de 1.x solo producía cadenas de longitud 2;
+            // con el árbol del juez la cadena es unit → org → app.
+            const alice = subject();
+            const org = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, org);
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+        });
+        since('2.0', 'grant en una org vale en sus units, no en app ni en la org hermana', async ({ assert, }) => {
+            // N1b
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, orgA);
+            await driver.grant(alice, 'org-editor', orgA);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+            assert.isFalse(await driver.authorize(alice, 'docs:write', APP_SCOPE));
+            assert.isFalse(await driver.authorize(alice, 'docs:write', orgB));
+        });
+        since('2.0', 'deny en una org hereda a sus units y solo hacia abajo; no toca otros permisos', async ({ assert, }) => {
+            // N2
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, orgA);
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            await driver.deny(alice, 'docs:write', orgA);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unit));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', orgB));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', APP_SCOPE));
+            assert.isTrue(await driver.authorize(alice, 'docs:read', unit));
+        });
+        since('2.0', 'mover una unit fuera de la org donde hay grant le quita el permiso, sin otra escritura', async ({ assert, }) => {
+            // N4. Lo único que cambia entre las dos preguntas es el árbol: no hay
+            // revoke, ni deny, ni re-grant. Si el driver cacheara la cadena, o
+            // dependiera de hechos que `move` no toca, el segundo authorize seguiría
+            // en true.
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, orgA);
+            await driver.grant(alice, 'org-editor', orgA);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+            await tree.move(unit, orgB);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unit));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', orgA));
+        });
+        since('2.0', 'mover una unit bajo la org donde hay grant le da el permiso', async ({ assert }) => {
+            // N5. Sin esta cara positiva, N4 se satisfaría borrándolo todo.
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, orgA);
+            await driver.grant(alice, 'org-editor', orgB);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unit));
+            await tree.move(unit, orgB);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+        });
+        since('2.0', 'mover una unit no afecta a lo heredado de app', async ({ assert }) => {
+            // N6
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, orgA);
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+            await tree.move(unit, orgB);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+        });
+        since('2.0', 'con un árbol real los list* siguen sin enumerar descendientes heredados', async ({ assert, }) => {
+            // I7set (invariante 7). Con el resolutor plano no había descendientes
+            // que enumerar por error; con app → org → unit sí. Igualdad de conjunto:
+            // un driver que "ayudara" devolviendo la unit heredada pasaría con
+            // `includeMembers`.
+            const alice = subject();
+            const org = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, org);
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+            assert.deepEqual(scopeKeys(await driver.listScopes(alice, 'docs:write')), scopeKeys([APP_SCOPE]));
+            assert.deepEqual(await driver.listRoles(alice, unit), []);
+            assert.deepEqual(await driver.listRoleScopes(alice, 'unit'), []);
+            assert.deepEqual(await driver.listRoleScopes(alice, 'organization'), []);
+        });
+        since('2.0', 'listScopes resta el deny aunque el sujeto tenga más denies de OTROS permisos que el tope del backend (L0.7)', async ({ assert, }) => {
+            // L0.7, el único fail-open de L0. El driver openfga pedía TODOS los
+            // denies del sujeto con `ListObjects` (tope del servidor, sin señal de
+            // corte) y filtraba por permiso en cliente: cuatro denies irrelevantes
+            // desplazaban al relevante fuera de la página y `listScopes` devolvía
+            // como concedido un scope donde `authorize` responde false. Con el
+            // servidor de tope 3 de CI el rojo se ve con cinco denies; contra un
+            // servidor por defecto harían falta mil. Los denies de ruido van
+            // PRIMERO y en scopes sin grant, para que lo único que pueda fallar
+            // sea la resta del deny (no el recuento de bindings). Son 150 (D16):
+            // más de una página de `Read` (100), para que un driver que no siga
+            // el `continuation_token` también caiga aquí, y no solo en el unitario.
+            const alice = subject();
+            for (let i = 0; i < 75; i++) {
+                const noise = await orgUnder(tree, APP_SCOPE);
+                await driver.deny(alice, 'docs:read', noise);
+                await driver.deny(alice, 'billing:read', noise);
+            }
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            await driver.grant(alice, 'org-editor', orgA);
+            await driver.grant(alice, 'org-editor', orgB);
+            await driver.deny(alice, 'docs:write', orgB);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', orgB));
+            const scopes = await driver.listScopes(alice, 'docs:write');
+            assert.notInclude(scopeKeys(scopes), scopeKeys([orgB])[0], 'orgB está denegada y se listó como concedida');
+            assert.deepEqual(scopeKeys(scopes), scopeKeys([orgA]));
+        })?.timeout(60_000);
+        since('2.0', 'un scope retirado del árbol deja de responder: deny por defecto, sin herencia implícita de app', async ({ assert, }) => {
+            // L0.3, cara del ciclo de vida. Lo único que cambia es el árbol: el
+            // grant directo en la org sigue escrito (o purgado, si el harness
+            // purga al desconectar — da igual), pero un scope que el árbol ya no
+            // conoce no puede resolverse a "cuelga de app" ni a "cuelga de nada":
+            // se deniega, y lo heredado de la raíz tampoco llega.
+            const alice = subject();
+            const bob = subject();
+            const org = await orgUnder(tree, APP_SCOPE);
+            await driver.grant(alice, 'org-editor', org);
+            await driver.grant(bob, 'editor', APP_SCOPE);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', org));
+            assert.isTrue(await driver.authorize(bob, 'docs:write', org));
+            await tree.detach(org);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', org));
+            assert.isFalse(await driver.hasRole(alice, 'org-editor', org));
+            assert.isFalse(await driver.authorize(bob, 'docs:write', org));
+            assert.isTrue(await driver.authorize(bob, 'docs:write', APP_SCOPE));
+        });
+        since('2.0', 'listRoles y listRoleScopes tampoco responden por un scope que el árbol no conoce', async ({ assert, }) => {
+            // D8 (CR8). `authorize`/`hasRole` ya aplicaban "scope desconocido ⇒
+            // nada" (L0.3); las dos enumeraciones de membresía no: un scope que el
+            // consumidor borró sin avisar (sin `scopes.detached`) seguía listando
+            // sus roles y apareciendo como scope con membresía. Aquí el árbol deja
+            // de conocer la org SIN purgar (el hecho sigue escrito), que es
+            // exactamente la situación que L0.3 cierra: lo que el árbol no conoce
+            // no existe para el motor.
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            await driver.grant(alice, 'org-editor', orgA);
+            await driver.grant(alice, 'org-editor', orgB);
+            assert.deepEqual(await driver.listRoles(alice, orgA), ['org-editor']);
+            assert.deepEqual(scopeKeys(await driver.listRoleScopes(alice, 'organization')), scopeKeys([orgA, orgB]));
+            const original = tree.chainOf;
+            const forgotten = `${orgA.type}:${orgA.uuid}`;
+            tree.chainOf = async (scope) => `${scope.type}:${scope.uuid}` === forgotten ? null : original.call(tree, scope);
+            try {
+                assert.deepEqual(await driver.listRoles(alice, orgA), []);
+                assert.deepEqual(scopeKeys(await driver.listRoleScopes(alice, 'organization')), scopeKeys([orgB]));
+                assert.deepEqual(await driver.listRoles(alice, orgB), ['org-editor']);
+            }
+            finally {
+                tree.chainOf = original;
+            }
+            // El hecho seguía escrito: al volver a conocer el scope, vuelve.
+            assert.deepEqual(await driver.listRoles(alice, orgA), ['org-editor']);
+        });
+        since('2.0', 'quitar un permiso de un rol y re-sincronizar el catálogo lo retira: sin privilegios zombi', async ({ assert, }) => {
+            // L0.9 (N1). El sync era solo aditivo: quitar `docs:write` de `editor`
+            // en el config no lo quitaba de ningún entorno, para siempre. Ahora el
+            // sync poda los vínculos que el spec ya no lista (solo de los roles
+            // del spec; nunca borra roles ni permisos). Es un caso del juez porque
+            // un driver que proyecte el catálogo (modo facts) tiene que reflejarlo.
+            const alice = subject();
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', APP_SCOPE));
+            await harness.seedCatalog({
+                ...CONTRACT_CATALOG,
+                roles: CONTRACT_CATALOG.roles.map((role) => role.slug === 'editor' ? { ...role, permissions: ['docs:read'] } : role),
+            });
+            assert.isFalse(await driver.authorize(alice, 'docs:write', APP_SCOPE));
+            assert.isTrue(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+            assert.deepEqual(await driver.listScopes(alice, 'docs:write'), []);
+            // El rol sigue asignado: lo que cambió es lo que concede.
+            assert.isTrue(await driver.hasRole(alice, 'editor', APP_SCOPE));
+        });
+        since('2.0', 'detach purga los hechos del scope: nada resucita al volver a colgarlo', async ({ assert, }) => {
+            // N7 (N5 del auditor). Borrar un tenant dejaba sus grants y denies
+            // vivos para siempre: sin FK (el scope es polimórfico), sin nada en
+            // FGA. Con reutilización de uuid, o al re-colgar el nodo, resucitaban.
+            // La segunda mitad es la que importa: sin ella "purga" podría ser
+            // "desconecta".
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, orgA);
+            await driver.grant(alice, 'editor', APP_SCOPE);
+            await driver.grant(alice, 'unit-editor', unit);
+            await driver.deny(alice, 'docs:read', unit);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+            assert.isFalse(await driver.authorize(alice, 'docs:read', unit));
+            await tree.detach(unit);
+            assert.deepEqual(await driver.listRoles(alice, unit), []);
+            assert.deepEqual(await driver.listRoleScopes(alice, 'unit'), []);
+            assert.notInclude(scopeKeys(await driver.listScopes(alice, 'docs:write')), scopeKeys([unit])[0]);
+            await tree.attach(unit, orgB);
+            // Ni el grant ni el deny resucitan: solo queda lo heredado de app.
+            assert.deepEqual(await driver.listRoles(alice, unit), []);
+            assert.isFalse(await driver.hasRole(alice, 'unit-editor', unit));
+            assert.isTrue(await driver.authorize(alice, 'docs:read', unit));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+        });
+        since('2.0', 'detach es quirúrgico: los hermanos y el padre conservan sus hechos', async ({ assert, }) => {
+            // N8
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const unit1 = await unitUnder(tree, orgA);
+            const unit2 = await unitUnder(tree, orgA);
+            await driver.grant(alice, 'org-editor', orgA);
+            await driver.grant(alice, 'unit-editor', unit1);
+            await driver.grant(alice, 'unit-editor', unit2);
+            await driver.deny(alice, 'docs:read', unit2);
+            await tree.detach(unit1);
+            assert.deepEqual(await driver.listRoles(alice, unit2), ['unit-editor']);
+            assert.deepEqual(await driver.listRoles(alice, orgA), ['org-editor']);
+            assert.deepEqual(scopeKeys(await driver.listRoleScopes(alice, 'unit')), scopeKeys([unit2]));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit2));
+            assert.isFalse(await driver.authorize(alice, 'docs:read', unit2));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', orgA));
+        });
+        // ── Nivel 2.1 (Fase 2 · Lote 2B: primitivas) ────────────────────────
+        // Composición del manager sobre el puerto (ver `managerOver`). Los
+        // drivers no cambian de firma; lo que se juzga es que la primitiva
+        // responda igual sobre cualquier driver que pase 2.0.
+        since('2.1', 'within: grant/deny dentro de la cadena escriben; fuera ⇒ 422 E_AUTHZ_NOT_WITHIN sin escribir; app y el propio scope contienen', async ({ assert, }) => {
+            // B1 (tester §5 E · within 1-4). El administrador de la org A concede
+            // en una unit: el call-site declara `within: orgA` y el motor comprueba
+            // `orgA ∈ chain(unit)` contra el árbol en fresco. Con la unit de B, el
+            // uuid es válido y existe: sin `within` el grant habría pasado.
+            const authz = managerOver();
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            const unitB1 = await unitUnder(tree, orgB);
+            await authz.grant(alice, 'unit-editor', unitA1, { within: orgA });
+            await authz.grant(alice, 'unit-editor', unitA1, { within: APP_SCOPE });
+            await authz.grant(alice, 'unit-editor', unitA1, { within: unitA1 });
+            await authz.deny(alice, 'docs:read', unitA1, { within: orgA });
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+            assert.isFalse(await driver.authorize(alice, 'docs:read', unitA1));
+            const expected = { status: 422, code: 'E_AUTHZ_NOT_WITHIN' };
+            await rejectsWith(assert, () => authz.grant(alice, 'unit-editor', unitB1, { within: orgA }), expected);
+            await rejectsWith(assert, () => authz.deny(alice, 'docs:write', unitB1, { within: orgA }), expected);
+            // Un hermano ni un descendiente contienen: la contención es hacia arriba.
+            await rejectsWith(assert, () => authz.grant(alice, 'org-editor', orgA, { within: orgB }), expected);
+            await rejectsWith(assert, () => authz.grant(alice, 'org-editor', orgA, { within: unitA1 }), expected);
+            await rejectsWith(assert, () => authz.grant(alice, 'editor', APP_SCOPE, { within: orgA }), expected);
+            // Nada de lo anterior escribió.
+            assert.deepEqual(await driver.listRoles(alice, unitB1), []);
+            assert.deepEqual(await driver.listRoles(alice, orgA), []);
+            assert.deepEqual(await driver.listRoles(alice, APP_SCOPE), []);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitB1));
+            // Un `within` que el árbol no conoce no contiene nada (422, no false).
+            await rejectsWith(assert, () => authz.grant(alice, 'unit-editor', unitA1, { within: orgScope() }), expected);
+            // Un scope desconocido sigue siendo E_AUTHZ_UNKNOWN_SCOPE, antes que la contención.
+            await rejectsWith(assert, () => authz.grant(alice, 'unit-editor', unitScope(), { within: orgA }), {
+                status: 422,
+                code: 'E_AUTHZ_UNKNOWN_SCOPE',
+            });
+            // `isWithin` es la misma pregunta, suelta.
+            assert.isTrue(await authz.isWithin(unitA1, orgA));
+            assert.isTrue(await authz.isWithin(unitA1, APP_SCOPE));
+            assert.isTrue(await authz.isWithin(unitA1, unitA1));
+            assert.isTrue(await authz.isWithin(APP_SCOPE, APP_SCOPE));
+            assert.isFalse(await authz.isWithin(unitB1, orgA));
+            assert.isFalse(await authz.isWithin(orgA, unitA1));
+            assert.isFalse(await authz.isWithin(APP_SCOPE, orgA));
+            assert.isFalse(await authz.isWithin(unitScope(), orgA));
+        });
+        since('2.1', 'within en las otras cuatro escrituras: revoke/removeDeny contra el scope, scopes.attached/moved contra el padre, scopes.detached contra el hijo; fuera ⇒ 422 sin escribir', async ({ assert, }) => {
+            // 2D · F2 (auditor 2, CR1). `within` solo cubría grant/deny; las demás
+            // lo aceptaban en JS y lo ignoraban. Quitar un deny ajeno es conceder;
+            // revocar un rol ajeno es sabotear; purgar o recolgar un scope ajeno,
+            // lo mismo. Las seis escrituras pasan por la misma barrera.
+            const authz = managerOver();
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unitB1 = await unitUnder(tree, orgB);
+            await driver.grant(alice, 'unit-editor', unitB1);
+            await driver.deny(alice, 'docs:read', unitB1);
+            const expected = { status: 422, code: 'E_AUTHZ_NOT_WITHIN' };
+            // El "admin de A" apunta a hechos de B.
+            await rejectsWith(assert, () => authz.removeDeny(alice, 'docs:read', unitB1, { within: orgA }), expected);
+            await rejectsWith(assert, () => authz.revoke(alice, 'unit-editor', unitB1, { within: orgA }), expected);
+            assert.isFalse(await driver.authorize(alice, 'docs:read', unitB1), 'el deny sigue');
+            assert.deepEqual(await driver.listRoles(alice, unitB1), ['unit-editor'], 'el rol sigue');
+            // Dentro de B (o de la raíz, o del propio scope) sí.
+            await authz.removeDeny(alice, 'docs:read', unitB1, { within: orgB });
+            await authz.revoke(alice, 'unit-editor', unitB1, { within: unitB1 });
+            assert.deepEqual(await driver.listRoles(alice, unitB1), []);
+            await driver.grant(alice, 'unit-editor', unitB1);
+            await authz.revoke(alice, 'unit-editor', unitB1, { within: APP_SCOPE });
+            assert.deepEqual(await driver.listRoles(alice, unitB1), []);
+            // scopes.attached / moved: el PADRE (nuevo) tiene que estar dentro.
+            const unitNew = unitScope();
+            const unitB2 = await unitUnder(tree, orgB);
+            const unitA1 = await unitUnder(tree, orgA);
+            await rejectsWith(assert, () => authz.scopes.attached(unitNew, orgB, { within: orgA }), expected);
+            await rejectsWith(assert, () => authz.scopes.attached(unitNew, unitB2, { within: orgA }), expected);
+            await rejectsWith(assert, () => authz.scopes.moved(unitB2, orgA, { within: orgB }), expected);
+            await authz.scopes.attached(unitNew, unitB2, { within: orgB });
+            await authz.scopes.moved(unitA1, orgA, { within: orgA });
+            await authz.scopes.moved(unitB2, orgA, { within: APP_SCOPE });
+            // scopes.detached: el HIJO tiene que estar dentro; y purga solo si lo está.
+            await driver.grant(alice, 'unit-editor', unitB1);
+            await rejectsWith(assert, () => authz.scopes.detached(unitB1, { within: orgA }), expected);
+            assert.deepEqual(await driver.listRoles(alice, unitB1), ['unit-editor'], 'nada purgado');
+            await authz.scopes.detached(unitB1, { within: orgB });
+            assert.deepEqual(await driver.listRoles(alice, unitB1), []);
+            // Un `within` desconocido no contiene nada; un scope que ya no está en el árbol no se puede contrastar.
+            await rejectsWith(assert, () => authz.revoke(alice, 'unit-editor', unitB2, { within: orgScope() }), expected);
+            await rejectsWith(assert, () => authz.scopes.detached(unitScope(), { within: orgB }), { status: 422, code: 'E_AUTHZ_UNKNOWN_SCOPE' });
+        });
+        since('2.1', 'within contrasta también el ORIGEN de scopes.moved/attached: una unit de B no se lleva a A con within: orgA ⇒ 422 E_AUTHZ_NOT_WITHIN sin llamar al driver, y la herencia no cruza', async ({ assert, }) => {
+            // 2E · H1 (auditor 1). Solo se contrastaba el DESTINO: el admin de A
+            // podía anexionarse `unit:B1` con el `within` de su sesión y, movida,
+            // `authorize` pasaba de false a true (heredaba todo el subárbol robado;
+            // peor que purgarlo). Ahora la cadena ACTUAL del hijo, resuelta en
+            // fresco, también tiene que contener `within` — por eso el consumidor
+            // notifica ANTES de recolgar su fila. Espía: cero llamadas al driver.
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            const unitA2 = await unitUnder(tree, orgA);
+            const unitB1 = await unitUnder(tree, orgB);
+            await driver.grant(alice, 'org-editor', orgA);
+            assert.isFalse(await driver.authorize(alice, 'docs:read', unitB1), 'precondición: la unit de B no hereda de A');
+            const touched = [];
+            const spied = new Proxy(driver, {
+                get: (target, prop, receiver) => {
+                    const value = Reflect.get(target, prop, receiver);
+                    if (typeof value === 'function' && typeof prop === 'string') {
+                        return (...args) => {
+                            touched.push(prop);
+                            return value.apply(receiver, args);
+                        };
+                    }
+                    return value;
+                },
+            });
+            const authz = managerOver({ requireWithin: 'non-root' }, spied);
+            const expected = { status: 422, code: 'E_AUTHZ_NOT_WITHIN' };
+            await rejectsWith(assert, () => authz.scopes.moved(unitB1, orgA, { within: orgA }), expected);
+            await rejectsWith(assert, () => authz.scopes.attached(unitB1, orgA, { within: orgA }), expected);
+            await rejectsWith(assert, () => authz.scopes.attached(unitB1, unitA1, { within: orgA }), expected);
+            // Origen dentro y destino fuera sigue siendo 422 (F2): las dos caras.
+            await rejectsWith(assert, () => authz.scopes.moved(unitA1, orgB, { within: orgA }), expected);
+            // Un hijo que el árbol no conoce no tiene origen que contrastar.
+            await rejectsWith(assert, () => authz.scopes.moved(unitScope(), orgA, { within: orgA }), { status: 422, code: 'E_AUTHZ_UNKNOWN_SCOPE' });
+            assert.deepEqual(touched, [], 'el driver no se toca cuando la contención falla');
+            // El consumidor no movió nada (el paquete rechazó): la herencia sigue sin cruzar.
+            assert.isFalse(await driver.authorize(alice, 'docs:read', unitB1));
+            assert.deepEqual(await tree.chainOf(unitB1), [unitB1, orgB, APP_SCOPE]);
+            // Dentro del mismo tenant sí: nodo nuevo bajo A, y una unit de A bajo otra unit de A.
+            const unitA3 = unitScope();
+            await authz.scopes.attached(unitA3, orgA, { within: orgA });
+            await tree.attach(unitA3, orgA);
+            await authz.scopes.moved(unitA1, unitA2, { within: orgA });
+            await tree.move(unitA1, unitA2);
+            assert.isTrue(await driver.authorize(alice, 'docs:read', unitA1));
+            // Y la plataforma (sin 'non-root') cruza tenants declarando la raíz: es un movimiento legítimo.
+            await managerOver({}, spied).scopes.moved(unitB1, orgA, { within: APP_SCOPE });
+            await tree.move(unitB1, orgA);
+            assert.isTrue(await driver.authorize(alice, 'docs:read', unitB1));
+        });
+        since('2.1', "requireWithin: true ⇒ las seis escrituras sin within ⇒ 422 E_AUTHZ_WITHIN_REQUIRED sin escribir; 'non-root' rechaza además within: app; con el default (false) siguen escribiendo", async ({ assert, }) => {
+            // B1 (tester 5-6, auditor E2) + 2D · F2 (auditor 2 y 9). La cara
+            // negativa prueba que el flag hace algo: con `false` la escritura sin
+            // `within` pasa, y ESO es lo que el aviso del manager nombra como
+            // opt-in. `'non-root'` cierra el comodín `within: APP_SCOPE`, que
+            // satisfacía la regla sin acotar nada.
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            const strict = managerOver({ requireWithin: true });
+            const expected = { status: 422, code: 'E_AUTHZ_WITHIN_REQUIRED' };
+            await rejectsWith(assert, () => strict.grant(alice, 'org-editor', orgA), expected);
+            await rejectsWith(assert, () => strict.deny(alice, 'docs:read', orgA), expected);
+            await rejectsWith(assert, () => strict.grant(alice, 'editor', APP_SCOPE), expected);
+            await rejectsWith(assert, () => strict.revoke(alice, 'org-editor', orgA), expected);
+            await rejectsWith(assert, () => strict.removeDeny(alice, 'docs:read', orgA), expected);
+            await rejectsWith(assert, () => strict.scopes.attached(unitScope(), orgA), expected);
+            await rejectsWith(assert, () => strict.scopes.moved(unitA1, orgA), expected);
+            await rejectsWith(assert, () => strict.scopes.detached(unitA1), expected);
+            assert.deepEqual(await driver.listRoles(alice, orgA), []);
+            assert.isFalse(await driver.authorize(alice, 'docs:read', orgA));
+            // Con `within` las seis escriben (`APP_SCOPE` vale con `true`).
+            await strict.grant(alice, 'org-editor', orgA, { within: orgA });
+            await strict.deny(alice, 'docs:write', orgA, { within: APP_SCOPE });
+            assert.isTrue(await driver.authorize(alice, 'docs:read', orgA));
+            assert.isFalse(await driver.authorize(alice, 'docs:write', orgA));
+            await strict.removeDeny(alice, 'docs:write', orgA, { within: orgA });
+            assert.isTrue(await driver.authorize(alice, 'docs:write', orgA));
+            await strict.revoke(alice, 'org-editor', orgA, { within: orgA });
+            assert.isFalse(await driver.authorize(alice, 'docs:read', orgA));
+            const unitA2 = unitScope();
+            await strict.scopes.attached(unitA2, orgA, { within: orgA });
+            await strict.scopes.moved(unitA1, orgA, { within: orgA });
+            await driver.grant(alice, 'unit-editor', unitA1);
+            await strict.scopes.detached(unitA1, { within: orgA });
+            assert.deepEqual(await driver.listRoles(alice, unitA1), []);
+            // 'non-root': la raíz como `within` no acota nada ⇒ 422 en las seis.
+            const nonRoot = managerOver({ requireWithin: 'non-root' });
+            const root = { status: 422, code: 'E_AUTHZ_WITHIN_ROOT_FORBIDDEN' };
+            await rejectsWith(assert, () => nonRoot.grant(alice, 'org-editor', orgA, { within: APP_SCOPE }), root);
+            await rejectsWith(assert, () => nonRoot.deny(alice, 'docs:read', orgA, { within: APP_SCOPE }), root);
+            await rejectsWith(assert, () => nonRoot.revoke(alice, 'org-editor', orgA, { within: APP_SCOPE }), root);
+            await rejectsWith(assert, () => nonRoot.removeDeny(alice, 'docs:read', orgA, { within: APP_SCOPE }), root);
+            await rejectsWith(assert, () => nonRoot.scopes.attached(unitScope(), orgA, { within: APP_SCOPE }), root);
+            await rejectsWith(assert, () => nonRoot.scopes.moved(unitA2, orgA, { within: APP_SCOPE }), root);
+            await rejectsWith(assert, () => nonRoot.scopes.detached(unitA2, { within: APP_SCOPE }), root);
+            await rejectsWith(assert, () => nonRoot.grant(alice, 'org-editor', orgA), expected);
+            assert.deepEqual(await driver.listRoles(alice, orgA), []);
+            // Con un tenant declarado, escribe; y en la raíz no se puede escribir por aquí (el driver o una config sin flag).
+            await nonRoot.grant(alice, 'org-editor', orgA, { within: orgA });
+            assert.isTrue(await driver.authorize(alice, 'docs:read', orgA));
+            await rejectsWith(assert, () => nonRoot.grant(alice, 'editor', APP_SCOPE, { within: APP_SCOPE }), root);
+            await rejectsWith(assert, () => nonRoot.grant(alice, 'editor', APP_SCOPE, { within: orgA }), { status: 422, code: 'E_AUTHZ_NOT_WITHIN' });
+            assert.deepEqual(await driver.listRoles(alice, APP_SCOPE), []);
+            const lax = managerOver();
+            await lax.revoke(alice, 'org-editor', orgA);
+            await lax.grant(alice, 'org-editor', orgA);
+            assert.isTrue(await driver.authorize(alice, 'docs:read', orgA));
+        });
+        since('2.1', 'authorizeMany: idéntico a N authorize por posición (duplicados, desconocidos, denegados); vacío ⇒ [] sin backend ni árbol; identidad inválida ⇒ 422 antes de tocar nada', async ({ assert, }) => {
+            // B6 (tester §5 E · authorizeMany 1-4). Composición por defecto
+            // (`Promise.all` de `authorize` sobre una vista memoizada) o el método
+            // opcional del driver (openfga: un solo batchCheck correlacionado por
+            // id, L0.14): la respuesta tiene que ser la misma. Nunca parcial: si
+            // una posición no se puede responder, no se responde ninguna.
+            const authz = managerOver();
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            const unitB1 = await unitUnder(tree, orgB);
+            const ghost = orgScope();
+            await driver.grant(alice, 'org-editor', orgA);
+            await driver.grant(alice, 'unit-editor', unitB1);
+            await driver.deny(alice, 'docs:write', unitA1);
+            const scopes = [APP_SCOPE, orgA, unitA1, orgB, unitB1, ghost, orgA, unitB1];
+            const expected = await Promise.all(scopes.map((s) => driver.authorize(alice, 'docs:write', s)));
+            assert.deepEqual(expected, [false, true, false, false, true, false, true, true], 'precondición del caso');
+            assert.deepEqual(await authz.authorizeMany(alice, 'docs:write', scopes), expected);
+            assert.deepEqual(await authz.authorizeMany(alice, 'docs:read', scopes), await Promise.all(scopes.map((s) => driver.authorize(alice, 'docs:read', s))));
+            assert.deepEqual(await authz.authorizeMany(alice, 'no:existe', [orgA, unitB1]), [false, false]);
+            assert.deepEqual(await authz.authorizeMany(subject(), 'docs:write', [orgA, unitB1]), [false, false]);
+            // Vacío: [] sin tocar el driver ni el árbol.
+            const original = tree.chainOf;
+            let asked = 0;
+            tree.chainOf = async (scope) => {
+                asked += 1;
+                return original.call(tree, scope);
+            };
+            // Espía que sobrevive a `withChainResolver` (2D · F7, CR5): con
+            // `value.apply(target)` la vista `Object.create(this)` heredaba del
+            // driver real, no del Proxy, y la aserción "0 llamadas" era vacía.
+            // Con `receiver` la vista hereda del Proxy y sus llamadas se ven.
+            const touched = [];
+            const spied = new Proxy(driver, {
+                get: (target, prop, receiver) => {
+                    const value = Reflect.get(target, prop, receiver);
+                    if (typeof value === 'function' && typeof prop === 'string') {
+                        return (...args) => {
+                            touched.push(prop);
+                            return value.apply(receiver, args);
+                        };
+                    }
+                    return value;
+                },
+            });
+            const watched = new AuthorizationManager({
+                default: harness.name,
+                drivers: { [harness.name]: () => spied },
+                scopes: { resolveChain: resolveChainFrom(tree), descendantsOf: descendantsFrom(tree), acceptScopeDriftRisk: true },
+                warnOnOptInSecurity: false,
+            });
+            try {
+                assert.deepEqual(await watched.authorizeMany(alice, 'docs:write', []), []);
+                assert.deepEqual(touched, []);
+                assert.equal(asked, 0);
+                // Qué pasa cuando el ÁRBOL del consumidor falla en una posición no se
+                // juzga aquí: es el par de capacidad `hierarchyFacts` (3b-2k · K1 ·
+                // R2 (b)). Con el árbol en manos del consumidor lanza entero (503);
+                // con el árbol como hechos del backend, `authorize` ya no lo necesita
+                // y responde — que es justo la propiedad que este modo compra.
+                //
+                // Identidad inválida en cualquier posición: 422 antes de tocar nada.
+                touched.length = 0;
+                await rejectsWith(assert, () => watched.authorizeMany(alice, 'docs:write', [orgA, { type: 'app', uuid: 'X' }]), {
+                    status: 422,
+                    code: 'E_AUTHZ_INVALID_IDENTITY',
+                });
+                assert.deepEqual(touched, [], 'ni withChainResolver ni authorize antes del 422');
+                // Y el espía VE lo que pasa por la vista: una llamada válida se cuenta.
+                touched.length = 0;
+                assert.deepEqual(await watched.authorizeMany(alice, 'docs:write', [orgA]), [true]);
+                assert.isTrue(touched.includes('authorize') || touched.includes('authorizeMany'), `el espía no vio nada: ${touched.join(',')}`);
+            }
+            finally {
+                tree.chainOf = original;
+            }
+        });
+        // ── Concurrencia (2.5 · J4) ──────────────────────────────────────────
+        // Sin `{trx}` en el puerto (`transactions: false` sigue; es el diferido
+        // 2.6): lo que se fija es que dos escrituras solapadas nunca dejan un
+        // estado que ninguna de las dos habría dejado sola. Con el harness en
+        // memoria (pool 1) se solapan a nivel de consulta; con `sqlite-file`, PG
+        // y MySQL (pool ≥ 2) a nivel de conexión.
+        since('2.1', 'dos grant concurrentes con caducidades distintas ⇒ UNA sola asignación y la caducidad final es una de las dos; ninguno falla (o falla con 409, nunca con 500/503)', async ({ assert, }) => {
+            // J4 (a). Carrera check-then-insert: ambos ven «no hay nada» y ambos
+            // insertan; el unique (centinela incluido) o el «tuple already exists»
+            // de FGA detecta al perdedor, que degrada a re-grant sobre lo del
+            // ganador. Un duplicado (dos filas), una caducidad inventada o un 503
+            // por la carrera romperían el invariante 6.
+            const base = Date.now();
+            const e1 = new Date(base + 3_600_000);
+            const e2 = new Date(base + 7_200_000);
+            for (let round = 0; round < 6; round++) {
+                const holder = subject();
+                const [first, second] = round % 2 === 0 ? [e1, e2] : [e2, e1];
+                const settled = await Promise.allSettled([
+                    driver.grant(holder, 'editor', APP_SCOPE, { expiresAt: first }),
+                    driver.grant(holder, 'editor', APP_SCOPE, { expiresAt: second }),
+                ]);
+                for (const outcome of settled) {
+                    if (outcome.status === 'rejected') {
+                        const error = outcome.reason;
+                        assert.equal(error?.status, 409, `ronda ${round}: ${error?.message}`);
+                        assert.match(String(error?.code), /^E_AUTHZ_/);
+                    }
+                }
+                assert.isTrue(settled.some((o) => o.status === 'fulfilled'), `ronda ${round}: al menos un grant escribió`);
+                const holders = await driver.listSubjects('editor', APP_SCOPE);
+                assert.lengthOf(holders.filter((h) => h.uuid === holder.uuid), 1, `ronda ${round}: una sola asignación`);
+                // La caducidad que quedó es una de las dos pedidas, nunca otra ni ninguna.
+                const state = await driver.grant(holder, 'editor', APP_SCOPE);
+                assert.isTrue(state.existed);
+                assert.oneOf(state.previousExpiresAt?.getTime(), [e1.getTime(), e2.getTime()], `ronda ${round}: caducidad final`);
+                assert.equal(state.expiresAt?.getTime(), state.previousExpiresAt?.getTime(), 'el re-grant sin opciones no la toca');
+                assert.isTrue(await driver.authorize(holder, 'docs:read', APP_SCOPE));
+            }
+        })?.timeout(60_000);
+        since('2.1', 'purgeScope concurrente con grant en el mismo scope ⇒ nunca un estado a medias: o la asignación está entera y concede, o no está; y la purga siguiente demuestra cero', async ({ assert, }) => {
+            // J4 (b). La purga borra en transacción (SQL) o borra y relee (FGA);
+            // un grant que aterriza en medio queda ENTERO (y el scope sigue en el
+            // árbol: es legítimo) o no queda. Lo que no puede pasar: una fila que
+            // `listRoles` ve y `authorize` no (o al revés), dos filas, o un error
+            // que no sea el «no pude demostrar cero» (500 E_AUTHZ_PURGE_INCOMPLETE)
+            // que la purga tiene derecho a lanzar cuando alguien escribe debajo.
+            const alice = subject();
+            const later = new Date(Date.now() + 3_600_000);
+            for (let round = 0; round < 6; round++) {
+                const org = await orgUnder(tree, APP_SCOPE);
+                await driver.grant(alice, 'org-editor', org);
+                await driver.deny(alice, 'docs:read', org);
+                const settled = await Promise.allSettled([
+                    driver.purgeScope(org),
+                    driver.grant(alice, 'org-editor', org, { expiresAt: later }),
+                ]);
+                const [purge, grant] = settled;
+                if (purge.status === 'rejected') {
+                    const error = purge.reason;
+                    assert.equal(error?.code, 'E_AUTHZ_PURGE_INCOMPLETE', `ronda ${round}: ${error?.message}`);
+                }
+                assert.equal(grant.status, 'fulfilled', `ronda ${round}: el grant no falla por la purga (${grant.reason?.message ?? ''})`);
+                // Lo que el grant DICE que dejó (K4): la caducidad pedida, siempre;
+                // `existed: true` solo si de verdad refrescó una fila que seguía ahí.
+                const outcome = grant.value;
+                assert.equal(outcome.expiresAt?.getTime(), later.getTime(), `ronda ${round}: el outcome lleva la caducidad pedida`);
+                const roles = await driver.listRoles(alice, org);
+                assert.include([0, 1], roles.length, `ronda ${round}: cero o una asignación`);
+                const present = roles.length === 1;
+                assert.equal(await driver.hasRole(alice, 'org-editor', org), present, `ronda ${round}: hasRole coherente`);
+                assert.equal(await driver.authorize(alice, 'docs:write', org), present, `ronda ${round}: authorize coherente`);
+                assert.lengthOf((await driver.listSubjects('org-editor', org)).filter((h) => h.uuid === alice.uuid), roles.length);
+                if (present) {
+                    const state = await driver.grant(alice, 'org-editor', org);
+                    assert.equal(state.previousExpiresAt?.getTime(), later.getTime(), `ronda ${round}: la que quedó es la del grant concurrente, entera`);
+                }
+                // Demostrar cero: una purga sin nadie escribiendo debajo deja el scope vacío.
+                await driver.purgeScope(org);
+                assert.deepEqual(await driver.listRoles(alice, org), []);
+                assert.isFalse(await driver.authorize(alice, 'docs:write', org));
+                // El deny purgado ya no bloquea, pero tampoco queda grant: denegación por defecto.
+                assert.isFalse(await driver.authorize(alice, 'docs:read', org));
+            }
+        })?.timeout(60_000);
+        since('2.1', 'syncAuthzCatalog concurrente con authorize ⇒ nunca una foto mixta permisiva: en cuanto una respuesta ve el permiso retirado, ninguna posterior lo concede (aquí y en otro memo)', async ({ assert, }) => {
+            // J4 (c). El memo captura la versión ANTES de leer las tres tablas; un
+            // sync que aterriza a mitad de carga deja la foto marcada como vieja y
+            // la siguiente pregunta recarga. Una foto mixta solo puede ser MÁS
+            // restrictiva (permisos → roles → vínculos), nunca conceder lo que el
+            // catálogo nuevo retira. Lo observable: la secuencia de respuestas es
+            // monótona (true… false…), la última es false, y el otro memo (otro
+            // proceso) también deniega en su siguiente pregunta.
+            const twin = harness.makeTwin ? await harness.makeTwin(driver, tree) : twinOf(driver);
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            await driver.grant(alice, 'org-editor', orgA);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', orgA));
+            assert.isTrue(await twin.authorize(alice, 'docs:write', orgA));
+            const answers = [];
+            let synced = false;
+            const sync = harness
+                .seedCatalog({
+                ...CONTRACT_CATALOG,
+                roles: CONTRACT_CATALOG.roles.map((role) => role.slug === 'org-editor' ? { ...role, permissions: ['docs:read'] } : role),
+            })
+                .finally(() => {
+                synced = true;
+            });
+            while (!synced)
+                answers.push(await driver.authorize(alice, 'docs:write', orgA));
+            await sync;
+            answers.push(await driver.authorize(alice, 'docs:write', orgA));
+            assert.isFalse(answers[answers.length - 1], 'tras el sync, denegado');
+            const firstDenied = answers.indexOf(false);
+            assert.isTrue(answers.slice(firstDenied).every((a) => a === false), `no vuelve a conceder tras denegar: ${answers.join(',')}`);
+            assert.isFalse(await twin.authorize(alice, 'docs:write', orgA), 'el otro memo lo ve en su siguiente pregunta');
+            assert.isTrue(await driver.authorize(alice, 'docs:read', orgA), 'lo que sigue en el catálogo sigue concediendo');
+            // Y el catálogo del juez se restaura para el resto (el setup lo re-siembra igualmente).
+            await harness.seedCatalog(CONTRACT_CATALOG);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', orgA));
+            assert.isTrue(await twin.authorize(alice, 'docs:write', orgA));
+        })?.timeout(60_000);
+        // ── Nivel 2.2 (Fase 3 · Lote 3B: roles locales a un scope) ───────────
+        // Un rol tiene un OWNER (`authz_roles.owner_scope_key`): `global` (el
+        // catálogo del config) o la clave del scope que lo define. Regla única:
+        // una asignación en el scope S de un rol R cuenta si y solo si R es
+        // global o su owner está en chain(S) (S inclusive). `assignableAt`,
+        // `rank` y `delegablePermissions` son controles de COMPOSICIÓN y de
+        // ESCRITURA; `authorize` sigue siendo «¿hay un grant vigente en mi
+        // cadena sin deny?» (invariantes 1, 2 y 8 intactos). Los casos de aquí
+        // juzgan al DRIVER con roles locales escritos como los dejaría otro
+        // proceso (`localRole`); la policy de `defineScopedRole` se juzga bajo
+        // el par `listDenies` (necesita `effectivePermissions`).
+        since('2.2', 'un rol local de la organization A concede en A y sus units (también anidadas), no en B ni en app; hasRole/listRoles/listSubjects/listScopes/listRoleScopes respetan el owner; grant fuera del owner ⇒ 422 E_AUTHZ_ROLE_NOT_VISIBLE sin escribir; mover la unit fuera de A retira lo concedido, y volverla lo restaura', async ({ assert, }) => {
+            // 3B · B2. El owner es el CONTENEDOR del rol: fuera de él el rol no
+            // existe (ni concede, ni es membresía, ni se puede asignar). Un rol
+            // global con el mismo slug NO existe aquí (`lead`, `org-lead`): lo que
+            // se observa es el owner, no una colisión.
+            const alice = subject();
+            const bob = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            const unitA1x = await unitUnder(tree, unitA1);
+            const unitB1 = await unitUnder(tree, orgB);
+            const leadA = await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+            await localRole(orgA, { slug: 'org-lead', scopeType: 'organization', permissions: ['billing:read'] });
+            // Un rol local de nivel `app` no es asignable en ningún sitio: la raíz
+            // no cuelga de ningún owner. Existe (es una fila) pero no es visible.
+            await localRole(orgA, { slug: 'phantom', scopeType: 'app', permissions: ['docs:read'] });
+            await driver.grant(alice, 'lead', unitA1);
+            await driver.grant(alice, 'org-lead', orgA);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1x), 'hereda hacia abajo dentro del owner');
+            assert.isTrue(await driver.authorize(alice, 'billing:read', unitA1));
+            assert.isTrue(await driver.authorize(alice, 'billing:read', orgA));
+            assert.isFalse(await driver.authorize(alice, 'docs:write', orgA), 'el rol de unit no vale en la org (no es herencia hacia arriba)');
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitB1));
+            assert.isFalse(await driver.authorize(alice, 'billing:read', orgB));
+            assert.isFalse(await driver.authorize(alice, 'billing:read', APP_SCOPE));
+            assert.isFalse(await driver.authorize(alice, 'docs:read', APP_SCOPE));
+            const notVisible = { status: 422, code: 'E_AUTHZ_ROLE_NOT_VISIBLE' };
+            await rejectsWith(assert, () => driver.grant(bob, 'lead', unitB1), notVisible);
+            await rejectsWith(assert, () => driver.grant(bob, 'org-lead', orgB), notVisible);
+            await rejectsWith(assert, () => driver.grant(bob, 'phantom', APP_SCOPE), notVisible);
+            // Un rol que no existe en ningún owner sigue siendo E_AUTHZ_UNKNOWN_ROLE.
+            await rejectsWith(assert, () => driver.grant(bob, 'no-existe', unitB1), { status: 422, code: 'E_AUTHZ_UNKNOWN_ROLE' });
+            assert.deepEqual(await driver.listRoles(bob, unitB1), []);
+            assert.deepEqual(await driver.listRoles(bob, orgB), []);
+            assert.isFalse(await driver.authorize(bob, 'docs:write', unitB1));
+            // Membresía y enumeraciones: solo dentro del owner.
+            assert.isTrue(await driver.hasRole(alice, 'lead', unitA1));
+            assert.isTrue(await driver.hasRole(alice, 'lead', unitA1x));
+            assert.isTrue(await driver.hasRole(alice, { slug: 'lead', scopeType: 'unit' }, unitA1x));
+            assert.isFalse(await driver.hasRole(alice, 'lead', unitB1));
+            assert.isTrue(await driver.hasRole(alice, 'org-lead', unitA1));
+            assert.isFalse(await driver.hasRole(alice, 'org-lead', orgB));
+            assert.deepEqual(await driver.listRoles(alice, unitA1), ['lead']);
+            assert.deepEqual(await driver.listRoles(alice, orgA), ['org-lead']);
+            assert.deepEqual((await driver.listSubjects('lead', unitA1)).map((h) => h.uuid), [alice.uuid]);
+            assert.deepEqual(await driver.listSubjects('lead', unitB1), [], 'el rol no existe en B: nadie lo tiene');
+            // Y lo mismo preguntando por `{ uuid }` (3D · M1 c, tester): la
+            // resolución exacta no exime de la regla de owner — dentro responde…
+            assert.isTrue(await driver.hasRole(alice, { uuid: leadA }, unitA1x));
+            assert.deepEqual((await driver.listSubjects({ uuid: leadA }, unitA1)).map((h) => h.uuid), [alice.uuid]);
+            assert.deepEqual(scopeKeys(await driver.listScopes(alice, 'docs:write')), scopeKeys([unitA1]));
+            assert.deepEqual(scopeKeys(await driver.listScopes(alice, 'billing:read')), scopeKeys([orgA]));
+            assert.deepEqual(scopeKeys(await driver.listRoleScopes(alice, 'unit')), scopeKeys([unitA1]));
+            assert.deepEqual(scopeKeys(await driver.listRoleScopes(alice, 'organization')), scopeKeys([orgA]));
+            // La visibilidad se decide con el árbol de HOY: la unit sale de A y el
+            // rol de A deja de existir para ella (sin escribir nada); vuelve, y vuelve.
+            await tree.move(unitA1, orgB);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1));
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1x));
+            assert.isFalse(await driver.hasRole(alice, 'lead', unitA1));
+            assert.deepEqual(await driver.listRoles(alice, unitA1), [], 'una asignación cuyo rol ya no es visible no es membresía');
+            assert.deepEqual(await driver.listSubjects('lead', unitA1), []);
+            // …y fuera, no: el uuid del rol de A no resucita la asignación que el
+            // árbol de HOY dejó fuera de su owner (misma regla que por slug).
+            assert.isFalse(await driver.hasRole(alice, { uuid: leadA }, unitA1));
+            assert.deepEqual(await driver.listSubjects({ uuid: leadA }, unitA1), []);
+            assert.deepEqual(await driver.listScopes(alice, 'docs:write'), []);
+            assert.deepEqual(await driver.listRoleScopes(alice, 'unit'), []);
+            await tree.move(unitA1, orgA);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1x));
+            assert.deepEqual(await driver.listRoles(alice, unitA1), ['lead']);
+            // revoke fuera del owner es un no-op (no hay nada que quitar); dentro, quita.
+            await driver.revoke(alice, 'lead', unitB1);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+            await driver.revoke(alice, 'lead', unitA1);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1));
+        });
+        since('2.2', 'la visibilidad se decide POR NIVEL, no por el conjunto de la cadena: si el árbol se recuelga y el owner queda POR DEBAJO del scope de la asignación, esa asignación deja de contar aunque el owner siga en la cadena de la pregunta', async ({ assert, }) => {
+            // 3B · B2 (desviación 2 del lote, sin caso hasta aquí). La regla es
+            // «una asignación en el scope S cuenta si su rol EXISTE EN S»: el owner
+            // tiene que ser ancestro-o-igual de S, no de la pregunta. Con la lectura
+            // por CONJUNTO («owner ∈ chain(scope preguntado)») este caso concedería:
+            // orgA sigue estando en la cadena de unitA2. El mutante que sustituye
+            // `keys.slice(i)` por `keys` en `chainKeysFrom` pasa toda la suite sin
+            // este caso, en los dos drivers y en los tres motores.
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+            await driver.grant(alice, 'lead', unitA1);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+            // El consumidor recuelga su árbol: unitA1 pasa a la raíz y orgA cuelga
+            // de ella. Ninguna escritura de hechos: solo cambia el árbol.
+            await tree.move(unitA1, APP_SCOPE);
+            await tree.move(orgA, unitA1);
+            const unitA2 = await unitUnder(tree, orgA);
+            // chain(unitA2) = [unitA2, orgA, unitA1, app]: el owner está en la
+            // cadena, pero POR DEBAJO de la asignación (unitA1) — no cuenta.
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA2), 'por conjunto concedería; por nivel no');
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1));
+            assert.isFalse(await driver.hasRole(alice, 'lead', unitA2));
+            assert.isFalse(await driver.hasRole(alice, 'lead', unitA1));
+            assert.deepEqual(await driver.listRoles(alice, unitA1), []);
+            assert.deepEqual(await driver.listRoles(alice, unitA2), []);
+            assert.deepEqual(await driver.listScopes(alice, 'docs:write'), []);
+            assert.deepEqual(await driver.listRoleScopes(alice, 'unit'), []);
+            // El inverso, que es lo que hace significativo al caso: con el árbol
+            // nuevo, una asignación DENTRO del owner sigue concediendo hacia abajo.
+            const unitA2x = await unitUnder(tree, unitA2);
+            await driver.grant(alice, 'lead', unitA2);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA2));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA2x));
+            assert.deepEqual(await driver.listRoles(alice, unitA2), ['lead']);
+            // Y la de unitA1 sigue sin contar: no ha revivido por el camino.
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1));
+        });
+        since('2.2', 'dos tenants definen el mismo slug (lead@unit) con permisos distintos: cada uno concede lo suyo y listRoles/listSubjects/hasRole/revoke no cruzan tenants — el slug ya no identifica al rol, el uuid sí', async ({ assert, }) => {
+            // 3B · B2 (tester §4: el pin de regresión de `listSubjects` promovido).
+            // Con `unique(slug, scope_type, owner_scope_key)` hay DOS roles `lead@unit`
+            // con uuids distintos; todo resuelve por uuid dentro del owner.
+            const alice = subject();
+            const bob = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            const unitB1 = await unitUnder(tree, orgB);
+            const leadA = await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+            const leadB = await localRole(orgB, { slug: 'lead', scopeType: 'unit', permissions: ['docs:read'] });
+            await driver.grant(alice, 'lead', unitA1);
+            await driver.grant(bob, 'lead', unitB1);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+            assert.isFalse(await driver.authorize(alice, 'docs:read', unitA1), 'el lead de A no lleva docs:read');
+            assert.isTrue(await driver.authorize(bob, 'docs:read', unitB1));
+            assert.isFalse(await driver.authorize(bob, 'docs:write', unitB1), 'el lead de B no lleva docs:write');
+            assert.deepEqual((await driver.listSubjects('lead', unitA1)).map((h) => h.uuid), [alice.uuid]);
+            assert.deepEqual((await driver.listSubjects('lead', unitB1)).map((h) => h.uuid), [bob.uuid]);
+            assert.deepEqual(await driver.listRoles(alice, unitA1), ['lead']);
+            assert.deepEqual(await driver.listRoles(alice, unitB1), []);
+            assert.isTrue(await driver.hasRole(bob, 'lead', unitB1));
+            assert.isFalse(await driver.hasRole(alice, 'lead', unitB1));
+            assert.deepEqual(scopeKeys(await driver.listScopes(bob, 'docs:read')), scopeKeys([unitB1]));
+            assert.deepEqual(await driver.listScopes(bob, 'docs:write'), []);
+            // Y el uuid tampoco cruza tenants (3D · M1 c, tester): `{ uuid }` es
+            // resolución EXACTA, no un permiso para saltarse al owner. El uuid del
+            // rol de B es público (sale en `rolesInChain`, en el evento
+            // `role_defined` y en el 422 de ambigüedad), así que si la ruta por
+            // uuid no comprobara la visibilidad bastaría con pasarlo para asignar
+            // dentro de A el rol de otro tenant. Hasta aquí solo había caso para
+            // «el uuid es de otro NIVEL»; esta es la otra mitad de la regla.
+            await rejectsWith(assert, () => driver.grant(alice, { uuid: leadB }, unitA1), {
+                status: 422,
+                code: 'E_AUTHZ_ROLE_NOT_VISIBLE',
+            });
+            assert.deepEqual(await driver.listRoles(alice, unitA1), ['lead'], 'y no escribió nada');
+            assert.isFalse(await driver.authorize(alice, 'docs:read', unitA1));
+            // Membresía: fuera del owner el rol no existe (false y [], nunca throw).
+            assert.isFalse(await driver.hasRole(bob, { uuid: leadB }, unitA1));
+            assert.isFalse(await driver.hasRole(alice, { uuid: leadA }, unitB1));
+            assert.deepEqual(await driver.listSubjects({ uuid: leadB }, unitA1), []);
+            assert.deepEqual(await driver.listSubjects({ uuid: leadA }, unitB1), []);
+            // Donde el owner SÍ está en la cadena, el mismo uuid responde.
+            assert.isTrue(await driver.hasRole(bob, { uuid: leadB }, unitB1));
+            assert.deepEqual((await driver.listSubjects({ uuid: leadB }, unitB1)).map((h) => h.uuid), [bob.uuid]);
+            assert.deepEqual((await driver.listSubjects({ uuid: leadA }, unitA1)).map((h) => h.uuid), [alice.uuid]);
+            // Revocar «lead» en B no toca al lead de A.
+            await driver.revoke(alice, 'lead', unitB1);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+            await driver.revoke(bob, 'lead', unitB1);
+            assert.isFalse(await driver.authorize(bob, 'docs:read', unitB1));
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+        });
+        since('2.2', 'un scopes.moved legítimo junta dos homónimos en la misma cadena: TODA ruta por slug falla cerrada con 422 E_AUTHZ_AMBIGUOUS_ROLE (grant, revoke, hasRole, listSubjects), { uuid } resuelve el correcto y authorize —que no direcciona por slug— sigue respondiendo', async ({ assert, }) => {
+            // 3D · M1 (auditor V3, reproducido en PG). U1 nace en el tenant B, que
+            // define ahí su `lead@unit`; A define el suyo en su organization
+            // (subárboles disjuntos: ninguna colisión). La plataforma transfiere U1
+            // a A —operación legítima— y de repente los dos son visibles en la
+            // misma cadena. Hasta 3C ganaba «el owner más cercano» y el admin de A
+            // concedía SIN SABERLO el rol de B (`billing`/`docs:write` de otro
+            // tenant). Ahora la ambigüedad es un error: nadie elige por él.
+            const victima = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unitU1 = await unitUnder(tree, orgB);
+            const leadB = await localRole(unitU1, { slug: 'lead', scopeType: 'unit', permissions: ['docs:read'] });
+            const leadA = await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+            // Antes del move cada uno es el único visible en su subárbol.
+            await driver.grant(victima, 'lead', unitU1);
+            assert.isTrue(await driver.authorize(victima, 'docs:read', unitU1), 'el de B, que es el único visible ahí');
+            await driver.revoke(victima, 'lead', unitU1);
+            await tree.move(unitU1, orgA);
+            const ambiguo = { status: 422, code: 'E_AUTHZ_AMBIGUOUS_ROLE' };
+            await rejectsWith(assert, () => driver.grant(victima, 'lead', unitU1), ambiguo);
+            await rejectsWith(assert, () => driver.grant(victima, { slug: 'lead', scopeType: 'unit' }, unitU1), ambiguo);
+            await rejectsWith(assert, () => driver.hasRole(victima, 'lead', unitU1), ambiguo);
+            await rejectsWith(assert, () => driver.listSubjects('lead', unitU1), ambiguo);
+            assert.deepEqual(await driver.listRoles(victima, unitU1), [], 'nada escrito: el 422 fue antes del backend');
+            // `{ uuid }` es la forma exacta: concede EL rol que se pidió.
+            await driver.grant(victima, { uuid: leadA }, unitU1);
+            assert.isTrue(await driver.authorize(victima, 'docs:write', unitU1), 'authorize no direcciona por slug: responde');
+            assert.isFalse(await driver.authorize(victima, 'docs:read', unitU1), 'el rol de B no se le ha dado');
+            assert.isTrue(await driver.hasRole(victima, { uuid: leadA }, unitU1));
+            assert.isFalse(await driver.hasRole(victima, { uuid: leadB }, unitU1));
+            assert.deepEqual((await driver.listSubjects({ uuid: leadA }, unitU1)).map((h) => h.uuid), [victima.uuid]);
+            assert.deepEqual(await driver.listSubjects({ uuid: leadB }, unitU1), []);
+            // La membresía habla en slugs y por eso puede tener homónimos: el
+            // puerto lo documenta y la forma sin ambigüedad es `{ uuid }`.
+            assert.deepEqual(await driver.listRoles(victima, unitU1), ['lead']);
+            // Y el slug sigue siendo 422 aunque haya una asignación de por medio.
+            await rejectsWith(assert, () => driver.hasRole(victima, 'lead', unitU1), ambiguo);
+            // `revoke` por slug NO elige: quita los hechos de todos los homónimos
+            // del scope exacto (quitar nunca concede). Por uuid, solo el suyo.
+            await driver.grant(victima, { uuid: leadB }, unitU1);
+            assert.isTrue(await driver.authorize(victima, 'docs:read', unitU1));
+            await driver.revoke(victima, { uuid: leadB }, unitU1);
+            assert.isFalse(await driver.authorize(victima, 'docs:read', unitU1));
+            assert.isTrue(await driver.authorize(victima, 'docs:write', unitU1));
+            await driver.grant(victima, { uuid: leadB }, unitU1);
+            await driver.revoke(victima, 'lead', unitU1);
+            assert.isFalse(await driver.authorize(victima, 'docs:write', unitU1));
+            assert.isFalse(await driver.authorize(victima, 'docs:read', unitU1));
+            // Deshecho el cruce, el slug vuelve a responder — y responde al de B.
+            await tree.move(unitU1, orgB);
+            await driver.grant(victima, 'lead', unitU1);
+            assert.isTrue(await driver.authorize(victima, 'docs:read', unitU1));
+            assert.isFalse(await driver.authorize(victima, 'docs:write', unitU1), 'el rol de A ya no existe aquí');
+            assert.isTrue(await driver.hasRole(victima, 'lead', unitU1));
+        });
+        since('2.2', 'paridad entre drivers (3D · N1): una asignación cuyo rol está declarado para OTRO nivel no cuenta en ninguno de los dos — ni concede, ni es membresía, ni se enumera — y vuelve a contar en cuanto el nivel del rol coincide otra vez', async ({ assert, }) => {
+            // Desviación 3 del lote 3B («`database.authorize` exige además
+            // `r.scope_type = a.scope_type`, como ya hacía `openfga`») era una
+            // promesa de PARIDAD sin juez: el mutante que la revertía pasaba las
+            // suites enteras (tester H4). Solo es alcanzable retocando el catálogo
+            // —`grant` lo impide—, y el catálogo es SQL en los dos drivers.
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            const lead = await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+            await driver.grant(alice, 'lead', unitA1);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+            // El rol pasa a estar declarado para `organization`: la asignación
+            // sigue en un scope `unit` y deja de contar.
+            await retypeRole(lead, 'organization');
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1), 'el rol ya no existe en ese nivel');
+            assert.isFalse(await driver.hasRole(alice, 'lead', unitA1));
+            assert.isFalse(await driver.hasRole(alice, { slug: 'lead', scopeType: 'unit' }, unitA1));
+            assert.deepEqual(await driver.listRoles(alice, unitA1), []);
+            assert.deepEqual(await driver.listSubjects('lead', unitA1), []);
+            assert.deepEqual(await driver.listScopes(alice, 'docs:write'), []);
+            assert.deepEqual(await driver.listRoleScopes(alice, 'unit'), []);
+            // Y tampoco cuenta «hacia arriba»: no hay asignación en orgA.
+            assert.isFalse(await driver.authorize(alice, 'docs:write', orgA));
+            await rejectsWith(assert, () => driver.grant(alice, 'lead', unitA1), { status: 422, code: 'E_AUTHZ_UNKNOWN_ROLE' });
+            await retypeRole(lead, 'unit');
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1), 'vuelve a coincidir el nivel: vuelve a contar');
+            assert.deepEqual(await driver.listRoles(alice, unitA1), ['lead']);
+        });
+        since('2.2', "la clave de owner 'global' está reservada: un scope de TIPO 'global' produce la clave 'global|<uuid>' y sus roles son locales a él, nunca globales", async ({ assert, }) => {
+            // 3B · B1/B2 (tester §4, mismo patrón que el centinela de la raíz). Un
+            // tenant cuyo tipo de scope se llame `global` no se hace pasar por el
+            // catálogo global: la clave de owner lleva siempre `<tipo>|<uuid>` (la
+            // raíz no es owner), así que `global` a secas no la produce ningún scope.
+            const alice = subject();
+            const bob = subject();
+            const weird = { type: 'global', uuid: uuidv7() };
+            await tree.attach(weird, APP_SCOPE);
+            const unitW = await unitUnder(tree, weird);
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            await localRole(weird, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+            await driver.grant(alice, 'lead', unitW);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitW));
+            await rejectsWith(assert, () => driver.grant(bob, 'lead', unitA1), { status: 422, code: 'E_AUTHZ_ROLE_NOT_VISIBLE' });
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1));
+            assert.deepEqual(await driver.listSubjects('lead', unitA1), []);
+        });
+        since('2.2', 'deny × rol local: un deny en cualquier punto de la cadena gana sobre un rol local; quitarlo restaura (invariante 2 en el módulo nuevo)', async ({ assert, }) => {
+            // 3B · B2 (tester §4). El owner no es una excepción al deny: `authorize`
+            // sigue siendo «sin deny en la cadena Y un grant vigente y visible».
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            const unitA1x = await unitUnder(tree, unitA1);
+            await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write', 'docs:read'] });
+            await driver.grant(alice, 'lead', unitA1);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1x));
+            await driver.deny(alice, 'docs:write', orgA); // por encima del grant
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1));
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1x));
+            assert.isTrue(await driver.authorize(alice, 'docs:read', unitA1x), 'el deny es quirúrgico');
+            assert.isTrue(await driver.hasRole(alice, 'lead', unitA1x), 'membresía intacta: el deny no la gobierna');
+            await driver.deny(alice, 'docs:read', unitA1x); // por debajo del grant
+            assert.isFalse(await driver.authorize(alice, 'docs:read', unitA1x));
+            assert.isTrue(await driver.authorize(alice, 'docs:read', unitA1));
+            assert.deepEqual(scopeKeys(await driver.listScopes(alice, 'docs:write')), [], 'listScopes resta el deny heredado');
+            await driver.removeDeny(alice, 'docs:write', orgA);
+            await driver.removeDeny(alice, 'docs:read', unitA1x);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1x));
+            assert.isTrue(await driver.authorize(alice, 'docs:read', unitA1x));
+        });
+        since('2.2', 'assignableAt es control de COMPOSICIÓN, jamás de evaluación: un rol que lleva (a mano) un permiso no asignable en su nivel sigue concediendo lo ya asignado; un grant NUEVO de ese rol ⇒ 422 E_AUTHZ_ROLE_NOT_ASSIGNABLE_AT sin escribir', async ({ assert, }) => {
+            // 3B · B5 (tester H). `org:settings` solo pueden llevarlo roles de
+            // app/organization. `unit-editor@unit` no lo lleva (el sync lo
+            // rechazaría); se le vincula A MANO después de conceder. Lo que fija
+            // el caso: `authorize` NO mira `assignableAt` (invariante 1: un grant
+            // vigente concede lo que su rol concede), y la barrera está en la
+            // escritura (`grant`), donde el rol «no es asignable en ese nivel».
+            const alice = subject();
+            const bob = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const unitA1 = await unitUnder(tree, orgA);
+            const unitA2 = await unitUnder(tree, orgA);
+            await driver.grant(alice, 'unit-editor', unitA1);
+            assert.isFalse(await driver.authorize(alice, 'org:settings', unitA1));
+            const unitEditor = (await new CatalogCache().view()).role('unit-editor', 'unit').uuid;
+            await linkByHand(unitEditor, 'org:settings');
+            assert.isTrue(await driver.authorize(alice, 'org:settings', unitA1), 'lo ya asignado sigue concediendo: no se evalúa');
+            assert.isTrue(await driver.hasRole(alice, 'unit-editor', unitA1));
+            await rejectsWith(assert, () => driver.grant(bob, 'unit-editor', unitA2), { status: 422, code: 'E_AUTHZ_ROLE_NOT_ASSIGNABLE_AT' });
+            assert.deepEqual(await driver.listRoles(bob, unitA2), []);
+            assert.isFalse(await driver.authorize(bob, 'org:settings', unitA2));
+            // Un rol de organization sí puede llevarlo: se asigna con normalidad.
+            await driver.grant(bob, 'org-admin', orgA);
+            assert.isTrue(await driver.authorize(bob, 'org:settings', unitA2));
+        });
+        // ── Par de capacidad `purgeRole` (3B · B4) ───────────────────────────
+        caseFor('purgeRole', {
+            whenTrue: () => {
+                since('2.2', 'purgeRole(uuid) revoca todas las asignaciones del rol en TODOS los scopes (owner y descendientes), borra sus vínculos y el rol; recrear el slug (otro uuid) no revive nada; un uuid desconocido o mal formado ⇒ 422', async ({ assert, }) => {
+                    // 3B · B4 (tester §4: con asignaciones en descendientes y con denies
+                    // del permiso del rol). Es lo que `deleteScopedRole` necesita del
+                    // puerto: borrar el rol sin dejar asignaciones huérfanas que
+                    // resuciten si el slug vuelve a existir.
+                    assert.typeOf(driver.purgeRole, 'function', 'purgeRole: true exige purgeRole en el puerto');
+                    const alice = subject();
+                    const bob = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const unitA1 = await unitUnder(tree, orgA);
+                    const unitA1x = await unitUnder(tree, unitA1);
+                    const lead = await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+                    await driver.grant(alice, 'lead', unitA1);
+                    await driver.grant(bob, 'lead', unitA1x);
+                    await driver.grant(alice, 'unit-editor', unitA1); // otro rol: intacto
+                    await driver.deny(bob, 'docs:read', unitA1x); // un deny: intacto
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+                    assert.isTrue(await driver.authorize(bob, 'docs:write', unitA1x));
+                    assert.equal(await linksOf(lead), 1, 'el rol tenía su vínculo');
+                    await driver.purgeRole(lead);
+                    // El conteo de vínculos documenta la promesa; quien la GARANTIZA en
+                    // este esquema es el `CASCADE` (ver `linksOf`, 3F · U2).
+                    assert.equal(await linksOf(lead), 0, 'purgeRole borra también los vínculos rol→permiso');
+                    assert.isNull((await new CatalogCache().view()).roleByUuid(lead), 'y la fila del rol');
+                    assert.isFalse(await driver.hasRole(alice, 'lead', unitA1));
+                    assert.deepEqual(await driver.listRoles(alice, unitA1), ['unit-editor'], 'solo cae el rol purgado');
+                    assert.deepEqual(await driver.listRoles(bob, unitA1x), []);
+                    assert.isFalse(await driver.authorize(bob, 'docs:write', unitA1x));
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1), 'unit-editor sigue concediendo');
+                    assert.isFalse(await driver.authorize(bob, 'docs:read', unitA1x), 'el deny sigue');
+                    await rejectsWith(assert, () => driver.grant(bob, 'lead', unitA1), { status: 422, code: 'E_AUTHZ_UNKNOWN_ROLE' });
+                    await rejectsWith(assert, () => driver.purgeRole(lead), { status: 422, code: 'E_AUTHZ_UNKNOWN_ROLE' });
+                    await rejectsWith(assert, () => driver.purgeRole('lead'), { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' });
+                    // El slug vuelve a existir (otro uuid): nada resucita.
+                    await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+                    assert.isFalse(await driver.hasRole(alice, 'lead', unitA1));
+                    assert.isFalse(await driver.authorize(bob, 'docs:write', unitA1x));
+                    assert.deepEqual(await driver.listSubjects('lead', unitA1), []);
+                    assert.deepEqual(await driver.listSubjects('lead', unitA1x), []);
+                    await driver.grant(bob, 'lead', unitA1x);
+                    assert.isTrue(await driver.authorize(bob, 'docs:write', unitA1x));
+                    assert.deepEqual((await driver.listSubjects('lead', unitA1x)).map((h) => h.uuid), [bob.uuid]);
+                    // El cero, por el PUERTO PÚBLICO y en CADA scope donde había una
+                    // asignación (3D · M6 c, tester H3): hasta aquí a los mutantes de
+                    // `purgeRole` los mataba una FK del espejo de tests que ni siquiera
+                    // coincidía con el stub publicado, no una aserción.
+                    const carol = subject();
+                    await driver.grant(carol, 'lead', unitA1);
+                    assert.deepEqual((await driver.listSubjects('lead', unitA1)).map((h) => h.uuid), [carol.uuid], 'alice no resucita con el slug');
+                    assert.isFalse(await driver.hasRole(alice, 'lead', unitA1));
+                    assert.isFalse(await driver.hasRole(alice, 'lead', unitA1x));
+                });
+                since('2.2', 'scopes.detached purga los HECHOS del scope y SOLO los hechos (invariante 11): los roles locales de ese owner —y los del subárbol— sobreviven DORMIDOS (no conceden, no son membresía, no se asignan) y ningún actor los destruye por esta vía; la salida es pruneOrphanRoles, que es de plataforma', async ({ assert, }) => {
+                    // 3b-0 · Z1. Entre 3D y 3G `scopes.detached` arrastraba además los
+                    // roles LOCALES del owner (y, con `descendantsOf`, los del
+                    // subárbol), con policy de rango, degradación y un retorno que
+                    // contaba lo purgado. Cinco lotes la tocaron y TRES de las cuatro
+                    // regresiones de la Fase 3 nacieron ahí, siempre por COMPOSICIÓN
+                    // (3E · P3 + 3F · S1/S2 ⇒ 3G · W1: un `detached` de un ancestro
+                    // desconocido destruía roles de descendientes VIVOS). Lo que este
+                    // caso fija es que esa superficie NO VUELVE: el catálogo no se
+                    // escribe desde el árbol.
+                    const authz = managerOver();
+                    const alice = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const unitA1 = await unitUnder(tree, orgA);
+                    const unitA1x = await unitUnder(tree, unitA1);
+                    const propio = await localRole(unitA1, { slug: 'propio', scopeType: 'unit', permissions: ['docs:write'] });
+                    const delNieto = await localRole(unitA1x, { slug: 'nieto', scopeType: 'unit', permissions: ['docs:read'] });
+                    await driver.grant(alice, 'propio', unitA1);
+                    await driver.grant(alice, 'nieto', unitA1x);
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+                    assert.isUndefined(await authz.scopes.detached(unitA1), 'no devuelve nada que declarar a medias');
+                    assert.deepEqual(await driver.listRoles(alice, unitA1), [], 'los HECHOS del scope, purgados');
+                    assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1));
+                    const view = await new CatalogCache().view();
+                    assert.isNotNull(view.roleByUuid(propio), 'la fila del rol NO se toca: el catálogo no se escribe desde el árbol');
+                    assert.isNotNull(view.roleByUuid(delNieto), 'ni la del descendiente');
+                    assert.equal(await linksOf(propio), 1, 'ni sus vínculos');
+                    // Dormido: con el owner fuera del árbol el rol no concede, no es
+                    // membresía y no se puede asignar (invariante 18, sin cambios).
+                    await tree.detach(unitA1);
+                    assert.isFalse(await driver.authorize(alice, 'docs:read', unitA1x), 'el nieto pierde su cadena y con ella todo');
+                    await rejectsWith(assert, () => authz.grant(alice, { uuid: propio }, unitA1x), { status: 422, code: 'E_AUTHZ_UNKNOWN_SCOPE' });
+                    // La salida es de PLATAFORMA y en dos tiempos: primero se mira.
+                    const seco = await authz.pruneOrphanRoles();
+                    assert.deepEqual(seco.orphans.map((o) => o.role.uuid).sort(), [delNieto, propio].sort());
+                    assert.deepEqual(seco.purged, [], 'el default no escribe');
+                    assert.isNotNull((await new CatalogCache().view()).roleByUuid(propio));
+                    // 3b-0b · AA1: los dos tenían hechos, y los hechos siguen ahí (el
+                    // `detached` purgó los del scope, no los del rol), así que el
+                    // barrido AVISA de que no está recogiendo basura inerte.
+                    assert.deepEqual(seco.orphans.filter((o) => o.stillGranting).map((o) => o.role.uuid).sort(), [delNieto].sort(), 'el del nieto conserva su hecho; el del scope purgado, no');
+                    // 3b-0b · AA2: aquí TODOS los owners locales están huérfanos, que
+                    // es la firma de un resolutor ciego. Se rechaza sin borrar nada.
+                    assert.isTrue(seco.massPurge);
+                    await rejectsWith(assert, () => authz.pruneOrphanRoles({ force: true }), { status: 500, code: 'E_AUTHZ_MASS_PURGE_REFUSED' });
+                    assert.isNotNull((await new CatalogCache().view()).roleByUuid(propio), 'el rechazo no borra nada');
+                    const purga = await authz.pruneOrphanRoles({ force: true, allowMassPurge: true });
+                    assert.deepEqual(purga.purged.map((r) => r.uuid).sort(), [delNieto, propio].sort());
+                    assert.deepEqual(purga.skipped, [], 'ningún owner volvió durante la pasada');
+                    const tras = await new CatalogCache().view();
+                    assert.isNull(tras.roleByUuid(propio), 'ahora sí: la fila se va');
+                    assert.deepEqual(tras.rolesNamed('propio', 'unit'), [], 'y ese (slug, nivel) vuelve a estar libre');
+                    assert.equal(await linksOf(propio), 0, 'sin vínculos huérfanos');
+                    assert.equal(await linksOf(delNieto), 0);
+                    // Nada resucita por el slug: un rol nuevo con ese nombre en otro
+                    // árbol no hereda lo que concedía el purgado.
+                    const orgB = await orgUnder(tree, APP_SCOPE);
+                    const unitB1 = await unitUnder(tree, orgB);
+                    await localRole(orgB, { slug: 'propio', scopeType: 'unit', permissions: ['docs:read'] });
+                    await driver.grant(alice, 'propio', unitB1);
+                    assert.isTrue(await driver.authorize(alice, 'docs:read', unitB1));
+                    assert.isFalse(await driver.authorize(alice, 'docs:write', unitB1), 'el rol viejo no revive por el slug');
+                });
+                // ── Casos de COMPOSICIÓN (3G · W4) ────────────────────────────────
+                // Las tres regresiones seguidas de 3E/3F/3G nacieron de componer
+                // piezas correctas por separado: cada una tenía su caso, ninguna lo
+                // tenía JUNTO a las otras. De los CUATRO que se escribieron en 3G,
+                // tres eran del `scopes.detached` que purgaba roles (ancestro
+                // desconocido con descendientes vivos, cota superada con rango
+                // insuficiente, `descendantsOf` que falla). Con 3b-0 · Z1 esa
+                // composición ya no existe —la operación no toca el catálogo, no
+                // mide rango y no enumera el subárbol—, así que los tres se
+                // borraron: no hay piezas que componer. El cuarto sigue vivo, en el
+                // par `listDenies` con el resto de la delegación (`defineScopedRole`
+                // que ensombrece con el subárbol sin enumerar), porque ahí sí siguen
+                // componiéndose la regla de nivel degradada y el rango del
+                // ensombrecido.
+            },
+            whenFalse: () => {
+                since('2.2', 'sin purgeRole: el puerto NO lo trae (opcional desde 3E · Q4) y el manager lo dice con 500 E_AUTHZ_UNSUPPORTED ANTES de escribir — defineScopedRole no crea el rol, deleteScopedRole y pruneOrphanRoles lo dicen sin tocar nada; scopes.detached, que solo purga HECHOS, no lo necesita', async ({ assert, }) => {
+                    // 3B · B4 + 3E · P4. Hasta 3E este caso FIJABA UN CALLEJÓN SIN
+                    // SALIDA como comportamiento esperado: `defineScopedRole` creaba el
+                    // rol contra un driver que jamás podría borrarlo y aquí se afirmaba
+                    // que `scopes.detached` de ese scope respondía 500 «sin tocar
+                    // nada» — para siempre, hechos incluidos. Lo que se juzga ahora es
+                    // lo contrario: ese estado NO SE CREA (el 500 llega antes de
+                    // escribir) y, si llega por otra vía (catálogo escrito a mano, una
+                    // migración), la salida existe y está aquí demostrada.
+                    const authz = managerOver({ delegablePermissions: ['docs:read', 'docs:write'] });
+                    const alice = subject();
+                    const admin = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const unitA1 = await unitUnder(tree, orgA);
+                    assert.isUndefined(driver.purgeRole, 'purgeRole: false ⇒ el puerto no lo trae; un método que solo lanza al llamarlo no deja al manager protegerte');
+                    await driver.grant(admin, 'org-admin', orgA);
+                    // (1) La API de delegación se niega ANTES de escribir nada.
+                    const spec = { slug: 'lead', scopeType: 'unit', rank: 20, permissions: ['docs:write'] };
+                    await rejectsWith(assert, () => authz.defineScopedRole(admin, orgA, spec), { status: 500, code: 'E_AUTHZ_UNSUPPORTED' });
+                    assert.deepEqual((await new CatalogCache().view()).rolesNamed('lead', 'unit'), [], 'nada escrito');
+                    // (2) Los roles locales que existan por otra vía se LEEN con
+                    //     normalidad (el catálogo es SQL en los dos drivers) y lo que
+                    //     no se puede deshacer se dice, sin dejar nada a medias.
+                    const lead = await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'], rank: 20 });
+                    await driver.grant(alice, 'lead', unitA1);
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1));
+                    await rejectsWith(assert, () => authz.deleteScopedRole(admin, lead), { status: 500, code: 'E_AUTHZ_UNSUPPORTED' });
+                    await rejectsWith(assert, () => authz.deleteScopedRole(admin, 'lead'), { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' });
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1), 'el rol sigue concediendo');
+                    assert.deepEqual(await driver.listRoles(alice, unitA1), ['lead']);
+                    assert.isNotNull((await new CatalogCache().view()).roleByUuid(lead), 'el rol sigue en el catálogo');
+                    assert.equal(await linksOf(lead), 1, 'y sus vínculos');
+                    // (3) 3b-0 · Z1: `scopes.detached` NO depende de `purgeRole`, ni
+                    //     siquiera sobre un scope que ES owner de roles locales: purga
+                    //     los HECHOS y no toca el catálogo (invariante 11). Hasta 3G
+                    //     respondía 500 aquí, y el callejón —un scope cuyos hechos
+                    //     nadie podía purgar— era real hasta que 3E · P4 lo cerró por
+                    //     la otra punta. Ahora no hay callejón que cerrar.
+                    const owner = await unitUnder(tree, orgA);
+                    const propio = await localRole(owner, { slug: 'propio', scopeType: 'unit', permissions: ['docs:write'] });
+                    await driver.grant(alice, 'propio', owner);
+                    await authz.scopes.detached(owner);
+                    assert.deepEqual(await driver.listRoles(alice, owner), [], 'los hechos del scope, purgados');
+                    assert.isFalse(await driver.authorize(alice, 'docs:write', owner));
+                    assert.isNotNull((await new CatalogCache().view()).roleByUuid(propio), 'y el rol local sigue: purgarlo es otra operación');
+                    // (4) La que SÍ necesita `purgeRole` lo dice antes de leer nada:
+                    //     `pruneOrphanRoles` (el motor de `authz:catalog:prune-orphans`).
+                    await rejectsWith(assert, () => authz.pruneOrphanRoles(), { status: 500, code: 'E_AUTHZ_UNSUPPORTED' });
+                    //     Y la salida sigue siendo la de siempre: el catálogo es SQL y
+                    //     es de la plataforma.
+                    await forgetRoleByHand(propio);
+                    assert.isNull((await new CatalogCache().view()).roleByUuid(propio));
+                    // (5) Un scope SIN roles locales propios se purga siempre.
+                    const simple = await unitUnder(tree, orgA);
+                    await driver.grant(alice, 'unit-editor', simple);
+                    await authz.scopes.detached(simple);
+                    assert.deepEqual(await driver.listRoles(alice, simple), []);
+                });
+            },
+        });
+        // ── Par de capacidad `countRoleAssignments` (3b-2j) ───────────────────
+        // `pruneOrphanRoles().stillGranting` avisa de que una purga puede estar
+        // revocando permisos VIVOS (3b-0b · AA1) y su contrato publicado es
+        // «falso ⇒ este rol seguro que no concede». Hasta 3b-2j lo calculaba el
+        // barrido contando `authz_assignments` —la tabla del driver `database`—,
+        // así que con un driver cuyos hechos viven en otro sitio (`openfga` en
+        // modo `facts`, el store) era SIEMPRE `false`, justo antes de un borrado
+        // destructivo. Contar los hechos de un rol pasa a ser una pregunta del
+        // PUERTO. Un driver que la responda declara `countRoleAssignments: true`
+        // y se le juzga el conteo; uno que no, declara `false` y se le juzga que
+        // el barrido lo DIGA (`undefined`) en vez de degradarlo a «no concede».
+        // Nunca un skip. **Es breaking para un driver de terceros de 2.2.**
+        caseFor('countRoleAssignments', {
+            whenTrue: () => {
+                since('2.2', 'countRoleAssignments(uuids) cuenta los hechos VIGENTES de cada rol en TODOS los scopes y responde POR POSICIÓN: la asignación caducada no cuenta, un revoke lo baja, un rol sin hechos —o que el motor no conoce— es 0 y un uuid mal formado es 422', async ({ assert, }) => {
+                    // 3b-2j (decisión del dueño del 2026-08-31 (3)). Es el método que
+                    // hace VERDADERO el `stillGranting` de `pruneOrphanRoles` en los dos
+                    // drivers; aquí se juzga en el puerto, que es donde vive.
+                    assert.typeOf(driver.countRoleAssignments, 'function', 'countRoleAssignments: true exige el método en el puerto');
+                    const cuenta = (uuids) => driver.countRoleAssignments(uuids);
+                    const alice = subject();
+                    const bob = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const unitA1 = await unitUnder(tree, orgA);
+                    const unitA2 = await unitUnder(tree, orgA);
+                    const lead = await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+                    const mudo = await localRole(orgA, { slug: 'mudo', scopeType: 'unit', permissions: ['docs:read'] });
+                    assert.deepEqual(await cuenta([lead, mudo]), [0, 0], 'un rol recién definido no tiene hechos');
+                    assert.deepEqual(await cuenta([]), [], 'sin uuids no hay nada que contar (ni que preguntarle al backend)');
+                    // Hechos en DOS scopes y de dos holders: se cuentan todos, sin
+                    // herencia y sin re-resolver el scope de cada uno (es conservador).
+                    await driver.grant(alice, { uuid: lead }, unitA1);
+                    await driver.grant(bob, { uuid: lead }, unitA1);
+                    await driver.grant(alice, { uuid: lead }, unitA2);
+                    // Y uno CADUCADO, que no cuenta: la caducidad es estricta y es la
+                    // misma con la que responde `authorize`.
+                    await driver.grant(bob, { uuid: lead }, unitA2, { expiresAt: new Date(Date.now() - 60_000) });
+                    assert.isFalse(await driver.authorize(bob, 'docs:write', unitA2), 'el caducado no concede…');
+                    assert.deepEqual(await cuenta([lead, mudo]), [3, 0], '…y tampoco cuenta');
+                    // El orden es el de la pregunta, no el del backend.
+                    assert.deepEqual(await cuenta([mudo, lead]), [0, 3], 'la respuesta va POR POSICIÓN');
+                    // Un uuid que el motor no conoce es 0 (es un conteo de hechos, no
+                    // una consulta al catálogo) y uno mal formado es 422.
+                    assert.deepEqual(await cuenta([uuidv7()]), [0], 'un rol que el motor no conoce no tiene hechos');
+                    await rejectsWith(assert, () => cuenta([lead, 'lead']), { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' });
+                    // Lo que baja el contador es que el hecho DEJE de existir.
+                    await driver.revoke(alice, { uuid: lead }, unitA2);
+                    assert.deepEqual(await cuenta([lead]), [2]);
+                    await driver.revoke(alice, { uuid: lead }, unitA1);
+                    await driver.revoke(bob, { uuid: lead }, unitA1);
+                    assert.deepEqual(await cuenta([lead]), [0], 'sin hechos vigentes: el barrido puede decir «no concede» con verdad');
+                });
+            },
+            whenFalse: () => {
+                since('2.2', 'sin countRoleAssignments: el puerto NO lo trae y pruneOrphanRoles deja stillGranting (y assignments) en `undefined` —JAMÁS en `false`—, y el comando lista ese rol aparte: «no lo sé» no puede degradar a «no concede» justo antes de purgar', async ({ assert, }) => {
+                    // La cara que un driver de terceros escrito para 2.2 estrena con
+                    // este lote (breaking del puerto, decisión del dueño del
+                    // 2026-08-31 (3) · consecuencia 1). El `false` de antes no era
+                    // conservador: era falso, y se leía justo antes de un borrado.
+                    assert.isUndefined(driver.countRoleAssignments, 'countRoleAssignments: false ⇒ el puerto no lo trae; un método que solo lanza al llamarlo no deja al manager protegerte');
+                    const alice = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const unitA1 = await unitUnder(tree, orgA);
+                    const unitA1x = await unitUnder(tree, unitA1);
+                    const lead = await localRole(unitA1, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+                    await driver.grant(alice, { uuid: lead }, unitA1x);
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1x), 'el rol concede HOY');
+                    // El driver de terceros COMPLETO: sabe purgar (si no,
+                    // `pruneOrphanRoles` es 500 antes de leer nada — par `purgeRole`) y
+                    // no sabe contar. Su `purgeRole` no debe llegar a llamarse: el
+                    // default es `--dry-run`.
+                    const tercero = Object.create(driver);
+                    Object.defineProperty(tercero, 'purgeRole', {
+                        value: async () => assert.fail('el dry-run no purga'),
+                        enumerable: false,
+                    });
+                    const authz = managerOver({}, tercero);
+                    // El owner sale del árbol; el NIETO conserva su ruta materializada
+                    // por él, así que el rol sigue concediendo (3b-0b · AA1).
+                    await tree.detach(unitA1);
+                    const seco = await authz.pruneOrphanRoles();
+                    assert.deepEqual(seco.orphans.map((o) => o.role.uuid), [lead]);
+                    assert.isUndefined(seco.orphans[0].stillGranting, 'sin el método del puerto: no se sabe');
+                    assert.notStrictEqual(seco.orphans[0].stillGranting, false, '«no lo sé» NUNCA es «no concede»');
+                    assert.isUndefined(seco.orphans[0].assignments, 'ni se inventa el contador que lo respaldaría');
+                    assert.deepEqual(seco.purged, [], 'y el dry-run no ha borrado nada');
+                });
+            },
+        });
+        // ── Par de capacidad `enumerateFacts` (3b-3b) ────────────────────────
+        // Ser el ORIGEN de `authz:reconcile`. El 3a dejó `reconcile` con el patrón
+        // de método opcional del puerto (`E_AUTHZ_UNSUPPORTED`) y sin capacidad
+        // nueva; ésta es la entrada que faltaba, y tiene las DOS caras con caso
+        // porque los dos drivers del paquete las ocupan: `openfga` sabe entregar
+        // sus hechos (viven en el store y solo él sabe volverlos a
+        // `(holder, rol, scope)`) y `database` no lo trae a propósito (sus hechos
+        // SON `authz_assignments`/`authz_denies`, el esquema publicado).
+        caseFor('enumerateFacts', {
+            whenTrue: () => {
+                since('2.2', 'enumerateFacts: los hechos del driver salen paginados, con su caducidad SIN filtrar y con un cursor que avanza — es lo que `authz:reconcile --to=<otro>` lee como origen', async ({ assert, }) => {
+                    const alice = subject();
+                    const bob = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const vencida = new Date(Date.now() - 60_000);
+                    await driver.grant(alice, 'org-editor', org);
+                    await driver.grant(bob, 'org-editor', org, { expiresAt: vencida });
+                    await driver.deny(alice, 'docs:write', org);
+                    const todos = [];
+                    let after;
+                    const cursores = new Set();
+                    for (let page = 0; page < 100; page++) {
+                        const got = await driver.enumerateFacts({ limit: 1, after });
+                        assert.isAtMost(got.facts.length, 1, 'nunca más de `limit` por página');
+                        todos.push(...got.facts);
+                        if (!got.cursor)
+                            break;
+                        assert.isFalse(cursores.has(got.cursor), 'el cursor tiene que AVANZAR, nunca repetirse');
+                        cursores.add(got.cursor);
+                        after = got.cursor;
+                    }
+                    const asignaciones = todos.filter((f) => f.kind === 'assignment');
+                    const denies = todos.filter((f) => f.kind === 'deny');
+                    assert.lengthOf(denies, 1, 'el deny es un hecho y sale');
+                    assert.equal(denies[0].permission, 'docs:write');
+                    assert.deepEqual(scopeKeys([denies[0].scope]), scopeKeys([org]));
+                    assert.lengthOf(asignaciones, 2, 'la CADUCADA también sale: filtrarla la haría desaparecer sin contarla');
+                    const deBob = asignaciones.find((f) => f.holder.uuid === bob.uuid);
+                    assert.equal(deBob.expiresAt?.getTime(), vencida.getTime(), 'y con su instante, para que el destino la cuente');
+                    assert.isString(deBob.roleUuid, 'la identidad del rol es el uuid, nunca el slug');
+                    assert.isString(deBob.detail, 'y viene nombrada: un motivo sin la fila no se arregla');
+                    // Y con una página grande sale exactamente el mismo conjunto (el
+                    // puerto promete «como mucho `limit`», no «exactamente `limit`»: un
+                    // backend con su propio tope de página lo respeta y da cursor).
+                    const grande = [];
+                    let siguiente;
+                    for (let page = 0; page < 100; page++) {
+                        const got = await driver.enumerateFacts({ limit: 1_000, after: siguiente });
+                        assert.isAtMost(got.facts.length, 1_000);
+                        grande.push(...got.facts);
+                        if (!got.cursor)
+                            break;
+                        siguiente = got.cursor;
+                    }
+                    assert.lengthOf(grande, todos.length);
+                });
+            },
+            whenFalse: () => {
+                since('2.2', 'sin enumerateFacts el driver NO puede ser el origen de una migración, y authz:reconcile lo DICE (500 E_AUTHZ_UNSUPPORTED nombrándolo) en vez de leer cero hechos y vaciar el destino con --prune', async ({ assert, }) => {
+                    assert.isUndefined(driver.enumerateFacts, 'enumerateFacts: false ⇒ el puerto no lo trae');
+                    // Un destino de laboratorio que SÍ sabe reconstruirse: lo que se
+                    // juzga es que la pasada muera nombrando al ORIGEN, no al destino.
+                    const destino = {
+                        capabilities: driver.capabilities,
+                        async reconcile(source) {
+                            await source.facts({ limit: 10 });
+                            assert.fail('no debería haber llegado a leer hechos');
+                        },
+                    };
+                    const authz = managerOver({
+                        drivers: { [harness.name]: () => driver, destino: () => destino },
+                        scopes: {
+                            resolveChain: resolveChainFrom(tree),
+                            descendantsOf: descendantsFrom(tree),
+                            enumerateEdges: async () => ({ edges: [] }),
+                        },
+                    });
+                    const error = await rejectsWith(assert, () => authz.reconcile({ to: 'destino' }), {
+                        status: 500,
+                        code: 'E_AUTHZ_UNSUPPORTED',
+                    });
+                    assert.include(String(error.message), 'enumerateFacts');
+                });
+            },
+        });
+        // ── Par de capacidad `listDenies` (2E · I5) ──────────────────────────
+        // Todo lo que RESTA denies (`listDenies`, `effectivePermissions`,
+        // `authorizedScopes`, y F1, que observa el catálogo a través de
+        // `effectivePermissions`) necesita el método opcional del puerto. Un
+        // driver que lo trae declara `listDenies: true` y se le juzgan estos
+        // casos; uno que no lo trae declara `false` y se le juzga que las tres
+        // primitivas lo DIGAN (500 `E_AUTHZ_UNSUPPORTED` nombrándolo) en vez de
+        // simular «sin denies», que sería fail-open. Nunca un skip.
+        caseFor('listDenies', {
+            whenTrue: () => {
+                since('2.1', 'el catálogo que decide es el de la base: un sync en otro proceso (otro memo) retira el permiso en la siguiente pregunta, en el driver y en effectivePermissions', async ({ assert, }) => {
+                    // 2D · F1 (auditor 1 y 4). Dos managers sobre dos instancias del
+                    // driver con memos DISTINTOS y sin señal en memoria entre ellas: lo
+                    // único que cruza procesos es la base (`authz_catalog_version`). Un
+                    // vínculo retirado por "otro proceso" tiene que dejar de conceder en
+                    // la siguiente pregunta de este, sin reiniciar y sin TTL.
+                    const twin = harness.makeTwin ? await harness.makeTwin(driver, tree) : twinOf(driver);
+                    const here = managerOver();
+                    const there = managerOver({}, twin);
+                    const alice = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    await here.grant(alice, 'org-editor', orgA); // docs:read, docs:write
+                    assert.isTrue(await here.authorize(alice, 'docs:write', orgA));
+                    assert.isTrue(await there.authorize(alice, 'docs:write', orgA));
+                    assert.include(await there.effectivePermissions(alice, orgA), 'docs:write');
+                    // "Otro proceso" sincroniza `org-editor` sin `docs:write`: cambia la
+                    // base y sube la versión en su transacción. Ni `here` ni `there`
+                    // reciben llamada alguna.
+                    await withoutLink('org-editor', 'organization', 'docs:write');
+                    assert.isFalse(await there.authorize(alice, 'docs:write', orgA), 'el otro memo recarga por la versión');
+                    assert.isFalse(await here.authorize(alice, 'docs:write', orgA));
+                    assert.notInclude(await there.effectivePermissions(alice, orgA), 'docs:write');
+                    assert.notInclude(await here.effectivePermissions(alice, orgA), 'docs:write');
+                    assert.isTrue(await there.authorize(alice, 'docs:read', orgA), 'lo que sigue en el catálogo sigue concediendo');
+                    assert.deepEqual(await there.authorizeMany(alice, 'docs:write', [orgA, APP_SCOPE]), [false, false]);
+                    // Y un sync real (el del harness) lo devuelve en ambos.
+                    await harness.seedCatalog(CONTRACT_CATALOG);
+                    assert.isTrue(await there.authorize(alice, 'docs:write', orgA));
+                    assert.isTrue(await here.authorize(alice, 'docs:write', orgA));
+                    assert.include(await there.effectivePermissions(alice, orgA), 'docs:write');
+                });
+                since('2.1', 'listDenies: denies directos vigentes del scope exacto (sin herencia) o todos los del sujeto; fuera del catálogo no cuenta', async ({ assert, }) => {
+                    // B5 (tester §5 E · listDenies 1-3). Método OPCIONAL del puerto que
+                    // ambos drivers del paquete implementan; es lo que `effectivePermissions`
+                    // y `authorizedScopes` necesitan para restar. Invariante 7: directo y
+                    // exacto, como los demás `list*`.
+                    const alice = subject();
+                    const bob = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const unit = await unitUnder(tree, orgA);
+                    await driver.deny(alice, 'docs:read', orgA);
+                    await driver.deny(alice, 'docs:write', orgA);
+                    await driver.deny(alice, 'billing:read', unit);
+                    await driver.deny(alice, 'docs:read', APP_SCOPE);
+                    await driver.deny(bob, 'docs:read', orgA);
+                    const perms = (denies) => denies.map((d) => d.permission).sort();
+                    assert.deepEqual(perms(await driver.listDenies(alice, orgA)), ['docs:read', 'docs:write']);
+                    assert.deepEqual(perms(await driver.listDenies(alice, unit)), ['billing:read']);
+                    assert.deepEqual(perms(await driver.listDenies(alice, APP_SCOPE)), ['docs:read']);
+                    assert.deepEqual(await driver.listDenies(bob, unit), []);
+                    assert.deepEqual(await driver.listDenies(subject(), orgA), []);
+                    assert.deepEqual(await driver.listDenies(alice, orgScope()), [], 'scope desconocido: nada');
+                    // Sin scope: todos los denies directos del sujeto, con su scope.
+                    const all = await driver.listDenies(alice);
+                    assert.deepEqual(all.map((d) => `${d.permission}@${d.scope.type}:${d.scope.uuid ?? ''}`).sort(), [
+                        `billing:read@unit:${unit.uuid}`,
+                        `docs:read@app:`,
+                        `docs:read@organization:${orgA.uuid}`,
+                        `docs:write@organization:${orgA.uuid}`,
+                    ]);
+                    await driver.removeDeny(alice, 'docs:write', orgA);
+                    assert.deepEqual(perms(await driver.listDenies(alice, orgA)), ['docs:read']);
+                    assert.lengthOf(await driver.listDenies(alice), 3);
+                });
+                since('2.1', 'effectivePermissions: unión de los roles vigentes de la cadena menos lo denegado en ella; el orden de escritura no importa', async ({ assert, }) => {
+                    // B5 (tester §5 E · effectivePermissions 1-4). Composición del manager:
+                    // `listRoles` por nivel + catálogo memo, menos `listDenies` por nivel.
+                    // Prerrequisito de `catalog/` (3): es lo que un PEP por permiso ve.
+                    const authz = managerOver();
+                    const alice = subject();
+                    const bob = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const unit = await unitUnder(tree, orgA);
+                    await driver.grant(alice, 'owner', APP_SCOPE); // billing:read (app)
+                    await driver.grant(alice, 'viewer', APP_SCOPE, { expiresAt: new Date(Date.now() - 60_000) }); // expirado: nada
+                    await driver.grant(alice, 'org-editor', orgA); // docs:read, docs:write
+                    await driver.grant(alice, 'unit-editor', unit); // docs:write
+                    await driver.deny(alice, 'docs:write', orgA);
+                    assert.deepEqual((await authz.effectivePermissions(alice, APP_SCOPE)).sort(), ['billing:read']);
+                    assert.deepEqual((await authz.effectivePermissions(alice, orgA)).sort(), ['billing:read', 'docs:read']);
+                    assert.deepEqual((await authz.effectivePermissions(alice, unit)).sort(), ['billing:read', 'docs:read']);
+                    assert.deepEqual(await authz.effectivePermissions(subject(), unit), []);
+                    assert.deepEqual(await authz.effectivePermissions(alice, orgScope()), [], 'scope desconocido: nada');
+                    // Coherente con `authorize`, permiso a permiso.
+                    for (const permission of ['docs:read', 'docs:write', 'billing:read']) {
+                        assert.equal((await authz.effectivePermissions(alice, unit)).includes(permission), await driver.authorize(alice, permission, unit), permission);
+                    }
+                    // Mismo conjunto con las escrituras en orden inverso.
+                    await driver.deny(bob, 'docs:write', orgA);
+                    await driver.grant(bob, 'unit-editor', unit);
+                    await driver.grant(bob, 'org-editor', orgA);
+                    await driver.grant(bob, 'owner', APP_SCOPE);
+                    assert.deepEqual((await authz.effectivePermissions(bob, unit)).sort(), ['billing:read', 'docs:read']);
+                    // Quitar el deny restaura.
+                    await driver.removeDeny(alice, 'docs:write', orgA);
+                    assert.deepEqual((await authz.effectivePermissions(alice, unit)).sort(), ['billing:read', 'docs:read', 'docs:write']);
+                });
+                since('2.1', 'authorizedScopes: all SOLO con excludedSubtrees (un deny vivo nunca da un all silencioso); deny en app ⇒ none; sin grants ⇒ none', async ({ assert, }) => {
+                    // B3 (juez cruce 5, auditor E1; tester §5 E · authorizedScopes 1 y 3).
+                    // `all` = hay un grant vigente en la raíz (ancestro común de todo el
+                    // tipo). Los denies del permiso NO desaparecen dentro de `all`: van en
+                    // `excludedSubtrees` para que el consumidor los reste en su listado —
+                    // sin eso, la org B aparecería listada aunque `authorize` dijera false.
+                    const authz = managerOver();
+                    const alice = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const orgB = await orgUnder(tree, APP_SCOPE);
+                    const unitA1 = await unitUnder(tree, orgA);
+                    await driver.grant(alice, 'editor', APP_SCOPE);
+                    assert.deepEqual(await authz.authorizedScopes(alice, 'docs:write', 'organization'), { kind: 'all', excludedSubtrees: [] });
+                    assert.deepEqual(await authz.authorizedScopes(alice, 'docs:write', 'unit'), { kind: 'all', excludedSubtrees: [] });
+                    await driver.deny(alice, 'docs:write', orgB);
+                    await driver.deny(alice, 'docs:write', unitA1);
+                    await driver.deny(alice, 'docs:read', orgA); // otro permiso: no cuenta
+                    const result = await authz.authorizedScopes(alice, 'docs:write', 'organization');
+                    assert.equal(result.kind, 'all');
+                    const excluded = result.excludedSubtrees;
+                    assert.deepEqual(scopeKeys(excluded.map((e) => e.scope)), scopeKeys([orgB, unitA1]));
+                    assert.isTrue(excluded.every((e) => e.includesDescendants === true), 'un subárbol, no un scope (F10)');
+                    assert.isFalse(await driver.authorize(alice, 'docs:write', orgB));
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', orgA));
+                    // Expandido (F10): lo que hay que restar es cada deny Y su subárbol —
+                    // exactamente los scopes donde `authorize` es false.
+                    const unitB1 = await unitUnder(tree, orgB);
+                    const unitB1x = await unitUnder(tree, unitB1);
+                    const unitA1y = await unitUnder(tree, unitA1);
+                    const expanded = await authz.expandExcludedSubtrees(excluded);
+                    assert.deepEqual(scopeKeys(expanded), scopeKeys([orgB, unitA1, unitB1, unitB1x, unitA1y]));
+                    for (const s of [orgA, orgB, unitA1, unitB1, unitB1x, unitA1y]) {
+                        assert.equal(!scopeKeys(expanded).includes(scopeKeys([s])[0]), await driver.authorize(alice, 'docs:write', s), scopeKeys([s])[0]);
+                    }
+                    // Y para el otro permiso, solo orgA está excluida.
+                    assert.deepEqual(await authz.authorizedScopes(alice, 'docs:read', 'organization'), {
+                        kind: 'all',
+                        excludedSubtrees: [{ scope: orgA, includesDescendants: true }],
+                    });
+                    // Deny en la raíz: el grant de app está bloqueado ⇒ nada, no `all`.
+                    await driver.deny(alice, 'docs:write', APP_SCOPE);
+                    assert.deepEqual(await authz.authorizedScopes(alice, 'docs:write', 'organization'), { kind: 'none' });
+                    await driver.removeDeny(alice, 'docs:write', APP_SCOPE);
+                    assert.equal((await authz.authorizedScopes(alice, 'docs:write', 'organization')).kind, 'all');
+                    assert.deepEqual(await authz.authorizedScopes(subject(), 'docs:write', 'organization'), { kind: 'none' });
+                    assert.deepEqual(await authz.authorizedScopes(alice, 'no:existe', 'organization'), { kind: 'none' });
+                });
+                since('2.1', 'authorizedScopes: some = directos del tipo ∪ descendientes vía descendantsOf, menos subárboles denegados; listScopes sigue sin enumerar (invariante 7)', async ({ assert, }) => {
+                    // B3 (tester §5 E · 2 y 4). La ÚNICA API del paquete que enumera
+                    // descendientes, y lo hace con el `descendantsOf` del consumidor —
+                    // nunca con N+1 llamadas a `resolveChain`. Un deny excluye su
+                    // subárbol entero, igual que `authorize` lo deniega.
+                    const authz = managerOver();
+                    const alice = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const orgB = await orgUnder(tree, APP_SCOPE);
+                    const orgC = await orgUnder(tree, APP_SCOPE);
+                    const unitA1 = await unitUnder(tree, orgA);
+                    const unitA2 = await unitUnder(tree, orgA);
+                    const unitA1x = await unitUnder(tree, unitA1); // unit bajo unit: profundidad 2
+                    const unitB1 = await unitUnder(tree, orgB);
+                    const unitC1 = await unitUnder(tree, orgC);
+                    await driver.grant(alice, 'org-editor', orgA);
+                    await driver.grant(alice, 'org-editor', orgB);
+                    await driver.grant(alice, 'unit-editor', unitC1); // directo de tipo unit, en una org sin grant
+                    const orgs = await authz.authorizedScopes(alice, 'docs:write', 'organization');
+                    assert.equal(orgs.kind, 'some');
+                    assert.deepEqual(scopeKeys(orgs.scopes), scopeKeys([orgA, orgB]));
+                    const units = await authz.authorizedScopes(alice, 'docs:write', 'unit');
+                    assert.equal(units.kind, 'some');
+                    assert.deepEqual(scopeKeys(units.scopes), scopeKeys([unitA1, unitA2, unitA1x, unitB1, unitC1]));
+                    // Invariante 7: los list* siguen siendo directos.
+                    assert.deepEqual(scopeKeys(await driver.listScopes(alice, 'docs:write')), scopeKeys([orgA, orgB, unitC1]));
+                    assert.deepEqual(await driver.listRoleScopes(alice, 'unit'), [unitC1]);
+                    // Denies: un subárbol entero fuera; un grant directo dentro de un
+                    // subárbol denegado tampoco cuenta (authorize lo deniega).
+                    await driver.deny(alice, 'docs:write', unitA1);
+                    await driver.deny(alice, 'docs:write', orgB);
+                    await driver.grant(alice, 'unit-editor', unitB1);
+                    assert.isFalse(await driver.authorize(alice, 'docs:write', unitB1));
+                    const afterDeny = await authz.authorizedScopes(alice, 'docs:write', 'unit');
+                    assert.equal(afterDeny.kind, 'some');
+                    assert.deepEqual(scopeKeys(afterDeny.scopes), scopeKeys([unitA2, unitC1]));
+                    assert.deepEqual(scopeKeys((await authz.authorizedScopes(alice, 'docs:write', 'organization')).scopes), scopeKeys([orgA]));
+                    // Coherente con authorize, scope a scope.
+                    for (const s of [unitA1, unitA2, unitA1x, unitB1, unitC1]) {
+                        assert.equal(scopeKeys(afterDeny.scopes).includes(scopeKeys([s])[0]), await driver.authorize(alice, 'docs:write', s), scopeKeys([s])[0]);
+                    }
+                    // Quitar los denies restaura; un tipo sin nodos ⇒ none.
+                    await driver.removeDeny(alice, 'docs:write', unitA1);
+                    await driver.removeDeny(alice, 'docs:write', orgB);
+                    assert.lengthOf((await authz.authorizedScopes(alice, 'docs:write', 'unit')).scopes, 5);
+                    assert.deepEqual(await authz.authorizedScopes(alice, 'docs:write', 'team'), { kind: 'none' });
+                });
+                since('2.1', 'authorizedScopes ≡ { s | authorize(s) } scope a scope, con deny intermedio y tres niveles; si descendantsOf y resolveChain discrepan (nodo ajeno, o subárbol denegado que no sabe enumerar) ⇒ 503, nunca una lista con cruces', async ({ assert, }) => {
+                    // 2D · F3 (auditor 3). Antes, `descendantsOf(deny) === null` valía `[]`
+                    // y el subárbol denegado se listaba como concedido; y un descendiente
+                    // ajeno devuelto por un `descendantsOf` roto se aceptaba (cruce de
+                    // tenant). Ahora cada candidato se contrasta con `resolveChain`:
+                    // su cadena decide (deny en la cadena ⇒ fuera, igual que `authorize`)
+                    // y si no cuelga del scope concedente se lanza.
+                    const authz = managerOver();
+                    const alice = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const orgB = await orgUnder(tree, APP_SCOPE);
+                    const unitA1 = await unitUnder(tree, orgA);
+                    const unitA2 = await unitUnder(tree, orgA);
+                    const teamA1a = await unitUnder(tree, unitA1);
+                    const teamA1b = await unitUnder(tree, unitA1);
+                    const teamA2a = await unitUnder(tree, unitA2);
+                    const unitB1 = await unitUnder(tree, orgB);
+                    await driver.grant(alice, 'org-editor', orgA);
+                    await driver.deny(alice, 'docs:write', unitA1); // deny intermedio: fuera teamA1a y teamA1b
+                    await driver.grant(alice, 'unit-editor', teamA1b); // un grant DENTRO del subárbol denegado no lo salva
+                    const all = [orgA, orgB, unitA1, unitA2, teamA1a, teamA1b, teamA2a, unitB1];
+                    const listed = (await authz.authorizedScopes(alice, 'docs:write', 'unit'));
+                    assert.equal(listed.kind, 'some');
+                    assert.deepEqual(scopeKeys(listed.scopes), scopeKeys([unitA2, teamA2a]));
+                    for (const s of all) {
+                        assert.equal(scopeKeys(listed.scopes).includes(scopeKeys([s])[0]), s.type === 'unit' && (await driver.authorize(alice, 'docs:write', s)), scopeKeys([s])[0]);
+                    }
+                    assert.deepEqual(scopeKeys((await authz.authorizedScopes(alice, 'docs:write', 'organization')).scopes), scopeKeys([orgA]));
+                    // Un `descendantsOf` que no sabe enumerar el subárbol denegado (null)
+                    // ya no importa: el deny se aplica por la cadena del candidato.
+                    const full = descendantsFrom(tree);
+                    const blind = managerOver({
+                        scopes: {
+                            resolveChain: resolveChainFrom(tree),
+                            descendantsOf: (scope, o) => (scopeKeys([scope])[0] === scopeKeys([unitA1])[0] ? Promise.resolve(null) : full(scope, o)),
+                        },
+                    });
+                    assert.deepEqual(scopeKeys((await blind.authorizedScopes(alice, 'docs:write', 'unit')).scopes), scopeKeys([unitA2, teamA2a]));
+                    // Un `descendantsOf` que devuelve un nodo de OTRO tenant: 503, no una lista con la unit de B.
+                    const expected = { status: 503, code: 'E_AUTHZ_RESOLVER_FAILED' };
+                    const crossed = managerOver({
+                        scopes: {
+                            resolveChain: resolveChainFrom(tree),
+                            descendantsOf: async (scope, o) => {
+                                const own = (await full(scope, o)) ?? [];
+                                return scopeKeys([scope])[0] === scopeKeys([orgA])[0] ? [...own, unitB1] : own;
+                            },
+                        },
+                    });
+                    await rejectsWith(assert, () => crossed.authorizedScopes(alice, 'docs:write', 'unit'), expected);
+                    // Y uno que devuelve un nodo que `resolveChain` no conoce, lo mismo.
+                    const ghost = managerOver({
+                        scopes: {
+                            resolveChain: resolveChainFrom(tree),
+                            descendantsOf: async (scope, o) => [...((await full(scope, o)) ?? []), unitScope()],
+                        },
+                    });
+                    await rejectsWith(assert, () => ghost.authorizedScopes(alice, 'docs:write', 'unit'), expected);
+                    // La pertenencia se contrasta con el memo por request: una llamada al árbol por candidato como mucho.
+                    let asked = 0;
+                    const original = tree.chainOf;
+                    tree.chainOf = async (scope) => {
+                        asked += 1;
+                        return original.call(tree, scope);
+                    };
+                    try {
+                        await authz.authorizedScopes(alice, 'docs:write', 'unit');
+                        assert.isAtMost(asked, all.length + 1);
+                    }
+                    finally {
+                        tree.chainOf = original;
+                    }
+                });
+                since('2.1', 'authorizedScopes: maxScopes superado ⇒ 422 E_AUTHZ_TOO_MANY_SCOPES (nunca parcial), la frontera exacta responde; sin descendantsOf ⇒ 500 aunque no haya grants; descendantsOf jamás se llama desde authorize/list*', async ({ assert, }) => {
+                    // B3/B2 (tester §5 E · 5, 6, 7 y el test de arquitectura). Una lista
+                    // truncada en silencio es el peor resultado posible: se lanza. Sin
+                    // `descendantsOf` no hay `none` (sería un fail-closed mentiroso: el
+                    // sujeto puede tener scopes). Y `descendantsOf` es abierto: prohibido
+                    // en el camino de decisión.
+                    let descendantsCalls = 0;
+                    const descendantsOf = descendantsFrom(tree);
+                    const authz = managerOver({
+                        scopes: {
+                            resolveChain: resolveChainFrom(tree),
+                            descendantsOf: (scope, options) => {
+                                descendantsCalls += 1;
+                                return descendantsOf(scope, options);
+                            },
+                        },
+                    });
+                    const alice = subject();
+                    const orgs = [];
+                    for (let i = 0; i < 3; i++) {
+                        const org = await orgUnder(tree, APP_SCOPE);
+                        await unitUnder(tree, org);
+                        orgs.push(org);
+                        await driver.grant(alice, 'org-editor', org);
+                    }
+                    await rejectsWith(assert, () => authz.authorizedScopes(alice, 'docs:write', 'organization', { maxScopes: 2 }), {
+                        status: 422,
+                        code: 'E_AUTHZ_TOO_MANY_SCOPES',
+                    });
+                    const exact = await authz.authorizedScopes(alice, 'docs:write', 'organization', { maxScopes: 3 });
+                    assert.equal(exact.kind, 'some');
+                    assert.lengthOf(exact.scopes, 3);
+                    // La cota es sobre la RESPUESTA: 3 units bajo esas orgs con maxScopes 3.
+                    assert.lengthOf((await authz.authorizedScopes(alice, 'docs:write', 'unit', { maxScopes: 3 })).scopes, 3);
+                    const capped = managerOver({ scopes: { resolveChain: resolveChainFrom(tree), descendantsOf, maxScopes: 2 } });
+                    await rejectsWith(assert, () => capped.authorizedScopes(alice, 'docs:write', 'organization'), { status: 422, code: 'E_AUTHZ_TOO_MANY_SCOPES' });
+                    // F8: la cota por llamada solo puede BAJAR la del config, nunca subirla.
+                    await rejectsWith(assert, () => capped.authorizedScopes(alice, 'docs:write', 'organization', { maxScopes: 100 }), { status: 422, code: 'E_AUTHZ_TOO_MANY_SCOPES' });
+                    // F8: se corta antes de bajar (3 orgs directas > 2: ni una llamada a descendantsOf).
+                    descendantsCalls = 0;
+                    await rejectsWith(assert, () => authz.authorizedScopes(alice, 'docs:write', 'organization', { maxScopes: 2 }), { status: 422, code: 'E_AUTHZ_TOO_MANY_SCOPES' });
+                    assert.equal(descendantsCalls, 0);
+                    const noDescendants = managerOver({ scopes: { resolveChain: resolveChainFrom(tree) } });
+                    const expected = { status: 500, code: 'E_AUTHZ_NO_DESCENDANTS_RESOLVER' };
+                    await rejectsWith(assert, () => noDescendants.authorizedScopes(alice, 'docs:write', 'organization'), expected);
+                    await rejectsWith(assert, () => noDescendants.authorizedScopes(subject(), 'docs:write', 'organization'), expected);
+                    // Arquitectura: el camino de decisión y los list* no tocan descendantsOf.
+                    descendantsCalls = 0;
+                    const unit = (await descendantsOf(orgs[0], { maxNodes: 10 }))[0];
+                    await authz.authorize(alice, 'docs:write', unit);
+                    await authz.authorizeMany(alice, 'docs:write', [unit, orgs[1]]);
+                    await authz.hasRole(alice, 'org-editor', unit);
+                    await authz.listScopes(alice, 'docs:write');
+                    await authz.listRoles(alice, orgs[0]);
+                    await authz.listRoleScopes(alice, 'organization');
+                    await authz.listSubjects('org-editor', orgs[0]);
+                    await authz.effectivePermissions(alice, unit);
+                    await authz.listDenies(alice);
+                    await authz.isWithin(unit, orgs[0]);
+                    await authz.grant(alice, 'unit-editor', unit, { within: orgs[0] });
+                    await authz.deny(alice, 'docs:read', unit);
+                    assert.equal(descendantsCalls, 0);
+                    await authz.authorizedScopes(alice, 'docs:write', 'unit');
+                    assert.isAbove(descendantsCalls, 0);
+                });
+                // 3E · P4: la API de DELEGACIÓN entera cuelga de `purgeRole`. Un rol
+                // local en un driver que no sabe purgarlo es estado que nada puede
+                // borrar: ni `deleteScopedRole` ni `scopes.detached` de ese scope
+                // volverían a funcionar NUNCA. Por eso su policy solo se juzga con la
+                // capacidad, y la cara `false` juzga que se diga ANTES de escribir.
+                caseFor('purgeRole', {
+                    whenTrue: () => {
+                        since('2.2', 'defineScopedRole: el rol que el administrador de A delega concede en A y sus descendientes y no fuera; effectivePermissions y authorizedScopes respetan el owner; otro proceso (otro memo) lo ve en su siguiente pregunta; updateScopedRole cambia lo que concede; fuera de la policy ⇒ 422 sin escribir', async ({ assert, }) => {
+                            // 3B · B3 (+ B7: la versión compartida sube en la misma transacción).
+                            // La policy completa se juzga en `manager.spec`; aquí, que el rol
+                            // definido por la API es un rol del DRIVER como cualquier otro, en
+                            // ambos drivers, y que la delegación tiene barreras.
+                            const delegable = ['docs:read', 'docs:write', 'billing:read', 'org:settings'];
+                            const twin = harness.makeTwin ? await harness.makeTwin(driver, tree) : twinOf(driver);
+                            const here = managerOver({ delegablePermissions: delegable });
+                            const there = managerOver({ delegablePermissions: delegable }, twin);
+                            const admin = subject();
+                            const adminB = subject();
+                            const bob = subject();
+                            const orgA = await orgUnder(tree, APP_SCOPE);
+                            const orgB = await orgUnder(tree, APP_SCOPE);
+                            const unitA1 = await unitUnder(tree, orgA);
+                            const unitA1x = await unitUnder(tree, unitA1);
+                            const unitA2 = await unitUnder(tree, orgA);
+                            const unitB1 = await unitUnder(tree, orgB);
+                            await driver.grant(admin, 'org-admin', orgA);
+                            await driver.grant(adminB, 'org-admin', orgB);
+                            const lead = await here.defineScopedRole(admin, orgA, { slug: 'lead', scopeType: 'unit', rank: 20, permissions: ['docs:write'] });
+                            assert.deepEqual(lead, { uuid: lead.uuid, slug: 'lead', scopeType: 'unit', owner: `organization|${orgA.uuid}`, rank: 20 });
+                            await here.grant(bob, 'lead', unitA1, { within: orgA });
+                            assert.isTrue(await driver.authorize(bob, 'docs:write', unitA1));
+                            assert.isTrue(await driver.authorize(bob, 'docs:write', unitA1x));
+                            assert.isFalse(await driver.authorize(bob, 'docs:write', unitA2), 'la asignación es en unitA1: no en la hermana');
+                            assert.isFalse(await driver.authorize(bob, 'docs:write', unitB1));
+                            assert.isFalse(await driver.authorize(bob, 'docs:read', unitA1));
+                            // Otro proceso: sin señal en memoria, por la versión compartida.
+                            assert.isTrue(await there.authorize(bob, 'docs:write', unitA1x));
+                            assert.isTrue(await there.hasRole(bob, 'lead', unitA1x));
+                            assert.deepEqual(await there.listRoles(bob, unitA1), ['lead']);
+                            assert.deepEqual(await there.effectivePermissions(bob, unitA1x), ['docs:write']);
+                            assert.deepEqual(await here.effectivePermissions(bob, unitB1), []);
+                            const listed = await here.authorizedScopes(bob, 'docs:write', 'unit');
+                            assert.equal(listed.kind, 'some');
+                            assert.deepEqual(scopeKeys(listed.scopes), scopeKeys([unitA1, unitA1x]));
+                            await rejectsWith(assert, () => here.grant(bob, 'lead', unitB1, { within: orgB }), { status: 422, code: 'E_AUTHZ_ROLE_NOT_VISIBLE' });
+                            await rejectsWith(assert, () => there.grant(bob, 'lead', unitB1), { status: 422, code: 'E_AUTHZ_ROLE_NOT_VISIBLE' });
+                            // updateScopedRole: lo que concede cambia en el acto, en los dos memos.
+                            await here.updateScopedRole(admin, lead.uuid, { permissions: ['docs:read'] });
+                            assert.isFalse(await driver.authorize(bob, 'docs:write', unitA1x));
+                            assert.isTrue(await driver.authorize(bob, 'docs:read', unitA1x));
+                            assert.isFalse(await there.authorize(bob, 'docs:write', unitA1x));
+                            assert.deepEqual(await there.effectivePermissions(bob, unitA1x), ['docs:read']);
+                            // Barreras (422, nada escrito): permiso no delegable/no efectivo, deny del actor (C2),
+                            // rank ≥ actor, composición por nivel (B5), colisión con un global, owner raíz, otro tenant.
+                            const spec = { slug: 'lead2', scopeType: 'unit', rank: 20, permissions: ['docs:write'] };
+                            await rejectsWith(assert, () => managerOver().defineScopedRole(admin, orgA, spec), { status: 422, code: 'E_AUTHZ_PERMISSION_NOT_DELEGABLE' });
+                            await rejectsWith(assert, () => here.defineScopedRole(adminB, orgA, spec), { status: 422, code: 'E_AUTHZ_PERMISSION_NOT_DELEGABLE' });
+                            await driver.deny(admin, 'docs:write', orgA);
+                            await rejectsWith(assert, () => here.defineScopedRole(admin, orgA, spec), { status: 422, code: 'E_AUTHZ_PERMISSION_NOT_DELEGABLE' });
+                            await driver.removeDeny(admin, 'docs:write', orgA);
+                            await rejectsWith(assert, () => here.defineScopedRole(admin, orgA, { ...spec, rank: 50 }), { status: 422, code: 'E_AUTHZ_RANK_EXCEEDED' });
+                            await rejectsWith(assert, () => here.defineScopedRole(admin, orgA, { ...spec, permissions: ['org:settings'] }), { status: 422, code: 'E_AUTHZ_ROLE_NOT_ASSIGNABLE_AT' });
+                            await rejectsWith(assert, () => here.defineScopedRole(admin, orgA, { ...spec, slug: 'unit-editor' }), { status: 422, code: 'E_AUTHZ_CATALOG_CONFLICT' });
+                            await rejectsWith(assert, () => here.defineScopedRole(admin, APP_SCOPE, spec), { status: 422, code: 'E_AUTHZ_INVALID_IDENTITY' });
+                            await rejectsWith(assert, () => here.defineScopedRole(admin, orgB, spec), { status: 422, code: 'E_AUTHZ_PERMISSION_NOT_DELEGABLE' });
+                            await rejectsWith(assert, () => here.grant(bob, 'lead2', unitA1), { status: 422, code: 'E_AUTHZ_UNKNOWN_ROLE' });
+                            assert.isNull((await new CatalogCache().view()).rolesNamed('lead2', 'unit')[0] ?? null);
+                            // Y con la policy en regla, el mismo spec escribe.
+                            const lead2 = await here.defineScopedRole(admin, orgA, spec);
+                            await there.grant(bob, 'lead2', unitA2, { within: orgA });
+                            assert.isTrue(await driver.authorize(bob, 'docs:write', unitA2));
+                            assert.equal(lead2.owner, lead.owner);
+                        });
+                        // 3E · R2 (tester): la carrera de M2 es un PAR de capacidad. Con
+                        // escrituras de catálogo serializadas (PG/MySQL, cerrojo sobre la
+                        // fila de versión) el juez exige lo que el README promete —
+                        // exactamente un ganador y 422 para el perdedor—; sin ellas (SQLite
+                        // bloquea la base entera) solo lo innegociable: nunca dos, y el
+                        // perdedor no escribe. Aceptar `oneOf([422, 503])` en todas partes
+                        // dejaba vivo un mutante que convertía la colisión en un 503.
+                        const raceOfDefines = (serialized) => since('2.2', serialized
+                            ? 'dos defineScopedRole del MISMO (slug, nivel) con owners de la misma cadena, en paralelo y con memos distintos: EXACTAMENTE uno gana y el perdedor es 422 E_AUTHZ_CATALOG_CONFLICT — la unicidad no es una carrera'
+                            : 'dos defineScopedRole del MISMO (slug, nivel) con owners de la misma cadena, en paralelo y con memos distintos: nunca dos ganadores y el perdedor no escribe (sin escrituras de catálogo serializadas su transacción puede morir con 503)', async ({ assert }) => {
+                            // 3D · M2 (auditor V2 🔴 A, reproducido en PG: los dos se insertaban
+                            // porque el unique de la base es (slug, scope_type, owner_scope_key)
+                            // y cada uno comprobaba la colisión contra SU foto del memo). Ahora
+                            // las escrituras del catálogo van en serie (cerrojo sobre la fila de
+                            // `authz_catalog_version`) y la colisión se re-comprueba DENTRO de la
+                            // transacción, leyendo la base.
+                            const delegable = ['docs:read', 'docs:write', 'billing:read'];
+                            const twin = harness.makeTwin ? await harness.makeTwin(driver, tree) : twinOf(driver);
+                            const here = managerOver({ delegablePermissions: delegable });
+                            const there = managerOver({ delegablePermissions: delegable }, twin);
+                            const admin = subject();
+                            const orgA = await orgUnder(tree, APP_SCOPE);
+                            const unitA1 = await unitUnder(tree, orgA);
+                            await driver.grant(admin, 'org-admin', orgA);
+                            // Los dos memos calientes ANTES de escribir: cada uno con su foto.
+                            assert.deepEqual(await here.listRoles(admin, orgA), ['org-admin']);
+                            assert.deepEqual(await there.listRoles(admin, orgA), ['org-admin']);
+                            const spec = { slug: 'lead', scopeType: 'unit', rank: 20, permissions: ['docs:write'] };
+                            const results = await Promise.allSettled([
+                                here.defineScopedRole(admin, orgA, spec),
+                                there.defineScopedRole(admin, unitA1, { ...spec, permissions: ['docs:read'] }),
+                            ]);
+                            const ok = results.filter((r) => r.status === 'fulfilled');
+                            const estado = JSON.stringify(results.map((r) => (r.status === 'rejected' ? `${r.reason?.status} ${r.reason?.code}` : 'ok')));
+                            if (serialized) {
+                                // 3F · S3 (tester): desde que la colisión se decide por AUTORIDAD
+                                // esta carrera tiene DOS finales legales, y cuál sale depende de
+                                // quién CONFIRME primero — 2 ms de jitter bastan para cambiarlo,
+                                // medido en PostgreSQL y en MySQL—: si confirma el del ANCESTRO
+                                // (orgA), el del descendiente choca con 422; si confirma el del
+                                // DESCENDIENTE (unitA1), el del ancestro ya NO choca — entra y lo
+                                // ENSOMBRECE. Exigir aquí «exactamente un ganador» afirmaba una
+                                // unicidad que el paquete ya no promete en esa dirección y hacía
+                                // el caso FLAKY (pasaba porque el primero del array suele ganar).
+                                // Lo innegociable no cambia y se afirma abajo: en la base está
+                                // exactamente lo que se confirmó, nunca dos con el MISMO owner, y
+                                // quien no escribe lo sabe. La promesa fuerte de la capacidad —un
+                                // solo ganador y 422 para el perdedor— se juzga con el MISMO
+                                // owner, donde no hay asimetría de autoridad (`gemelo`, abajo).
+                                assert.oneOf(ok.length, [1, 2], `un ganador, o el del ancestro ensombreciendo al del descendiente (${estado})`);
+                            }
+                            else {
+                                // Sin serialización garantizada: nunca dos. Cuántos confirman
+                                // depende del motor — SQLite bloquea la base entera y el segundo
+                                // escritor puede recibir `SQLITE_BUSY`, un fallo de backend
+                                // legítimo (503) porque su transacción NO se aplicó.
+                                assert.isAtMost(ok.length, 1, `nunca dos ganadores (${estado})`);
+                            }
+                            for (const rejected of results.filter((r) => r.status === 'rejected')) {
+                                const error = rejected.reason;
+                                if (serialized) {
+                                    assert.equal(error?.status, 422, `el perdedor choca, no se cae: ${error?.code} ${error?.message}`);
+                                    assert.equal(error?.code, 'E_AUTHZ_CATALOG_CONFLICT');
+                                }
+                                else {
+                                    assert.oneOf(error?.status, [422, 503], `el perdedor no escribe: ${error?.code} ${error?.message}`);
+                                    if (error?.status === 422)
+                                        assert.equal(error?.code, 'E_AUTHZ_CATALOG_CONFLICT');
+                                }
+                            }
+                            let named = (await new CatalogCache().view()).rolesNamed('lead', 'unit');
+                            assert.lengthOf(named, ok.length, 'en la base hay exactamente lo que se confirmó');
+                            assert.deepEqual(named.map((r) => r.uuid).sort(), ok.map((w) => w.value.uuid).sort(), 'y son exactamente los uuid que confirmaron: nadie escribe sin decirlo');
+                            assert.equal(new Set(named.map((r) => r.owner)).size, named.length, 'nunca dos roles con el MISMO owner');
+                            if (named.length === 2) {
+                                // El único que puede convivir con otro es el del ANCESTRO, y
+                                // dentro del subárbol del descendiente el slug pasa a ser AMBIGUO
+                                // (fail-closed, M1). Se purga el ensombrecido para que el resto
+                                // del caso siga desde un estado conocido, venga de donde venga.
+                                assert.isDefined(named.find((r) => r.owner === scopeKey(orgA)), 'el que puede convivir es el del ANCESTRO');
+                                await rejectsWith(assert, () => driver.grant(subject(), 'lead', unitA1), { status: 422, code: 'E_AUTHZ_AMBIGUOUS_ROLE' });
+                                await driver.purgeRole(named.find((r) => r.owner !== scopeKey(orgA)).uuid);
+                                named = (await new CatalogCache().view()).rolesNamed('lead', 'unit');
+                            }
+                            if (named.length === 0) {
+                                await here.defineScopedRole(admin, orgA, spec);
+                                named = (await new CatalogCache().view()).rolesNamed('lead', 'unit');
+                            }
+                            assert.lengthOf(named, 1);
+                            // La promesa FUERTE de la capacidad, sin la asimetría de S3: dos
+                            // `define` del MISMO owner, en paralelo y con memos distintos. Ahí
+                            // los dos tienen la MISMA autoridad, así que el segundo choca gane
+                            // quien gane — exactamente uno escribe y el perdedor es 422, que es
+                            // lo que dice el README de `serializedCatalogWrites`.
+                            assert.deepEqual(await here.listRoles(admin, orgA), ['org-admin']);
+                            assert.deepEqual(await there.listRoles(admin, orgA), ['org-admin']);
+                            const gemelos = await Promise.allSettled([
+                                here.defineScopedRole(admin, orgA, { ...spec, slug: 'gemelo' }),
+                                there.defineScopedRole(admin, orgA, { ...spec, slug: 'gemelo', permissions: ['docs:read'] }),
+                            ]);
+                            const ganan = gemelos.filter((r) => r.status === 'fulfilled');
+                            const cuento = JSON.stringify(gemelos.map((r) => (r.status === 'rejected' ? `${r.reason?.status} ${r.reason?.code}` : 'ok')));
+                            if (serialized) {
+                                assert.lengthOf(ganan, 1, `exactamente un ganador con el MISMO owner (${cuento})`);
+                                for (const perdedor of gemelos.filter((r) => r.status === 'rejected')) {
+                                    const error = perdedor.reason;
+                                    assert.equal(error?.status, 422, `el perdedor choca, no se cae: ${error?.code} ${error?.message}`);
+                                    assert.equal(error?.code, 'E_AUTHZ_CATALOG_CONFLICT');
+                                }
+                            }
+                            else {
+                                assert.isAtMost(ganan.length, 1, `nunca dos ganadores (${cuento})`);
+                            }
+                            assert.lengthOf((await new CatalogCache().view()).rolesNamed('gemelo', 'unit'), ganan.length, 'en la base, exactamente lo confirmado — con el mismo owner no hay ensombrecimiento posible');
+                            // Y en SERIE —sin carrera que confunda— el segundo `define` choca
+                            // SIEMPRE y con el error preciso, desde el MISMO scope y desde
+                            // cualquier DESCENDIENTE del owner que ganó (da igual cuál de los
+                            // dos fuera: la carrera no decide qué se juzga aquí).
+                            const conflicto = { status: 422, code: 'E_AUTHZ_CATALOG_CONFLICT' };
+                            const dueno = named[0].owner === scopeKey(orgA) ? orgA : unitA1;
+                            const debajo = named[0].owner === scopeKey(orgA) ? unitA1 : await unitUnder(tree, unitA1);
+                            await rejectsWith(assert, () => there.defineScopedRole(admin, dueno, spec), conflicto);
+                            await rejectsWith(assert, () => here.defineScopedRole(admin, dueno, spec), conflicto);
+                            await rejectsWith(assert, () => there.defineScopedRole(admin, debajo, spec), conflicto);
+                            assert.lengthOf((await new CatalogCache().view()).rolesNamed('lead', 'unit'), 1);
+                            // 3F · S3: hacia ARRIBA no se choca, se ENSOMBRECE — la autoridad
+                            // manda (global > local de un ancestro > local de un descendiente),
+                            // así que el dueño del árbol siempre puede definir su rol aunque
+                            // alguien de abajo le haya ocupado el nombre (hasta 3E era 422 y
+                            // era la última forma de la mina de slug). Con otro slug, para no
+                            // tocar el estado de `lead`.
+                            const squat = await there.defineScopedRole(admin, debajo, { ...spec, slug: 'ocupado' });
+                            const delDueno = await here.defineScopedRole(admin, dueno, { ...spec, slug: 'ocupado' });
+                            assert.notEqual(delDueno.uuid, squat.uuid);
+                            assert.lengthOf((await new CatalogCache().view()).rolesNamed('ocupado', 'unit'), 2, 'el del ancestro entra y ensombrece al del descendiente');
+                            // Y dentro del subárbol del ocupante el slug es AMBIGUO, en los DOS
+                            // drivers: fail-closed, se opera por `{ uuid }`.
+                            await rejectsWith(assert, () => driver.grant(subject(), 'ocupado', debajo), { status: 422, code: 'E_AUTHZ_AMBIGUOUS_ROLE' });
+                            await driver.grant(subject(), { uuid: delDueno.uuid }, debajo);
+                            // Y por tanto el slug no es ambiguo en ninguna parte de la cadena.
+                            const bob = subject();
+                            await driver.grant(bob, 'lead', unitA1);
+                            assert.isTrue(await driver.hasRole(bob, 'lead', unitA1));
+                            // El RE-CHEQUEO dentro de la transacción (3D · M2 b), que hasta 3E
+                            // no ejercitaba ningún caso (tester R2: el mutante «sin
+                            // re-chequeo», forzado a serie, pasaba la suite entera): el rol
+                            // homónimo aparece SIN subir la versión del catálogo —exactamente
+                            // lo que ve un escritor cuya foto se tomó antes de que el otro
+                            // proceso confirmara—, así que el chequeo barato contra el memo lo
+                            // deja pasar y solo la relectura de la BASE puede pararlo.
+                            await insertRoleUnseen({ slug: 'sigiloso', scopeType: 'unit', owner: scopeKey(orgA) });
+                            await rejectsWith(assert, () => here.defineScopedRole(admin, unitA1, { ...spec, slug: 'sigiloso' }), conflicto);
+                            assert.lengthOf(await rowsNamed('sigiloso', 'unit'), 1, 'no se escribe a ciegas sobre lo que el memo no vio');
+                            // Y la rama del re-chequeo que NO se puede juzgar ahí dentro (3F ·
+                            // U3, tester 3E · §4.2): un homónimo cuyo owner no es global ni
+                            // ancestro-o-igual del owner pedido —una unit HERMANA— no se
+                            // clasifica sin resolver su cadena, y resolverla con el cerrojo del
+                            // catálogo sostenido sería un abrazo mortal con un pool de 1. Se
+                            // rechaza igual, con el 422 que pide REINTENTAR, y no escribe.
+                            // Hasta 3F esa rama solo la observaba la carrera de arriba, y solo
+                            // en el harness cuyo árbol SQL ensancha la ventana: aquí va EN
+                            // SERIE (el memo se recalienta primero, así que la fila nueva le es
+                            // invisible y solo la relectura de la BASE la ve).
+                            const unitA2 = await unitUnder(tree, orgA);
+                            assert.deepEqual(await here.listRoles(admin, orgA), ['org-admin'], 'memo recalentado tras el fallo anterior');
+                            await insertRoleUnseen({ slug: 'lateral', scopeType: 'unit', owner: scopeKey(unitA2) });
+                            const cambio = await rejectsWith(assert, () => here.defineScopedRole(admin, unitA1, { ...spec, slug: 'lateral' }), conflicto);
+                            assert.include(String(cambio?.message), 'El catálogo cambió mientras se validaba');
+                            assert.lengthOf(await rowsNamed('lateral', 'unit'), 1, 'el 422 genérico tampoco escribe a ciegas');
+                        });
+                        caseFor('serializedCatalogWrites', {
+                            whenTrue: () => raceOfDefines(true),
+                            whenFalse: () => raceOfDefines(false),
+                        });
+                        since('2.2', 'composición (3G · W4 iii): un defineScopedRole que ENSOMBRECE al homónimo de un descendiente Y a la vez tiene el subárbol por encima de la cota — la regla de nivel degrada, pero el rango sobre el ensombrecido se exige igual (422 sin escribir); con rango suficiente entra, lo reporta y el slug pasa a ser ambiguo solo ahí abajo', async ({ assert, }) => {
+                            // 3G · W3 × 3F · S2: la degradación de `descendantsOf` relaja la
+                            // regla de NIVEL (y el actor puede provocarla creando hijos), así
+                            // que lo que protege al descendiente en ese estado es el RANGO. Si
+                            // alguna vez las dos comprobaciones se funden en una, este caso lo
+                            // dice.
+                            const eventos = [];
+                            const admin = subject();
+                            const orgA = await orgUnder(tree, APP_SCOPE);
+                            const unitA1 = await unitUnder(tree, orgA);
+                            await unitUnder(tree, orgA);
+                            await unitUnder(tree, orgA);
+                            const authz = managerOver({
+                                delegablePermissions: ['docs:read', 'docs:write'],
+                                scopes: { resolveChain: resolveChainFrom(tree), descendantsOf: descendantsFrom(tree), maxDescendants: 1 },
+                                hooks: { onCatalogWrite: async (event) => void eventos.push(event) },
+                            });
+                            await driver.grant(admin, 'org-admin', orgA);
+                            const critico = await localRole(unitA1, { slug: 'critico', scopeType: 'unit', rank: 80, permissions: ['docs:write'] });
+                            // La regla de NIVEL degrada a la mínima: un tipo que no es de un
+                            // ancestro se acepta sin poder comprobar que cuelga del owner.
+                            const suelto = await authz.defineScopedRole(admin, orgA, { slug: 'suelto', scopeType: 'team', rank: 20, permissions: ['docs:read'] });
+                            assert.equal(suelto.scopeType, 'team', 'con el subárbol sin enumerar, la regla de nivel es la mínima');
+                            // Y aun así, ensombrecer exige superar en rango al ensombrecido.
+                            await rejectsWith(assert, () => authz.defineScopedRole(admin, orgA, { slug: 'critico', scopeType: 'unit', rank: 20, permissions: ['docs:read'] }), { status: 422, code: 'E_AUTHZ_RANK_EXCEEDED' });
+                            assert.lengthOf((await new CatalogCache().view()).rolesNamed('critico', 'unit'), 1, 'nada escrito');
+                            await driver.grant(subject(), 'critico', unitA1);
+                            // La otra cara: con rango de sobra sobre el homónimo, la autoridad
+                            // del ancestro sigue intacta (3F · S3) y se REPORTA a quién ensombrece.
+                            const flojo = await localRole(unitA1, { slug: 'flojo', scopeType: 'unit', rank: 10, permissions: ['docs:write'] });
+                            const sombra = await authz.defineScopedRole(admin, orgA, { slug: 'flojo', scopeType: 'unit', rank: 20, permissions: ['docs:read'] });
+                            assert.deepEqual(eventos.filter((e) => e.action === 'role_defined' && e.role.uuid === sombra.uuid).map((e) => e.shadowedByAncestor?.map((r) => r.uuid)), [[flojo]], 'el evento dice a quién acaba de ensombrecer');
+                            await rejectsWith(assert, () => driver.grant(subject(), 'flojo', unitA1), { status: 422, code: 'E_AUTHZ_AMBIGUOUS_ROLE' });
+                            assert.isNotNull((await new CatalogCache().view()).roleByUuid(critico), 'y el rol de rank 80 sigue intacto');
+                        });
+                        since('2.2', 'effectivePermissions es EXACTAMENTE {p | authorize(p)} aunque en la cadena haya un homónimo del rol del holder, y defineScopedRole no delega lo que solo tiene el homónimo (la policy mide por uuid, nunca del slug al catálogo)', async ({ assert, }) => {
+                            // 3D · M1 (auditor V1 🔴, escalada reproducida en PG): `rolesInChain`
+                            // devolvía el SLUG y el manager lo volvía a resolver con «el owner
+                            // más cercano gana», así que `effectivePermissions(pepe, U1)` decía
+                            // `docs:write` mientras `authorize` decía `false`, y con eso `pepe`
+                            // delegaba `docs:write` a un títere. Ahora el puerto habla por uuid.
+                            const delegable = ['docs:read', 'docs:write', 'billing:read'];
+                            const here = managerOver({ delegablePermissions: delegable });
+                            const pepe = subject();
+                            const titere = subject();
+                            const orgA = await orgUnder(tree, APP_SCOPE);
+                            const unitU1 = await unitUnder(tree, orgA);
+                            // El rol de pepe: `lead@unit` owner orgA, con SOLO docs:read.
+                            const suyo = await localRole(orgA, { slug: 'lead', scopeType: 'unit', rank: 20, permissions: ['docs:read'] });
+                            await driver.grant(pepe, { uuid: suyo }, unitU1);
+                            // Y el homónimo, owner de la propia unit, con docs:write. Pepe NO lo tiene.
+                            const ajeno = await localRole(unitU1, { slug: 'lead', scopeType: 'unit', rank: 20, permissions: ['docs:write'] });
+                            assert.notEqual(suyo, ajeno);
+                            assert.isTrue(await driver.authorize(pepe, 'docs:read', unitU1));
+                            assert.isFalse(await driver.authorize(pepe, 'docs:write', unitU1));
+                            assert.deepEqual(await here.effectivePermissions(pepe, unitU1), ['docs:read'], 'exactamente {p | authorize(p)}');
+                            assert.deepEqual(await here.effectivePermissions(pepe, orgA), []);
+                            // La policy de delegación mide lo mismo: docs:write no es suyo.
+                            await rejectsWith(assert, () => here.defineScopedRole(pepe, unitU1, { slug: 'jefe', scopeType: 'unit', rank: 10, permissions: ['docs:write'] }), { status: 422, code: 'E_AUTHZ_PERMISSION_NOT_DELEGABLE' });
+                            assert.deepEqual((await new CatalogCache().view()).rolesNamed('jefe', 'unit'), [], 'nada escrito');
+                            // Lo que SÍ es suyo se delega, y el rank del homónimo tampoco se hereda.
+                            const jefe = await here.defineScopedRole(pepe, unitU1, { slug: 'jefe', scopeType: 'unit', rank: 10, permissions: ['docs:read'] });
+                            await driver.grant(titere, { uuid: jefe.uuid }, unitU1);
+                            assert.isTrue(await driver.authorize(titere, 'docs:read', unitU1));
+                            assert.isFalse(await driver.authorize(titere, 'docs:write', unitU1), 'la escalada del auditor, cerrada');
+                            await rejectsWith(assert, () => here.defineScopedRole(pepe, unitU1, { slug: 'jefe2', scopeType: 'unit', rank: 20, permissions: ['docs:read'] }), { status: 422, code: 'E_AUTHZ_RANK_EXCEEDED' });
+                        });
+                    },
+                    // La cara `false` la juzga el par `purgeRole` de arriba (3E · P4):
+                    // `defineScopedRole` es 500 antes de escribir, así que esta policy
+                    // no existe para un driver que no sabe purgar.
+                });
+            },
+            whenFalse: () => {
+                since('2.1', 'sin listDenies en el puerto: listDenies, effectivePermissions y authorizedScopes son 500 E_AUTHZ_UNSUPPORTED nombrándolo (nunca un [] simulado); el puerto 2.0 sigue respondiendo', async ({ assert, }) => {
+                    // 2E · I5 (tester ⚪). Hasta aquí solo lo vigilaba `manager.spec`
+                    // con un driver falso; ahora lo juzga el contrato sobre el driver
+                    // real del harness. Un `[]` en su lugar diría «sin denies» y
+                    // `effectivePermissions` concedería lo denegado.
+                    assert.notTypeOf(driver.listDenies, 'function', 'el harness declara listDenies: false y el driver lo implementa: declara lo observable');
+                    const authz = managerOver();
+                    const alice = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    await driver.grant(alice, 'org-editor', orgA);
+                    for (const [label, call] of [
+                        ['listDenies', () => authz.listDenies(alice, orgA)],
+                        ['listDenies (todos)', () => authz.listDenies(alice)],
+                        ['effectivePermissions', () => authz.effectivePermissions(alice, orgA)],
+                        ['authorizedScopes', () => authz.authorizedScopes(alice, 'docs:write', 'organization')],
+                    ]) {
+                        try {
+                            await call();
+                            assert.fail(`${label}: debería haber rechazado`);
+                        }
+                        catch (error) {
+                            assert.equal(error?.status, 500, `${label}: ${error?.message}`);
+                            assert.equal(error?.code, 'E_AUTHZ_UNSUPPORTED', label);
+                            assert.include(String(error?.message), 'listDenies', label);
+                        }
+                    }
+                    // El puerto 2.0 y las primitivas que no restan denies siguen respondiendo.
+                    assert.isTrue(await authz.authorize(alice, 'docs:write', orgA));
+                    assert.deepEqual(await authz.authorizeMany(alice, 'docs:write', [orgA, APP_SCOPE]), [true, false]);
+                    assert.deepEqual(await authz.listRoles(alice, orgA), ['org-editor']);
+                    assert.isTrue(await authz.isWithin(orgA, APP_SCOPE));
+                });
+                since('2.2', 'sin listDenies en el puerto: defineScopedRole y updateScopedRole son 500 E_AUTHZ_UNSUPPORTED nombrándolo (la policy resta denies del actor: sin ellos no se delega), nada escrito; deleteScopedRole no lo necesita', async ({ assert, }) => {
+                    // 3B · B3 + 2E · I5: `defineScopedRole` exige `effectivePermissions`
+                    // del actor (C2: resta denies). Sin `listDenies` no se puede saber
+                    // si el actor tiene denegado lo que delega ⇒ se DICE, nunca se
+                    // asume «sin denies» (sería el lavado del auditor).
+                    const authz = managerOver({ delegablePermissions: ['docs:read', 'docs:write'] });
+                    const admin = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    // El nivel del rol tiene que colgar del owner (3E · P1): la unit
+                    // existe para que lo que se juzgue aquí sea `listDenies`.
+                    await unitUnder(tree, orgA);
+                    await driver.grant(admin, 'org-admin', orgA);
+                    const spec = { slug: 'lead', scopeType: 'unit', rank: 20, permissions: ['docs:write'] };
+                    for (const [label, call] of [
+                        ['defineScopedRole', () => authz.defineScopedRole(admin, orgA, spec)],
+                    ]) {
+                        try {
+                            await call();
+                            assert.fail(`${label}: debería haber rechazado`);
+                        }
+                        catch (error) {
+                            assert.equal(error?.status, 500, `${label}: ${error?.message}`);
+                            assert.equal(error?.code, 'E_AUTHZ_UNSUPPORTED', label);
+                            assert.include(String(error?.message), 'listDenies', label);
+                        }
+                    }
+                    assert.deepEqual((await new CatalogCache().view()).rolesNamed('lead', 'unit'), []);
+                    // Un rol local escrito por otro proceso: updateScopedRole con permisos también lo dice; deleteScopedRole no lo necesita.
+                    const lead = await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'], rank: 20 });
+                    try {
+                        await authz.updateScopedRole(admin, lead, { permissions: ['docs:read'] });
+                        assert.fail('updateScopedRole: debería haber rechazado');
+                    }
+                    catch (error) {
+                        assert.equal(error?.status, 500, error?.message);
+                        assert.equal(error?.code, 'E_AUTHZ_UNSUPPORTED');
+                    }
+                    assert.deepEqual([...(await new CatalogCache().view()).rolePermissionsOf(lead)], ['docs:write']);
+                    // Sin cambiar permisos no hace falta restar denies: el rank se cambia.
+                    assert.equal((await authz.updateScopedRole(admin, lead, { rank: 21 })).rank, 21);
+                });
+            },
+        });
+        // ── Pares de capacidad ──────────────────────────────────────────────
+        // `hierarchyFacts: false` → lo observan N1b/N2/N4/N5 (arriba): el driver
+        // responde según el árbol que le resuelve el consumidor, y `tree.move`
+        // cambia la respuesta sin escritura. `true` llega en Fase 3b.
+        // `injectableClock` tiene su par arriba (2.5 · J1). `transactions` (2.6)
+        // y `singleCheckAuthorize` (Fase 3b): pares en su fase; hoy solo pueden
+        // declararse `false`.
+        // ── 3b-2e · E6 · `singleCheckAuthorize` ──────────────────────────────
+        caseFor('singleCheckAuthorize', {
+            whenTrue: () => {
+                test('`authorize` no consulta el árbol del consumidor (0 resolveChain) y aun así hereda hacia abajo', async ({ assert, }) => {
+                    // El literal aprobado (panel 2, cruce 6): en modo `facts` la
+                    // DECISIÓN no pasa por el árbol del consumidor. Lo que sigue
+                    // pasando por él es la MEMBRESÍA (`roleInheritanceNative: false`,
+                    // su propio par), y por eso el titular «sin SQL» está prohibido.
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const unit = await unitUnder(tree, org);
+                    await driver.grant(alice, 'org-editor', org);
+                    const abajo = await withChainSpy(() => driver.authorize(alice, 'docs:read', unit));
+                    assert.isTrue(abajo.result, 'la herencia la resuelve el backend');
+                    assert.equal(abajo.calls, 0, 'y sin preguntarle al árbol del consumidor ni una vez');
+                    const hermana = await orgUnder(tree, APP_SCOPE);
+                    const fuera = await withChainSpy(() => driver.authorize(alice, 'docs:read', hermana));
+                    assert.isFalse(fuera.result);
+                    assert.equal(fuera.calls, 0);
+                });
+            },
+            whenFalse: () => {
+                test('`authorize` resuelve la cadena con el árbol del consumidor (lo consulta al menos una vez)', async ({ assert, }) => {
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const unit = await unitUnder(tree, org);
+                    await driver.grant(alice, 'org-editor', org);
+                    const { result, calls } = await withChainSpy(() => driver.authorize(alice, 'docs:read', unit));
+                    assert.isTrue(result);
+                    assert.isAbove(calls, 0);
+                });
+            },
+        });
+        caseFor('hierarchyFacts', {
+            // Con el árbol en manos del consumidor (`resolveChain`), el árbol
+            // es una dependencia más de cada pregunta: su caída se clasifica como la
+            // del backend (503, código propio), nunca como un `false` ni como el
+            // error crudo del consumidor. La cara `true` (árbol como hechos del
+            // backend, donde el resolutor no participa) llega en Fase 3b.
+            whenFalse: () => {
+                test('un resolutor de ancestros que lanza ⇒ 503 E_AUTHZ_RESOLVER_FAILED, nunca false', async ({ assert, }) => {
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    await driver.grant(alice, 'editor', APP_SCOPE);
+                    assert.isTrue(await driver.authorize(alice, 'docs:read', org));
+                    const original = tree.chainOf;
+                    tree.chainOf = async () => {
+                        throw new Error('el árbol del consumidor está caído');
+                    };
+                    try {
+                        const expected = { status: 503, code: 'E_AUTHZ_RESOLVER_FAILED' };
+                        await rejectsWith(assert, () => driver.authorize(alice, 'docs:read', org), expected);
+                        await rejectsWith(assert, () => driver.hasRole(alice, 'editor', org), expected);
+                    }
+                    finally {
+                        tree.chainOf = original;
+                    }
+                    assert.isTrue(await driver.authorize(alice, 'docs:read', org));
+                });
+                /**
+                 * La otra mitad de R2 (b), en el nivel del MANAGER (3b-2k · K1).
+                 * Salió del caso general de `authorizeMany`, que lo afirmaba para
+                 * todo driver: con el árbol en manos del consumidor una posición que
+                 * no se puede resolver tumba la llamada ENTERA (nunca un array
+                 * parcial, que sería un `false` disfrazado de respuesta).
+                 */
+                since('2.1', 'authorizeMany con un scope cuyo árbol lanza: 503 E_AUTHZ_RESOLVER_FAILED entero, jamás un array parcial', async ({ assert, }) => {
+                    const authz = managerOver();
+                    const alice = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const orgB = await orgUnder(tree, APP_SCOPE);
+                    const unitB1 = await unitUnder(tree, orgB);
+                    await driver.grant(alice, 'org-editor', orgA);
+                    const original = tree.chainOf;
+                    tree.chainOf = async (scope) => {
+                        if (`${scope.type}:${scope.uuid}` === `${unitB1.type}:${unitB1.uuid}`)
+                            throw new Error('árbol caído');
+                        return original.call(tree, scope);
+                    };
+                    try {
+                        await rejectsWith(assert, () => authz.authorizeMany(alice, 'docs:write', [orgA, unitB1, orgB]), {
+                            status: 503,
+                            code: 'E_AUTHZ_RESOLVER_FAILED',
+                        });
+                    }
+                    finally {
+                        tree.chainOf = original;
+                    }
+                });
+            },
+            /**
+             * Con el árbol como HECHOS del backend, la caída del resolutor del
+             * consumidor deja de tumbar la DECISIÓN: `authorize` sigue respondiendo
+             * (es la ganancia de disponibilidad de este modo). Lo que NO sobrevive
+             * es la membresía, que sigue pasando por el árbol (cruce 6): ahí el
+             * 503 se conserva, porque un `false` sería fail-open.
+             */
+            whenTrue: () => {
+                test('el árbol vive en el backend: con el resolutor del consumidor caído el modo es *grant-only* — `authorize` responde `true` y NADA se puede revocar (hasRole/list*/revoke/deny/removeDeny/purgeScope son 503)', async ({ assert, }) => {
+                    // 3b-2k · K1 · R2 (b), con la ampliación del 🟡 5 del auditor R2:
+                    // no basta decir «authorize sobrevive». Lo que hay que decir, y lo
+                    // que este caso fija, es que sobrevive **concediendo** mientras
+                    // todo lo que quitaría ese acceso está caído — el paquete no
+                    // ofrece, mientras dura, ninguna forma de retirarlo. Es la
+                    // propiedad que el dueño compró (PDP autónomo) con su precio
+                    // escrito, no un fallo: cerrarla sería volver a meter
+                    // `resolveChain` en el camino caliente de `authorize`.
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const unit = await unitUnder(tree, org);
+                    await driver.grant(alice, 'org-editor', org);
+                    assert.isTrue(await driver.authorize(alice, 'docs:read', unit));
+                    const original = tree.chainOf;
+                    tree.chainOf = async () => {
+                        throw new Error('el árbol del consumidor está caído');
+                    };
+                    const down = { status: 503, code: 'E_AUTHZ_RESOLVER_FAILED' };
+                    try {
+                        assert.isTrue(await driver.authorize(alice, 'docs:read', unit), 'la decisión no lo necesita');
+                        assert.isTrue(await driver.authorize(alice, 'docs:write', org), 'ni en el scope exacto');
+                        // Y ninguna de las salidas para quitarlo responde.
+                        for (const [label, call] of [
+                            ['hasRole', () => driver.hasRole(alice, 'org-editor', unit)],
+                            ['listRoles', () => driver.listRoles(alice, org)],
+                            ['listRoleScopes', () => driver.listRoleScopes(alice, 'organization')],
+                            ['listSubjects', () => driver.listSubjects('org-editor', org)],
+                            ['listScopes', () => driver.listScopes(alice, 'docs:read')],
+                            ['revoke', () => driver.revoke(alice, 'org-editor', org)],
+                            ['deny', () => driver.deny(alice, 'docs:read', unit)],
+                            ['removeDeny', () => driver.removeDeny(alice, 'docs:read', unit)],
+                            ['purgeScope', () => driver.purgeScope(org)],
+                        ]) {
+                            const error = await rejectsWith(assert, call, down);
+                            assert.equal(error?.code, down.code, label);
+                        }
+                        // La consecuencia, dicha entera: sigue concediendo.
+                        assert.isTrue(await driver.authorize(alice, 'docs:read', unit), 'concede y no se puede revocar');
+                    }
+                    finally {
+                        tree.chainOf = original;
+                    }
+                    // Con el árbol de vuelta, revocar vuelve a funcionar: la ventana es
+                    // exactamente la caída, no un estado que quede pegado.
+                    await driver.revoke(alice, 'org-editor', org);
+                    assert.isFalse(await driver.authorize(alice, 'docs:read', unit));
+                });
+                since('2.1', 'authorizeMany con un scope cuyo árbol lanza: RESPONDE con el árbol del store (no hay 503), porque la decisión no pasa por el resolutor', async ({ assert, }) => {
+                    // La cara `true` de lo que el caso general de `authorizeMany`
+                    // afirmaba para todos (3b-2k · K1 · R2 (b)). No es un caso más
+                    // laxo: exige la respuesta EXACTA, la misma que daría el árbol del
+                    // store con el resolutor en pie.
+                    const authz = managerOver();
+                    const alice = subject();
+                    const orgA = await orgUnder(tree, APP_SCOPE);
+                    const orgB = await orgUnder(tree, APP_SCOPE);
+                    const unitB1 = await unitUnder(tree, orgB);
+                    await driver.grant(alice, 'org-editor', orgA);
+                    const esperado = await authz.authorizeMany(alice, 'docs:write', [orgA, unitB1, orgB]);
+                    assert.deepEqual(esperado, [true, false, false], 'precondición del caso');
+                    const original = tree.chainOf;
+                    tree.chainOf = async (scope) => {
+                        if (`${scope.type}:${scope.uuid}` === `${unitB1.type}:${unitB1.uuid}`)
+                            throw new Error('árbol caído');
+                        return original.call(tree, scope);
+                    };
+                    try {
+                        assert.deepEqual(await authz.authorizeMany(alice, 'docs:write', [orgA, unitB1, orgB]), esperado, 'la misma respuesta que con el árbol en pie');
+                    }
+                    finally {
+                        tree.chainOf = original;
+                    }
+                });
+            },
+        });
+        // ── 3b-2k · K1 · R2 (c) · `canonicalScopeReads` ──────────────────────
+        caseFor('canonicalScopeReads', {
+            whenTrue: () => {
+                test('un alias del uuid que el árbol funde con la fila canónica encuentra sus hechos: `authorize` responde lo mismo que sobre la forma canónica', async ({ assert, }) => {
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const unit = await unitUnder(tree, org);
+                    await driver.grant(alice, 'unit-editor', unit);
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', unit), 'precondición del caso');
+                    const alias = { type: 'unit', uuid: unit.uuid.replaceAll('-', '') };
+                    await withAliasFused(alias, unit, async () => {
+                        assert.isTrue(await driver.authorize(alice, 'docs:write', alias), 'con canonicalScopeReads: true la lectura usa chain[0] (invariante 17)');
+                    });
+                });
+            },
+            whenFalse: () => {
+                test('un alias del uuid que el árbol funde con la fila canónica NO encuentra sus hechos: `authorize` es false (fail-CLOSED) donde la forma canónica concede — pero las ESCRITURAS sí canonizan', async ({ assert, }) => {
+                    // 3b-2k · K1 · R2 (c). La divergencia es de LECTURA y de una sola
+                    // dirección: nunca convierte un `false` en `true` (no evade denies
+                    // ni concede de más), pero no es la misma respuesta que
+                    // `database`, y quien pasa uuids con otra ortografía que la de su
+                    // tabla se queda fuera sin ningún aviso. La cara fail-OPEN, que sí
+                    // era un bug, la cerró 3b-2h (🟠 3 del auditor R2): la escritura
+                    // canoniza, y este caso lo fija aquí para que la capacidad no se
+                    // lea como «en `facts` la ortografía da igual».
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const unit = await unitUnder(tree, org);
+                    await driver.grant(alice, 'unit-editor', unit);
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', unit), 'precondición del caso');
+                    const eve = subject();
+                    const alias = { type: 'unit', uuid: unit.uuid.replaceAll('-', '') };
+                    await withAliasFused(alias, unit, async () => {
+                        assert.isFalse(await driver.authorize(alice, 'docs:write', alias), 'fail-CLOSED: no encuentra sus hechos');
+                        assert.isTrue(await driver.authorize(alice, 'docs:write', unit), 'y la forma canónica sigue concediendo');
+                        // La escritura sí canoniza (3b-2h · 🟠 3), en las cuatro puertas.
+                        await driver.grant(eve, 'unit-editor', alias);
+                        assert.deepEqual(await driver.listRoles(eve, unit), ['unit-editor'], 'el grant sobre el alias queda bajo la forma canónica');
+                        await driver.revoke(eve, 'unit-editor', alias);
+                        assert.deepEqual(await driver.listRoles(eve, unit), [], 'y el revoke sobre el alias quita el hecho canónico');
+                        await driver.deny(alice, 'docs:write', alias);
+                        assert.isFalse(await driver.authorize(alice, 'docs:write', unit), 'el deny sobre el alias bloquea la forma canónica');
+                        await driver.removeDeny(alice, 'docs:write', alias);
+                        assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+                        await driver.purgeScope(alias);
+                        assert.isFalse(await driver.authorize(alice, 'docs:write', unit), 'purgeScope sobre el alias purga los hechos CANÓNICOS');
+                    });
+                });
+            },
+        });
+        /**
+         * El árbol del consumidor FUNDE dos ortografías del mismo uuid, que es lo
+         * que hace de verdad una columna `uuid` de PostgreSQL o una collation
+         * `*_ci` de MySQL. Se parchea `chainOf` en vez de depender del motor para
+         * que el par `canonicalScopeReads` se juzgue igual en TODOS los harness,
+         * también con el árbol en memoria (donde el alias sería, si no,
+         * simplemente desconocido y el caso no probaría nada).
+         */
+        async function withAliasFused(alias, canonical, fn) {
+            const original = tree.chainOf;
+            tree.chainOf = async (scope) => {
+                const fused = scope.type === alias.type && scope.uuid === alias.uuid ? canonical : scope;
+                return original.call(tree, fused);
+            };
+            try {
+                await fn();
+            }
+            finally {
+                tree.chainOf = original;
+            }
+        }
+        /**
+         * Un espía sobre el árbol del consumidor: cuántas veces lo consulta cada
+         * primitiva. Es la única forma de juzgar «esto NO pasa por el árbol» sin
+         * mirar dentro del driver.
+         */
+        async function withChainSpy(fn) {
+            const original = tree.chainOf;
+            let calls = 0;
+            tree.chainOf = async (scope) => {
+                calls += 1;
+                return original.call(tree, scope);
+            };
+            try {
+                return { result: await fn(), calls };
+            }
+            finally {
+                tree.chainOf = original;
+            }
+        }
+        // ── 3b-2e · E2 · `roleInheritanceNative` ─────────────────────────────
+        caseFor('roleInheritanceNative', {
+            whenFalse: () => {
+                test('la MEMBRESÍA la resuelve el paquete con el árbol del consumidor: hasRole/listRoles/listRoleScopes/listSubjects/listScopes lo consultan (cruce 6)', async ({ assert, }) => {
+                    // Es la declaración honesta que el README tiene que hacer: lo que
+                    // un modo `facts` puede prometer es «un solo Check en `authorize`»,
+                    // no «sin SQL». Estas cinco lecturas siguen pasando por el árbol en
+                    // LOS DOS drivers, y un driver que lo cambie tiene que declararlo.
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const unit = await unitUnder(tree, org);
+                    await driver.grant(alice, 'org-editor', org);
+                    const primitives = [
+                        ['hasRole', () => driver.hasRole(alice, 'org-editor', unit)],
+                        ['listRoles', () => driver.listRoles(alice, org)],
+                        ['listRoleScopes', () => driver.listRoleScopes(alice, 'organization')],
+                        ['listSubjects', () => driver.listSubjects('org-editor', org)],
+                        ['listScopes', () => driver.listScopes(alice, 'docs:read')],
+                    ];
+                    for (const [name, run] of primitives) {
+                        const { calls } = await withChainSpy(run);
+                        assert.isAbove(calls, 0, `${name}: con roleInheritanceNative: false tiene que consultar el árbol`);
+                    }
+                    // Y la consecuencia observable: mover el nodo cambia la membresía
+                    // sin escribir un solo hecho.
+                    assert.isTrue(await driver.hasRole(alice, 'org-editor', unit));
+                    const otra = await orgUnder(tree, APP_SCOPE);
+                    await tree.move(unit, otra);
+                    assert.isFalse(await driver.hasRole(alice, 'org-editor', unit), 'la membresía es del árbol de HOY');
+                });
+            },
+        });
+        // ── 3b-2e · E2 · `listObjectsInherited` ──────────────────────────────
+        caseFor('listObjectsInherited', {
+            whenFalse: () => {
+                test('los `list*` NO enumeran herencia (invariante 7): un grant en el ancestro no aparece abajo, aunque authorize diga true', async ({ assert, }) => {
+                    // El rol es del MISMO nivel que los dos scopes (`unit-editor@unit`)
+                    // a propósito: con un rol de otro nivel el filtro de nivel taparía
+                    // una enumeración que sí heredara, y el caso no probaría nada.
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const unit = await unitUnder(tree, org);
+                    const sub = await unitUnder(tree, unit);
+                    await driver.grant(alice, 'unit-editor', unit);
+                    assert.isTrue(await driver.authorize(alice, 'docs:write', sub), 'la DECISIÓN sí hereda');
+                    assert.deepEqual(await driver.listRoles(alice, sub), [], 'la enumeración NO');
+                    assert.deepEqual(await driver.listSubjects('unit-editor', sub), [], 'ni por el otro lado');
+                    assert.deepEqual(scopeKeys(await driver.listScopes(alice, 'docs:write')), scopeKeys([unit]));
+                    assert.deepEqual(scopeKeys(await driver.listRoleScopes(alice, 'unit')), scopeKeys([unit]));
+                    // Y en el scope EXACTO sí está: lo que no se enumera es lo heredado.
+                    assert.deepEqual(await driver.listRoles(alice, unit), ['unit-editor']);
+                });
+            },
+        });
+        caseFor('truncationSignal', {
+            // `whenTrue` (el driver señala el truncamiento) no tiene caso: ningún
+            // driver del paquete trunca. Declarar `true` deja la capacidad sin
+            // cubrir y la suite lanza al cerrar el grupo.
+            whenFalse: () => caseFor('exhaustiveLists', {
+                // Backend sin tope, o driver que enumera sin tope (`Read` paginado
+                // en openfga): la única garantía honesta es que la lista es
+                // completa por grande que sea. Contra el OpenFGA de tope 3 de CI
+                // este caso es la prueba de que la enumeración no depende del tope.
+                whenTrue: () => {
+                    test('listas exhaustivas: 1.200 asignaciones directas se devuelven enteras', async ({ assert, }) => {
+                        const alice = subject();
+                        const orgs = [];
+                        for (let i = 0; i < 1_200; i++) {
+                            const org = await orgUnder(tree, APP_SCOPE);
+                            orgs.push(org);
+                            await driver.grant(alice, 'org-editor', org);
+                        }
+                        const scopes = await driver.listScopes(alice, 'docs:write');
+                        assert.deepEqual(scopeKeys(scopes), scopeKeys(orgs));
+                        assert.lengthOf(await driver.listRoleScopes(alice, 'organization'), 1_200);
+                    })?.timeout(60_000);
+                },
+                // Backend con tope y driver que no lo señala (un driver de
+                // terceros): lo único que se puede afirmar es la FRONTERA —
+                // exactamente `listMaxResults` asignaciones se devuelven enteras.
+                // Con una más el backend truncaría en silencio; eso no se codifica
+                // como aceptado, solo se deja de afirmar.
+                whenFalse: () => {
+                    const limit = harness.limits?.listMaxResults;
+                    if (!limit) {
+                        throw new Error(`[contrato ${harness.name}] declara 'exhaustiveLists: false' sin ` +
+                            `'limits.listMaxResults': el juez necesita el tope para probar la frontera.`);
+                    }
+                    test(`frontera del tope: ${limit} asignaciones directas se devuelven enteras`, async ({ assert, }) => {
+                        const alice = subject();
+                        const orgs = [];
+                        for (let i = 0; i < limit; i++) {
+                            const org = await orgUnder(tree, APP_SCOPE);
+                            orgs.push(org);
+                            await driver.grant(alice, 'org-editor', org);
+                        }
+                        const scopes = await driver.listScopes(alice, 'docs:write');
+                        assert.deepEqual(scopeKeys(scopes), scopeKeys(orgs));
+                    })?.timeout(120_000);
+                },
+            }),
+        });
     });
+    // Al cerrar el grupo: toda capacidad declarada `true` tiene que haber
+    // registrado su par. Es la regla "jamás un skip" hecha ejecutable.
+    const uncovered = Object.keys(harness.capabilities).filter((capability) => harness.capabilities[capability] && !covered.has(capability));
+    if (uncovered.length) {
+        throw new Error(`[contrato ${harness.name}] declara ${uncovered.map((c) => `'${c}: true'`).join(', ')} ` +
+            `pero el contrato no tiene caso para ese valor todavía. Declara lo observable hoy.`);
+    }
 }
 //# sourceMappingURL=contract.js.map