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

package/build/src/manager.js

@@ -1,16 +1,17 @@
 var _a;
 import { Exception } from '@adonisjs/core/exceptions';
 import { v7 as uuidv7 } from 'uuid';
+import { activeRelationsDriverKey } from './define_config.js';
 import { assertCatalogUuid, assertIdentity, assertScope, assertScopeType, assertSubject, assertValidSlug, chainKeysFrom, normalizeRoleQuery, scopeFromKey, scopeKey, scopeSpellings, } from './identity.js';
 import { expiryChanged } from './expiry.js';
 import { randomBytes } from 'node:crypto';
-import { DEFAULT_FREEZE_LEASE_MS, acquireFreeze, freezeIsLive, freezeKindOf, readFreezeRow, releaseFreeze, renewFreeze, } from './freeze.js';
+import { DEFAULT_FREEZE_LEASE_MS, acquireFreezeOutcome, UNKNOWN_HOLDER, freezeIsLive, freezeKindOf, readFreezeRow, assertNotFrozenRow, releaseFreeze, renewFreeze, } from './freeze.js';
 import { assertKnownScope, isAuthzError, resolveChain, rootOnlyResolver } from './shared/backend_guard.js';
 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, AuthorizationBackendTimeoutError, AuthorizationFrozenError, AuthorizationConfigError, AuthorizationInternalError, CatalogConflictError, InvalidIdentityError, MassPurgeRefusedError, PruneInterruptedError, NoDescendantsResolverError, NotWithinError, PermissionNotDelegableError, RankExceededError, RoleImmutableError, RoleLevelAboveOwnerError, ScopeCycleError, ScopeResolverError, TooManyScopesError, UnknownPermissionError, UnknownRoleError, FreezeHeldError, UnsupportedOperationError, ViewExpiredError, WithinRequiredError, WithinRootForbiddenError, ScopeDriftUnguardedError, } from './errors.js';
-import { APP_SCOPE_TYPE } from './types.js';
+import { ActorRequiredError, AuthorizationBackendError, AuthorizationBackendTimeoutError, 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 { APP_SCOPE_TYPE, normalizeAuthorizationCapabilities } from './types.js';
 import { memoizeAncestors } from './memoize_ancestors.js';
 import { AUTHZ_TABLES_ORIGIN } from './reconcile.js';
 /** Longitudes de `authz_roles.name`/`description` (el esquema publicado). */
@@ -62,8 +63,49 @@ 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;
+/**
+ * **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`
+ * (0,69 ms) sobre una entrada NO pedida; la cadena es de ids estrictamente
+ * decrecientes, así que termina sola — la cota solo acota el coste dentro de
+ * una petición inline. Pasada la cota el origen se toma por FALLO (la purga se
+ * aplaza a la pasada completa): degrada hacia lo seguro, nunca aplica sin saber.
+ */
+export const RELAY_ORIGIN_MAX_HOPS = 100;
+/**
+ * **Cota PROPIA del censo de aparcadas** (alpha.5 · cierre, auditor 🟠 2). Las
+ * claves de `dead()` que taponan `attached`/`moved` se leen COMPLETAS en cada
+ * pasada, sean cuales sean `limit` y `batchSize` (con `--limit 50` o la receta
+ * inline `{ only, limit: 1 }` un censo acotado por `limit` dejaba a la aparcada
+ * 101 sin taponar y el `attached` colgaba del padre VIEJO — y la sonda de
+ * `only` no la ve porque `earlierPending` excluye lo aparcado). Si hay más
+ * aparcadas que esto, la pasada se NIEGA (500) en vez de aplicar con un tapón
+ * incompleto: una cola así es un incidente, no un lote.
+ */
+export const PARKED_CENSUS_MAX = 50_000;
 /** Vida por defecto de una vista de `forRequest()` para LEER (F9): un request, no un módulo. */
 export const DEFAULT_VIEW_MAX_AGE_MS = 30_000;
+/**
+ * Cada cuánto reintenta `acquire()` una pasada con `waitForLeaseMs` (2.4.0-alpha.8;
+ * panel relay 2, cuestión 7). Medido en PG: 0,29 ms por sondeo ocupado, y el
+ * sondeo no retiene conexión entre intentos (la transacción del intento fallido
+ * se revierte). El default de `waitForLeaseMs` es 0: el `busy` inmediato de
+ * siempre.
+ */
+export const RELAY_LEASE_POLL_MS = 25;
+/**
+ * Tope de `waitForLeaseMs` (cierre alpha.8, 🟡 1 del auditor): una espera sin tope
+ * cuelga la petición de un tenant; por encima es 500 `E_AUTHZ_CONFIG`. Y la espera
+ * se cuenta en SONDEOS (`waitForLeaseMs / RELAY_LEASE_POLL_MS`), no solo con el
+ * reloj de pared: con `config.clock` fijo el sondeo por reloj no terminaba nunca.
+ */
+export const RELAY_WAIT_LEASE_MAX_MS = 60_000;
+/** Las opciones que `relayScopeChanges` conoce (2.4.0-alpha.8 · X-1: cualquier otra es 500). */
+const RELAY_OPTIONS = ['limit', 'batchSize', 'dryRun', 'only', 'waitForLeaseMs', 'deadDetail'];
+/** Precedencia de los orígenes de un bloqueo por clave (2.4.0-alpha.8): un fallo real pisa todo; una pendiente pisa a un aparcado. */
+const BLOCK_RANK = { parked: 0, pending: 1, failed: 2 };
+/** Las opciones que `requeueScopeChanges` conoce (2.4.0-alpha.8 · X-1: cualquier otra es 500). */
+const REQUEUE_OPTIONS = ['force', 'apply', 'waitForLeaseMs'];
 /** Reloj monótono del proceso: inmune a NTP, snapshots y `Date.now` parcheado. */
 const monotonicNow = () => performance.now();
 /**
@@ -196,10 +238,96 @@ export class AuthorizationManager {
             }
             driver = driver.withClock(clock);
         }
+        this.#assertTransactionalWritesRequired(driver);
         this.#assertScopeDriftGuarded(driver);
         this.#driver = driver;
         return driver;
     }
+    /**
+     * **Lo que el driver ACTIVO declara, de solo lectura** (2.4.0-alpha.4;
+     * pregunta 1 de COGNITIV, panel alpha.4). Para que el código de tenant
+     * pueda ramificar —`if ((await authorization.capabilities()).transactionalWrites)
+     * grant(…, { transaction }) else grant(…)`— sin llamar a `driver()`, que
+     * sigue siendo API de PLATAFORMA (el grep del README sigue significando lo
+     * que significa).
+     *
+     * Es `(await this.driver()).capabilities` y NADA más, a propósito:
+     *  - las capacidades son de la INSTANCIA (`database` decide
+     *    `transactionalWrites` desde sus opciones), así que hay que resolver;
+     *  - y se resuelve POR `driver()`, con sus dos puertas
+     *    (`requireTransactionalWrites` y el gate de deriva del árbol) y su
+     *    caché. Resolverlo por otro camino «para que la lectura no lance» y
+     *    guardarlo en `#driver` dejaría `driver()` sirviendo un driver que
+     *    nunca pasó por las puertas: un bypass permanente del gate de deriva
+     *    (🔴 1 del auditor). Por eso hereda los 500 de las puertas
+     *    (`E_AUTHZ_CONFIG`, `E_AUTHZ_SCOPE_DRIFT_UNGUARDED`) y la factory del
+     *    consumidor: llámalo al arrancar (un hook `booted`/`ready`), no por
+     *    request en un endpoint de metadatos.
+     *
+     * Devuelve una copia CONGELADA y NORMALIZADA: todas las claves de
+     * `AuthorizationDriverCapabilities` presentes, solo `true` es `true`
+     * (la misma lectura que la puerta 1), nunca `undefined`; mutarla no toca
+     * el objeto que leen las puertas. La vista de `forRequest()` delega en el
+     * padre (por `driver()`).
+     */
+    async capabilities() {
+        const driver = await this.driver();
+        return normalizeAuthorizationCapabilities(driver.capabilities);
+    }
+    /**
+     * **Puerta 2 de `{ transaction }`** (L-2, opt-in): con
+     * `requireTransactionalWrites: true` el driver activo tiene que declarar
+     * `transactionalWrites: true` o el manager falla AL RESOLVERLO — antes de
+     * cachearlo, así que toda lectura, toda escritura y `driver()` fallan igual:
+     * el despliegue no arranca. Es la forma honesta de «fallar al construirse»:
+     * el roadmap lo pedía incondicional y eso haría `openfga` inconstruible en
+     * cualquier app que solo lo tenga registrado (y el driver se resuelve
+     * perezosamente y por nombre, así que al construir no se sabe si alguien
+     * pasará `{ transaction }`). Quien quiera fallar al arrancar, lo pide.
+     */
+    #assertTransactionalWritesRequired(driver) {
+        if (this.#config.requireTransactionalWrites !== true)
+            return;
+        if (driver.capabilities?.transactionalWrites === true)
+            return;
+        throw new AuthorizationConfigError(`config.requireTransactionalWrites está en true y el driver '${this.#config.default}' declara ` +
+            `transactionalWrites: ${driver.capabilities ? String(driver.capabilities.transactionalWrites) : 'nada (sin capabilities)'}: ` +
+            `no puede inscribir grant/revoke/deny/removeDeny en la transacción del consumidor («los dos o ninguno»), así ` +
+            `que el manager no se resuelve. Usa un driver que la declare (database) o quita requireTransactionalWrites.`);
+    }
+    /**
+     * **Puerta 1 de `{ transaction }`** (L-2, siempre activa): una escritura de
+     * HECHOS con `{ transaction }` a un driver que no declara
+     * `transactionalWrites: true` es 500 `E_AUTHZ_UNSUPPORTED` nombrando driver
+     * y operación, ANTES de la barrera, de la identidad y del driver (cero
+     * llamadas). Nunca se ignora, nunca un `logger.warn`: aceptarla y no
+     * cumplirla sería publicar con nuestra firma la fuga del cruce 4 · S5.
+     * `scopes.*` NO pasa por aquí: su `transaction` ENCOLA (encolar ≠ escribir).
+     */
+    async #assertTransactionalWrite(options, operation) {
+        if (options?.transaction === undefined || options.transaction === null)
+            return;
+        const driver = await this.driver();
+        if (driver.capabilities?.transactionalWrites === true)
+            return;
+        throw UnsupportedOperationError.transactional(operation, this.#config.default, 'roles');
+    }
+    /**
+     * La marca del evento de una escritura inscrita en la transacción del
+     * llamante (L-3): `onWrite` se dispara cuando el DRIVER vuelve, y en ese
+     * momento la fila existe solo dentro de esa transacción — es un hecho si y
+     * solo si el llamante confirma, cosa que el paquete nunca ve. Quien audita
+     * lo necesita para no registrar como firme lo que un rollback deshace.
+     */
+    #transactional(options) {
+        return options?.transaction === undefined || options.transaction === null ? {} : { transactional: true };
+    }
+    /** La API de delegación no admite `{ transaction }` (§1.4 del veredicto `{trx}`): 500 antes de tocar nada. */
+    #assertNoTransaction(options, operation) {
+        if (options?.transaction === undefined || options.transaction === null)
+            return;
+        throw UnsupportedOperationError.transactionalCatalog(operation);
+    }
     /**
      * **El gate de deriva del árbol, en el MANAGER** (3b-2e · E3; cierra el
      * agujero que declaró el 3b-2d).
@@ -279,12 +407,30 @@ export class AuthorizationManager {
         const finalReason = reason ?? 'una operación de plataforma';
         const holder = `${kind}:${process.pid}:${randomBytes(4).toString('hex')}`;
         const nowMs = root.#wallMs();
-        const token = await acquireFreeze({ reason: finalReason, holder, untilMs: leaseMs === null ? null : nowMs + leaseMs, nowMs }, { driver: this.#config.default });
-        if (token === null) {
-            const row = await readFreezeRow({ driver: this.#config.default });
+        // alpha.10 · S2 (+ cierre del auditor · R2): una ventana de OPERADOR
+        // caducada no se pisa en silencio. Una fila con el lease vencido se toma
+        // encima (así la flota vuelve sola tras un SIGKILL de una pasada), pero la
+        // del operador es EVIDENCIA: pisarla y soltarla después la deja a NULL y
+        // borra el único rastro de que las escrituras volvieron a entrar a mitad
+        // del cutover. La exclusión vive DENTRO del UPDATE de `acquireFreezeOutcome`
+        // (atómica): aquí solo se lee el veredicto y la fila para redactarlo — un
+        // «compruebo y luego tomo» con dos lecturas del reloj era un TOCTOU.
+        const outcome = await acquireFreezeOutcome({ reason: finalReason, holder, untilMs: leaseMs === null ? null : nowMs + leaseMs, nowMs }, { driver: this.#config.default });
+        if (outcome.status === 'expired-operator') {
+            const row = outcome.row;
+            const when = row.untilMs === null ? '?' : new Date(row.untilMs).toISOString();
+            throw new OperatorWindowExpiredError(`freeze (${reason ?? kind}): la ventana del OPERADOR (${row.holder ?? '?'}, ${row.reason}, fence ` +
+                `${row.fence}) CADUCÓ el ${when} y nadie la cerró: desde entonces las escrituras volvieron a entrar en ` +
+                `toda la flota. No se toma una ventana propia encima —borraría ese rastro al soltarla y la pasada se ` +
+                `certificaría como si hubiera corrido dentro del cutover—. Reconócela con authz:unfreeze (dice cuánto ` +
+                `tiempo estuvo abierta y limpia la fila) y reabre la ventana con authz:freeze antes de repetir.`);
+        }
+        if (outcome.status === 'held') {
+            const row = outcome.row;
             throw new FreezeHeldError(`freeze: ya hay un freeze VIVO de otro dueño (${row.holder ?? '?'}, fence ${row.fence}, motivo: ${row.reason ?? '?'}). ` +
                 `Espera a que termine, o levántalo con authz:unfreeze si su proceso murió sin lease.`);
         }
+        const token = outcome.token;
         const held = { token, reason: finalReason, kind, leaseMs, timer: null, lapsed: false };
         if (leaseMs !== null) {
             const interval = Math.max(250, Math.floor(leaseMs / 3));
@@ -345,6 +491,39 @@ export class AuthorizationManager {
     get frozen() {
         return this.#root().#heldFreeze !== null;
     }
+    /**
+     * La clave (en `relations.drivers`) del driver de RELACIONES activo:
+     * `relations.default ?? default` (2.4.0-alpha.10). La lee el guard de la
+     * dirección rancia de `runRelationsReconcile`; desde el cierre del auditor
+     * (R4) el llamante ya no puede contradecirla con un `activeKey` propio.
+     */
+    relationsDriverKey() {
+        return activeRelationsDriverKey(this.#root().#config);
+    }
+    /** Las claves registradas en `relations.drivers` del config de ESTE manager (vacío si no hay relaciones). */
+    relationsDriverKeys() {
+        return Object.keys(this.#root().#config.relations?.drivers ?? {});
+    }
+    /**
+     * La factory registrada bajo `key` en `relations.drivers` de ESTE manager, o
+     * `undefined` (cierre del auditor de alpha.10 · R4). `runRelationsReconcile`
+     * resuelve el origen y el destino por aquí —del MISMO config que decide el
+     * activo— y juzga la identidad por la factory resuelta, no por la etiqueta:
+     * dos claves con la misma factory son el mismo driver (y dos factories DISTINTAS
+     * sobre el mismo backend NO: límite declarado, cierre-2 · C1).
+     *
+     * **API de PLATAFORMA, junto a `driver()`** (cierre-2 · C6): con esta factory
+     * cualquier código que tenga el manager —vistas de `forRequest()` incluidas—
+     * construye un driver de relaciones NO activo y escribe en él sin `assertWrite`,
+     * `requireActor`, freeze ni `onRelationWrite`. No añade capacidad (el config ya
+     * da las factories), pero es otra cosa que buscar en una revisión.
+     */
+    relationsDriverFactory(key) {
+        const drivers = this.#root().#config.relations?.drivers;
+        if (drivers === undefined || !Object.prototype.hasOwnProperty.call(drivers, key))
+            return undefined;
+        return drivers[key];
+    }
     /** El freeze VIVO de la fila compartida, o `null`. Lo lee cualquiera; solo el token lo levanta. */
     async freezeStatus() {
         const row = await readFreezeRow({ driver: this.#config.default });
@@ -352,12 +531,42 @@ export class AuthorizationManager {
             return null;
         return {
             reason: row.reason,
-            holder: row.holder ?? '?',
+            holder: row.holder ?? UNKNOWN_HOLDER,
             kind: freezeKindOf(row.holder),
             untilMs: row.untilMs,
             fence: row.fence,
         };
     }
+    /**
+     * **La ÚLTIMA ventana de la fila, también la CADUCADA** (2.4.0-alpha.10, 🟠 2
+     * del sexto informe de COGNITIV). `freezeStatus()` responde solo lo VIVO —y
+     * así lo siguen usando la barrera y los comandos—, de modo que una ventana
+     * cuyo lease venció era indistinguible de «nunca hubo»: `authz:unfreeze`
+     * decía éxito y el último paso del cutover no delataba que las escrituras
+     * habían vuelto a entrar a mitad. Se distingue por la fila: `releaseFreeze`
+     * pone el motivo a `null` al levantar, así que motivo puesto + `untilMs` en
+     * el pasado es una ventana que CADUCÓ sin que nadie la cerrase.
+     *
+     * `null` = nunca hubo o ya se levantó; `expired: false` = viva (lo mismo que
+     * `freezeStatus()`); `expired: true` = caducada. `checkedAtMs` es el instante
+     * del reloj del config con el que se decidió.
+     */
+    async lastFreezeStatus() {
+        const row = await readFreezeRow({ driver: this.#config.default });
+        if (row.reason === null)
+            return null;
+        const nowMs = this.#root().#wallMs();
+        return {
+            reason: row.reason,
+            holder: row.holder ?? UNKNOWN_HOLDER,
+            kind: freezeKindOf(row.holder),
+            untilMs: row.untilMs,
+            fence: row.fence,
+            expired: !freezeIsLive(row, nowMs),
+            // El instante (reloj del config) con el que se decidió `expired`.
+            checkedAtMs: nowMs,
+        };
+    }
     /**
      * `freeze()` + `finally unfreeze(token)`. El `finally` es la parte que
      * importa: una migración que revienta a la mitad no puede dejar la
@@ -366,10 +575,22 @@ export class AuthorizationManager {
      * A1.1/A1.3): si este manager ya sostiene el freeze, la ventana interior
      * no toma otro ni lo levanta al salir — la exterior sigue en pie.
      */
-    async withFrozenWrites(reason, fn) {
-        const context = await this.#durableFreezeContext(reason, 'platform', { operatorAsContext: false });
+    async withFrozenWrites(reason, fn, options = {}) {
+        // L-1 · J1: una pasada que quiera correr DENTRO de la ventana del
+        // operador (el cutover) y publicar su `lapsed` —`authz:relations:reconcile`,
+        // que vive fuera de este manager— pide `kind: 'reconcile'` y
+        // `operatorAsContext: true`, lo mismo que hace `reconcile` de roles.
+        const context = await this.#durableFreezeContext(reason, options.kind ?? 'platform', {
+            operatorAsContext: options.operatorAsContext === true,
+        });
         try {
-            return await fn();
+            return await fn({
+                fence: context.fence,
+                leaseMs: context.leaseMs,
+                lapsed: context.lapsed,
+                ...(context.untilMs === undefined ? {} : { untilMs: context.untilMs }),
+                ...(context.window === undefined ? {} : { window: context.window }),
+            });
         }
         finally {
             await context.release();
@@ -395,6 +616,7 @@ export class AuthorizationManager {
             return {
                 fence: outer.token.fence,
                 leaseMs: outer.leaseMs,
+                window: 'enclosing',
                 release: async () => { },
                 lapsed: () => root.#tokenLapsed(outer.token, outer.lapsed),
             };
@@ -403,9 +625,14 @@ export class AuthorizationManager {
             const status = await this.freezeStatus();
             if (status !== null && status.kind === 'operator') {
                 const token = { fence: status.fence, holder: status.holder };
+                // alpha.10 · 3: la caducidad REAL de la ventana adoptada. Hasta alpha.9
+                // `leaseMs: null` fijo — el reporte decía «sin caducidad» de una ventana
+                // abierta con `--lease-ms` (la certificación sí leía la fila).
                 return {
                     fence: status.fence,
-                    leaseMs: null,
+                    leaseMs: status.untilMs === null ? null : Math.max(0, status.untilMs - root.#wallMs()),
+                    untilMs: status.untilMs,
+                    window: 'operator',
                     release: async () => { },
                     lapsed: () => root.#tokenLapsed(token, false),
                 };
@@ -416,6 +643,7 @@ export class AuthorizationManager {
         return {
             fence: token.fence,
             leaseMs: held.leaseMs,
+            window: 'own',
             release: async () => {
                 try {
                     await this.unfreeze(token);
@@ -454,25 +682,23 @@ export class AuthorizationManager {
      * freeze, y con `catalogRevalidate: { everyMs }` la fila del memo ni se
      * lee.
      */
-    async #assertNotFrozen(operation, transaction) {
+    async #assertNotFrozen(operation) {
         const root = this.#root();
         const held = root.#heldFreeze;
         if (held) {
             throw new AuthorizationFrozenError(`${operation}: el motor de autorización está congelado (${held.reason}) y no acepta escrituras. ` +
                 `Las lecturas siguen funcionando; reintenta esta escritura cuando la operación termine.`);
         }
-        // Si la escritura llegó con la TRANSACCIÓN del consumidor, la fila se lee
-        // por ella: exigir una segunda conexión con la suya abierta interbloquea
-        // un pool de 1 (SQLite `:memory:`). El precio va declarado en freeze.ts.
-        const client = transaction && typeof transaction.from === 'function'
-            ? transaction
-            : undefined;
-        const row = await readFreezeRow({ driver: this.#config.default, client });
-        if (!freezeIsLive(row, root.#wallMs()))
-            return;
-        const lift = freezeKindOf(row.holder) === 'operator' ? ' (la levanta authz:unfreeze)' : '';
-        throw new AuthorizationFrozenError(`${operation}: el motor de autorización está congelado (${row.reason})${lift} y no acepta escrituras. ` +
-            `Las lecturas siguen funcionando; reintenta esta escritura cuando la ventana termine.`);
+        // La fila se lee SIEMPRE por la conexión del motor (L-1 · 🟠 8). Hasta
+        // L-1 se leía por la transacción del consumidor si la escritura llegaba
+        // con una —«para no interbloquear un pool de 1»—, y eso era el agujero:
+        // la barrera la decidía el snapshot del llamante (medido en SQLite, MySQL
+        // y PG). Con pool 1 el precio es un 503 con deadline, no un bypass.
+        await assertNotFrozenRow(operation, {
+            driver: this.#config.default,
+            nowMs: root.#wallMs(),
+            timeoutMs: this.#config.freezeTimeoutMs,
+        });
     }
     /** Solo tests: fuerza re-resolución del driver. */
     clearCachedDriver() {
@@ -529,10 +755,11 @@ export class AuthorizationManager {
             await this.#assertWithinOrigin(child, options, 'scopes.attached', 'if-known');
             const outbox = this.#outbox();
             if (outbox) {
-                await outbox.enqueue({ op: 'attached', child: edge.child, parent: edge.chain[0] }, { transaction: options?.transaction, ...actor });
-                return;
+                const receipt = await outbox.enqueue({ op: 'attached', child: edge.child, parent: edge.chain[0] }, { transaction: options?.transaction, ...actor });
+                return _a.#receiptOf([receipt]);
             }
             await (await this.driver()).onScopeAttached?.(child, parent);
+            return { queued: [] };
         },
         /**
          * `moved` NO vuelve a juzgar el catálogo, y no tiene por qué (3b-1 · D3,
@@ -554,10 +781,11 @@ export class AuthorizationManager {
             await this.#assertWithinOrigin(child, options, 'scopes.moved', 'required');
             const outbox = this.#outbox();
             if (outbox) {
-                await outbox.enqueue({ op: 'moved', child: edge.child, parent: edge.chain[0] }, { transaction: options?.transaction, ...actor });
-                return;
+                const receipt = await outbox.enqueue({ op: 'moved', child: edge.child, parent: edge.chain[0] }, { transaction: options?.transaction, ...actor });
+                return _a.#receiptOf([receipt]);
             }
             await (await this.driver()).onScopeMoved?.(child, newParent);
+            return { queued: [] };
         },
         /**
          * Hechos primero (el driver demuestra cero o lanza), arista después
@@ -611,10 +839,12 @@ export class AuthorizationManager {
                 // La identidad se resuelve AQUÍ, con la fila del consumidor todavía
                 // viva si la hay: al relevar el cambio ya no resolvería. Y no se
                 // audita `scope_purged` todavía, porque todavía no ha pasado nada.
+                // El recibo es PLURAL por esto mismo: una fila por ortografía.
+                const receipts = [];
                 for (const target of targets) {
-                    await outbox.enqueue({ op: 'detached', child: target }, { transaction: options?.transaction, ...actor });
+                    receipts.push(await outbox.enqueue({ op: 'detached', child: target }, { transaction: options?.transaction, ...actor }));
                 }
-                return;
+                return _a.#receiptOf(receipts);
             }
             const driver = await this.driver();
             for (const purged of targets) {
@@ -623,8 +853,23 @@ export class AuthorizationManager {
                 await driver.onScopeDetached?.(purged);
                 await this.#notify(event);
             }
+            return { queued: [] };
         },
     };
+    /**
+     * El recibo del encolado (alpha.5 · R1): los ids que la outbox devolvió,
+     * en orden. Una outbox que devuelve `void` (terceros anteriores a alpha.5)
+     * no deja id, y el recibo sale vacío: nunca se inventa uno.
+     */
+    static #receiptOf(receipts) {
+        const queued = [];
+        for (const receipt of receipts) {
+            if (receipt && typeof receipt === 'object' && (typeof receipt.id === 'number' || typeof receipt.id === 'string')) {
+                queued.push(receipt.id);
+            }
+        }
+        return { queued };
+    }
     /**
      * **Drena la outbox del árbol y aplica los cambios al driver** (3b-2d).
      * Es lo que hay detrás de `node ace authz:scopes:relay`.
@@ -668,8 +913,29 @@ export class AuthorizationManager {
      * **fail-open temporal** —el tenant antiguo conserva acceso tras un
      * `moved`, los denies heredados no aplican tras un `attached`—. No hay
      * 2PC; es el precio de tener el árbol en dos sitios.
+     *
+     * **`only` (2.4.0-alpha.5 · R1)**: relevar SOLO estas entradas —los ids del
+     * recibo de `scopes.*` que ESTE proceso acaba de recibir, jamás del cuerpo
+     * de una petición— sin leer la cola de los demás (medido: 4 507 ms → 19 ms
+     * con 500 entradas ajenas por delante). El orden por clave NO se relaja:
+     * antes de aplicar cada entrada pedida se sondea la cola ENTERA
+     * (`earlierPending`, o paginando `pending()` si la outbox no lo tiene) y,
+     * si hay una pendiente ANTERIOR que comparte clave de scope con ella, sale
+     * `deferred` con `depends-on:<id>` — nunca aplicada fuera de orden (el 🔴 1
+     * del panel relay, medido: un `attached(child, unit)` aplicado antes que su
+     * `moved(unit → orgB)` dejaba al editor de la org VIEJA autorizando sobre el
+     * hijo). `remaining` y `dead` siguen siendo GLOBALES. `only: []` es 500
+     * (un `filter` vacío del consumidor no puede acabar en drenaje ni en un
+     * reporte vacío en verde), y una outbox que no honre el filtro también.
+     *
+     * **Lo aparcado tapona por clave (alpha.5 · R2a)**: las claves de `dead()`
+     * siembran el bloqueo al inicio de la pasada para lo que CONCEDE o recuelga
+     * (`attached`/`moved`, `deferred` con `parked:<id>`) y dejan pasar lo que
+     * RETIRA (`detached`: una purga nunca queda bloqueada, invariante 11). Y un
+     * 503 del backend NO consume intento (`markFailed(..., { transient })`).
      */
     async relayScopeChanges(options = {}) {
+        _a.#assertKnownOptions('relayScopeChanges', options, RELAY_OPTIONS);
         // El relay ESCRIBE el árbol en el driver: durante una migración se aplaza
         // como cualquier otra escritura (lo que quede en la cola sigue ahí).
         await this.#assertNotFrozen('authz:scopes:relay');
@@ -681,138 +947,708 @@ export class AuthorizationManager {
         const limit = _a.#positive(options.limit, DEFAULT_RELAY_LIMIT, 'limit');
         const batchSize = _a.#positive(options.batchSize, DEFAULT_RELAY_BATCH, 'batchSize');
         const dryRun = options.dryRun === true;
-        /** Lo aparcado por la outbox, si sabe aparcar: se reporta SIEMPRE. */
-        const dead = await _a.#deadLetters(outbox, batchSize);
+        const waitForLeaseMs = _a.#waitMs(options.waitForLeaseMs);
+        if (options.deadDetail !== undefined && options.deadDetail !== 'full') {
+            throw new AuthorizationConfigError(`authz:scopes:relay: deadDetail solo admite 'full' (llegó ${JSON.stringify(options.deadDetail)}); sin él, bajo only, dead[] va sin error.`);
+        }
+        const inputs = await _a.#relayInputs(outbox, options.only, batchSize, options.deadDetail);
+        const { only, filter, dead, deadCount, deadEntries, unseenOf } = inputs;
         if (dryRun) {
-            const batch = await outbox.pending(limit);
+            const batch = await outbox.pending(limit, undefined, filter);
+            _a.#assertOnlyHonoured(batch, only);
             const extra = batch.length >= limit ? true : false;
+            const seen = new Set([...batch.map((b) => String(b.id)), ...deadEntries.map((d) => String(d.id))]);
+            const unseen = await unseenOf(seen);
+            // La edad es GLOBAL: sin filtro la cabeza es `batch[0]`; con `only` hay que mirar la cola entera.
+            const queue = filter === undefined ? this.#queueOf(batch[0]) : (await this.#queueStatus(outbox)).queue;
             return {
                 applied: [],
                 failed: null,
                 failures: [],
                 deferred: [],
                 dead,
+                deadCount,
+                queue,
                 busy: false,
                 remaining: batch.length > 0 || extra,
                 dryRun: true,
                 wouldApply: batch.map((item) => ({ id: item.id, change: item.change, attempts: item.attempts })),
+                entries: deadEntries,
+                ...unseen,
             };
         }
         // El lease del escritor ÚNICO. Una outbox que no sabe darlo se comporta
         // como hasta ahora (y el README dice que entonces el relay tiene que
-        // correr de uno en uno).
-        const lease = outbox.acquire ? await outbox.acquire() : null;
-        if (outbox.acquire && lease === null) {
+        // correr de uno en uno). Con `waitForLeaseMs` se reintenta hasta el tope.
+        const lease = await this.#acquireLease(outbox, waitForLeaseMs);
+        if (outbox.acquire && lease === null)
+            return this.#busyReport(outbox, inputs);
+        try {
+            return await this.#drainScopeChanges(outbox, { limit, batchSize, ...inputs });
+        }
+        finally {
+            await lease?.release();
+        }
+    }
+    /**
+     * Lo que una pasada necesita saber de la cola antes de tomar el lease
+     * (`only` normalizado, el filtro para el puerto, lo APARCADO —siempre
+     * global— y sus entradas para el reporte). Compartido por `relayScopeChanges`
+     * y por `requeueScopeChanges({ apply })` (2.4.0-alpha.8), que releva bajo
+     * el MISMO lease y necesita releer lo aparcado DESPUÉS de reencolar.
+     */
+    static async #relayInputs(outbox, onlyIds, batchSize, deadDetail) {
+        const only = _a.#onlyOf(onlyIds);
+        // Al puerto van los ids TAL CUAL los dio el llamante (el recibo); el
+        // conjunto de cadenas es solo para comparar sin depender del tipo.
+        const filter = only === undefined ? undefined : { ids: [...onlyIds] };
+        /** Lo aparcado por la outbox, si sabe aparcar: se reporta SIEMPRE, y GLOBAL. */
+        const read = await _a.#deadLetters(outbox, batchSize);
+        // Bajo `only` (2.4.0-alpha.8, coordinador): la lista sigue siendo global
+        // —ids, `change`, `attempts`— pero SIN `error` salvo `deadDetail: 'full'`:
+        // la causa es texto del backend sobre el árbol de otro tenant, y la receta
+        // inline corre dentro de una petición. Lo pedido (`deadEntries`) sí la
+        // lleva: es lo suyo.
+        const dead = only === undefined || deadDetail === 'full' ? read : read.map(({ error: _error, ...safe }) => safe);
+        // El censo COMPLETO (cierre alpha.5, 🟠 2): lo que `#parkedKeys` siembra y,
+        // desde 2.4.0-alpha.8, lo que cuenta `deadCount` (`dead.length` miente al
+        // llegar a `batchSize`). Una sola lectura de más, y solo si no cabía.
+        const census = dead.length < batchSize ? dead : await _a.#deadLetters(outbox, PARKED_CENSUS_MAX);
+        const deadCount = census.length;
+        /**
+         * Lo aparcado que se pidió (con `only`) o todo lo aparcado, para `entries`.
+         * Cierre-2 · C2 (gemelo): con `only` sale del CENSO completo si la lectura se
+         * cortó en `batchSize` — si no, un id pedido aparcado más allá del primer lote
+         * era `missing` («no estaba ni pendiente ni aparcado») estando aparcado.
+         */
+        const deadSource = only !== undefined && read.length >= batchSize ? census : read;
+        const deadEntries = deadSource
+            .filter((item) => only === undefined || only.has(String(item.id)))
+            .map((item) => ({
+            id: item.id,
+            change: item.change,
+            status: 'dead',
+            attempts: item.attempts,
+            ...(item.error === undefined ? {} : { reason: item.error }),
+        }));
+        /**
+         * **Qué fue de los ids pedidos que la pasada NO vio** (cierre-2 de alpha.10 ·
+         * C2). Hasta el cierre-2 todos eran `missing`; pero un id fuera del lote porque
+         * la pasada alcanzó `limit` sigue PENDIENTE. Se pregunta a la cola —filtrada por
+         * esos ids, sin límite propio, UNA lectura y solo si hay alguno sin ver—: lo que
+         * sigue pendiente es `notEvaluated`; el resto, `missing` (no está en la cola: lo
+         * aparcado ya está en `seen`).
+         */
+        const unseenOf = async (seen) => {
+            if (only === undefined)
+                return { missing: [], notEvaluated: [] };
+            const unseen = [...only.values()].filter((id) => !seen.has(id)).map((id) => _a.#rawId(onlyIds, id));
+            if (unseen.length === 0)
+                return { missing: [], notEvaluated: [] };
+            const stillPending = await outbox.pending(unseen.length, undefined, { ids: unseen });
+            _a.#assertOnlyHonoured(stillPending, new Set(unseen.map(String)));
+            const pendingIds = new Set(stillPending.map((item) => String(item.id)));
             return {
-                applied: [],
-                failed: null,
-                failures: [],
-                deferred: [],
-                dead,
-                busy: true,
-                remaining: (await outbox.pending(1)).length > 0,
-                dryRun: false,
-                wouldApply: [],
+                missing: unseen.filter((id) => !pendingIds.has(String(id))),
+                notEvaluated: unseen.filter((id) => pendingIds.has(String(id))),
             };
+        };
+        return { only, filter, dead, census, deadCount, deadEntries, unseenOf };
+    }
+    /** El reporte de una pasada que NO entró: otra tiene el lease. Nada aplicado, nada tocado. */
+    async #busyReport(outbox, inputs) {
+        const { remaining, queue } = await this.#queueStatus(outbox);
+        return {
+            applied: [],
+            failed: null,
+            failures: [],
+            deferred: [],
+            dead: inputs.dead,
+            deadCount: inputs.deadCount,
+            queue,
+            busy: true,
+            remaining,
+            dryRun: false,
+            wouldApply: [],
+            entries: inputs.deadEntries,
+            missing: [],
+            notEvaluated: [],
+        };
+    }
+    /**
+     * **La cabeza GLOBAL de la cola y su edad** (2.4.0-alpha.8; panel relay 2,
+     * cuestión 5). Es el `pending(1)` que la pasada ya hacía al final para
+     * `remaining` —cero consultas nuevas—, leído SIN filtro aunque haya `only`:
+     * la edad, como `remaining` y `dead`, es de la cola entera. La edad la mide
+     * el reloj INYECTABLE del manager (`#wallMs`), nunca `Date.now()`.
+     */
+    async #queueStatus(outbox) {
+        const head = await outbox.pending(1);
+        return { remaining: head.length > 0, queue: this.#queueOf(head[0]) };
+    }
+    /**
+     * La edad de una cabeza: `Math.max(0, ahora − createdAt)` —nunca negativa:
+     * el sello lo puso el reloj de OTRA réplica, con su skew—; sin cabeza o sin
+     * `createdAt` (una outbox de terceros que no lo trae) ⇒ `null` en los dos
+     * campos, jamás `0` ni «ahora».
+     */
+    #queueOf(head) {
+        const createdAt = head?.createdAt;
+        if (!(createdAt instanceof Date) || Number.isNaN(createdAt.getTime()))
+            return { oldestPendingAt: null, pendingAgeMs: null };
+        return { oldestPendingAt: createdAt, pendingAgeMs: Math.max(0, this.#root().#wallMs() - createdAt.getTime()) };
+    }
+    /**
+     * **El lease del escritor único, con espera acotada** (2.4.0-alpha.8;
+     * `waitForLeaseMs`, panel relay 2, cuestión 7). Con `0` (el default) es
+     * UN intento y `null` = `busy`, como siempre — el caso «dos pasadas a la vez
+     * ⇒ busy» no cambia. Con un tope, reintenta `acquire()` cada
+     * `RELAY_LEASE_POLL_MS` hasta vencerlo: `busy` al vencer, jamás un cuelgue.
+     * El reloj es el inyectable del manager (nunca `Date.now()` en `src/`).
+     * Exige pool ≥ 2 (README): con pool 1 el que espera puede estar reteniendo
+     * la única conexión que necesita el que tiene el lease.
+     */
+    async #acquireLease(outbox, waitForLeaseMs) {
+        if (!outbox.acquire)
+            return null;
+        let lease = await outbox.acquire();
+        if (lease !== null || waitForLeaseMs <= 0)
+            return lease;
+        const deadline = this.#root().#wallMs() + waitForLeaseMs;
+        // Dos topes a la vez: el reloj de pared (inyectable) y el NÚMERO de sondeos —
+        // con un reloj fijo el primero no vence jamás (medido por el auditor de alpha.8).
+        const maxPolls = Math.ceil(waitForLeaseMs / RELAY_LEASE_POLL_MS);
+        for (let polls = 0; lease === null && polls < maxPolls && this.#root().#wallMs() < deadline; polls++) {
+            await new Promise((resolve) => setTimeout(resolve, RELAY_LEASE_POLL_MS));
+            lease = await outbox.acquire();
+        }
+        return lease;
+    }
+    /** `waitForLeaseMs` normalizado: entero >= 0 (500 si no); ausente = 0. */
+    static #waitMs(value) {
+        if (value === undefined)
+            return 0;
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+            throw new AuthorizationConfigError(`authz:scopes:relay: waitForLeaseMs debe ser un entero >= 0 en milisegundos (llegó ${String(value)})`);
         }
-        try {
-            const driver = await this.driver();
-            const applied = [];
-            const deferred = [];
-            const failures = [];
-            /** Claves de scope contaminadas: lo que las toque se aplaza. */
-            const blocked = new Set();
-            // Una outbox que no marca lo aplicado devolvería el mismo pendiente
-            // para siempre: el relay no puede quedarse dando vueltas ni
-            // "arreglarlo" por su cuenta, así que lo denuncia (500) en cuanto
-            // vuelve a ver un id que YA aplicó.
-            const done = new Set();
-            /** Ids que esta pasada dejó a propósito (fallo o aplazo): reaparecen. */
-            const parked = new Set();
-            /** El último id visto: la outbox pagina desde ahí (lo saltado se queda). */
-            let after;
-            outer: while (applied.length < limit) {
-                // **La barrera del freeze se RE-AFIRMA por lote** (3b-8 · B3). La
-                // mirada única de la entrada dejaba hasta `DEFAULT_RELAY_LIMIT`
-                // (10.000) escrituras de árbol colándose DESPUÉS de que otra pasada
-                // adquiriera el freeze durable: escrituras que no salen en ningún
-                // contador de la pasada certificada y que pueden invalidar su
-                // resultado. El trade-off documentado en freeze.ts cubre «una
-                // escritura que ya pasó su barrera», no una pasada entera. El coste
-                // (una lectura de la fila `id=2` por lote; 0,14 ms/escritura ya
-                // medidos y aceptados) va fuera del camino caliente. Un freeze
-                // adquirido a mitad corta AQUÍ con el 503 reintentable de siempre:
-                // lo ya aplicado está marcado en la outbox (la pasada es reanudable)
-                // y el resto sigue pendiente para después de la ventana.
-                await this.#assertNotFrozen('authz:scopes:relay');
-                const batch = await outbox.pending(Math.min(batchSize, limit - applied.length), after);
-                if (batch.length === 0)
-                    break;
-                let progress = false;
-                for (const item of batch) {
-                    const id = String(item.id);
-                    if (done.has(id)) {
-                        throw new AuthorizationConfigError(`authz:scopes:relay: la outbox sigue devolviendo el cambio ${id} como pendiente después de markApplied. ` +
-                            'Tu implementación de ScopeOutbox no marca lo aplicado; el relay para antes de dar vueltas para siempre.');
-                    }
-                    if (parked.has(id))
-                        continue;
-                    progress = true;
-                    after = item.id;
-                    if (applied.length >= limit)
-                        break outer;
-                    const keys = _a.#changeKeys(item.change);
-                    const collision = keys.find((key) => blocked.has(key));
-                    if (collision !== undefined) {
-                        for (const key of keys)
-                            blocked.add(key);
-                        parked.add(id);
-                        deferred.push({
-                            id: item.id,
-                            change: item.change,
-                            attempts: item.attempts,
-                            error: `aplazado: depende de ${collision}, que quedó sin aplicar en esta pasada`,
-                        });
+        if (value > RELAY_WAIT_LEASE_MAX_MS) {
+            throw new AuthorizationConfigError(`authz:scopes:relay: waitForLeaseMs = ${value} supera el tope RELAY_WAIT_LEASE_MAX_MS (${RELAY_WAIT_LEASE_MAX_MS} ms): ` +
+                `una espera sin tope cuelga la petición del tenant; acorta la pasada (only/limit) en vez de esperar más.`);
+        }
+        return value;
+    }
+    /**
+     * **La pasada, ya con el lease tomado**: lo que hasta 2.4.0-alpha.7 era el
+     * cuerpo de `relayScopeChanges`. Compartida con `requeueScopeChanges({
+     * apply })`, que la llama bajo SU lease con `only` = los ids reencolados
+     * (auditor 🟠 5: tomar el lease dos veces era `busy` en verde).
+     */
+    async #drainScopeChanges(outbox, input) {
+        const { limit, batchSize, only, filter, dead, census, deadCount, deadEntries, unseenOf } = input;
+        const driver = await this.driver();
+        const applied = [];
+        const deferred = [];
+        const failures = [];
+        const entries = [];
+        /**
+         * Claves de scope contaminadas ⇒ el id que las contaminó y el ORIGEN del
+         * bloqueo (alpha.5 · cierre, auditor 🟠 1). `parked: true` = la causa
+         * raíz (transitiva) es una entrada APARCADA: tapona solo lo que concede
+         * o recuelga (`attached`/`moved`), NUNCA un `detached` — si no, un
+         * `attached` aplazado por aparcado congelaba la purga del nodo que el
+         * tenant ya borró, para siempre (medido: el scope conservaba sus hechos
+         * y su arista, y seguía concediendo; invariante 11). `parked: false` =
+         * un FALLO real de esta pasada (o una pendiente anterior no pedida):
+         * contamina todo, `detached` incluido — el orden entre un `attached`
+         * que falló y la purga de ese mismo nodo sigue importando (3b-2h).
+         */
+        const blocked = new Map();
+        /** Origen ya sondeado de entradas NO pedidas (alpha.6): `parked` = retenida solo por un aparcado. Se olvida en cuanto la pasada registra un bloqueo que no es de aparcado (podría contaminar una clave ya sondeada). */
+        const origins = new Map();
+        const block = (key, id, origin) => {
+            const current = blocked.get(key);
+            // Precedencia `failed > pending > parked` (2.4.0-alpha.8; desde el
+            // cierre de alpha.5: un fallo real pisa a un aparcado, nunca al revés).
+            if (current === undefined || BLOCK_RANK[origin] > BLOCK_RANK[current.origin])
+                blocked.set(key, { id, origin });
+            if (origin !== 'parked')
+                origins.clear();
+        };
+        /**
+         * **Las claves de lo APARCADO** (alpha.5 · R2a): taponan lo que concede
+         * o recuelga y dejan pasar lo que retira. El censo es COMPLETO —no
+         * depende de `limit` ni de `batchSize` (cierre, 🟠 2)— con su propia
+         * cota; el reporte sigue enseñando las primeras `batchSize`.
+         */
+        const parkedKeys = _a.#parkedKeys(census);
+        // Una outbox que no marca lo aplicado devolvería el mismo pendiente
+        // para siempre: el relay no puede quedarse dando vueltas ni
+        // "arreglarlo" por su cuenta, así que lo denuncia (500) en cuanto
+        // vuelve a ver un id que YA aplicó.
+        const done = new Set();
+        /** Ids que esta pasada dejó a propósito (fallo o aplazo): reaparecen. */
+        const parked = new Set();
+        /** El último id visto: la outbox pagina desde ahí (lo saltado se queda). */
+        let after;
+        const defer = (item, keys, reason, error, origin) => {
+            for (const key of keys)
+                block(key, item.id, origin);
+            parked.add(String(item.id));
+            deferred.push({ id: item.id, change: item.change, attempts: item.attempts, error });
+            // `origin` se DERIVA del bloqueo (2.4.0-alpha.8), jamás del prefijo de `reason`.
+            entries.push({ id: item.id, change: item.change, status: 'deferred', reason, attempts: item.attempts, origin });
+        };
+        outer: while (applied.length < limit) {
+            // **La barrera del freeze se RE-AFIRMA por lote** (3b-8 · B3). La
+            // mirada única de la entrada dejaba hasta `DEFAULT_RELAY_LIMIT`
+            // (10.000) escrituras de árbol colándose DESPUÉS de que otra pasada
+            // adquiriera el freeze durable: escrituras que no salen en ningún
+            // contador de la pasada certificada y que pueden invalidar su
+            // resultado. El trade-off documentado en freeze.ts cubre «una
+            // escritura que ya pasó su barrera», no una pasada entera. El coste
+            // (una lectura de la fila `id=2` por lote; 0,14 ms/escritura ya
+            // medidos y aceptados) va fuera del camino caliente. Un freeze
+            // adquirido a mitad corta AQUÍ con el 503 reintentable de siempre:
+            // lo ya aplicado está marcado en la outbox (la pasada es reanudable)
+            // y el resto sigue pendiente para después de la ventana.
+            await this.#assertNotFrozen('authz:scopes:relay');
+            const batch = await outbox.pending(Math.min(batchSize, limit - applied.length), after, filter);
+            if (batch.length === 0)
+                break;
+            _a.#assertOnlyHonoured(batch, only);
+            let progress = false;
+            for (const item of batch) {
+                const id = String(item.id);
+                if (done.has(id)) {
+                    throw new AuthorizationConfigError(`authz:scopes:relay: la outbox sigue devolviendo el cambio ${id} como pendiente después de markApplied. ` +
+                        'Tu implementación de ScopeOutbox no marca lo aplicado; el relay para antes de dar vueltas para siempre.');
+                }
+                if (parked.has(id))
+                    continue;
+                progress = true;
+                after = item.id;
+                if (applied.length >= limit)
+                    break outer;
+                const keys = _a.#changeKeys(item.change);
+                // Una purga solo la frena un bloqueo cuyo origen sea un FALLO real;
+                // el que nace de un aparcado la deja pasar (invariante 11).
+                const collision = keys.find((key) => {
+                    const hit = blocked.get(key);
+                    return hit !== undefined && !(item.change.op === 'detached' && hit.origin === 'parked');
+                });
+                if (collision !== undefined) {
+                    const by = blocked.get(collision);
+                    defer(item, keys, `depends-on:${by.id}`, `aplazado: depende de ${collision}, que quedó sin aplicar en esta pasada (#${by.id})`, by.origin);
+                    continue;
+                }
+                // Lo aparcado tapona lo que CONCEDE o recuelga; una purga pasa.
+                if (item.change.op !== 'detached') {
+                    const parkedKey = keys.find((key) => parkedKeys.has(key));
+                    if (parkedKey !== undefined) {
+                        const by = parkedKeys.get(parkedKey);
+                        defer(item, keys, `parked:${by}`, `aplazado: depende de ${parkedKey}, que nombra la entrada APARCADA #${by} (parked:${by}); no se aplica hasta que alguien la mire`, 'parked');
                         continue;
                     }
-                    try {
-                        await this.#applyScopeChange(driver, item);
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        await outbox.markFailed(item.id, message);
-                        for (const key of keys)
-                            blocked.add(key);
-                        parked.add(id);
-                        failures.push({ id: item.id, change: item.change, error: message });
-                        continue;
+                }
+                // Con `only`, la sonda contra la cola ENTERA: una pendiente anterior
+                // que comparta clave y no se pidió ⇒ aplazado, nunca fuera de orden.
+                // **Y la sonda hereda el ORIGEN de esa anterior** (alpha.6, auditor 🟡 A
+                // de alpha.5): si la anterior está —transitivamente— retenida solo por
+                // un APARCADO, es el mismo bloqueo `parked:` que en la pasada completa
+                // deja pasar la purga (invariante 11): el `detached` SE APLICA. Si la
+                // anterior es un `attached`/`moved` pendiente de verdad (aplicable, o
+                // retenido por un FALLO real), el `detached` sigue `deferred`: aplicarlo
+                // antes que un `moved` pendiente del mismo scope dejaría deriva.
+                if (only !== undefined) {
+                    const earlier = await this.#dependencyOf(outbox, item, batchSize);
+                    if (earlier !== null) {
+                        const origin = await this.#blockOriginOf(outbox, earlier, blocked, parkedKeys, batchSize, origins);
+                        if (!(item.change.op === 'detached' && origin === 'parked')) {
+                            const shared = _a.#changeKeys(earlier.change).find((key) => keys.includes(key)) ?? keys[0];
+                            defer(item, keys, `depends-on:${earlier.id}`, `aplazado: depende de ${shared}, que nombra la entrada anterior #${earlier.id} todavía sin aplicar (depends-on:${earlier.id}); ` +
+                                (origin === 'parked' ? 'espera a una entrada APARCADA; mira dead()' : 'corre el relay completo'), origin);
+                            continue;
+                        }
                     }
-                    await outbox.markApplied(item.id);
-                    done.add(id);
-                    applied.push({ id: item.id, change: item.change, attempts: item.attempts });
                 }
-                // 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
-                // haya detrás, sigue pendiente para la siguiente).
-                if (!progress)
-                    break;
+                try {
+                    await this.#applyScopeChange(driver, item);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    const transient = _a.#isTransientRelayFailure(error);
+                    await outbox.markFailed(item.id, message, { transient });
+                    for (const key of keys)
+                        block(key, item.id, 'failed');
+                    parked.add(id);
+                    failures.push({ id: item.id, change: item.change, error: message, transient });
+                    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 });
             }
-            return {
-                applied,
-                failed: failures[0] ?? null,
-                failures,
-                deferred,
-                dead,
-                busy: false,
-                remaining: (await outbox.pending(1)).length > 0,
-                dryRun: false,
-                wouldApply: [],
-            };
+            // 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
+            // haya detrás, sigue pendiente para la siguiente).
+            if (!progress)
+                break;
+        }
+        entries.push(...deadEntries);
+        // La cabeza global de la cola: `remaining` y, desde alpha.8, su EDAD.
+        const { remaining, queue } = await this.#queueStatus(outbox);
+        return {
+            applied,
+            failed: failures[0] ?? null,
+            failures,
+            deferred,
+            dead,
+            deadCount,
+            queue,
+            busy: false,
+            remaining,
+            dryRun: false,
+            wouldApply: [],
+            entries,
+            ...(await unseenOf(new Set(entries.map((e) => String(e.id))))),
+        };
+    }
+    /**
+     * `only` normalizado (alpha.5 · R1): un conjunto de ids como cadena (el id
+     * de `sqlScopeOutbox` es un entero que según el motor y el driver llega
+     * como `number` o como `string`; comparar con `===` sería un no-op
+     * silencioso). `undefined` = sin filtro. **`[]` es 500**, nunca «sin
+     * filtro»: un `filter` vacío del consumidor —o una outbox de terceros sin
+     * recibo, que deja `queued: []`— no puede acabar drenando la cola entera
+     * bajo el lease de una petición HTTP, ni en un reporte vacío en verde.
+     */
+    static #onlyOf(only) {
+        if (only === undefined)
+            return undefined;
+        if (!Array.isArray(only) || only.some((id) => typeof id !== 'number' && typeof id !== 'string')) {
+            throw new AuthorizationConfigError(`authz:scopes:relay: 'only' debe ser una lista de ids (number | string); llegó ${JSON.stringify(only)}`);
+        }
+        if (only.length === 0) {
+            throw new AuthorizationConfigError("authz:scopes:relay: 'only' está vacío. Un recibo vacío significa que no hay nada que relevar (sin outbox el cambio ya " +
+                'se aplicó en línea; con una outbox de terceros sin recibo no hay `only`): relevar «nada» no es relevar «todo». ' +
+                'Quita `only` para drenar la cola entera.');
+        }
+        return new Set(only.map(String));
+    }
+    /** El id tal como lo pasó el llamante en `only` (para `missing`). */
+    static #rawId(only, key) {
+        return only.find((id) => String(id) === key) ?? key;
+    }
+    /**
+     * Una outbox que IGNORA `filter.ids` devuelve lo que no se pidió: el
+     * backlog ajeno se aplicaría dentro de la petición del consumidor, en
+     * silencio. Se detecta y se para (500), como el `markApplied` no honrado.
+     */
+    static #assertOnlyHonoured(batch, only) {
+        if (only === undefined)
+            return;
+        const stranger = batch.find((item) => !only.has(String(item.id)));
+        if (stranger !== undefined) {
+            throw new AuthorizationConfigError(`authz:scopes:relay: la outbox devolvió el cambio ${String(stranger.id)}, que no está en 'only'. ` +
+                'Tu implementación de ScopeOutbox no honra `pending(limit, after, { ids })`: el relay para antes de aplicar ' +
+                '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
+     * cabe entero en un lote (menos de `batchSize` filas = no hay más); si no,
+     * la cola ENTERA hasta `PARKED_CENSUS_MAX` — nunca acotado por `limit`
+     * (cierre, 🟠 2: con `--limit 50` o `{ only, limit: 1 }` la aparcada 101 no
+     * taponaba y el `attached` colgaba del padre viejo)—, y si la cota se
+     * alcanza la pasada se niega (500): un tapón incompleto no es un tapón.
+     */
+    static #parkedKeys(census) {
+        if (census.length >= PARKED_CENSUS_MAX) {
+            throw new AuthorizationConfigError(`authz:scopes:relay: la outbox tiene ${PARKED_CENSUS_MAX} o más entradas APARCADAS y el censo de sus claves no cabe ` +
+                `(PARKED_CENSUS_MAX): sin el censo entero el tapón por clave sería ciego y un attached podría colgarse del padre ` +
+                `VIEJO. No se ha aplicado nada. Mira dead(), reencola o reconcilia antes de volver a relevar.`);
+        }
+        const keys = new Map();
+        for (const item of census) {
+            // **Solo la clave del HIJO** (2.4.0-alpha.8 · variante B; dueño: sí).
+            // Una aparcada dice que la POSICIÓN DE SU HIJO en el store es
+            // incorrecta; no dice nada de su padre nuevo: un `attached(otraUnit,
+            // orgA)` detrás de un `moved(unit → orgA)` aparcado escribe otra arista
+            // y conmuta (medido, `m7-tapon.ts`: se aplazaba sin motivo y el store
+            // conservaba el padre VIEJO de todo lo que colgara de orgA). Lo que SÍ
+            // nombra al hijo —`attached(child, unit)`, `moved(unit → orgC)`— sigue
+            // taponado. Vive SOLO aquí, en la siembra: al COMPARAR (`#changeKeys`
+            // en `blocked`, el respaldo de la sonda) van siempre las dos claves, o
+            // el caso 1136 se pierde (trampa medida por el juez).
+            const key = scopeKey(item.change.child);
+            if (!keys.has(key))
+                keys.set(key, item.id);
+        }
+        return keys;
+    }
+    /**
+     * **La sonda de dependencia de `only`** (alpha.5 · R1): la pendiente más
+     * antigua ANTERIOR a `item` que comparta clave de scope con ella, o `null`.
+     * Con `earlierPending` es una consulta de existencia (0,69 ms medidos);
+     * sin ella se pagina `pending()` desde el principio hasta `item.id` —
+     * correcto, O(cola)— y si la cola no se deja recorrer en
+     * `RELAY_WINDOW_MAX_PAGES` lotes se para (500 nombrando el método), nunca
+     * se aplica sin saber.
+     */
+    async #dependencyOf(outbox, item, batchSize) {
+        const keys = _a.#changeKeys(item.change);
+        if (typeof outbox.earlierPending === 'function') {
+            // La misma lista que `#changeKeys` (la raíz exenta, alpha.8): el SQL del
+            // puerto sí sabe casar `parent_type = 'app'`; el manager no se lo pide.
+            return outbox.earlierPending(item.id, _a.#changeScopes(item.change));
+        }
+        const mine = String(item.id);
+        let after;
+        for (let page = 0; page < RELAY_WINDOW_MAX_PAGES; page++) {
+            const batch = await outbox.pending(batchSize, after);
+            for (const earlier of batch) {
+                if (String(earlier.id) === mine)
+                    return null;
+                if (_a.#changeKeys(earlier.change).some((key) => keys.includes(key)))
+                    return earlier;
+            }
+            if (batch.length < batchSize)
+                return null;
+            after = batch[batch.length - 1].id;
+        }
+        throw new AuthorizationConfigError(`authz:scopes:relay: no se pudo sondear si el cambio ${mine} depende de una entrada anterior: la cola tiene más de ` +
+            `${RELAY_WINDOW_MAX_PAGES * batchSize} pendientes por delante y tu ScopeOutbox no implementa earlierPending(). ` +
+            'Implementa la sonda, o releva sin `only`.');
+    }
+    /**
+     * **El ORIGEN del bloqueo de una entrada NO pedida** (2.4.0-alpha.6): ¿en la
+     * pasada COMPLETA saldría `deferred` por un APARCADO —directo (`parked:`) o
+     * heredado (`depends-on:` de otra que lo está)— y no por un fallo real ni
+     * porque simplemente se aplicaría? `true` = retenida solo por un aparcado.
+     * Es la misma regla que aplica `block`/`defer` a lo que la pasada SÍ procesa,
+     * simulada hacia atrás sobre lo que no procesa:
+     *  1. una clave suya en `blocked` (esta pasada) con origen FALLO ⇒ fallo;
+     *  2. `attached`/`moved` con una clave en `parkedKeys`, o en `blocked` con
+     *     origen aparcado ⇒ aparcado;
+     *  3. si no, su propia anterior con clave compartida (`earlierPending`):
+     *     ninguna ⇒ se aplicaría ⇒ NO es aparcado (la pedida espera su turno);
+     *     alguna ⇒ el origen de ESA (recursivo, ids decrecientes, memoizado,
+     *     `RELAY_ORIGIN_MAX_HOPS`; pasada la cota ⇒ fallo, hacia lo seguro).
+     * Un `detached` anterior nunca es «aparcado» (una purga pasa; si sigue
+     * pendiente es porque se aplicará): la pedida espera detrás.
+     */
+    async #blockOriginOf(outbox, entry, blocked, parkedKeys, batchSize, memo, hops = 0) {
+        const id = String(entry.id);
+        const known = memo.get(id);
+        if (known !== undefined)
+            return known;
+        const decide = (origin) => {
+            memo.set(id, origin);
+            return origin;
+        };
+        // Pasada la cota, hacia lo seguro: como un fallo real.
+        if (hops >= RELAY_ORIGIN_MAX_HOPS)
+            return decide('failed');
+        const keys = _a.#changeKeys(entry.change);
+        const hits = keys.map((key) => blocked.get(key)).filter((hit) => hit !== undefined);
+        // Desde 2.4.0-alpha.8 el origen es TRI-estado (`failed > pending > parked`):
+        // la decisión aplicar/aplazar no cambia (solo `parked` exime a la purga);
+        // lo que cambia es que el reporte distingue «espera a una pendiente de
+        // verdad» de «bloqueada por un fallo».
+        if (hits.some((hit) => hit.origin === 'failed'))
+            return decide('failed');
+        if (hits.some((hit) => hit.origin === 'pending'))
+            return decide('pending');
+        if (entry.change.op !== 'detached') {
+            if (hits.length > 0 || keys.some((key) => parkedKeys.has(key)))
+                return decide('parked');
+        }
+        const earlier = await this.#dependencyOf(outbox, entry, batchSize);
+        // Ninguna anterior: se aplicaría en la pasada completa ⇒ la pedida espera a una PENDIENTE de verdad.
+        if (earlier === null)
+            return decide('pending');
+        return decide(await this.#blockOriginOf(outbox, earlier, blocked, parkedKeys, batchSize, memo, hops + 1));
+    }
+    /**
+     * **Devuelve entradas APARCADAS a la cola** (2.4.0-alpha.5 · R2b; panel
+     * relay, cuestión 2). Es lo que hay detrás de `node ace authz:scopes:requeue
+     * --id`. Operación de PLATAFORMA como `relayScopeChanges` y `driver()`: sin
+     * actor, sin `within`, **no se expone por HTTP**.
+     *
+     * **La sonda anti-reversión vive AQUÍ, no en la outbox**: reaplicar una
+     * entrada ANTERIOR a otra ya APLICADA sobre la misma clave de scope
+     * reescribe el árbol del store en un orden que nunca existió — el `moved`
+     * viejo tras el nuevo deja el padre VIEJO con UN solo padre, así que
+     * `assertOneParent` no lo delata y el tenant antiguo recupera el acceso
+     * (auditor 🔴 2, `relay-auditor-5.ts`, medido). Por eso, antes de tocar la
+     * cola, cada aparcada pedida se compara contra las aplicadas posteriores
+     * que compartan clave (`outbox.laterApplied`, espejo de `earlierPending`)
+     * y si hay alguna se NIEGA con 500 `E_AUTHZ_REQUEUE_REFUSED` nombrándola —
+     * todo o nada, cero filas tocadas—. El remedio correcto es
+     * `authz:reconcile --to=<driver>`, que recalcula con el árbol de HOY. La
+     * sonda es del manager porque necesita las claves del cambio
+     * (`#changeKeys`); `outbox.requeue` queda mecánico y una outbox de
+     * terceros la hereda gratis.
+     *
+     * **`force`** salta la sonda y devuelve el diff en `overrides`. Existe para
+     * el comando ace —que lo imprime y exige el flag explícito (decisión del
+     * dueño del 2026-09-09 (2))— y para nada más: llamarlo con `force: true`
+     * desde un endpoint es policy en una API sin policy.
+     *
+     * `attempts` queda en `maxAttempts − 1` (lo hace la outbox): si la causa
+     * sigue rota la entrada vuelve a aparcarse en UNA pasada y contamina su
+     * clave solo en esa pasada —un requeue automatizado de lo irreparable no
+     * es un grifo de aplazamiento permanente (auditor 🔴 2, segunda mitad)—; si
+     * el operador la arregló, entra a la primera. No hay bucle: lo aparcado no
+     * vuelve solo a `pending()`.
+     *
+     * Exige `dead`, `requeue` y `laterApplied` en el puerto (500
+     * `E_AUTHZ_UNSUPPORTED` nombrando el que falte): sin censo no se sabe qué
+     * se reencola y sin sonda no hay requeue. Sin `apply` no pasa por la
+     * barrera del freeze: no escribe en el backend; la pasada que aplique la
+     * entrada sí la pasa.
+     *
+     * **`apply: true` — reencolar Y relevar en la misma llamada** (2.4.0-alpha.8;
+     * panel relay 2, cuestión 4; decisión del dueño 2026-09-10 (4)). Medido
+     * (tester P14): la reencolada vuelve con su id ORIGINAL (menor) y la
+     * siguiente pasada `only` del tenant salía `deferred · depends-on:` — el
+     * incidente no se cerraba con un comando. Con `apply`, tras reencolar se
+     * releva SOLO eso (`only` = exactamente los ids reencolados: los
+     * dependientes NO se arrastran, quedan `deferred`/pendientes y el reporte lo
+     * dice —«`only` es mi recibo»—) y el reporte del relay viaja en
+     * `report.relay`. Cuatro condiciones, todas fijadas con caso: (1) **un solo
+     * lease** para toda la llamada (tomarlo dos veces era `busy` en verde,
+     * auditor 🟠 5) — se toma PRIMERO, y si está ocupado es `relay.busy` con
+     * CERO filas reencoladas (reencolar y decir `busy` dejaba `attempts = max −
+     * 1` y la entrada se volvía a aparcar contaminando su clave); (2) **pasa la
+     * barrera del freeze** ANTES de tocar nada (con `apply` escribe el árbol);
+     * (3) **excluyente con `force`** (500 juntos: con las dos, revertir el árbol
+     * pasaba de dos llamadas de plataforma a una, auditor 🟠 6); (4) la sonda
+     * anti-reversión corre ANTES de reencolar, como siempre. `waitForLeaseMs`
+     * (solo con `apply`) es la misma espera acotada que en el relay, para que
+     * el comando que cierra el incidente no pierda siempre contra el cron.
+     */
+    async requeueScopeChanges(ids, options = {}) {
+        _a.#assertKnownOptions('requeueScopeChanges', options, REQUEUE_OPTIONS);
+        const apply = options.apply === true;
+        if (apply && options.force === true) {
+            throw new AuthorizationConfigError('authz:scopes:requeue: apply y force no se combinan: con las dos, revertir el árbol del store por encima de lo ya ' +
+                'aplicado sería UNA sola llamada. Reencola con --force y releva después a sabiendas, o usa --apply sin --force. ' +
+                'No se ha hecho nada.');
+        }
+        if (!apply && options.waitForLeaseMs !== undefined) {
+            throw new AuthorizationConfigError('authz:scopes:requeue: waitForLeaseMs solo tiene sentido con apply (sin apply no se toma ningún lease). No se ha hecho nada.');
+        }
+        const waitForLeaseMs = _a.#waitMs(options.waitForLeaseMs);
+        // Con `apply` se ESCRIBE el árbol: la barrera del freeze va antes de nada.
+        if (apply)
+            await this.#assertNotFrozen('authz:scopes:requeue --apply');
+        const outbox = this.#outbox();
+        if (!outbox) {
+            throw new AuthorizationConfigError("authz:scopes:requeue necesita 'scopes.outbox' en config/authorization.ts: sin cola no hay nada aparcado que reencolar.");
+        }
+        const wanted = _a.#requeueIds(ids);
+        for (const method of ['dead', 'requeue', 'laterApplied']) {
+            if (typeof outbox[method] !== 'function') {
+                throw new UnsupportedOperationError(method, 'authz:scopes:requeue', 'scopes.outbox', method === 'laterApplied'
+                    ? 'Sin la sonda anti-reversión (laterApplied: las entradas APLICADAS posteriores que comparten clave) no hay ' +
+                        'requeue: reaplicar una entrada vieja por encima de una nueva revierte el árbol del store en silencio.'
+                    : method === 'dead'
+                        ? 'Sin dead() no se sabe qué está aparcado, y solo lo aparcado se reencola.'
+                        : 'Devuelve la entrada aparcada a pending() con attempts = maxAttempts − 1, todo o nada.');
+            }
+        }
+        // Con `apply`, el lease PRIMERO (una vez para toda la llamada): ocupado ⇒
+        // `busy` con cero filas tocadas. Sin `apply` no hay lease que tomar.
+        const lease = apply ? await this.#acquireLease(outbox, waitForLeaseMs) : null;
+        if (apply && outbox.acquire && lease === null) {
+            const inputs = await _a.#relayInputs(outbox, [...wanted], DEFAULT_RELAY_BATCH);
+            return { requeued: [], overrides: [], forced: false, relay: await this.#busyReport(outbox, inputs) };
+        }
+        try {
+            return await this.#requeueHeld(outbox, wanted, options.force === true, apply);
         }
         finally {
             await lease?.release();
         }
     }
+    /** `requeueScopeChanges` con el lease (si `apply`) ya tomado: censo, sonda anti-reversión, requeue y —con `apply`— el relay de esos ids. */
+    async #requeueHeld(outbox, wanted, force, apply) {
+        // El censo de lo aparcado (acotado como el del relay): solo eso se reencola.
+        const parked = await outbox.dead(DEFAULT_RELAY_LIMIT);
+        const byId = new Map();
+        for (const item of parked)
+            byId.set(String(item.id), item);
+        const unknown = wanted.filter((id) => !byId.has(String(id)));
+        if (unknown.length > 0) {
+            throw new AuthorizationConfigError(`authz:scopes:requeue: ${unknown.map(String).join(', ')} no está(n) aparcada(s) —no existe, ya se aplicó, o sigue ` +
+                `pendiente con intentos por gastar—: no se ha reencolado NADA (todo o nada). Solo se reencola lo que sale por ` +
+                `dead(); una entrada aplicada no revive jamás.`);
+        }
+        const conflicts = [];
+        for (const id of wanted) {
+            const item = byId.get(String(id));
+            // La misma lista que `#changeKeys` (la raíz exenta, alpha.8): dos altas de
+            // tenant no se revierten entre sí, y el conflicto que salía era falso.
+            const scopes = _a.#changeScopes(item.change);
+            // Se pide UNA de más para saber si el diff que va a leer el operador está cortado (cierre, ⚪ 6).
+            const later = await outbox.laterApplied(item.id, scopes, DEFAULT_RELAY_BATCH + 1);
+            const applied = later.slice(0, DEFAULT_RELAY_BATCH);
+            if (applied.length > 0) {
+                conflicts.push({ parked: item, applied, ...(later.length > DEFAULT_RELAY_BATCH ? { truncated: true } : {}) });
+            }
+        }
+        if (conflicts.length > 0 && !force) {
+            const detail = conflicts
+                .map((conflict) => {
+                const keys = _a.#changeKeys(conflict.parked.change);
+                const shared = conflict.applied.map((entry) => {
+                    const key = _a.#changeKeys(entry.change).find((k) => keys.includes(k)) ?? keys[0];
+                    return `#${entry.id} (${entry.change.op}, clave ${key})`;
+                });
+                return `#${conflict.parked.id} (${conflict.parked.change.op}) revertiría ${shared.join(', ')}`;
+            })
+                .join('; ');
+            throw new ScopeRequeueRefusedError(`authz:scopes:requeue: reencolar reaplicaría un cambio ANTERIOR a otro ya APLICADO sobre la misma clave de scope, ` +
+                `y el árbol del store quedaría en un orden que nunca existió: ${detail}. No se ha reencolado nada. ` +
+                `Para recalcular con el árbol de HOY: authz:reconcile --to=<driver>. Si de verdad quieres revertir, el comando ` +
+                `ace admite --force (imprime este diff y entra igual).`, conflicts);
+        }
+        await outbox.requeue([...wanted]);
+        const report = { requeued: wanted.map((id) => byId.get(String(id))), overrides: conflicts, forced: force };
+        if (!apply)
+            return report;
+        // Bajo el MISMO lease: solo los ids reencolados, con lo aparcado releído
+        // (las reencoladas ya no salen por `dead()`); la barrera del freeze se
+        // re-afirma por lote dentro, como en toda pasada.
+        const inputs = await _a.#relayInputs(outbox, [...wanted], DEFAULT_RELAY_BATCH);
+        report.relay = await this.#drainScopeChanges(outbox, { limit: DEFAULT_RELAY_LIMIT, batchSize: DEFAULT_RELAY_BATCH, ...inputs });
+        return report;
+    }
+    /** Los ids de `requeue`: lista NO vacía de números o cadenas, sin repetidos (500 si no). */
+    static #requeueIds(ids) {
+        if (!Array.isArray(ids) || ids.length === 0 || ids.some((id) => typeof id !== 'number' && typeof id !== 'string')) {
+            throw new AuthorizationConfigError(`authz:scopes:requeue: 'ids' debe ser una lista NO vacía de ids (number | string); llegó ${JSON.stringify(ids)}. ` +
+                'Sin ids no se reencola nada: «nada» no es «todo».');
+        }
+        const seen = new Set();
+        return ids.filter((id) => (seen.has(String(id)) ? false : (seen.add(String(id)), true)));
+    }
     /**
      * **`authz:reconcile --to=<driver>`** (3b-3a): la ÚNICA primitiva de
      * migración y verificación del paquete, y el motivo de la fase entera —
@@ -874,6 +1710,49 @@ export class AuthorizationManager {
             throw new UnsupportedOperationError('reconcile', `authz:reconcile --to=${name}`, name, `El driver '${name}' no sabe reconstruirse desde 'authz_*' + el árbol del consumidor. ` +
                 `El driver 'database' es ese caso a propósito: sus tablas son el ORIGEN.`);
         }
+        // **La dirección RANCIA** (2.4.0-alpha.10; 🔴 4 del sexto informe de
+        // COGNITIV y cuarta iteración del LINAJE «origen rancio del reconcile»:
+        // 3b-5 cerró la pasada por defecto, el primer guard de alpha.10 cerró
+        // `--from`, y quedaba abierto el origen elegido POR DESCARTE). Regla del
+        // dueño: el tercer defecto de un linaje se arregla estructuralmente, así
+        // que el guard NO mira la bandera, mira el ORIGEN RESUELTO — con la MISMA
+        // decisión que `#factsOrigin` (`#isMaintenancePass`), no con una copia:
+        // si `to` es el driver ACTIVO, el único origen legítimo es `to` mismo (la
+        // pasada de MANTENIMIENTO); cualquier otro —`--from`, el driver elegido por
+        // descarte o las tablas `authz_*`— dejó de ver los hechos en el cutover y la
+        // pasada re-escribiría lo revocado después (con o sin --prune; el seguro de
+        // borrado masivo no salta: el origen no está vacío). Se decide por `to`,
+        // nunca por `from`: el cutover inicial y la vuelta atrás ANTES de cambiar
+        // `default` tienen `to` ≠ activo y pasan. Antes de resolver el origen y de
+        // congelar. `--dry-run` no lanza (es el verificador): lo marca y
+        // `reconcileLines` lo hace deriva. `from === to` sigue siendo el 500
+        // E_AUTHZ_CONFIG de 3b-3b.
+        const stale = this.#sameDriver(name, this.#config.default) &&
+            (options.from === undefined || !this.#sameDriver(options.from, name)) &&
+            !this.#isMaintenancePass(name, target, options.from);
+        const allowStale = options.allowStaleSource === true;
+        if (stale && !allowStale && options.dryRun !== true) {
+            const how = options.from !== undefined ? `--from=${options.from}` : 'sin --from';
+            // Cierre del auditor (⚪ 8): con UN solo driver registrado no hay descarte que
+            // hacer; la letra no puede hablar de un origen que no existe.
+            const others = Object.keys(this.#config.drivers ?? {}).filter((key) => !this.#sameDriver(key, name));
+            const originLabel = options.from !== undefined
+                ? `el origen '${options.from}' no lo es`
+                : others.length === 0
+                    ? `no hay ningún otro driver registrado ni pasada de mantenimiento para él (no guarda sus hechos en su ` +
+                        `backend: no declara hierarchyFacts), así que no hay nada de dónde reconciliar hacia '${name}'`
+                    : `sin --from el origen se elegiría POR DESCARTE (las tablas authz_* u otro driver registrado: ` +
+                        `${others.join(', ')}), y no es '${name}'`;
+            throw new StaleSourceRefusedError(`authz:reconcile --to=${name} ${how}: '${name}' es el driver ACTIVO (config.default` +
+                `${name === this.#config.default ? '' : `: la clave resuelve la MISMA factory que '${this.#config.default}'`}) y ${originLabel}. ` +
+                `Esa dirección re-escribiría en el driver activo hechos que el origen ya no refleja: resucitaría las ` +
+                `revocaciones hechas desde el cutover (y con --prune borraría lo concedido después). No se ha leído, ` +
+                `congelado ni escrito nada. Hacia el driver activo el único origen es él mismo: la pasada de mantenimiento ` +
+                `(authz:reconcile --to=${name} [--dry-run], sin --from) si su driver guarda sus hechos; y si lo que quieres ` +
+                `es volver atrás, migra en la otra dirección ANTES de cambiar config.default. Si de verdad el origen sigue ` +
+                `siendo la fuente de verdad (el motor aún no ha escrito desde '${name}'), la decisión humana es ` +
+                `--allow-stale-source (allowStaleSource: true).`);
+        }
         // **De dónde salen los HECHOS** (3b-5): la decisión que faltaba, y la que
         // el destino no puede tomar por su cuenta. Ver `#factsOrigin`.
         const origin = await this.#factsOrigin(name, target, options.from);
@@ -885,6 +1764,18 @@ export class AuthorizationManager {
             // UNA vez.
             facts: origin.enumerate,
             factsOrigin: { name: origin.name, authzTables: origin.authzTables },
+            // El techo de profundidad del consumidor, si lo declaró (alpha.5 · R0):
+            // el mismo mando que el gate de `scopes.*`.
+            ...(this.#config.scopes?.maxDepth === undefined ? {} : { maxDepth: this.#config.scopes.maxDepth }),
+            // **Los tipos del OTRO subsistema del mismo backend** (alpha.9 · B · S4),
+            // si el consumidor declaró relaciones. Es SOLO para el reporte: parte lo
+            // ajeno en «declarado» y «no lo reclama nadie». La decisión de BORRAR no
+            // lo mira —la toma la lista blanca congelada del destino—, porque el
+            // proceso que corre un cutover puede no tener esta config y aun así
+            // tiene que respetar las tuplas de quien sí la tiene.
+            ...(this.#config.relations?.config === undefined
+                ? {}
+                : { relationTypes: this.#config.relations.config.objectTypes.map((type) => type.type) }),
         };
         const pass = async () => {
             const report = await target.reconcile(source, options);
@@ -894,6 +1785,8 @@ export class AuthorizationManager {
             // Quién fue el origen se DICE, siempre: es la diferencia entre una
             // migración y una pasada de mantenimiento contra el driver activo.
             report.factsFrom = origin.resolved();
+            if (stale)
+                report.staleSource = { to: name, from: origin.resolved(), allowed: allowStale };
             return report;
         };
         // La pasada que escribe congela; el verificador NO (ver el docblock).
@@ -917,6 +1810,8 @@ export class AuthorizationManager {
                 lapsed: await window.lapsed(),
                 leaseMs: window.leaseMs,
                 fence: window.fence,
+                ...(window.untilMs === undefined ? {} : { untilMs: window.untilMs }),
+                ...(window.window === undefined ? {} : { window: window.window }),
             };
             return report;
         }
@@ -944,7 +1839,9 @@ export class AuthorizationManager {
      *     MANTENIMIENTO: los hechos se leen del propio destino por el puerto
      *     (`enumerateFacts`), se rehace lo DERIVADO (marcador, catálogo, árbol)
      *     y se aplica el barrido de visibilidad del invariante 18 con el árbol
-     *     y el catálogo de HOY. No se inventa ni se borra un solo hecho. Un
+     *     y el catálogo de HOY. No se inventa ningún hecho; con `--prune` se
+     *     borran los que ya no respaldan nada (scopes que ya no resuelven,
+     *     caducados, roles/permisos retirados, y los que sobran). Un
      *     destino activo con `hierarchyFacts` que no sepa enumerar sus hechos
      *     es 500 `E_AUTHZ_UNSUPPORTED`: leerle `authz_*` sería justo el defecto.
      *  2. **`--from=<nombre>` manda**, y por eso se resuelve YA: de la
@@ -958,7 +1855,7 @@ export class AuthorizationManager {
      *     de 3b-3b (`#factsEnumerator`).
      */
     async #factsOrigin(to, target, from) {
-        if (from === undefined && to === this.#config.default && target.capabilities?.hierarchyFacts === true) {
+        if (this.#isMaintenancePass(to, target, from)) {
             if (typeof target.enumerateFacts !== 'function') {
                 throw new UnsupportedOperationError('enumerateFacts', `authz:reconcile --to=${to}`, to, `El motor SIRVE desde '${to}' y ese driver declara que el árbol y los hechos viven en su backend ` +
                     `(hierarchyFacts), así que 'authz_assignments'/'authz_denies' NO son la fuente de verdad de sus ` +
@@ -993,10 +1890,44 @@ export class AuthorizationManager {
         });
         return { name: AUTHZ_TABLES_ORIGIN, authzTables: true, enumerate, resolved: () => resolvedName };
     }
+    /**
+     * **¿Es la pasada de MANTENIMIENTO?** (3b-5; punto ÚNICO desde alpha.10): el
+     * destino es el driver ACTIVO, sus hechos viven en su backend
+     * (`hierarchyFacts`) y nadie nombró otro origen. Es la ÚNICA forma en la que
+     * el origen resuelto de una pasada hacia el driver activo es el propio
+     * destino, y la usan los dos que la necesitan: `#factsOrigin` (de dónde se
+     * leen los hechos) y el guard de la dirección rancia de `reconcile` (si ese
+     * origen es legítimo). Dos copias de esta condición eran dos respuestas.
+     */
+    #isMaintenancePass(to, target, from) {
+        return from === undefined && this.#sameDriver(to, this.#config.default) && target.capabilities?.hierarchyFacts === true;
+    }
+    /**
+     * **¿Dos claves de `drivers` son el MISMO driver?** (cierre del auditor de
+     * alpha.10 · R4, gemelo de roles): misma clave o la MISMA factory registrada
+     * bajo dos claves. El guard de la dirección rancia, el mantenimiento, el
+     * `from === to` y el descarte juzgan la identidad RESUELTA, no la etiqueta:
+     * con `drivers: { openfga: f, fga: f }` y `default: 'openfga'`, `--to=fga
+     * --from=database` es la misma dirección rancia que `--to=openfga`.
+     *
+     * **Límite DECLARADO (cierre-2 · C1)**: la identidad es la REFERENCIA de la
+     * factory, no el backend. Dos factories distintas que construyen el mismo
+     * store (`openfga: () => new OpenFga…(…)`, `fga: () => new OpenFga…(…)`) NO son
+     * el mismo driver para este predicado y el alias pasa el guard. Identidad de
+     * backend declarada por el driver ⇒ roadmap 2.5.
+     */
+    #sameDriver(a, b) {
+        if (a === b)
+            return true;
+        const drivers = this.#config.drivers ?? {};
+        const own = (key) => (Object.prototype.hasOwnProperty.call(drivers, key) ? drivers[key] : undefined);
+        const fa = own(a);
+        return fa !== undefined && fa === own(b);
+    }
     /** El driver que `--from` nombra, con los dos errores de 3b-3b intactos. */
     async #originDriver(from, to) {
         const registered = Object.keys(this.#config.drivers ?? {});
-        if (from === to) {
+        if (this.#sameDriver(from, to)) {
             throw new AuthorizationConfigError(`authz:reconcile --from=${from} --to=${to}: el origen y el destino son el mismo driver. ` +
                 `Si lo que quieres es VERIFICAR y reparar lo derivado del driver activo, no lo digas con --from: ` +
                 `la pasada ya lee sus hechos de él cuando es el driver por defecto.`);
@@ -1032,7 +1963,7 @@ export class AuthorizationManager {
             const registered = Object.keys(this.#config.drivers ?? {});
             const candidates = [];
             for (const candidate of registered) {
-                if (candidate === to)
+                if (this.#sameDriver(candidate, to))
                     continue;
                 const driver = await this.#config.drivers[candidate]();
                 if (typeof driver.enumerateFacts === 'function')
@@ -1101,11 +2032,42 @@ export class AuthorizationManager {
      * comparten ninguna no pueden interactuar en el árbol —toda dependencia
      * (recolgar, cerrar un ciclo, purgar) viaja por un nodo nombrado—, así que
      * el orden RELATIVO que hay que conservar es exactamente este.
+     *
+     * **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
+     * 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:
+     * una aparcada bajo la raíz congelaba el registro entero (5 pasadas con
+     * `applied = []`, medido en un consumidor), dos altas concurrentes con la
+     * receta inline dejaban la segunda `deferred` SIN nada aparcado, y
+     * `requeue` se negaba con un conflicto falso. Se decide por REF
+     * (`#isRootRef`), nunca por la cadena `'app'`, y en los TRES sitios que
+     * construyen la lista: aquí, `#dependencyOf` y `requeueScopeChanges` (los
+     * dos por `#changeScopes`); también para el bloqueo por FALLO (una sola
+     * regla). La lista nunca queda vacía: el hijo siempre va.
      */
     static #changeKeys(change) {
-        return change.op === 'detached'
-            ? [scopeKey(change.child)]
-            : [scopeKey(change.child), scopeKey(change.parent)];
+        return _a.#changeScopes(change).map((scope) => scopeKey(scope));
+    }
+    /**
+     * Los scopes de `#changeKeys` como REFERENCIAS: la lista que va al puerto
+     * (`earlierPending`/`laterApplied`). Es la misma decisión que
+     * `#changeKeys` y vive en un solo sitio a propósito (auditor 🟠 3 del panel
+     * relay 2: exentar la raíz solo en las claves dejaba el mutex vivo bajo
+     * `only`, porque el SQL de la sonda sí casa `parent_type = 'app'`).
+     */
+    static #changeScopes(change) {
+        if (change.op === 'detached')
+            return [change.child];
+        if (_a.#isRootRef(change.parent))
+            return [change.child];
+        return [change.child, change.parent];
+    }
+    /** ¿Es la raíz? Por REF (`type === 'app' && uuid === null`), jamás comparando la cadena `'app'`. */
+    static #isRootRef(scope) {
+        return scope.type === APP_SCOPE_TYPE && (scope.uuid ?? null) === null;
     }
     /** Lo aparcado por la outbox (si sabe aparcar), listo para el reporte. */
     static async #deadLetters(outbox, limit) {
@@ -1148,6 +2110,28 @@ export class AuthorizationManager {
         await this.#notify(event);
     }
     /** 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;
+     * tester del panel relay 2, §10-d). Medido en alpha.7: `requeueScopeChanges(ids,
+     * { apply: true })` y `relayScopeChanges({ waitForLeaseMs })` se IGNORABAN
+     * —el objeto de opciones no se validaba— y un consumidor en JS (o con
+     * `as any`) creía que aplicaba o esperaba cuando no; el síntoma era un
+     * `busy` o un `deferred` achacado a otra cosa. Se comprueban las CLAVES
+     * (un valor `undefined` en una clave conocida vale: es lo que pasan los
+     * comandos ace), y el objeto tiene que serlo.
+     */
+    static #assertKnownOptions(operation, options, known) {
+        if (options === undefined)
+            return;
+        if (options === null || typeof options !== 'object' || Array.isArray(options)) {
+            throw new AuthorizationConfigError(`${operation}: las opciones deben ser un objeto { ${known.join(', ')} }; llegó ${Array.isArray(options) ? 'una lista' : String(options)}.`);
+        }
+        const unknown = Object.keys(options).filter((key) => !known.includes(key));
+        if (unknown.length > 0) {
+            throw new AuthorizationConfigError(`${operation}: opción(es) desconocida(s): ${unknown.join(', ')}. Las conocidas son ${known.join(', ')}. ` +
+                'Una opción que no existe no se ignora: en JS creerías que aplica (o espera) cuando no. No se ha hecho nada.');
+        }
+    }
     static #positive(value, fallback, name) {
         if (value === undefined)
             return fallback;
@@ -1163,7 +2147,10 @@ export class AuthorizationManager {
      * `{}` si no hay actor: el evento no inventa autores).
      */
     async #writeOptions(options, operation) {
-        await this.#assertNotFrozen(operation, options?.transaction);
+        // Sin cast sobre `transaction` (L-1 · 🟠 8): la barrera no lee nada del
+        // llamante, y `transaction` solo lo consumen los tipos que lo declaran
+        // (`ScopeTreeWriteOptions`, para ENCOLAR — nunca para decidir).
+        await this.#assertNotFrozen(operation);
         if (options?.actor !== undefined)
             assertSubject(options.actor);
         if (this.#config.requireActor === true && !options?.actor) {
@@ -1339,8 +2326,36 @@ export class AuthorizationManager {
             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 };
     }
+    /**
+     * **El gate de profundidad, opt-in** (2.4.0-alpha.5 · R0; `scopes.maxDepth`).
+     * La cadena del padre incluye `app`, así que su longitud ES la profundidad
+     * a la que quedaría el hijo (saltos `parent` hasta la raíz): cero I/O de
+     * más. Se juzga ANTES de escribir o encolar. PARCIAL a propósito: no ve la
+     * altura del subárbol que un `moved` arrastra (ver `define_config.ts`).
+     */
+    #assertDepth(chain, child, parent, operation) {
+        const maxDepth = this.#config.scopes?.maxDepth;
+        if (maxDepth === undefined)
+            return;
+        if (typeof maxDepth !== 'number' || !Number.isInteger(maxDepth) || maxDepth < 1) {
+            throw new AuthorizationConfigError(`${operation}: scopes.maxDepth debe ser un entero >= 1 (llegó ${String(maxDepth)}); quítalo si no quieres techo.`);
+        }
+        if (chain.length > maxDepth) {
+            // El `message` es para el TENANT (2.4.0-alpha.8, cuestión 7.2): sin el
+            // nombre del backend ni sus constantes; eso va en `details`, para el log.
+            throw new ScopeDepthLimitError(`${operation}: colgar ${child.type}:${child.uuid} de ${parent.type}:${parent.uuid ?? ''} lo dejaría a ${chain.length} ` +
+                `saltos de la raíz y el techo es scopes.maxDepth=${maxDepth}. No se ha escrito ni encolado nada. Aplana el árbol ` +
+                `(o pide al operador que suba el techo).`, {
+                depth: chain.length,
+                maxDepth,
+                why: 'el modelo facts del driver openfga no resuelve de forma fiable más allá de FACTS_MAX_RESOLVE_DEPTH: pasado él, authorize es 503 para todo ese subárbol',
+                server: 'para subir el techo hay que subir también OPENFGA_RESOLVE_NODE_LIMIT en el servidor',
+            });
+        }
+    }
     // La identidad se valida AQUÍ, antes de resolver siquiera el driver: una
     // pregunta mal formada (uuid ausente, `{app, uuid}`, slug con `~`) es 422
     // sin tocar catálogo, árbol ni backend, y sin que el hook `onWrite` audite
@@ -1594,6 +2609,7 @@ export class AuthorizationManager {
      * Devuelve el rol y notifica `role_defined`.
      */
     async defineScopedRole(actor, ownerScope, spec, options) {
+        this.#assertNoTransaction(options, 'defineScopedRole');
         const who = await this.#requireActor(actor, 'defineScopedRole');
         this.#assertOwnerScope(ownerScope, 'defineScopedRole');
         const parsed = this.#parseScopedRoleSpec(spec);
@@ -1693,6 +2709,7 @@ export class AuthorizationManager {
      * escribe ni notifica (idempotente). Notifica `role_updated`.
      */
     async updateScopedRole(actor, roleUuid, changes, options) {
+        this.#assertNoTransaction(options, 'updateScopedRole');
         const who = await this.#requireActor(actor, 'updateScopedRole');
         assertCatalogUuid('rol', roleUuid);
         const parsed = this.#parseScopedRoleChanges(changes);
@@ -1786,6 +2803,7 @@ export class AuthorizationManager {
      * su owner. Notifica `role_purged`. No necesita `listDenies`.
      */
     async deleteScopedRole(actor, roleUuid, options) {
+        this.#assertNoTransaction(options, 'deleteScopedRole');
         const who = await this.#requireActor(actor, 'deleteScopedRole');
         assertCatalogUuid('rol', roleUuid);
         const driver = await this.driver();
@@ -2397,13 +3415,15 @@ export class AuthorizationManager {
      * `E_AUTHZ_AMBIGUOUS_ROLE`, nunca «el más cercano gana»).
      */
     async grant(subject, role, scope, options) {
+        await this.#assertTransactionalWrite(options, 'grant');
         const actor = await this.#writeOptions(options, 'grant');
         assertIdentity({ subject, role, scope, expiresAt: options?.expiresAt });
         await this.#assertWithin(scope, options, 'grant');
         // 3E · Q7: el evento lleva el rol RESUELTO (uuid + slug + nivel + owner),
         // no la pregunta cruda. Solo se resuelve si hay hook que lo vaya a leer.
         const roles = await this.#resolvedRoles(role, scope, 'grant');
-        const outcome = (await this.#write({ action: 'granted', subject, scope, roles, expiresAt: options?.expiresAt ?? null, ...actor }, async () => (await this.driver()).grant(subject, role, scope, options))) ??
+        const transactional = this.#transactional(options);
+        const outcome = (await this.#write({ action: 'granted', subject, scope, roles, expiresAt: options?.expiresAt ?? null, ...actor, ...transactional }, async () => (await this.driver()).grant(subject, role, scope, options))) ??
             // Un driver de terceros que aún devuelva `void`: la firma promete un
             // `GrantOutcome` y no miente (E1). Sin lectura previa no hay caducidad
             // anterior que contar: es lo que pidió el llamante, y `existed: false`.
@@ -2419,6 +3439,7 @@ export class AuthorizationManager {
                 expiresAt: outcome.expiresAt,
                 previousExpiresAt: outcome.previousExpiresAt,
                 ...actor,
+                ...transactional,
             });
         }
         else {
@@ -2429,6 +3450,7 @@ export class AuthorizationManager {
                 roles,
                 expiresAt: outcome.expiresAt,
                 ...actor,
+                ...transactional,
             });
         }
         return outcome;
@@ -2440,27 +3462,38 @@ export class AuthorizationManager {
      * rol.
      */
     async revoke(subject, role, scope, options) {
+        await this.#assertTransactionalWrite(options, 'revoke');
         const actor = await this.#writeOptions(options, 'revoke');
         assertIdentity({ subject, role, scope });
         await this.#assertWithin(scope, options, 'revoke');
-        const event = { action: 'revoked', subject, scope, roles: await this.#resolvedRoles(role, scope, 'revoke'), ...actor };
-        await this.#write(event, async () => (await this.driver()).revoke(subject, role, scope));
+        const event = {
+            action: 'revoked',
+            subject,
+            scope,
+            roles: await this.#resolvedRoles(role, scope, 'revoke'),
+            ...actor,
+            ...this.#transactional(options),
+        };
+        // L-2: las opciones viajan al driver (`transaction`, si la puerta la dejó pasar) — como en `grant`.
+        await this.#write(event, async () => (await this.driver()).revoke(subject, role, scope, options));
         await this.#notify(event);
     }
     async deny(subject, permission, scope, options) {
+        await this.#assertTransactionalWrite(options, 'deny');
         const actor = await this.#writeOptions(options, 'deny');
         assertIdentity({ subject, permission, scope });
         await this.#assertWithin(scope, options, 'deny');
-        const event = { action: 'denied', subject, scope, permission, ...actor };
-        await this.#write(event, async () => (await this.driver()).deny(subject, permission, scope));
+        const event = { action: 'denied', subject, scope, permission, ...actor, ...this.#transactional(options) };
+        await this.#write(event, async () => (await this.driver()).deny(subject, permission, scope, options));
         await this.#notify(event);
     }
     async removeDeny(subject, permission, scope, options) {
+        await this.#assertTransactionalWrite(options, 'removeDeny');
         const actor = await this.#writeOptions(options, 'removeDeny');
         assertIdentity({ subject, permission, scope });
         await this.#assertWithin(scope, options, 'removeDeny');
-        const event = { action: 'deny_removed', subject, scope, permission, ...actor };
-        await this.#write(event, async () => (await this.driver()).removeDeny(subject, permission, scope));
+        const event = { action: 'deny_removed', subject, scope, permission, ...actor, ...this.#transactional(options) };
+        await this.#write(event, async () => (await this.driver()).removeDeny(subject, permission, scope, options));
         await this.#notify(event);
     }
     /**
@@ -2711,6 +3744,17 @@ export class AuthorizationManager {
      * `indeterminate: true`, para que quien audita registre "puede haber
      * ocurrido" en vez de nada. Cualquier otro fallo (422, conexión rechazada)
      * significa que la escritura no ocurrió y se propaga sin evento.
+     *
+     * **Dentro de la transacción del llamante (L-3) el deadline sigue siendo
+     * `indeterminate: true`**, y el evento lleva además `transactional: true`.
+     * El auditor del panel `{trx}` (🟡 12) objetó que ahí «el rollback la
+     * determina»; pero lo que determina el rollback lo determina el LLAMANTE
+     * y el paquete no lo ve: en el instante del 503 la sentencia puede haber
+     * aterrizado en la transacción (SQLite no cancela; en PG la transacción
+     * queda abortada y ya no puede confirmar; en MySQL la sentencia se mata y
+     * la transacción sigue viva) y el llamante puede confirmar o no. Lo
+     * honesto es el mismo «no lo sé» de siempre más la marca de que la última
+     * palabra es su commit. Medido por motor en `database_transaction.spec.ts`.
      */
     async #write(event, fn) {
         try {