@jantstack/adonis-authz 2.0.0-alpha.1 → 2.4.0-alpha.2

package/build/src/testing/contract.js

@@ -4,9 +4,29 @@ import { v7 as uuidv7 } from 'uuid';
 import { APP_SCOPE } from '../types.js';
 import { AuthorizationManager } from '../manager.js';
 import db from '@adonisjs/lucid/services/db';
-import { CatalogCache, GLOBAL_OWNER_KEY, withAuthzCatalogWrite } from '../catalog_cache.js';
+import { CatalogCache, GLOBAL_OWNER_KEY, withAuthzCatalogWrite } from '../catalog/catalog_cache.js';
 import { scopeKey } from '../identity.js';
 import { descendantsFrom, memoryScopeTree, resolveChainFrom } from './scope_tree.js';
+/** El default de `DriverContractHarness.transactions`: Lucid + `authz_*`. */
+export function lucidContractTransactions() {
+    const count = async (table, subject) => {
+        const rows = await db
+            .from(table)
+            .where('holder_type', subject.type)
+            .where('holder_uuid', subject.uuid)
+            .count('* as n');
+        return Number(rows[0]?.n ?? 0);
+    };
+    return {
+        async begin() {
+            const trx = await db.transaction();
+            return { client: trx, commit: () => trx.commit(), rollback: () => trx.rollback() };
+        },
+        async census(subject) {
+            return { assignments: await count('authz_assignments', subject), denies: await count('authz_denies', subject) };
+        },
+    };
+}
 /**
  * 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
@@ -54,12 +74,15 @@ function twinOf(driver) {
  * transacción con el bump como última sentencia (`withAuthzCatalogWrite`, 2E
  * · H2). Ninguna señal en memoria: es exactamente lo que cruza procesos.
  */
-async function withoutLink(role, scopeType, permission) {
+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
@@ -69,7 +92,7 @@ async function withoutLink(role, scopeType, permission) {
  * owner) sin pasar por la policy del manager (que se juzga aparte, con
  * `defineScopedRole`). Devuelve el uuid del rol.
  */
-async function localRole(owner, spec) {
+async function insertLocalRole(owner, spec) {
     const uuid = uuidv7();
     await withAuthzCatalogWrite(async (trx) => {
         const now = new Date();
@@ -98,7 +121,7 @@ async function localRole(owner, spec) {
  * 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 retypeRole(roleUuid, scopeType) {
+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() });
     });
@@ -156,7 +179,7 @@ async function forgetRoleByHand(roleUuid) {
     });
 }
 /** Un vínculo rol→permiso escrito a mano (lo que un sync rechazaría), con la versión subida. */
-async function linkByHand(roleUuid, permission) {
+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() });
@@ -274,8 +297,50 @@ export function registerAuthorizationDriverContract(harness, api) {
             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();
@@ -288,17 +353,67 @@ export function registerAuthorizationDriverContract(harness, api) {
          * 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 },
-                scopes: {
-                    resolveChain: resolveChainFrom(tree),
-                    descendantsOf: descendantsFrom(tree),
-                    ...overrides.scopes,
-                },
                 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 }) => {
@@ -1021,21 +1136,37 @@ export function registerAuthorizationDriverContract(harness, api) {
             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 los
-                // hechos casan (`docs:write` concede ⇒ el `false` de arriba es el
-                // deny canónico, no un scope desconocido).
-                assert.isTrue(await driver.authorize(mallory, 'docs:write', alias), 'sin guiones: lo concedido sigue concedido');
+                // 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, }) => {
@@ -1498,7 +1629,7 @@ export function registerAuthorizationDriverContract(harness, api) {
             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; un scope que lanza ⇒ lanza entero', async ({ assert, }) => {
+        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
@@ -1548,23 +1679,19 @@ export function registerAuthorizationDriverContract(harness, api) {
             const watched = new AuthorizationManager({
                 default: harness.name,
                 drivers: { [harness.name]: () => spied },
-                scopes: { resolveChain: resolveChainFrom(tree), descendantsOf: descendantsFrom(tree) },
+                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);
-                // Un scope cuyo árbol falla: lanza entero (503), no un array parcial.
-                tree.chainOf = async (scope) => {
-                    if (`${scope.type}:${scope.uuid}` === `${unitB1.type}:${unitB1.uuid}`)
-                        throw new Error('árbol caído');
-                    return original.call(tree, scope);
-                };
-                await rejectsWith(assert, () => watched.authorizeMany(alice, 'docs:write', [orgA, unitB1, orgB]), {
-                    status: 503,
-                    code: 'E_AUTHZ_RESOLVER_FAILED',
-                });
+                // 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' }]), {
@@ -1582,8 +1709,9 @@ export function registerAuthorizationDriverContract(harness, api) {
             }
         });
         // ── 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
+        // Sin `{trx}` en estos casos (la escritura en la transacción del
+        // llamante tiene su par, `transactionalWrites`, abajo): 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.
@@ -2096,158 +2224,86 @@ export function registerAuthorizationDriverContract(harness, api) {
                     assert.isFalse(await driver.hasRole(alice, 'lead', unitA1));
                     assert.isFalse(await driver.hasRole(alice, 'lead', unitA1x));
                 });
-                since('2.2', 'scopes.detached purga también los roles LOCALES cuyo owner es ese scope (3D · M4): la fila no sobrevive, ese (slug, nivel) vuelve a estar libre para el catálogo global y nada de lo que concedía queda en pie', async ({ assert, }) => {
-                    // Auditor V5 (reproducido en PG): `deleteScopedRole` respondía 422
-                    // `E_AUTHZ_UNKNOWN_SCOPE` en cuanto el owner salía del árbol (lo
-                    // resuelve en fresco) y la fila del rol sobrevivía bloqueando ese
-                    // `(slug, nivel)` para `syncAuthzCatalog` PARA SIEMPRE. Un rol sin
-                    // owner no es visible en ninguna parte: purgarlo no pierde nada.
+                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 huerfano = await localRole(unitA1, { slug: 'huerfano', scopeType: 'unit', permissions: ['docs:write'] });
-                    const deOrg = await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:read'] });
-                    // 3E · P2 (auditor A4) / R7: un rol cuyo owner es un DESCENDIENTE
-                    // del scope notificado. El consumidor notifica el nodo que borró —
-                    // no uno por hoja—, y estos quedaban huérfanos e indeleteables,
-                    // bloqueando su (slug, nivel) global para siempre.
+                    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, 'huerfano', unitA1);
-                    await driver.grant(alice, 'huerfano', unitA1x);
+                    await driver.grant(alice, 'propio', unitA1);
                     await driver.grant(alice, 'nieto', unitA1x);
-                    await driver.grant(alice, 'lead', unitA1);
-                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1x));
-                    await authz.scopes.detached(unitA1);
-                    await tree.detach(unitA1);
+                    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.isNull(view.roleByUuid(huerfano), 'la fila del rol cuyo owner desapareció no sobrevive');
-                    assert.deepEqual(view.rolesNamed('huerfano', 'unit'), [], 'el (slug, nivel) vuelve a estar libre');
-                    assert.isNull(view.roleByUuid(delNieto), 'ni la del rol de un descendiente del scope notificado');
-                    assert.deepEqual(view.rolesNamed('nieto', 'unit'), []);
-                    assert.equal(await linksOf(huerfano), 0, 'sin vínculos huérfanos');
+                    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);
-                    assert.isNotNull(view.roleByUuid(deOrg), 'el rol de la organization, que sigue en el árbol, no se toca');
-                    assert.deepEqual(await driver.listSubjects({ uuid: huerfano }, unitA1x), []);
-                    // El subárbol lo purga el consumidor nodo a nodo (invariante 7): lo
-                    // que aquí se fija es que el ROL no deja rastro que resucite.
+                    // 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: 'huerfano', scopeType: 'unit', permissions: ['docs:read'] });
-                    await driver.grant(alice, 'huerfano', unitB1);
+                    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. Estos son los que las habrían cazado.
-                since('2.2', 'composición (3G · W4 i): detached de un ANCESTRO que el árbol ya no conoce, con requireActor y descendantsOf declarado, NO destruye los roles locales de descendientes VIVOS — el rango se mide en la cadena del OWNER de cada rol (422 y no se purga ninguno); cuando el owner de cada rol tampoco resuelve, la purga procede y lo dice', async ({ assert, }) => {
-                    // Auditor P1 (🟠 3G · W1): S1 (sin cadena donde medir, la purga
-                    // procede) + S2 (con `descendantsOf` la purga baja al subárbol) =
-                    // un rol de rank 80 de una unit VIVA destruido por un actor de
-                    // rank 50, mientras `deleteScopedRole` se lo negaba.
-                    const alice = subject();
-                    const admin = subject();
-                    const orgA = await orgUnder(tree, APP_SCOPE);
-                    const unitA1 = await unitUnder(tree, orgA);
-                    const oculto = new Set();
-                    const cadena = resolveChainFrom(tree);
-                    const authz = managerOver({
-                        requireActor: true,
-                        scopes: {
-                            // La fila del scope se borró; los hijos conservan su ruta.
-                            resolveChain: (scope) => (oculto.has(scopeKey(scope)) ? Promise.resolve(null) : cadena(scope)),
-                            // El consumidor es la autoridad sobre su tabla: sigue
-                            // respondiendo por los hijos del padre borrado.
-                            descendantsOf: descendantsFrom(tree),
-                        },
-                    });
-                    await driver.grant(admin, 'org-admin', orgA);
-                    const caro = await localRole(unitA1, { slug: 'caro', scopeType: 'unit', rank: 80, permissions: ['docs:write'] });
-                    const barato = await localRole(unitA1, { slug: 'barato', scopeType: 'unit', rank: 10, permissions: ['docs:read'] });
-                    await driver.grant(alice, { uuid: caro }, unitA1);
-                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1), 'el rol de rank 80 CONCEDE ahora mismo');
-                    oculto.add(scopeKey(orgA));
-                    await rejectsWith(assert, () => authz.scopes.detached(orgA, { actor: admin }), { status: 422, code: 'E_AUTHZ_RANK_EXCEEDED' });
-                    const vista = await new CatalogCache().view();
-                    assert.isNotNull(vista.roleByUuid(caro), 'el rol de la unit viva sobrevive');
-                    assert.isNotNull(vista.roleByUuid(barato), 'y el de rango bajo tampoco cae: se comprueban TODOS antes de tocar ninguno');
-                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1), 'y sigue concediendo');
-                    // La otra cara (S1 intacta): con el owner de cada rol también fuera
-                    // del árbol —invisibles en todas partes— la purga procede saltándose
-                    // el rango, y el retorno lo dice.
-                    oculto.add(scopeKey(unitA1));
-                    const salida = await authz.scopes.detached(orgA, { actor: admin });
-                    assert.equal(salida.purgedRoles, 2);
-                    assert.equal(salida.reason, 'owner-detached-unknown');
-                    const tras = await new CatalogCache().view();
-                    assert.isNull(tras.roleByUuid(caro));
-                    assert.isNull(tras.roleByUuid(barato));
-                });
-                since('2.2', 'composición (3G · W4 ii): con el subárbol POR ENCIMA de la cota el detached DEGRADA, pero la policy de rango corre igual sobre los roles del scope EXACTO: rango insuficiente ⇒ 422 y no se purga nada (tampoco los hechos); con rango suficiente ⇒ purga el scope exacto y marca el resultado como parcial', async ({ assert, }) => {
-                    // Auditor P4 (efecto lateral) + 3G · X2: con `below = []` por
-                    // degradación la policy se saltaba entera si nadie la invocaba.
-                    const alice = subject();
-                    const admin = subject();
-                    const plataforma = subject();
-                    const orgA = await orgUnder(tree, APP_SCOPE);
-                    await unitUnder(tree, orgA);
-                    await unitUnder(tree, orgA);
-                    await unitUnder(tree, orgA);
-                    const authz = managerOver({
-                        requireActor: true,
-                        scopes: { resolveChain: resolveChainFrom(tree), descendantsOf: descendantsFrom(tree), maxDescendants: 1 },
-                    });
-                    await driver.grant(admin, 'org-admin', orgA);
-                    const jefazo = await localRole(orgA, { slug: 'jefazo', scopeType: 'organization', rank: 80, permissions: ['docs:write'] });
-                    await driver.grant(alice, { uuid: jefazo }, orgA);
-                    assert.isTrue(await driver.authorize(alice, 'docs:write', orgA));
-                    await rejectsWith(assert, () => authz.scopes.detached(orgA, { actor: admin }), { status: 422, code: 'E_AUTHZ_RANK_EXCEEDED' });
-                    assert.isNotNull((await new CatalogCache().view()).roleByUuid(jefazo), 'el rol sigue');
-                    assert.isTrue(await driver.authorize(alice, 'docs:write', orgA), 'y los HECHOS también: la purga no llegó a correr');
-                    await driver.grant(plataforma, 'auditor-senior', APP_SCOPE);
-                    const salida = await authz.scopes.detached(orgA, { actor: plataforma });
-                    assert.deepEqual(salida, { purgedRoles: 1, truncated: true }, 'purga el scope exacto y dice que es parcial');
-                    assert.isNull((await new CatalogCache().view()).roleByUuid(jefazo));
-                    assert.isFalse(await driver.authorize(alice, 'docs:write', orgA));
-                });
-                since('2.2', 'composición (3G · W4 iv): detached de un scope desconocido cuyo descendantsOf FALLA purga solo lo que puede demostrar (los roles de ESE owner, sin rango que medir), jamás los de un descendiente vivo —que ni se leen—, y el resultado es parcial; con el resolutor sano ese mismo descendiente exige rango: degradar nunca da MÁS poder que enumerar', async ({ assert, }) => {
-                    const alice = subject();
-                    const forastero = subject();
-                    const orgA = await orgUnder(tree, APP_SCOPE);
-                    const unitA1 = await unitUnder(tree, orgA);
-                    const cadena = resolveChainFrom(tree);
-                    const abajo = descendantsFrom(tree);
-                    let roto = true;
-                    const authz = managerOver({
-                        requireActor: true,
-                        scopes: {
-                            resolveChain: (scope) => (scopeKey(scope) === scopeKey(orgA) ? Promise.resolve(null) : cadena(scope)),
-                            descendantsOf: (scope, options) => {
-                                if (roto)
-                                    throw new Error('la réplica del árbol no responde');
-                                return abajo(scope, options);
-                            },
-                        },
-                    });
-                    const propio = await localRole(orgA, { slug: 'propio', scopeType: 'organization', rank: 80, permissions: ['docs:write'] });
-                    const hijo = await localRole(unitA1, { slug: 'hijo', scopeType: 'unit', rank: 80, permissions: ['docs:write'] });
-                    await driver.grant(alice, { uuid: hijo }, unitA1);
-                    const salida = await authz.scopes.detached(orgA, { actor: forastero });
-                    assert.deepEqual(salida, { purgedRoles: 1, truncated: true, reason: 'owner-detached-unknown' });
-                    const vista = await new CatalogCache().view();
-                    assert.isNull(vista.roleByUuid(propio), 'el rol del scope que ya no existe se va: no era visible en ninguna parte');
-                    assert.isNotNull(vista.roleByUuid(hijo), 'el de la unit VIVA no lo toca nadie con rank 0');
-                    assert.isTrue(await driver.authorize(alice, 'docs:write', unitA1), 'y sigue concediendo');
-                    roto = false;
-                    await rejectsWith(assert, () => authz.scopes.detached(orgA, { actor: forastero }), { status: 422, code: 'E_AUTHZ_RANK_EXCEEDED' });
-                    assert.isNotNull((await new CatalogCache().view()).roleByUuid(hijo));
-                });
+                // 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 scopes.detached de un scope con roles locales no tocan nada; y el callejón tiene salida: borrada la fila del rol, el scope se purga con normalidad', async ({ assert, }) => {
+                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
@@ -2279,22 +2335,26 @@ export function registerAuthorizationDriverContract(harness, api) {
                     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) 3D · M4: `scopes.detached` de un scope que ES owner de roles
-                    //     locales necesita purgarlos; sin `purgeRole` lo dice con 500
-                    //     ANTES de tocar los hechos (nada purgado a medias).
+                    // (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 rejectsWith(assert, () => authz.scopes.detached(owner), { status: 500, code: 'E_AUTHZ_UNSUPPORTED' });
-                    assert.isTrue(await driver.authorize(alice, 'docs:write', owner), 'los hechos del scope siguen: no se purgó nada');
-                    assert.deepEqual(await driver.listRoles(alice, owner), ['propio']);
-                    // (4) LA SALIDA: la plataforma borra la fila del rol (el catálogo
-                    //     es suyo y es SQL) y el scope se purga con normalidad. Nadie
-                    //     queda encerrado.
-                    await forgetRoleByHand(propio);
                     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);
@@ -2303,6 +2363,180 @@ export function registerAuthorizationDriverContract(harness, api) {
                 });
             },
         });
+        // ── 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
@@ -3042,9 +3276,234 @@ export function registerAuthorizationDriverContract(harness, api) {
         // `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`.
+        // `injectableClock` tiene su par arriba (2.5 · J1). `transactionalWrites`
+        // (L-2) tiene su par al final: la cara `false` hoy, la `true` con L-3.
+        // ── L-2 · `transactionalWrites` (panel `{trx}`, (C)) ──────────────────
+        // Las DOS caras son obligatorias en este par (`BOTH_FACES_REQUIRED`): una
+        // `whenFalse` ausente se saltaba en silencio y «rechazo activo» sería
+        // una etiqueta. Lo que la cara `false` fija es la PUERTA 1 (por llamada,
+        // siempre activa) y la PUERTA 2 (por config, opt-in), las dos con el
+        // manager construido sobre el driver del harness, en TODOS los niveles:
+        // son composición del manager sobre `driver.capabilities`, así que un
+        // driver de terceros de nivel `core` también las observa.
+        caseFor('transactionalWrites', {
+            // L-3: la cara `true`. Lo que se juzga es «los dos o ninguno con TU
+            // transacción» POR CENSO: el rollback deja CERO filas nuevas (no solo
+            // `authorize` false — una respuesta puede salir bien con la fila viva),
+            // el commit las deja escritas, y mientras la transacción está abierta
+            // la autoridad (que lee por la conexión del motor) no ve nada. Y la
+            // otra mitad de la regla: una transacción que NO es la del driver no
+            // recibe ni una sentencia. Cuatro escrituras, las dos caras cada una.
+            whenTrue: () => {
+                test('transactionalWrites: true · grant/revoke/deny/removeDeny con { transaction } + rollback ⇒ authorize sin cambio Y CERO filas (censo); + commit ⇒ aplicado; una transacción ajena, un cliente sin transacción o el `db` entero ⇒ 500 E_AUTHZ_CONFIG sin UNA sentencia por ella', async ({ assert, }) => {
+                    assert.equal(driver.capabilities?.transactionalWrites, true, 'el harness declara transactionalWrites: true y el driver no: declara lo observable');
+                    const tx = harness.transactions ?? lucidContractTransactions();
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const authz = managerOver({});
+                    const can = () => driver.authorize(alice, 'docs:read', org);
+                    const census = () => tx.census(alice);
+                    // Una transacción que se queda abierta tras una aserción fallida
+                    // retiene una conexión del pool y arrastra a los casos siguientes:
+                    // el rollback va en `finally`, y el commit solo si nada falló.
+                    const rolledBack = async (fn) => {
+                        const t = await tx.begin();
+                        try {
+                            await fn(t.client);
+                        }
+                        finally {
+                            await t.rollback();
+                        }
+                    };
+                    const committed = async (fn) => {
+                        const t = await tx.begin();
+                        try {
+                            await fn(t.client);
+                        }
+                        catch (error) {
+                            await t.rollback();
+                            throw error;
+                        }
+                        await t.commit();
+                    };
+                    // grant: dentro no se ve desde fuera; rollback ⇒ nada; commit ⇒ concede.
+                    let seenInside;
+                    await rolledBack(async (transaction) => {
+                        await authz.grant(alice, 'org-editor', org, { transaction });
+                        seenInside = await can();
+                    });
+                    assert.deepEqual(await census(), { assignments: 0, denies: 0 }, 'ROJO: la asignación sobrevivió al rollback (la escritura NO fue por la transacción del llamante)');
+                    assert.isFalse(await can(), 'grant + rollback ⇒ no concede');
+                    assert.isFalse(seenInside, 'la autoridad lee por la conexión del motor: el grant sin confirmar no concede');
+                    await committed(async (transaction) => {
+                        await authz.grant(alice, 'org-editor', org, { transaction });
+                    });
+                    assert.isTrue(await can(), 'grant + commit ⇒ concede');
+                    assert.deepEqual(await census(), { assignments: 1, denies: 0 });
+                    // revoke: rollback ⇒ la asignación sigue; commit ⇒ se va.
+                    await rolledBack(async (transaction) => {
+                        await authz.revoke(alice, 'org-editor', org, { transaction });
+                        seenInside = await can();
+                    });
+                    assert.deepEqual(await census(), { assignments: 1, denies: 0 }, 'ROJO: el revoke sobrevivió al rollback');
+                    assert.isTrue(await can(), 'revoke + rollback ⇒ sigue concediendo');
+                    assert.isTrue(seenInside, 'el revoke sin confirmar no se ve desde la conexión del motor');
+                    await committed(async (transaction) => {
+                        await authz.revoke(alice, 'org-editor', org, { transaction });
+                    });
+                    assert.isFalse(await can(), 'revoke + commit ⇒ no concede');
+                    assert.deepEqual(await census(), { assignments: 0, denies: 0 });
+                    // deny (sobre un grant confirmado): rollback ⇒ sigue concediendo; commit ⇒ deniega.
+                    await authz.grant(alice, 'org-editor', org);
+                    await rolledBack(async (transaction) => {
+                        await authz.deny(alice, 'docs:read', org, { transaction });
+                        seenInside = await can();
+                    });
+                    assert.deepEqual(await census(), { assignments: 1, denies: 0 }, 'ROJO: el deny sobrevivió al rollback');
+                    assert.isTrue(await can(), 'deny + rollback ⇒ sigue concediendo');
+                    assert.isTrue(seenInside, 'el deny sin confirmar no se ve desde la conexión del motor');
+                    await committed(async (transaction) => {
+                        await authz.deny(alice, 'docs:read', org, { transaction });
+                    });
+                    assert.isFalse(await can(), 'deny + commit ⇒ deniega');
+                    assert.deepEqual(await census(), { assignments: 1, denies: 1 });
+                    // removeDeny: rollback ⇒ el deny sigue; commit ⇒ restaura.
+                    await rolledBack(async (transaction) => {
+                        await authz.removeDeny(alice, 'docs:read', org, { transaction });
+                        seenInside = await can();
+                    });
+                    assert.deepEqual(await census(), { assignments: 1, denies: 1 }, 'ROJO: el removeDeny sobrevivió al rollback');
+                    assert.isFalse(await can(), 'removeDeny + rollback ⇒ sigue denegando');
+                    assert.isFalse(seenInside, 'el removeDeny sin confirmar no se ve desde la conexión del motor');
+                    await committed(async (transaction) => {
+                        await authz.removeDeny(alice, 'docs:read', org, { transaction });
+                    });
+                    assert.isTrue(await can(), 'removeDeny + commit ⇒ restaura');
+                    assert.deepEqual(await census(), { assignments: 1, denies: 0 });
+                    // Una transacción que NO es la del driver (`assertCallerTransaction`):
+                    // 500 `E_AUTHZ_CONFIG` y ni una sentencia por ella (espía).
+                    const statements = [];
+                    const spy = (shape) => new Proxy(shape, {
+                        get(target, prop) {
+                            if (prop === 'from' || prop === 'table' || prop === 'raw' || prop === 'query' || prop === 'knexQuery') {
+                                return (...args) => {
+                                    statements.push(`${String(prop)}(${String(args[0] ?? '')})`);
+                                    return { where: () => ({}), select: async () => [], insert: async () => [], delete: async () => 0 };
+                                };
+                            }
+                            return Reflect.get(target, prop);
+                        },
+                    });
+                    const foreign = spy({ isTransaction: true, connectionName: `not-${harness.name}-${uuidv7()}` });
+                    const notATransaction = spy({ isTransaction: false, connectionName: 'primary' });
+                    const wholeDb = spy({ connection() { }, primaryConnectionName: 'primary' });
+                    const bob = subject();
+                    for (const [label, transaction] of [
+                        ['otra conexión', foreign],
+                        ['un cliente sin transacción', notATransaction],
+                        ['el db entero', wholeDb],
+                    ]) {
+                        for (const [operation, run] of [
+                            ['grant', () => authz.grant(bob, 'org-editor', org, { transaction })],
+                            ['revoke', () => authz.revoke(bob, 'org-editor', org, { transaction })],
+                            ['deny', () => authz.deny(bob, 'docs:read', org, { transaction })],
+                            ['removeDeny', () => authz.removeDeny(bob, 'docs:read', org, { transaction })],
+                        ]) {
+                            const error = await rejectsWith(assert, run, { status: 500, code: 'E_AUTHZ_CONFIG' });
+                            assert.include(error.message, operation, `${label}/${operation}: nombra la operación`);
+                        }
+                    }
+                    assert.deepEqual(statements, [], 'ni una sentencia por una transacción que no es la del driver');
+                    assert.deepEqual(await tx.census(bob), { assignments: 0, denies: 0 });
+                    assert.isFalse(await driver.authorize(bob, 'docs:read', org));
+                })?.timeout(30_000);
+            },
+            whenFalse: () => {
+                test('transactionalWrites: false · { transaction } en grant/revoke/deny/removeDeny es 500 E_AUTHZ_UNSUPPORTED nombrando driver y operación, con CERO llamadas al driver (espía); y requireTransactionalWrites: true ⇒ 500 E_AUTHZ_CONFIG al RESOLVER el driver', async ({ assert, }) => {
+                    // El harness declara `false`: el driver tiene que decir lo mismo
+                    // (el manager lee `driver.capabilities`, no el harness).
+                    assert.notEqual(driver.capabilities?.transactionalWrites, true, 'el harness declara transactionalWrites: false y el driver declara true: declara lo observable');
+                    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;
+                        },
+                    });
+                    // La forma de un `TransactionClientContract` de Lucid: la puerta
+                    // decide por la CAPACIDAD, antes de mirar qué transacción es.
+                    const trx = { from() { }, table() { }, isTransaction: true, connectionName: 'primary' };
+                    const alice = subject();
+                    const org = await orgUnder(tree, APP_SCOPE);
+                    const authz = managerOver({}, spied);
+                    const writes = [
+                        ['grant', () => authz.grant(alice, 'org-editor', org, { transaction: trx })],
+                        ['revoke', () => authz.revoke(alice, 'org-editor', org, { transaction: trx })],
+                        ['deny', () => authz.deny(alice, 'docs:read', org, { transaction: trx })],
+                        ['removeDeny', () => authz.removeDeny(alice, 'docs:read', org, { transaction: trx })],
+                    ];
+                    for (const [operation, run] of writes) {
+                        const error = await rejectsWith(assert, run, { status: 500, code: 'E_AUTHZ_UNSUPPORTED' });
+                        assert.include(error.message, `'${harness.name}'`, `${operation}: nombra el driver`);
+                        assert.include(error.message, operation, `${operation}: nombra la operación`);
+                        assert.include(error.message, 'requireTransactionalWrites', `${operation}: la letra lleva la salida`);
+                    }
+                    assert.deepEqual(touched, [], 'cero llamadas al driver: el rechazo va ANTES del backend');
+                    // Sin `{ transaction }` la MISMA escritura entra: la puerta es del
+                    // parámetro, no del driver.
+                    await authz.grant(alice, 'org-editor', org);
+                    assert.isTrue(await driver.authorize(alice, 'docs:read', org));
+                    assert.include(touched, 'grant');
+                    // Puerta 2, opt-in: quien quiera fallar al ARRANCAR lo pide, y
+                    // entonces el driver ni se resuelve (tampoco para leer).
+                    const strict = managerOver({ requireTransactionalWrites: true }, spied);
+                    const atResolve = await rejectsWith(assert, () => strict.driver(), { status: 500, code: 'E_AUTHZ_CONFIG' });
+                    assert.include(atResolve.message, `'${harness.name}'`);
+                    assert.include(atResolve.message, 'transactionalWrites');
+                    await rejectsWith(assert, () => strict.authorize(alice, 'docs:read', org), { status: 500, code: 'E_AUTHZ_CONFIG' });
+                    await rejectsWith(assert, () => strict.grant(alice, 'org-editor', org), { status: 500, code: 'E_AUTHZ_CONFIG' });
+                });
+            },
+        });
+        // ── 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
@@ -3071,6 +3530,263 @@ export function registerAuthorizationDriverContract(harness, api) {
                     }
                     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', {
@@ -3123,11 +3839,30 @@ export function registerAuthorizationDriverContract(harness, api) {
         });
     });
     // 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));
+    // registrado su par — y las de `BOTH_FACES_REQUIRED`, también con `false`.
+    // Es la regla "jamás un skip" hecha ejecutable.
+    const uncovered = uncoveredCapabilities(harness.capabilities, covered);
     if (uncovered.length) {
-        throw new Error(`[contrato ${harness.name}] declara ${uncovered.map((c) => `'${c}: true'`).join(', ')} ` +
+        throw new Error(`[contrato ${harness.name}] declara ${uncovered.map((c) => `'${c}: ${String(harness.capabilities[c])}'`).join(', ')} ` +
             `pero el contrato no tiene caso para ese valor todavía. Declara lo observable hoy.`);
     }
 }
+/**
+ * La regla del guard, PURA (para que `contract_harness.spec.ts` la juzgue sin
+ * borrar caras): una capacidad `true` sin caso registrado queda sin cubrir;
+ * y una de `BOTH_FACES_REQUIRED` queda sin cubrir con CUALQUIER valor.
+ */
+export function uncoveredCapabilities(capabilities, covered) {
+    return Object.keys(capabilities).filter((capability) => (capabilities[capability] || BOTH_FACES_REQUIRED.has(capability)) && !covered.has(capability));
+}
+/**
+ * Capacidades cuyas DOS caras son obligatorias (L-2): declarar `false` sin
+ * un caso `whenFalse` registrado lanza igual que declarar `true` sin
+ * `whenTrue`. El guard general solo obliga a la cara `true` porque los pares
+ * de nivel (`listDenies`, `purgeRole`…) no registran nada en un harness
+ * `core` y `false` ahí es legítimo; `transactionalWrites` es composición del
+ * manager y se observa en todos los niveles, así que su `false` sin caso es
+ * un skip disfrazado — «rechazo activo» sería una etiqueta.
+ */
+const BOTH_FACES_REQUIRED = new Set(['transactionalWrites']);
 //# sourceMappingURL=contract.js.map