@jantstack/adonis-authz 2.5.0-alpha.3 → 2.5.0-rc.1

package/build/src/manager.js

@@ -10,7 +10,7 @@ import { assertKnownScope, canonicalScopeTargets, isAuthzError, resolveChain, ro
 import { CatalogCache, GLOBAL_OWNER_KEY, invalidateAuthzCatalog, isRoleVisibleWith, readLocalRoles, withAuthzCatalogWrite } from './catalog/catalog_cache.js';
 import { assertAssignableAt } from './catalog/catalog.js';
 import { systemClock } from './clock.js';
-import { ActorRequiredError, AuthorizationBackendError, AuthorizationBackendTimeoutError, isPartialWrite, AuthorizationFrozenError, AuthorizationConfigError, AuthorizationInternalError, CatalogConflictError, InvalidIdentityError, MassPurgeRefusedError, PruneInterruptedError, NoDescendantsResolverError, NotWithinError, PermissionNotDelegableError, RankExceededError, RoleImmutableError, RoleLevelAboveOwnerError, ScopeCycleError, ScopeResolverError, TooManyScopesError, UnknownPermissionError, UnknownRoleError, FreezeHeldError, UnsupportedOperationError, ViewExpiredError, WithinRequiredError, WithinRootForbiddenError, ScopeDriftUnguardedError, ScopeDepthLimitError, ScopeRequeueRefusedError, StaleSourceRefusedError, OperatorWindowExpiredError, } from './errors.js';
+import { ActorRequiredError, AuthorizationBackendTimeoutError, isPartialWrite, AuthorizationFrozenError, AuthorizationConfigError, AuthorizationInternalError, CatalogConflictError, InvalidIdentityError, MassPurgeRefusedError, PruneInterruptedError, NoDescendantsResolverError, NotWithinError, PermissionNotDelegableError, RankExceededError, RoleImmutableError, RoleLevelAboveOwnerError, ScopeCycleError, ScopeResolverError, ScopeTreeDriftError, TooManyScopesError, UnknownPermissionError, UnknownRoleError, UnknownScopeError, FreezeHeldError, UnsupportedOperationError, ViewExpiredError, WithinRequiredError, WithinRootForbiddenError, ScopeDriftUnguardedError, ScopeDepthLimitError, ScopeRequeueRefusedError, StaleSourceRefusedError, OperatorWindowExpiredError, isDeploymentFailure, isTransientRelayFailure, markDeploymentFailure, } from './errors.js';
 import { APP_SCOPE_TYPE, normalizeAuthorizationCapabilities } from './types.js';
 import { memoizeAncestors } from './memoize_ancestors.js';
 import { AUTHZ_TABLES_ORIGIN } from './reconcile.js';
@@ -77,6 +77,14 @@ export const DEFAULT_RELAY_BATCH = 100;
 export const DEFAULT_RELAY_LIMIT = 10_000;
 /** Páginas que `authz:reconcile` pasea para MEDIR la ventana del relay (3b-3a). */
 const RELAY_WINDOW_MAX_PAGES = 1_000;
+/**
+ * **Fallos del relay que solo dicen algo de la posición del HIJO** (asentar · cierre 2, O-2 del re-ataque): el
+ * `E_AUTHZ_SCOPE_TREE_DRIFT` del respaldo (el consumidor no pone al hijo bajo el padre ENCOLADO). La pasada contamina
+ * solo la clave del hijo, no la del padre encolado: un `attached` de OTRO hijo bajo ese padre escribe otra arista y
+ * conmuta (la misma lectura que la variante B del censo de aparcadas, alpha.8). Hasta aquí, mientras la entrada fallaba
+ * —hasta `maxAttempts` pasadas, y una más tras cada `requeue`— taponaba la org entera para los hijos nuevos.
+ */
+const CHILD_ONLY_FAILURES = new WeakSet();
 /**
  * **Saltos que la sonda de `only` sigue hacia atrás para heredar el ORIGEN de
  * un bloqueo** (2.4.0-alpha.6). Cada salto es una consulta `earlierPending`
@@ -767,11 +775,15 @@ export class AuthorizationManager {
         // se contrasta es la de origen, resuelta en fresco.
         attached: async (child, parent, options) => {
             const actor = await this.#writeOptions(options, 'scopes.attached');
-            const edge = await this.#assertEdge(child, parent, 'scopes.attached');
+            // RC2-B (rotación 2 · cierre 2, firmado: REORDENAR): `within` —destino Y origen, en fresco— se decide ANTES que el
+            // anti-ciclos y el techo de profundidad. Al revés, `SCOPE_CYCLE`/`SCOPE_DEPTH_LIMIT` sobre un scope AJENO decían
+            // DÓNDE está (de qué otro scope ajeno desciende, a cuántos saltos de la raíz) antes del `NOT_WITHIN`.
+            const edge = await this.#resolveEdge(child, parent, 'scopes.attached');
             this.#assertWithinChain(parent, edge.chain, options, 'scopes.attached');
             // Un hijo que el árbol ya conoce se está MOVIENDO (el `attach` de un
             // nodo existente es un `move`): su origen también tiene que estar dentro.
             await this.#assertWithinOrigin(child, options, 'scopes.attached', 'if-known');
+            this.#judgeEdge(edge, parent, 'scopes.attached');
             const outbox = this.#outbox();
             if (outbox) {
                 const receipt = await outbox.enqueue({ op: 'attached', child: edge.child, parent: edge.chain[0] }, { transaction: options?.transaction, ...actor });
@@ -795,9 +807,11 @@ export class AuthorizationManager {
          */
         moved: async (child, newParent, options) => {
             const actor = await this.#writeOptions(options, 'scopes.moved');
-            const edge = await this.#assertEdge(child, newParent, 'scopes.moved');
+            // RC2-B: `within` (destino y origen) antes que el anti-ciclos y el techo (ver `attached`).
+            const edge = await this.#resolveEdge(child, newParent, 'scopes.moved');
             this.#assertWithinChain(newParent, edge.chain, options, 'scopes.moved');
             await this.#assertWithinOrigin(child, options, 'scopes.moved', 'required');
+            this.#judgeEdge(edge, newParent, 'scopes.moved');
             const outbox = this.#outbox();
             if (outbox) {
                 const receipt = await outbox.enqueue({ op: 'moved', child: edge.child, parent: edge.chain[0] }, { transaction: options?.transaction, ...actor });
@@ -1214,6 +1228,7 @@ export class AuthorizationManager {
         const parked = new Set();
         /** El último id visto: la outbox pagina desde ahí (lo saltado se queda). */
         let after;
+        const passContext = { outbox, batchSize, appliedThisPass: [] };
         const defer = (item, keys, reason, error, origin) => {
             for (const key of keys)
                 block(key, item.id, origin);
@@ -1295,24 +1310,42 @@ export class AuthorizationManager {
                         }
                     }
                 }
+                let appliedHow;
                 try {
-                    await this.#applyScopeChange(driver, item);
+                    appliedHow = await this.#applyScopeChange(driver, item, passContext);
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
-                    const transient = _a.#isTransientRelayFailure(error);
+                    const transient = isTransientRelayFailure(error);
+                    const code = typeof error?.code === 'string' ? error.code : undefined;
                     await outbox.markFailed(item.id, message, { transient });
-                    for (const key of keys)
+                    const failedKeys = typeof error === 'object' && error !== null && CHILD_ONLY_FAILURES.has(error) ? [scopeKey(item.change.child)] : keys;
+                    for (const key of failedKeys)
                         block(key, item.id, 'failed');
                     parked.add(id);
-                    failures.push({ id: item.id, change: item.change, error: message, transient });
+                    failures.push({
+                        id: item.id,
+                        change: item.change,
+                        error: message,
+                        transient,
+                        ...(code !== undefined ? { code } : {}),
+                        ...(isDeploymentFailure(error) ? { deployment: true } : {}),
+                    });
                     entries.push({ id: item.id, change: item.change, status: 'failed', reason: message, attempts: item.attempts });
                     continue;
                 }
                 await outbox.markApplied(item.id);
                 done.add(id);
                 applied.push({ id: item.id, change: item.change, attempts: item.attempts });
-                entries.push({ id: item.id, change: item.change, status: 'applied', attempts: item.attempts });
+                passContext.appliedThisPass.push(item.change);
+                entries.push({
+                    id: item.id,
+                    change: item.change,
+                    status: 'applied',
+                    attempts: item.attempts,
+                    ...(appliedHow?.reason !== undefined ? { reason: appliedHow.reason } : {}),
+                    ...(appliedHow?.appliedParent !== undefined ? { appliedParent: appliedHow.appliedParent } : {}),
+                });
             }
             // Una outbox que ignora `after` devuelve el mismo lote atascado: la
             // pasada termina aquí en vez de dar vueltas (lo que quede, y lo que
@@ -1380,18 +1413,6 @@ export class AuthorizationManager {
                 'lo que no se pidió (filtra en el puerto, no en memoria).');
         }
     }
-    /**
-     * La caída del BACKEND no dice nada de la entrada (alpha.5 · R2a): un
-     * `AuthorizationBackendError` (503; el timeout es uno), y en general
-     * cualquier 503 (el freeze, el resolutor caído). Todo lo demás —422, 500,
-     * `E_AUTHZ_SCOPE_TREE_DRIFT`, el padre inexistente, un error sin status de
-     * un driver de terceros— es de la entrada y cuenta hacia el aparcado.
-     */
-    static #isTransientRelayFailure(error) {
-        if (error instanceof AuthorizationBackendError)
-            return true;
-        return typeof error === 'object' && error !== null && error.status === 503;
-    }
     /**
      * Las claves de scope de lo APARCADO ⇒ el id aparcado que las nombra
      * (alpha.5 · R2a). El censo lo lee `#relayInputs`: el `dead` ya leído si
@@ -2060,7 +2081,7 @@ export class AuthorizationManager {
      *
      * **La raíz `app` NO es clave** (2.4.0-alpha.8; panel relay 2, cuestión 1;
      * decisión del dueño 2026-09-10 (4)). La raíz no se mueve, no se purga y
-     * nunca es hijo (los tres 422 de `#assertEdge`/`scopes.detached`), así que
+     * nunca es hijo (los tres 422 de `#resolveEdge`/`#judgeEdge`/`scopes.detached`), así que
      * dos cambios cuyo ÚNICO cruce sea `app` conmutan: ningún orden que
      * conservar (el auditor lo buscó y no lo encontró; `m2-orden.ts`). Con
      * `[hijo, app]` toda alta de tenant compartía clave con todas las demás:
@@ -2112,17 +2133,105 @@ export class AuthorizationManager {
      * —el driver demuestra cero o lanza—, arista al final** (S6). Al revés,
      * una purga muerta a medias dejaría grants vivos en un scope sin ancestro,
      * los denies heredados dejarían de aplicar y esos permisos serían
-     * INDENEGABLES (invariante 2).
+     * INDENEGABLES (invariante 2). **Salvo el PADRE** (lote C · TREE): un
+     * `attached`/`moved` se aplica con el padre FRESCO del consumidor, no con
+     * el encolado (ver el cuerpo); devuelve `'superseded'` si el nodo ya no
+     * existe en el consumidor (aplicada sin arista).
      */
-    async #applyScopeChange(driver, item) {
+    async #applyScopeChange(driver, item, context) {
         const change = item.change;
-        if (change.op === 'attached') {
-            await driver.onScopeAttached?.(change.child, change.parent);
-            return;
-        }
-        if (change.op === 'moved') {
-            await driver.onScopeMoved?.(change.child, change.parent);
-            return;
+        if (change.op === 'attached' || change.op === 'moved') {
+            // **Asentar · cierre 1 (B4 del auditor del panel de estrategia)**: el padre FRESCO es SOLO para un driver que
+            // mantiene el árbol como HECHOS en su store (`capabilities.hierarchyFacts`: `openfga`). En `database` no hay árbol
+            // que pueda divergir —decide `resolveChain` en cada pregunta—, así que su relay se comporta EXACTAMENTE como en
+            // `f19fd37`: el padre ENCOLADO, sin resolutor ni modos de fallo nuevos (caso de paridad en `scope_outbox.spec`).
+            if (driver.capabilities?.hierarchyFacts !== true) {
+                if (change.op === 'attached')
+                    await driver.onScopeAttached?.(change.child, change.parent);
+                else
+                    await driver.onScopeMoved?.(change.child, change.parent);
+                return undefined;
+            }
+            // **El relay aplica el padre FRESCO del consumidor** (lote C · TREE, decisión del dueño 2026-10-20 (1), (d)
+            // corregida del juez; 🟠 «TREE con outbox»). El padre ENCOLADO es el que el consumidor quería al notificar, y la
+            // receta publicada notifica ANTES de confirmar la fila: dos `moved` del MISMO nodo pueden confirmar en un orden y
+            // encolarse en el otro, y relevar el padre encolado dejaba el store, para siempre y en silencio, con OTRO padre que
+            // la base del consumidor (medido: 1000/1000 forzado en PG y 200/200 en MySQL). Convergencia (juez TREE §2): la
+            // entrada del ÚLTIMO commit de un nodo se aplica después de ese commit y lee el estado final.
+            //
+            // **Pero el resolutor no es fiable por construcción** (🔴 1 del auditor del paso 4; firma del dueño 2026-10-21): uno
+            // filtrado por tenant responde `null` de todo en un comando (README «the realistic accident») y uno con caché/réplica
+            // responde el padre VIEJO. Aplicar a ciegas convertía un fallo ruidoso en un TREE persistente y MUDO. Regla mínima:
+            // el padre fresco se aplica cuando lo RESPALDA la propia cola —otra entrada del mismo hijo que lo dice (pendiente,
+            // aplicada en esta pasada o aplicada después)—; si no, la entrada FALLA con un error que CONSUME intento (y se aparca
+            // con su motivo tras `maxAttempts`, exit ≠ 0 en cada pasada):
+            //  - cadena con padre = encolado ⇒ se aplica (el caso normal);
+            //  - padre ≠ encolado RESPALDADO (otra entrada del hijo con ese padre) ⇒ se aplica el fresco, `reason:
+            //    'consumer-parent'` y `appliedParent` en el reporte (la carrera S1: el store converge);
+            //  - padre ≠ encolado SIN respaldo ⇒ 500 `E_AUTHZ_SCOPE_TREE_DRIFT` (resolutor rancio, o un cambio no notificado);
+            //    con un resolutor que se refresca (TTL), un reintento posterior ve el padre encolado y lo aplica;
+            //  - `null` RESPALDADO por un `detached` del hijo en la cola ⇒ aplicada SIN arista, `reason: 'superseded'` (D×D no
+            //    resucita un nodo borrado);
+            //  - `null` sin respaldo ⇒ 422 `E_AUTHZ_UNKNOWN_SCOPE` (resolutor filtrado por tenant, o hijo huérfano en la base);
+            //  - cadena TRUNCADA (`[hijo]` de un nodo que no es la raíz: le falta `app`) ⇒ 503 `E_AUTHZ_RESOLVER_FAILED`
+            //    (auditor ⚪ 7: jamás inventar la raíz);
+            //  - el resolutor LANZA ⇒ 503 transitorio, no consume intento (regla de alpha.5);
+            //  - sin `scopes.resolveChain` ⇒ 500 `E_AUTHZ_CONFIG` (desviación 6 del paso 4).
+            // Residuo declarado: con un resolutor rancio Y otra entrada del mismo hijo que respalde justo el padre rancio (dos
+            // movimientos seguidos del nodo dentro del TTL de la caché) el relay no puede distinguirlo de la carrera S1 y aplica;
+            // el reporte lo dice (`consumer-parent`, exit 1 del relay) y la red (`authz:reconcile --dry-run`, su fase `tree`) lo
+            // ve; el campo `drift.treeMismatch` NO existe todavía (llega en 2.6). Límite declarado `openfga.relay.stale-resolver`.
+            let resolver;
+            try {
+                resolver = this.#resolver('authz:scopes:relay');
+            }
+            catch (error) {
+                // Desviación 6 del paso 4, con su caso (asentar · cierre 1, 🟡-3 del tester): un proceso relay sin
+                // `scopes.resolveChain` es un DESPLIEGUE mal configurado ⇒ transitorio para el relay (inv. 5): no consume intento
+                // ni aparca la cola entera. Hasta el caso, el 500 contaba intento y la aparcaba en `maxAttempts` pasadas.
+                throw markDeploymentFailure(error);
+            }
+            const chain = await resolveChain(resolver, change.child, 'authz:scopes:relay');
+            const childKey = scopeKey(change.child);
+            if (chain === null) {
+                if (await this.#relayBacking(context, item, (other) => other.op === 'detached' && scopeKey(other.child) === childKey)) {
+                    return { reason: 'superseded', appliedParent: null };
+                }
+                throw new UnknownScopeError(`authz:scopes:relay: el resolutor del consumidor no conoce ${childKey} (devolvió null) y ninguna entrada ` +
+                    `'detached' de ese nodo en la cola lo respalda. No se aplica nada: un resolutor filtrado por tenant (sin ` +
+                    `petición en el comando) o con caché, o una fila huérfana en tu árbol. El resolutor del relay tiene que leer ` +
+                    `lo CONFIRMADO, sin contexto de tenant. La entrada consume intento y se aparca si persiste.`);
+            }
+            if (chain.length < 2) {
+                throw new ScopeResolverError('authz:scopes:relay', new TypeError(`resolveChain devolvió una cadena de un solo elemento para ${childKey}: le falta la raíz 'app'`));
+            }
+            const parent = chain[1];
+            const parentKey = scopeKey(parent);
+            let reason;
+            if (parentKey !== scopeKey(change.parent)) {
+                const backed = await this.#relayBacking(context, item, (other) => other.op !== 'detached' && scopeKey(other.child) === childKey && scopeKey(other.parent) === parentKey);
+                if (!backed) {
+                    const drift = new ScopeTreeDriftError(`authz:scopes:relay: el padre de ${childKey} que da el resolutor del consumidor (${parentKey}) no es el ` +
+                        `encolado (${scopeKey(change.parent)}) y ninguna otra entrada de ese nodo en la cola lo respalda. No se ` +
+                        `aplica nada: un resolutor con caché o réplica atrasada, o un cambio de árbol no notificado. El resolutor del ` +
+                        `relay tiene que leer lo CONFIRMADO, sin TTL. La entrada consume intento y se aparca si persiste. Si tu base ` +
+                        `ya tiene a ${childKey} bajo ${parentKey} y esta entrada es una intención VIEJA (otra entrada del nodo se ` +
+                        `aplicó antes en otra pasada), la salida es volver a notificar scopes.moved(${childKey}, ${parentKey}) —la ` +
+                        `entrada nueva la respalda— y reencolar #${String(item.id)} con authz:scopes:requeue ` +
+                        `--id=${String(item.id)} --apply. Si ese requeue se niega (E_AUTHZ_REQUEUE_REFUSED) solo por cambios ` +
+                        `aplicados de OTROS hijos bajo ${scopeKey(change.parent)}, el conflicto es falso: authz:scopes:requeue ` +
+                        `--id=${String(item.id)} --force y después authz:scopes:relay (el relay vuelve a resolver el padre en ` +
+                        `fresco y exige respaldo: no revierte nada).`);
+                    CHILD_ONLY_FAILURES.add(drift);
+                    throw drift;
+                }
+                reason = 'consumer-parent';
+            }
+            if (change.op === 'attached')
+                await driver.onScopeAttached?.(change.child, parent);
+            else
+                await driver.onScopeMoved?.(change.child, parent);
+            return { ...(reason !== undefined ? { reason } : {}), appliedParent: parent };
         }
         // La auditoría no pierde al autor por haber pasado por una cola.
         const event = {
@@ -2134,6 +2243,32 @@ export class AuthorizationManager {
         await driver.onScopeDetached?.(change.child);
         await this.#notify(event);
     }
+    /**
+     * **¿La cola RESPALDA el padre fresco?** (asentar · cierre 1, 🔴 1 del auditor). Otra entrada del mismo hijo que lo
+     * dice: aplicada en ESTA pasada, PENDIENTE (cualquier id; se pagina la cola entera, solo cuando el fresco no coincide
+     * con el encolado: raro) o APLICADA con un id posterior (`laterApplied`, si la outbox lo trae). Nunca una aplicada
+     * ANTERIOR de otra pasada: una caché rancia diría justo el padre de esa entrada vieja.
+     */
+    async #relayBacking(context, item, matches) {
+        if (context.appliedThisPass.some(matches))
+            return true;
+        const mine = String(item.id);
+        let after;
+        for (let page = 0; page < RELAY_WINDOW_MAX_PAGES; page++) {
+            const batch = await context.outbox.pending(context.batchSize, after);
+            if (batch.some((other) => String(other.id) !== mine && matches(other.change)))
+                return true;
+            if (batch.length < context.batchSize)
+                break;
+            after = batch[batch.length - 1].id;
+        }
+        if (typeof context.outbox.laterApplied === 'function') {
+            const later = await context.outbox.laterApplied(item.id, [item.change.child], RELAY_WINDOW_MAX_PAGES);
+            if (later.some((other) => matches(other.change)))
+                return true;
+        }
+        return false;
+    }
     /** Cota entera positiva de las opciones del relay (500 si llega otra cosa). */
     /**
      * **Una opción desconocida es 500, nunca silencio** (2.4.0-alpha.8 · X-1;
@@ -2269,16 +2404,35 @@ export class AuthorizationManager {
             return;
         this.#assertWithinChain(child, chain, options, operation);
     }
-    /** Lo mismo con una cadena ya resuelta (en fresco) por el llamante. */
-    #assertWithinChain(scope, chain, options, operation) {
+    /**
+     * Lo mismo con una cadena ya resuelta (en fresco) por el llamante. `asked` es cómo nombra el `message` lo que el
+     * llamante PASÓ cuando el scope contrastado NO lo pasó él (RC2-A, rotación 2 · cierre 2: en `updateScopedRole`/
+     * `deleteScopedRole` se contrasta el OWNER del rol, que sale del catálogo — el llamante solo pasó el uuid del rol).
+     */
+    #assertWithinChain(scope, chain, options, operation, asked) {
         const within = this.#requiredWithin(scope, options, operation);
         if (!within)
             return;
         if (!chain.some((s) => _a.#sameScope(s, within))) {
-            throw new NotWithinError(`${operation}: ${scope.type}:${scope.uuid ?? ''} no está dentro de ` +
-                `${within.type}:${within.uuid ?? ''} (la cadena es ${chain.map((s) => `${s.type}:${s.uuid ?? ''}`).join(' → ')}); ` +
-                `no se escribe fuera del scope declarado.`);
+            // R2-03: el `message` llega al tenant tal cual — solo nombra lo que el llamante PASÓ (el scope, o el rol, y su
+            // `within`); la cadena (identificadores de OTRO tenant) va a `error.details`, no enumerable, para el log del servidor.
+            throw new NotWithinError(`${operation}: ${asked ?? `${scope.type}:${scope.uuid ?? ''}`} no está dentro de ${within.type}:${within.uuid ?? ''}; ` +
+                `no se escribe fuera del scope declarado.`, { chain: chain.map((s) => ({ type: s.type, uuid: s.uuid ?? null })) });
+        }
+    }
+    /**
+     * La cadena (fresca) del OWNER de un rol local para `updateScopedRole`/`deleteScopedRole`, o 422
+     * `E_AUTHZ_UNKNOWN_SCOPE` si el owner ya no resuelve (rol DORMIDO). El `message` nombra el ROL tal como lo pasó el
+     * llamante, nunca el owner: el owner es un identificador que el llamante no aportó y puede ser de otro tenant (RC2-A).
+     * El owner va a `error.details.owner`, no enumerable. El CÓDIGO no cambia.
+     */
+    async #ownerChainOf(owner, roleUuid, operation) {
+        const chain = await resolveChain(this.#freshResolver(), owner, operation);
+        if (!chain) {
+            throw new UnknownScopeError(`El owner del rol ${roleUuid} no existe para el resolutor de la cadena (${operation}): el rol está dormido. ` +
+                `No se escribe sobre un scope que el árbol no reconoce; lo retira la plataforma (authz:catalog:prune-orphans).`, { owner: { type: owner.type, uuid: owner.uuid ?? null } });
         }
+        return chain;
     }
     /** El `within` a contrastar, validado y exigido según `requireWithin`; `null` si no hay que contrastar nada. */
     #requiredWithin(scope, options, operation) {
@@ -2327,13 +2481,13 @@ export class AuthorizationManager {
         return resolver;
     }
     /**
-     * Valida la arista y devuelve la cadena (fresca) del padre y el HIJO
-     * CANÓNICO (invariante 17). El hijo canónico se devuelve desde 3b-2d
+     * Resuelve la arista —identidad, padre conocido— y devuelve la cadena (fresca) del padre y el HIJO
+     * CANÓNICO (invariante 17); el anti-ciclos y el techo los juzga `#judgeEdge`, DESPUÉS de `within` (RC2-B). El hijo canónico se devuelve desde 3b-2d
      * porque la outbox lo encola: lo que se guarda en la cola es la fila del
      * árbol, no lo que escribió el llamante — si no, el relay abriría días
      * después una rama nueva en el store por un alias del uuid.
      */
-    async #assertEdge(child, parent, operation) {
+    async #resolveEdge(child, parent, operation) {
         const resolver = this.#resolver(operation);
         assertScope(child);
         assertScope(parent);
@@ -2345,14 +2499,22 @@ export class AuthorizationManager {
         // El hijo, si el árbol ya lo conoce, con su identidad canónica (K1): un
         // alias del uuid no puede colarse por debajo de la comprobación de ciclo.
         const known = await resolveChain(resolver, child, operation);
-        const canonicalChild = known ? known[0] : child;
-        const childKey = _a.#scopeKey(canonicalChild);
-        if (chain.some((s) => _a.#scopeKey(s) === childKey)) {
+        return { chain, child: known ? known[0] : child };
+    }
+    /**
+     * La otra mitad de la arista: anti-ciclos y techo de profundidad sobre lo que `#resolveEdge` resolvió. **Va DESPUÉS de
+     * `within`** (rotación 2 · cierre 2 · RC2-B, firmado: REORDENAR): los dos errores hablan de la cadena del PADRE —«desciende
+     * de …», «lo dejaría a N saltos»— y con un padre de otro tenant eran un oráculo de ESTRUCTURA ajena (de qué org cuelga
+     * una unit ajena, a qué profundidad está) que salía antes del `NOT_WITHIN`. Sin `within`, o con uno que pasa, el orden
+     * de los demás errores no cambia (identidad → padre desconocido → ciclo → profundidad).
+     */
+    #judgeEdge(edge, parent, operation) {
+        const childKey = _a.#scopeKey(edge.child);
+        if (edge.chain.some((s) => _a.#scopeKey(s) === childKey)) {
             throw new ScopeCycleError(`${operation}: ${parent.type}:${parent.uuid} desciende de ${childKey.replace('\u001f', ':')} (o es él mismo); ` +
                 `colgarlo cerraría un ciclo y la herencia dejaría de ser solo hacia abajo.`);
         }
-        this.#assertDepth(chain, canonicalChild, parent, operation);
-        return { chain, child: canonicalChild };
+        this.#assertDepth(edge.chain, edge.child, parent, operation);
     }
     /**
      * **El gate de profundidad, opt-in** (2.4.0-alpha.5 · R0; `scopes.maxDepth`).
@@ -2467,8 +2629,10 @@ export class AuthorizationManager {
         if (!chain)
             return [];
         const catalog = await this.#catalogFor(driver).view();
-        const { granted } = await this.#rolesAlong(driver, subject, chain, catalog);
-        const denied = await this.#deniedAlong(driver, subject, chain, 'effectivePermissions');
+        // Roles y denies en UNA foto (rotación 2 · cierre 3, L12): ver `#decisionFacts`.
+        const facts = await this.#decisionFacts(driver, subject, { chain, catalog }, 'effectivePermissions');
+        const { granted } = this.#grantedFrom(facts.roles, chain, catalog);
+        const denied = this.#deniedIn(facts.denies, chain);
         return [...granted].filter((permission) => !denied.has(permission));
     }
     /**
@@ -2492,11 +2656,18 @@ export class AuthorizationManager {
      * `E_AUTHZ_AMBIGUOUS_ROLE`) si hay homónimos visibles. Nunca elige uno.
      */
     async #rolesAlong(driver, subject, chain, catalog) {
+        return this.#grantedFrom(await this.#readRoles(driver, subject, chain, catalog), chain, catalog);
+    }
+    /** Los roles del holder en la cadena por el PUERTO: `rolesInChain` si el driver lo trae; si no, la composición por slug. */
+    async #readRoles(driver, subject, chain, catalog) {
+        return typeof driver.rolesInChain === 'function'
+            ? await driver.rolesInChain(subject, chain)
+            : await this.#rolesFromSlugs(driver, subject, chain, chainKeysFrom(chain), catalog);
+    }
+    /** Lo que conceden unos roles YA LEÍDOS a lo largo de la cadena, y el rank más alto (puro: el catálogo es el memo). */
+    #grantedFrom(roles, chain, catalog) {
         const keysFrom = chainKeysFrom(chain);
         const levelIndex = new Map(chain.map((s, i) => [scopeKey(s), i]));
-        const roles = typeof driver.rolesInChain === 'function'
-            ? await driver.rolesInChain(subject, chain)
-            : await this.#rolesFromSlugs(driver, subject, chain, keysFrom, catalog);
         const granted = new Set();
         let rank = 0;
         for (const { scope: level, role } of roles) {
@@ -2595,18 +2766,91 @@ export class AuthorizationManager {
             return undefined;
         }
     }
-    /** Permisos DENEGADOS al holder en algún scope de la cadena: `listDenies` en UNA lectura (500 `E_AUTHZ_UNSUPPORTED` sin él). */
-    async #deniedAlong(driver, subject, chain, primitive) {
-        const listDenies = this.#optional(driver, 'listDenies', primitive);
+    /** Permisos DENEGADOS al holder en algún scope de la cadena, sobre denies YA LEÍDOS (los de `listDenies(subject)`). */
+    #deniedIn(denies, chain) {
         const key = _a.#scopeKey;
         const chainKeys = new Set(chain.map(key));
         const denied = new Set();
-        for (const deny of await listDenies(subject)) {
+        for (const deny of denies) {
             if (chainKeys.has(key(deny.scope)))
                 denied.add(deny.permission);
         }
         return denied;
     }
+    /**
+     * **El punto de paso ÚNICO de las decisiones que el manager COMPONE con concesión y deny** (rotación 2 · cierre 3;
+     * 4.ª aparición del linaje L12 «lector rasgado»). `effectivePermissions`, la policy de delegación de
+     * `defineScopedRole`/`updateScopedRole` (`#assertDelegable`) y `authorizedScopes` combinan lo que el holder TIENE
+     * (`rolesInChain`, o `listScopes` de un permiso) con lo que tiene DENEGADO (`listDenies`). Hasta aquí eran dos métodos
+     * del puerto, dos lecturas sin foto común: un offboarding suelto (revoke y luego removeDeny) entre las dos hacía que
+     * `effectivePermissions` listara un permiso, `authorizedScopes` una unit y `defineScopedRole` delegara algo que el
+     * holder no tenía en NINGÚN estado real (repro `.claude/reproducciones/database-authorize-rasgado.spec.ts`, caso 5).
+     *
+     * Regla: con un driver que DECLARA la capacidad `snapshotDecisions: true` (opcional por D15) las DOS mitades salen de
+     * UNA llamada a `readSnapshot`, que el driver responde desde una sola foto de sus hechos; la respuesta se contrasta
+     * con lo pedido (una clave que falta o que no es un array es un bug del driver: 500 nombrándolo, como
+     * `authorizeMany`). Decide la CAPACIDAD, no la presencia del método (rotación 2 · cierre 3b, H3 del auditor; el
+     * patrón de `membersOfNative`): declarar `true` sin traer `readSnapshot` es 500 `E_AUTHZ_CONFIG` antes de leer nada,
+     * y un driver que declara `false` (o nada) compone como siempre aunque tenga un método con ese nombre —el hueco
+     * DECLARADO de un driver sin la capacidad (`openfga`, terceros)—. En los dos caminos, sin `listDenies` es 500
+     * `E_AUTHZ_UNSUPPORTED` antes de leer nada: nunca un «sin denies».
+     *
+     * `catalog` va con `chain` porque la composición por slug lo necesita; el catálogo y la cadena se leen FUERA de la
+     * foto (el memo contrasta la versión compartida; la cadena es del consumidor: «cadena frente a hechos», declarado).
+     *
+     * **Cuándo sale el 500 de «`true` sin `readSnapshot`»** (rotación 2 · cierre 3c, J3 del auditor): en la PRIMERA
+     * decisión compuesta (`effectivePermissions`, `authorizedScopes`, la policy de `defineScopedRole`/`updateScopedRole`),
+     * no al resolver el driver — `authorize` y los `list*` no lo necesitan y siguen respondiendo. Fail-closed y ruidoso,
+     * pero tarde; el patrón es el de `#optional` (una operación que falta se dice cuando se pide). El mensaje nombra el
+     * driver que lo EMITIÓ —la clave de `config.drivers` y la clase del objeto que la factory devolvió—, no solo
+     * `config.default`.
+     */
+    async #decisionFacts(driver, subject, request, primitive) {
+        const listDenies = this.#optional(driver, 'listDenies', primitive);
+        if (driver.capabilities?.snapshotDecisions === true) {
+            if (typeof driver.readSnapshot !== 'function') {
+                throw new AuthorizationConfigError(`${primitive}: el driver ${this.#emitter(driver)} declara snapshotDecisions: true y no trae readSnapshot. ` +
+                    'La capacidad promete leer en UNA foto lo que el manager compone; sin el método no hay foto que leer. ' +
+                    'Implementa readSnapshot o declara snapshotDecisions: false (el manager compone con dos lecturas, el hueco declarado).');
+            }
+            const answer = await driver.readSnapshot(subject, {
+                ...(request.chain ? { rolesInChain: request.chain } : {}),
+                ...(request.permission !== undefined ? { listScopes: request.permission } : {}),
+                listDenies: true,
+            });
+            const got = (answer ?? {});
+            const missing = [
+                ...(request.chain ? ['rolesInChain'] : []),
+                ...(request.permission !== undefined ? ['listScopes'] : []),
+                'listDenies',
+            ].filter((key) => !Array.isArray(got[key]));
+            if (answer === null || typeof answer !== 'object' || missing.length) {
+                throw new AuthorizationInternalError(`${primitive}: el driver ${this.#emitter(driver)} respondió a readSnapshot sin ${missing.join(', ') || 'un objeto'}; ` +
+                    'el puerto exige un array por cada lectura pedida, todas de la misma foto.');
+            }
+            return {
+                roles: got.rolesInChain,
+                scopes: got.listScopes,
+                denies: got.listDenies,
+            };
+        }
+        // Fallback DECLARADO (driver sin `snapshotDecisions: true`): dos lecturas del puerto sin foto común. Un método
+        // `readSnapshot` de un driver que no declara la capacidad NO se llama (puede ser otra cosa con el mismo nombre).
+        const roles = request.chain ? await this.#readRoles(driver, subject, request.chain, request.catalog) : undefined;
+        const scopes = request.permission !== undefined ? await driver.listScopes(subject, request.permission) : undefined;
+        return { roles, scopes, denies: await listDenies(subject) };
+    }
+    /**
+     * Cómo se nombra en un error el driver que lo EMITIÓ (cierre 3c, J3): la clave de `config.drivers` que lo resolvió y la
+     * clase del objeto que devolvió la factory (una vista `Object.create`/`withClock` hereda la del driver). La clave sola
+     * puede no decir qué objeto respondió (una factory que elige entre varios, una vista).
+     */
+    #emitter(driver) {
+        const kind = driver?.constructor?.name;
+        return typeof kind === 'string' && kind !== '' && kind !== 'Object'
+            ? `'${this.#config.default}' (${kind})`
+            : `'${this.#config.default}'`;
+    }
     // ── Roles locales a un scope (3B · B3): la API de DELEGACIÓN ─────────
     // Un administrador de un scope (el actor) define roles que solo existen
     // dentro de ese scope (owner) con permisos que él mismo tiene efectivos
@@ -2658,8 +2902,10 @@ export class AuthorizationManager {
         // Composición y lista blanca antes de leer hechos: lo barato primero.
         this.#assertComposable(parsed.permissions, parsed, catalog);
         await this.#assertLevelUnderOwner(parsed.scopeType, chain, 'defineScopedRole');
-        const { granted, rank: actorRank } = await this.#rolesAlong(driver, who, chain, catalog);
-        const denied = await this.#deniedAlong(driver, who, chain, 'defineScopedRole');
+        // Lo que el actor tiene y lo que tiene denegado, en UNA foto (rotación 2 · cierre 3, L12: `#decisionFacts`).
+        const facts = await this.#decisionFacts(driver, who, { chain, catalog }, 'defineScopedRole');
+        const { granted, rank: actorRank } = this.#grantedFrom(facts.roles, chain, catalog);
+        const denied = this.#deniedIn(facts.denies, chain);
         this.#assertDelegable(parsed.permissions, granted, denied, owner);
         this.#assertRank(parsed.rank, actorRank, catalog.topGlobalRank);
         const shadowedByAncestor = await this.#assertNoRoleCollision(parsed.slug, parsed.scopeType, owner, chain, catalog.rolesNamed(parsed.slug, parsed.scopeType));
@@ -2679,18 +2925,20 @@ export class AuthorizationManager {
             const known = new Set(catalog.rolesNamed(parsed.slug, parsed.scopeType).map((r) => r.owner));
             const fresh = [...new Set(rows.map((r) => String(r.owner_scope_key)).filter((o) => !known.has(o)))];
             if (fresh.length) {
-                // Los homónimos que el memo no tenía son de una escritura confirmada
-                // mientras validábamos. Los que se pueden juzgar SIN salir de la
-                // transacción (global, o un ancestro-o-igual del owner: la cadena ya
-                // está resuelta) dan el 422 preciso; el resto se rechaza igual —
-                // resolver su cadena aquí dentro pediría otra conexión mientras se
-                // sostiene el cerrojo del catálogo (con un pool de 1, un abrazo
-                // mortal). Reintentar es correcto: el memo ya está invalidado y el
-                // segundo intento valida con la foto buena.
+                // Los homónimos que el memo no tenía son de una escritura confirmada mientras validábamos. Se juzgan con la
+                // MISMA regla de colisión por AUTORIDAD que la comprobación previa (3F · S3, invariante 18), en lo que se puede
+                // juzgar SIN salir de la transacción —la cadena del owner ya está resuelta—: global o ancestro-o-igual ⇒ 422
+                // preciso (eso mantiene M2: dos `define` del mismo owner acaban en uno). **Cualquier otro owner NO es colisión**
+                // (rotación 2 · R2-05, decisión del dueño 2026-10-22): un hermano —otro tenant— puede tener el mismo slug, y
+                // un DESCENDIENTE queda ensombrecido, que es el segundo final legal de la carrera ancestro↔descendiente
+                // (3G · Y1). Hasta este cierre los dos se rechazaban con un 422 que NOMBRABA el owner ajeno («owner
+                // organization|<uuid de A>»): un oráculo de qué tenants definen qué slug, y una colisión falsa (reintentar
+                // entraba). Lo que NO se hace aquí, a propósito: resolver la cadena del owner nuevo dentro de la transacción
+                // (pediría otra conexión con el cerrojo del catálogo sostenido: abrazo mortal con pool 1), así que el rango
+                // sobre un descendiente confirmado EN la ventana no se mide (W3 protege a los roles que YA existían al validar;
+                // el mismo actor obtiene lo mismo yendo primero) y no sale en `shadowedByAncestor` del evento — sí en
+                // `authz:catalog:diff`. Declarado en el CHANGELOG.
                 await this.#assertNoRoleCollision(parsed.slug, parsed.scopeType, owner, chain, fresh.map((o) => ({ owner: o })), 'sin-árbol');
-                throw new CatalogConflictError(`El catálogo cambió mientras se validaba '${parsed.slug}@${parsed.scopeType}': apareció un rol con ese nombre ` +
-                    `(owner ${fresh.join(', ')}) que no estaba en la foto con la que se comprobaron las colisiones. ` +
-                    `No se escribe a ciegas; reintenta la operación.`);
             }
             const now = systemClock();
             await trx.table('authz_roles').insert({
@@ -2742,10 +2990,10 @@ export class AuthorizationManager {
         const catalog = await this.#catalogFor(driver).view();
         const role = this.#localRoleOrFail(catalog, roleUuid);
         const owner = this.#ownerOf(role);
-        const chain = await assertKnownScope(this.#freshResolver(), owner, 'updateScopedRole');
+        const chain = await this.#ownerChainOf(owner, role.uuid, 'updateScopedRole');
         // El scope contrastado es el OWNER del rol (3D · M3): editar un rol es
         // escribir dentro de su contenedor.
-        this.#assertWithinChain(owner, chain, options, 'updateScopedRole');
+        this.#assertWithinChain(owner, chain, options, 'updateScopedRole', `el rol ${role.uuid}`);
         const current = [...catalog.rolePermissionsOf(role.uuid)].sort();
         const next = {
             name: parsed.name ?? null,
@@ -2759,15 +3007,24 @@ export class AuthorizationManager {
         // POR ENCIMA de su owner (creado antes de 3E o a mano) no se perpetúa:
         // es una mina de slug y lo que toca es purgarlo, no editarlo.
         await this.#assertLevelUnderOwner(role.scopeType, chain, 'updateScopedRole');
-        const { granted, rank: actorRank } = await this.#rolesAlong(driver, who, chain, catalog);
+        // Con permisos nuevos la policy combina lo que el actor tiene con lo que tiene denegado: UNA foto (rotación 2 ·
+        // cierre 3, L12: `#decisionFacts`). Sin permisos solo hace falta el rank (una mitad: no rasga). Un driver SIN
+        // `listDenies` no tiene denies que leer: se leen solo los roles y el 500 `E_AUTHZ_UNSUPPORTED` sale DESPUÉS del 422
+        // de rango, en el orden de siempre (rotación 2 · cierre 3b, H4 del auditor).
+        const withDenies = Boolean(parsed.permissions) && typeof driver.listDenies === 'function';
+        const facts = withDenies
+            ? await this.#decisionFacts(driver, who, { chain, catalog }, 'updateScopedRole')
+            : { roles: await this.#readRoles(driver, who, chain, catalog), denies: [] };
+        const { granted, rank: actorRank } = this.#grantedFrom(facts.roles, chain, catalog);
         this.#assertAboveRole(actorRank, role);
         // 3G · W3: este rol puede estar ENSOMBRECIENDO al homónimo de un
         // descendiente (3F · S3). Cambiarle rank o permisos es seguir ejerciendo
         // esa autoridad, así que exige lo mismo que crearlo: superarlo en rango.
         this.#assertAboveShadowed(actorRank, await this.#shadowedBelow(scopeKey(owner), new Set(chain.map(scopeKey)), catalog.rolesNamed(role.slug, role.scopeType).filter((other) => other.uuid !== role.uuid), 'updateScopedRole'), 'updateScopedRole');
         if (parsed.permissions) {
-            const denied = await this.#deniedAlong(driver, who, chain, 'updateScopedRole');
-            this.#assertDelegable(parsed.permissions, granted, denied, owner);
+            if (!withDenies)
+                this.#optional(driver, 'listDenies', 'updateScopedRole');
+            this.#assertDelegable(parsed.permissions, granted, this.#deniedIn(facts.denies, chain), owner);
         }
         if (parsed.rank !== undefined)
             this.#assertRank(parsed.rank, actorRank, catalog.topGlobalRank);
@@ -2836,8 +3093,8 @@ export class AuthorizationManager {
         const catalog = await this.#catalogFor(driver).view();
         const role = this.#localRoleOrFail(catalog, roleUuid);
         const owner = this.#ownerOf(role);
-        const chain = await assertKnownScope(this.#freshResolver(), owner, 'deleteScopedRole');
-        this.#assertWithinChain(owner, chain, options, 'deleteScopedRole');
+        const chain = await this.#ownerChainOf(owner, role.uuid, 'deleteScopedRole');
+        this.#assertWithinChain(owner, chain, options, 'deleteScopedRole', `el rol ${role.uuid}`);
         const { rank: actorRank } = await this.#rolesAlong(driver, who, chain, catalog);
         this.#assertAboveRole(actorRank, role);
         const permissions = [...catalog.rolePermissionsOf(role.uuid)].sort();
@@ -2934,6 +3191,21 @@ export class AuthorizationManager {
      *    antes de su `purgeRole`; si ha vuelto, el rol se salta y se cuenta en
      *    `skipped` con `reason: 'owner-came-back'`.
      *
+     * **Tercer disparador del seguro** (rotación 2 de M4 · R2-02, decisión del dueño 2026-10-22 (2)): la
+     *    proporción la controla un TENANT —con la API de delegación legítima infla su catálogo local hasta que los
+     *    huérfanos de los demás bajan del 50 %—, y la variante realista del resolutor ciego no es «`null` para todo»
+     *    sino un contexto de tenant COLADO en el job de plataforma, que solo deja vivo a ese tenant. Así que, con
+     *    `force`, si los huérfanos son de MÁS DE UN owner y ALGUNO todavía concede (`stillGranting === true`) o no se
+     *    sabe (`undefined`: el driver no cuenta), también es 500 `E_AUTHZ_MASS_PURGE_REFUSED` antes de borrar nada,
+     *    salvo `allowMassPurge`. Un solo owner huérfano con asignaciones vivas sigue pasando (es el caso normal de un
+     *    tenant que se va, y el listado lo marca aparte). El `--dry-run` no lanza: lo marca en `massPurge` y dice por
+     *    qué en `massPurgeReasons` (`'all-owners' | 'proportion' | 'granting-across-owners'`).
+     *  - **Cota de lectura** (R2-04): `maxLocalRoles` (default `DEFAULT_MAX_LOCAL_ROLES`, `--max-local-roles` en el
+     *    comando) acota la lectura del catálogo local; pasarla es 500 `E_AUTHZ_TOO_MANY_LOCAL_ROLES`, nunca una lista
+     *    parcial. Hasta este cierre la opción no existía y el mensaje pedía «subir la cota» sin mando: un tenant con
+     *    10 001 roles locales dejaba `prune-orphans` muerto para todos. Un valor que no es un entero ≥ 1 es 500
+     *    `E_AUTHZ_CONFIG` antes de leer nada.
+     *
      * Coste: una lectura del catálogo local + un `resolveChain` por OWNER
      * DISTINTO (memoizado) + UNA llamada a `countRoleAssignments` con los
      * uuids de los huérfanos (ninguna si no hay) + un `resolveChain` más por
@@ -2942,6 +3214,12 @@ export class AuthorizationManager {
      * una petición.
      */
     async pruneOrphanRoles(options = {}) {
+        // R2-04: la cota es una entrada del operador y se valida antes de leer nada (L5: entrada inerte o rechazada).
+        const maxLocalRoles = options.maxLocalRoles;
+        if (maxLocalRoles !== undefined && !(Number.isInteger(maxLocalRoles) && maxLocalRoles >= 1)) {
+            throw new AuthorizationConfigError(`pruneOrphanRoles: maxLocalRoles (--max-local-roles) debe ser un entero >= 1 (llegó ${String(maxLocalRoles)}). ` +
+                `No se ha leído nada.`);
+        }
         const force = options.force === true;
         this.#resolver('authz:catalog:prune-orphans');
         const driver = await this.driver();
@@ -2953,7 +3231,7 @@ export class AuthorizationManager {
         if (force)
             await this.#assertNotFrozen('authz:catalog:prune-orphans');
         const resolver = this.#freshResolver();
-        const locals = await readLocalRoles({ driver: this.#config.default });
+        const locals = await readLocalRoles({ driver: this.#config.default, maxLocalRoles });
         const resolved = new Map();
         const orphans = [];
         for (const { role, permissions } of locals) {
@@ -2986,15 +3264,33 @@ export class AuthorizationManager {
         }
         const owners = new Set(locals.map(({ role }) => role.owner));
         const orphanOwners = new Set(orphans.map(({ role }) => role.owner));
-        const massPurge = orphans.length > 0 && (orphanOwners.size === owners.size || orphans.length * 2 > locals.length);
+        // Los TRES disparadores del seguro (AA2 + R2-02). Cada uno se reporta: el `--dry-run` dice POR QUÉ lo marca.
+        const granting = orphans.filter(({ stillGranting }) => stillGranting !== false);
+        const massPurgeReasons = [];
+        if (orphans.length > 0) {
+            if (orphanOwners.size === owners.size)
+                massPurgeReasons.push('all-owners');
+            if (orphans.length * 2 > locals.length)
+                massPurgeReasons.push('proportion');
+            if (orphanOwners.size > 1 && granting.length > 0)
+                massPurgeReasons.push('granting-across-owners');
+        }
+        const massPurge = massPurgeReasons.length > 0;
         if (!force)
-            return { orphans, purged: [], skipped: [], massPurge, dryRun: true };
+            return { orphans, purged: [], skipped: [], massPurge, massPurgeReasons, dryRun: true };
         if (massPurge && options.allowMassPurge !== true) {
+            // Solo CUENTAS: ni uuids ni slugs de owners (la lista ya la ve el operador en el `--dry-run`).
+            const motivos = massPurgeReasons.map((reason) => reason === 'all-owners'
+                ? `todos los owners distintos (${orphanOwners.size} de ${owners.size}) salen huérfanos`
+                : reason === 'proportion'
+                    ? `los huérfanos son más del 50 % de los roles locales (${orphans.length} de ${locals.length})`
+                    : `los huérfanos son de ${orphanOwners.size} owners distintos y ${granting.length} de ellos TODAVÍA conceden ` +
+                        `o no se sabe (stillGranting true/undefined)`);
             throw new MassPurgeRefusedError(`pruneOrphanRoles: ${orphans.length} de ${locals.length} roles locales (${orphanOwners.size} de ${owners.size} ` +
-                `owners distintos) tienen el owner fuera del árbol. Esa es la firma de un 'scopes.resolveChain' ciego —filtrado ` +
-                `por el tenant de la petición, o sin contexto— que devuelve null para todo: una pasada así borra el catálogo ` +
-                `local de todos los tenants. No se ha borrado nada. Comprueba el resolutor y, si la poda es real, repite con ` +
-                `allowMassPurge: true (--allow-mass-purge).`);
+                `owners distintos) tienen el owner fuera del árbol, y ${motivos.join('; ')}. Esa es la firma de un ` +
+                `'scopes.resolveChain' ciego —filtrado por el tenant de la petición, con el contexto de UN tenant colado en el ` +
+                `job, o sin contexto—: una pasada así borra el catálogo local, y las asignaciones vivas, de otros tenants. No se ` +
+                `ha borrado nada. Comprueba el resolutor y, si la poda es real, repite con allowMassPurge: true (--allow-mass-purge).`);
         }
         const purged = [];
         const skipped = [];
@@ -3032,7 +3328,7 @@ export class AuthorizationManager {
             purged.push(role);
             await this.#notifyCatalog({ action: 'role_purged', role, owner, permissions });
         }
-        return { orphans, purged, skipped, massPurge, dryRun: false };
+        return { orphans, purged, skipped, massPurge, massPurgeReasons, dryRun: false };
     }
     /** El actor de la API de delegación: obligatorio SIEMPRE (sin él no hay policy que evaluar) y bien formado. */
     async #requireActor(actor, operation) {
@@ -3557,12 +3853,13 @@ export class AuthorizationManager {
         // resuelven una vez.
         const view = this.#readResolver ? this : this.forRequest();
         const driver = await view.#reader();
-        const listDenies = this.#optional(driver, 'listDenies', 'authorizedScopes');
         const key = _a.#scopeKey;
-        const direct = await driver.listScopes(subject, permission);
+        // Los scopes directos que conceden y los denies, en UNA foto (rotación 2 · cierre 3, L12: `#decisionFacts`).
+        const facts = await view.#decisionFacts(driver, subject, { permission }, 'authorizedScopes');
+        const direct = facts.scopes;
         if (direct.length === 0)
             return { kind: 'none' };
-        const denied = (await listDenies(subject)).filter((d) => d.permission === permission).map((d) => d.scope);
+        const denied = facts.denies.filter((d) => d.permission === permission).map((d) => d.scope);
         if (direct.some((s) => s.type === APP_SCOPE_TYPE)) {
             if (denied.length > maxScopes) {
                 throw new TooManyScopesError(`authorizedScopes: ${denied.length} subárboles excluidos superan maxScopes=${maxScopes}; no se devuelve una lista parcial.`);
@@ -3642,7 +3939,7 @@ export class AuthorizationManager {
     }
     /**
      * Clave LAXA de un scope, solo para agrupar/deduplicar candidatos dentro
-     * de una operación (`authorizedScopes`, el anti-ciclo de `#assertEdge`).
+     * de una operación (`authorizedScopes`, el anti-ciclo de `#judgeEdge`).
      * NO es `scopeKey` de `identity.ts` —esa valida la gramática y es la que
      * identifica hechos, owners e ids de binding, y es la que usa
      * `#rolesAlong` (3D · N5)—: aquí los scopes vienen del `descendantsOf` del
@@ -3826,4 +4123,3 @@ export class AuthorizationManager {
     }
 }
 _a = AuthorizationManager;
-//# sourceMappingURL=manager.js.map