@jantstack/adonis-authz 2.5.0-alpha.2 → 2.5.0-alpha.4

package/build/src/drivers/openfga_driver.js

@@ -1,14 +1,14 @@
 import db from '@adonisjs/lucid/services/db';
 import { OpenFgaClient, ClientWriteRequestOnDuplicateWrites, ClientWriteRequestOnMissingDeletes, ConsistencyPreference, } from '@openfga/sdk';
-import { AuthorizationBackendError, AuthorizationBackendTimeoutError, AuthorizationConfigError, AuthorizationInternalError, InvalidIdentityError, MassReconcileRefusedError, ReconcileTooLargeError, PurgeIncompleteError, ScopeCycleError, ScopeDriftUnguardedError, ScopeTreeDriftError, UnknownPermissionError, UnknownRoleError, UnsupportedOperationError, WriteConflictError, } from '../errors.js';
+import { AuthorizationBackendError, AuthorizationBackendTimeoutError, AuthorizationConfigError, AuthorizationInternalError, InvalidIdentityError, ResolutionLimitError, MassReconcileRefusedError, DenyMigrationRefusedError, ReconcileTooLargeError, PurgeIncompleteError, ScopeCycleError, ScopeDriftUnguardedError, ScopeTreeDriftError, UnknownPermissionError, UnknownRoleError, UnsupportedOperationError, RenewalUnsafeError, WriteConflictError, markDeploymentFailure, markPartialWrite, } from '../errors.js';
 import { APP_SCOPE_TYPE } from '../types.js';
 import { AUTHZ_TABLES_ORIGIN, RECONCILE_MAX_DETAILS, emptyReconcilePhases as emptyPhases, reconcileBatchSize, reconcileMaxTuples, sumReconcilePhases as sumPhases, } from '../reconcile.js';
 import { assertRoleAssignableAt, declaredRoleAt, fromDbScopeUuid, hasRoleTargets, resolveRoleQuery, rolesToRevoke, visibleRoleFor, } from './database_driver.js';
 import { assertCatalogUuid, assertIdentity, assertScope, chainKeysFrom, isCatalogUuid, isValidScope, normalizeRoleQuery, scopeFromKey, scopeKey, } from '../identity.js';
-import { resolveGrantExpiry, sameInstant, toExpiryDate } from '../expiry.js';
-import { assertKnownScope, canonicalScope, canonicalScopeTargets, guardSql, isAuthzError, isTimeoutLike, resolveChain, rootOnlyResolver, withDeadline, } from '../shared/backend_guard.js';
+import { fgaTupleExpiry, resolveGrantExpiry, sameInstant } from '../expiry.js';
+import { assertKnownScope, canonicalScope, canonicalScopeTargets, classifyFgaFailure, fgaFailureError, guardSql, isAuthzError, isServerWriteLimit, isTimeoutLike, resolveChain, rootOnlyResolver, withDeadline, } from '../shared/backend_guard.js';
 import { CatalogCache, GLOBAL_OWNER_KEY, assertCatalogOptions, isRoleVisibleWith, withAuthzCatalogWrite } from '../catalog/catalog_cache.js';
-import { FACTS_ASSIGNEE_RELATION, FACTS_BINDING_RELATION, FACTS_BINDING_TYPE, FACTS_DENIED_PREFIX, FACTS_GROUP_TYPE, FACTS_MAX_RESOLVE_DEPTH, FACTS_PARENT_RELATION, FACTS_PERMITS_PREFIX, FACTS_ROLE_RELATION, FACTS_ROLE_TYPE, FACTS_ROOTED_RELATION, FACTS_SCOPE_TYPE, assertFactsModelPublishable, assertHolderTypes, factsBindingObject, factsBindingTuples, factsCatalogTuples, factsDenyTuple, factsParentTuple, factsRelationsOf, factsRootTuples, factsScopeBindingTuple, factsScopeObject, factsTupleId, openFgaFactsModel, } from './openfga_facts.js';
+import { FACTS_ASSIGNEE_RELATION, FACTS_BINDING_RELATION, FACTS_BINDING_TYPE, FACTS_DENIED_PREFIX, FACTS_GROUP_TYPE, FACTS_MAX_RESOLVE_DEPTH, FACTS_PARENT_RELATION, FACTS_PERMITS_PREFIX, FACTS_ROLE_RELATION, FACTS_ROLE_TYPE, FACTS_ROOTED_RELATION, FACTS_SCOPE_TYPE, assertFactsModelPublishable, assertHolderTypes, assertPinnedModel, assertExperimentalOptIn, factsModelDifferences, factsModelDriftError, factsBindingObject, factsBindingTuples, factsCatalogTuples, factsDenyTuple, factsParentTuple, factsRelationsOf, factsRootTuples, factsScopeBindingTuple, factsScopeObject, factsTupleId, openFgaFactsModel, } from './openfga_facts.js';
 import { readCatalogProjectionSnapshot } from '../catalog/catalog.js';
 import { isSqliteDialect, sqlExpiryCodec } from '../shared/sql_expiry.js';
 import { isClock, systemClock } from '../clock.js';
@@ -131,7 +131,11 @@ export function alignBatchResults(driver, operation, checks, results) {
     const aligned = correlateBatchResults(checks, results);
     const failed = aligned.find((r) => r.error);
     if (failed) {
-        throw new AuthorizationBackendError(driver, `${operation} (${failed.request?.relation} ${failed.request?.object})`, failed.error);
+        // R3 (injerto 10 del juez = H9 del auditor): el error POR ÍTEM pasa por el MISMO clasificador que la excepción —la
+        // clave del objeto `error` (`input_error`/`internal_error`) hace de `apiErrorCode`—, o `checkMany`/`decideMany`/
+        // `authorizeMany` divergirían de `check`. El primero en el orden de la PETICIÓN (alineado por `correlationId`: el
+        // servidor no devuelve en orden, F0 · M-d nota 2).
+        throw fgaFailureError(driver, `${operation} (${failed.request?.relation} ${failed.request?.object})`, failed.error);
     }
     return aligned;
 }
@@ -170,9 +174,11 @@ export async function provisionOpenFgaStore(apiUrl, name, holderTypeMap, permiss
     // en vez de 500 `E_AUTHZ_MODEL_TOO_LARGE`. Cero requests si no es publicable.
     assertFactsModelPublishable(holderTypeMap, permissions, undefined, relations);
     const model = openFgaFactsModel(holderTypeMap, permissions, relations);
-    const client = new OpenFgaClient({ apiUrl });
+    // Injerto 15 del juez (H12 del auditor): sin reintentos a escondidas también aquí. Desde el SDK 0.9.6 un cliente sin
+    // `retryParams` reintenta 3 veces los 429/5xx, y un `createStore` reintentado tras un 5xx puede dejar un store huérfano.
+    const client = new OpenFgaClient({ apiUrl, retryParams: { maxRetry: 0 } });
     const store = await client.createStore({ name });
-    const scoped = new OpenFgaClient({ apiUrl, storeId: store.id });
+    const scoped = new OpenFgaClient({ apiUrl, storeId: store.id, retryParams: { maxRetry: 0 } });
     const written = await scoped.writeAuthorizationModel(model);
     return { storeId: store.id, modelId: written.authorization_model_id };
 }
@@ -239,6 +245,22 @@ function withPreserveRecipe(error) {
             `escribe a ciegas: si la intención es "permanente", pasa { expiresAt: null }; si es temporal, una Date.`;
     return error;
 }
+/**
+ * **El gemelo de roles de N3** (lote D · D2; cierre 2 de D1 · ⚪ N3 lo cerró en relaciones): un servidor arrancado con
+ * `--max-tuples-per-write` < 100 rechaza con un 400 `exceeded_entity_limit` los `Write` que este driver parte en
+ * `PURGE_BATCH_SIZE` (100) — `projectCatalog` (la proyección del catálogo), `reconcile` (`applyReconcileWrites`) y
+ * `purgeScope`. Hasta D2 salía como 503 `E_AUTHZ_BACKEND_UNAVAILABLE`, que parece transitorio: repetido, vuelve a
+ * fallar igual para siempre. Es configuración del DESPLIEGUE ⇒ 500 `E_AUTHZ_CONFIG` con la letra del requisito, en el
+ * PUNTO DE PASO ÚNICO de todas las llamadas del cliente (`guardBackendErrors`).
+ */
+function serverWriteLimitError(operation, cause) {
+    const sdk = cause?.apiErrorMessage;
+    return new AuthorizationConfigError(`OpenFgaAuthorizationDriver: ${operation}: el servidor OpenFGA rechazó un Write por su tope de operaciones por Write ` +
+        `(exceeded_entity_limit${typeof sdk === 'string' ? `: «${sdk}»` : ''}). Este driver parte sus escrituras (proyección ` +
+        `del catálogo, reconcile, purgas) en lotes de ${PURGE_BATCH_SIZE} y exige --max-tuples-per-write ≥ ${PURGE_BATCH_SIZE} en ` +
+        `el servidor (OPENFGA_MAX_TUPLES_PER_WRITE; el default es ${PURGE_BATCH_SIZE}). No es transitorio: repetida, la operación ` +
+        `vuelve a fallar igual. Si ya se habían aplicado Write anteriores de la misma operación, quedó A MEDIAS.`, { cause });
+}
 /**
  * Devuelve el cliente con TODOS sus métodos envueltos: un fallo de red o un
  * 5xx sale como `AuthorizationBackendError` (503) y no como el `FgaError` del
@@ -254,6 +276,8 @@ function withPreserveRecipe(error) {
  * ahí el error del SDK es la información más útil y no rompe ninguna
  * abstracción.
  */
+/** Los métodos del cliente del SDK que ESCRIBEN en el store (cierre de R3, 🟡 R3-A2: su 504 es indeterminado). */
+const FGA_WRITE_METHODS = new Set(['write', 'writeTuples', 'deleteTuples']);
 function guardBackendErrors(client, timeoutMs) {
     return new Proxy(client, {
         get(target, prop, receiver) {
@@ -262,9 +286,15 @@ function guardBackendErrors(client, timeoutMs) {
                 return value;
             return (...args) => {
                 const operation = String(prop);
-                const fail = (cause) => isTimeoutLike(cause)
-                    ? new AuthorizationBackendTimeoutError('openfga', operation, timeoutMs, cause)
-                    : new AuthorizationBackendError('openfga', operation, cause);
+                // R3 (decisión del dueño 2026-10-17 (3)): la clase la decide `classifyFgaFailure` (por `statusCode` +
+                // `apiErrorCode`, jamás por el mensaje). El tope de `Write` del servidor es un despliegue con su letra propia.
+                const fail = (cause) => {
+                    // Cierre de R3 (🟡 R3-A2): el 504 / `deadline_exceeded` de un método que ESCRIBE es indeterminado (timeout).
+                    const failure = classifyFgaFailure(cause, { write: FGA_WRITE_METHODS.has(operation) });
+                    if (failure.kind === 'deployment' && isServerWriteLimit(cause))
+                        return markDeploymentFailure(serverWriteLimitError(operation, cause));
+                    return fgaFailureError('openfga', operation, cause, { timeoutMs, failure });
+                };
                 try {
                     const result = value.apply(target, args);
                     if (!(result instanceof Promise))
@@ -335,6 +365,55 @@ const TREE_WRITE_ATTEMPTS = 3;
 const PURGE_BATCH_SIZE = 100;
 /** Tamaño de página de `Read` (máximo del servidor). */
 const READ_PAGE_SIZE = 100;
+/**
+ * **Vueltas del settle** (lote C · carreras, resolución 7 del juez; linaje L13): aplicaciones que
+ * `settleRoleVisibility` intenta antes de rendirse. Al agotarlas BORRA las aristas `scope#binding` de los pares (fail-CLOSED,
+ * intra-tenant: el churn exige `within` en los dos padres) y lanza 409 `E_AUTHZ_WRITE_CONFLICT` marcado PARCIAL
+ * (invariante 13: `indeterminate: true` en `onWrite`).
+ */
+export const SETTLE_MAX_ROUNDS = 5;
+/** Vueltas de «borrar y releer» de `purgeRole` antes de rendirse con 500 `E_AUTHZ_PURGE_INCOMPLETE` (lote C, hallazgo 2). */
+const PURGE_ROLE_ROUNDS = 3;
+/**
+ * **La consistencia de TODA lectura que alimenta una escritura** (lote C · carreras, resolución 8 del juez; hallazgo 3 del
+ * panel TREE): `HIGHER_CONSISTENCY` SIEMPRE, también con `consistency: 'minimize_latency'`. El argumento del settle (tipo
+ * Dekker: «escribo y después leo») cae con UNA sola lectura servida desde una caché o una réplica que no ve la escritura
+ * propia, y el `minimize_latency` del driver es un opt-in para DECIDIR, no para dejar estado escrito (medido en el doble: el
+ * atajo idempotente de `reparent` con una foto atrasada deja el árbol del store con OTRO padre sin concurrencia, y el barrido
+ * de `moved` lee su propia arista rancia). Lo usan `readForWrite`, `checkForWrite` y `readAssignment`; una guardia de fuente
+ * (`tests/visibility_settle.spec.ts`) vigila que los métodos que escriben no lean con `this.consistency`.
+ */
+const WRITE_CONSISTENCY = ConsistencyPreference.HigherConsistency;
+const settlePairId = (pair) => `${pair.scope}|${pair.role}`;
+/** `scope#ancestor` = `parent or ancestor from parent` (NO reflexivo, K6): el `Check` del settle (resolución 9, M2: 26 saltos). */
+const FACTS_ANCESTOR_RELATION = 'ancestor';
+/**
+ * **El error ORIGINAL manda; el del settle va como causa** (resolución del juez, auditor 🟡 5 (iv)). El settle corre en un
+ * `finally` lógico de los tres escritores; si lanza, NO sustituye al error que ya llevaba la operación (un 500
+ * `E_AUTHZ_SCOPE_TREE_DRIFT` que aparca no puede salir como un 503 transitorio, ni perder su marca parcial). Se cuelga como
+ * `cause` si el original no tiene una; si ya la tiene, como `settleError` (no enumerable). Un error congelado se devuelve
+ * tal cual.
+ */
+/** `markPartialWrite` sobre un `unknown` (solo marca objetos). */
+function markPartialObject(error) {
+    return error !== null && typeof error === 'object' ? markPartialWrite(error) : error;
+}
+/** ¿Es el 409 de la COTA (o cualquier `E_AUTHZ_WRITE_CONFLICT`)? Ese ya decidió (borró y avisa): no se reintenta. */
+function isWriteConflictLike(error) {
+    return error instanceof WriteConflictError || error?.code === WriteConflictError.code;
+}
+function withSettleCause(original, settleError) {
+    if (original === null || typeof original !== 'object')
+        return original;
+    try {
+        const property = original.cause === undefined ? 'cause' : 'settleError';
+        Object.defineProperty(original, property, { value: settleError, enumerable: false, configurable: true, writable: true });
+    }
+    catch {
+        // congelado: se propaga el original sin la causa (nunca un TypeError en su lugar)
+    }
+    return original;
+}
 /**
  * El deny del modo `resolver` (≤ 2.2), que el modelo de hoy ni declara pero
  * un store de aquella versión sí tiene: `enumerateFacts` lo EMITE como deny
@@ -403,6 +482,9 @@ export class OpenFgaAuthorizationDriver {
             // `database` para lo que tenga que ir en su transacción, o
             // `requireTransactionalWrites` para fallar al arrancar).
             transactionalWrites: false,
+            // Estrategia 2.5.0 · firma 4 (regla D15: clave nueva OPCIONAL, normalizada a `false`): este driver es EXPERIMENTAL en
+            // 2.5.x — no se construye sin `experimental: 'openfga@2.5'` y sus límites declarados están en README «Limits».
+            experimental: true,
         });
     }
     client;
@@ -424,6 +506,12 @@ export class OpenFgaAuthorizationDriver {
      * con el que este driver escribe y responde, no el último del store.
      */
     modelId;
+    /**
+     * **La comparación modelo ↔ config de L11, UNA por proceso** (`modelGate`). Es un OBJETO que se MUTA y nunca se
+     * reasigna (H11 b): las vistas `withChainResolver`/`withClock` son `Object.create(this)` y lo heredan por prototipo,
+     * así que `forRequest()` no relee el modelo por petición.
+     */
+    modelMemo = {};
     consistency;
     /** Reloj de pared del driver (J1): el ÚNICO `now` de checks, filtros y re-grant. */
     now;
@@ -437,8 +525,13 @@ export class OpenFgaAuthorizationDriver {
      */
     catalog;
     constructor(options) {
+        // Estrategia 2.5.0 · firma 4: `openfga` es EXPERIMENTAL en 2.5.x. PRIMERA línea: sin el token, 500 sin crear el cliente.
+        assertExperimentalOptIn('OpenFgaAuthorizationDriver', options?.experimental);
         assertHolderTypes(options.holderTypes);
         assertCatalogOptions('OpenFgaAuthorizationDriver', options);
+        // L11 · `modelId` OBLIGATORIO, siempre (decisión del dueño 2026-10-17 (2)): sin pin, la puerta compararía el modelo
+        // del arranque y el servidor evaluaría con el último de AHORA.
+        assertPinnedModel('OpenFgaAuthorizationDriver', options.modelId);
         if (options.now !== undefined && !isClock(options.now)) {
             throw new AuthorizationConfigError(`OpenFgaAuthorizationDriver: 'now' debe ser una función () => Date (llegó ${typeof options.now})`);
         }
@@ -525,6 +618,53 @@ export class OpenFgaAuthorizationDriver {
     checkContext() {
         return checkContext(this.now());
     }
+    /**
+     * **La lectura del modelo, UNA por proceso** (L11): `readAuthorizationModel` del `modelId` FIJADO y
+     * `factsModelDifferences` con `slice: 'roles'` (los holders, `role`, `role_binding`, `scope` y las condiciones; la
+     * igualdad es «módulo el catálogo»: `P_M` sale del propio modelo). Se memoriza el ÉXITO —también con diferencias— y un
+     * generador que no puede generar (500); **un fallo al LEER el modelo NO se memoriza, sea 503 o 500** (cierre de L11).
+     */
+    modelGate() {
+        const memo = this.modelMemo;
+        if (memo.gate)
+            return memo.gate;
+        // Cierre de L11 (🟡-6 del tester): se memoriza lo que sale de una COMPARACIÓN HECHA —igual, distinta, o el 500 del
+        // generador, que es determinista con ese modelo—, NUNCA un fallo al LEER el modelo, sea de la clase que sea: hoy un
+        // 503 (o un 500 que el cliente ya clasifica, p. ej. el tope de Write) y, con R3, el 401/403 o el modelo inexistente
+        // que se clasificarán como despliegue (500): un token rotado tiene que poder recuperarse sin reiniciar el proceso.
+        let compared = false;
+        const pending = (async () => {
+            const response = await this.client.readAuthorizationModel();
+            const served = response?.authorization_model;
+            if (!Array.isArray(served?.type_definitions)) {
+                throw new AuthorizationBackendError('openfga', 'readAuthorizationModel', new Error('la respuesta de ReadAuthorizationModel no trae type_definitions; no se toma por un modelo igual'));
+            }
+            compared = true;
+            return factsModelDifferences(served, { holderTypes: this.holderTypes, slice: 'roles' });
+        })().catch((error) => {
+            if (!compared && memo.gate === pending)
+                memo.gate = undefined;
+            throw error;
+        });
+        memo.gate = pending;
+        pending.catch(() => { });
+        return pending;
+    }
+    /**
+     * **La puerta L11 del driver de ROLES** (lote «antes de RC», decisión del dueño 2026-10-17 (1); hasta L11 este driver
+     * no comparaba NINGUNA regla —P7: solo el conjunto de `permits_*`, «no es una barrera de seguridad»—: un `can_<P>` sin
+     * `but not denied_<P>`, un `rooted` cambiado o un `assignee` sin `not_expired` concedían o negaban sin error). Toda
+     * operación que llega al store la pasa ENTERA, justo después de validar su entrada y antes de la primera llamada
+     * (catálogo, resolutor y cliente incluidos); `enumerateFacts` —el ORIGEN de una migración— solo la parte
+     * `conditions`. Distinta ⇒ 500 `E_AUTHZ_CONFIG` con las rutas y CERO llamadas que evalúen o escriban.
+     */
+    async assertModel(operation, part = 'full') {
+        const comparison = await this.modelGate();
+        const hits = comparison.differences.filter((d) => (part === 'conditions' ? d.type === null && d.path.startsWith('conditions.') : true));
+        if (hits.length > 0)
+            throw factsModelDriftError('OpenFgaAuthorizationDriver', operation, this.modelId, hits);
+        return comparison;
+    }
     /**
      * Consulta al catálogo local clasificando su fallo. Con este driver el
      * catálogo SQL sigue siendo una dependencia dura de cada pregunta: su caída
@@ -555,6 +695,257 @@ export class OpenFgaAuthorizationDriver {
         // Antes la fase de roles y `hasRole` lo colapsaban en `false`.
         return alignBatchResults('openfga', 'batchCheck', withIds, response.result);
     }
+    /* ── L13 · el SETTLE de la visibilidad de los roles locales (lote C · carreras, opción C firmada 2026-10-20) ──────────
+     *
+     * En (c2) la visibilidad de un rol LOCAL es un dato DERIVADO materializado (la arista `scope#binding`, invariante 18)
+     * que se calcula leyendo OTRO dato mutable (las aristas `scope#parent`) y se escribe después: cualquier escritor que lea
+     * el árbol en t0 y escriba en t1 pierde frente a un cambio de árbol en (t0, t1) cuyo barrido ya pasó (TOCTOU entre
+     * escritores; R1/R2/R3/K2/K4 del panel, medidos en `loteC-asentar-fase1.md`). El remedio firmado es el SETTLE: tras toda
+     * escritura que puede dejar una arista equivocada, RELEER el store con HIGHER y corregir hasta un punto fijo. Por qué
+     * basta (tipo Dekker, sobre un store linealizable con HIGHER): cada escritor de visibilidad hace «escribo → leo el árbol»
+     * y cada escritor del árbol hace «escribo la arista → leo los bindings»; de dos escrituras concurrentes, al menos una de
+     * las dos lecturas posteriores ve la del otro, y quien la ve corrige. Lo que NO cierra (declarado, letra del paso 8): la
+     * ventana transitoria entre la escritura equivocada y su corrección, y una caída del proceso dentro de ella.
+     *
+     * **Punto de paso ÚNICO**: las ALTAS de `scope#binding` de un rol local solo salen de aquí (`writeBindingEdges`, que
+     * también usa la decisión previa del `grant`); los borrados pueden ir directos (borrar nunca concede). */
+    /**
+     * **El catálogo de una ESCRITURA** (K4, resolución 2 del juez): con la versión contrastada en fresco SIEMPRE
+     * (`CatalogCache.freshView`), ignore o no la ventana `{ everyMs }`. Un `catalog` inyectado que no lo traiga cae en
+     * `view()` (el contrato del memo es suyo).
+     */
+    writeCatalog() {
+        const catalog = this.catalog;
+        return typeof catalog.freshView === 'function' ? catalog.freshView() : catalog.view();
+    }
+    /**
+     * K4 (segunda mitad): un uuid de rol que el STORE tiene y el catálogo de la escritura no conoce fuerza UNA recarga del
+     * memo (`invalidate` + foto en fresco). Si tras ella sigue ausente, el rol se borró: quien llama BORRA su arista.
+     */
+    async writeCatalogKnowing(uuids) {
+        const view = await this.writeCatalog();
+        for (const uuid of uuids) {
+            if (view.roleByUuid(uuid))
+                continue;
+            this.catalog.invalidate();
+            return this.writeCatalog();
+        }
+        return view;
+    }
+    /**
+     * Un `batchCheck` con `HIGHER_CONSISTENCY` para el settle, SIN colapsar los errores por ítem: el llamante decide qué
+     * hacer con un `E_AUTHZ_RESOLUTION_LIMIT` de `ancestor` (caer a `storeChain`, condición 2 de la resolución 9) y propaga
+     * el resto (clasificados por el MISMO `fgaFailureError` que `alignBatchResults`).
+     */
+    async checkForWrite(checks) {
+        if (checks.length === 0)
+            return [];
+        const withIds = checks.map((check, index) => ({ ...check, correlationId: String(index) }));
+        const response = await this.client.batchCheck({ checks: withIds }, { consistency: WRITE_CONSISTENCY });
+        return correlateBatchResults(withIds, response.result).map((r) => r.error
+            ? { error: fgaFailureError('openfga', `settle (${r.request?.relation} ${r.request?.object})`, r.error) }
+            : { allowed: r.allowed === true });
+    }
+    /**
+     * **La decisión del settle**, con el STORE (todas las lecturas con HIGHER, en UN `batchCheck`): para cada par, si la
+     * arista TIENE que estar (`want`) y si ESTÁ (`has`). `want` exige, por este orden:
+     *  - el rol en el catálogo de la escritura (K4: en fresco y, si falta, tras una recarga; si sigue faltando, `known: false`
+     *    y la arista se borra — «rol ausente ⇒ borra»);
+     *  - declarado para el NIVEL del scope (3b-2g · R1);
+     *  - `role_binding#role` VIVO (auditor ⚪ 8: tras un `revoke`/`purgeScope`/`purgeRole` concurrente el settle no resucita
+     *    la arista; `liveness: false` solo en la decisión PREVIA del `grant`, que escribe esa arista en el mismo `Write`);
+     *  - y, si el rol es LOCAL, su owner ancestro-o-igual del scope EN EL STORE: atajo `scope == owner` (`ancestor` no es
+     *    reflexivo, K6), `Check(scope:<owner> ancestor scope:<S>)` y, si ese `Check` excede la cota del servidor (medido en M2:
+     *    solo cuando el owner SÍ es ancestro a > 26 saltos), la cadena del store salto a salto (`storeChain`) — nunca «borrar
+     *    por si acaso» (fail-closed aleatorio cerca de la cota). La laxitud de `ancestor` ante DOS padres es deriva que ya
+     *    denuncian `moved` y reconcile (riesgo declarado del juez).
+     */
+    async decideRoleVisibility(pairs, options = {}) {
+        const decisions = new Map();
+        if (pairs.length === 0)
+            return decisions;
+        const catalog = await this.writeCatalogKnowing(pairs.map((p) => p.role));
+        const context = this.checkContext();
+        const checks = [];
+        const slots = [];
+        const seen = new Set();
+        for (const pair of pairs) {
+            const id = settlePairId(pair);
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            const role = catalog.roleByUuid(pair.role);
+            const binding = factsBindingObject(pair.scope, pair.role);
+            const levelOk = role !== null && role.scopeType === scopeFromKey(pair.scope)?.type;
+            const slot = {
+                id,
+                pair,
+                role,
+                levelOk,
+                edge: checks.push({ user: binding, relation: FACTS_BINDING_RELATION, object: factsScopeObject(pair.scope), context }) - 1,
+            };
+            if (role && levelOk) {
+                if (options.liveness !== false) {
+                    slot.live = checks.push({ user: `${FACTS_ROLE_TYPE}:${pair.role}`, relation: FACTS_ROLE_RELATION, object: binding, context }) - 1;
+                }
+                if (role.owner !== GLOBAL_OWNER_KEY && role.owner !== pair.scope) {
+                    slot.anc = checks.push({ user: factsScopeObject(role.owner), relation: FACTS_ANCESTOR_RELATION, object: factsScopeObject(pair.scope), context }) - 1;
+                }
+            }
+            slots.push(slot);
+        }
+        const results = await this.checkForWrite(checks);
+        const verdict = (index) => {
+            const result = results[index];
+            if (result.error)
+                throw result.error;
+            return result.allowed === true;
+        };
+        for (const slot of slots) {
+            const has = verdict(slot.edge);
+            if (!slot.role || !slot.levelOk) {
+                decisions.set(slot.id, { want: false, has, known: slot.role !== null });
+                continue;
+            }
+            let want = slot.live === undefined ? true : verdict(slot.live);
+            if (want && slot.anc !== undefined) {
+                const result = results[slot.anc];
+                if (result.error) {
+                    if (!(result.error instanceof ResolutionLimitError))
+                        throw result.error;
+                    want = (await this.storeChain(slot.pair.scope)).includes(slot.role.owner);
+                }
+                else
+                    want = result.allowed === true;
+            }
+            decisions.set(slot.id, { want, has, known: true });
+        }
+        return decisions;
+    }
+    /**
+     * **El ÚNICO sitio que da de ALTA una arista `scope#binding` de rol local** (y borra las que se le pidan), en lotes ≤ 100
+     * (`Write` con `Ignore` en las dos direcciones: dice el estado que DEBE quedar, no el delta — invariante 6).
+     */
+    async writeBindingEdges(writes, deletes, progress) {
+        if (!writes.length && !deletes.length)
+            return;
+        const operations = [...deletes.map((tuple) => ({ delete: tuple })), ...writes.map((tuple) => ({ write: tuple }))];
+        for (let i = 0; i < operations.length; i += PURGE_BATCH_SIZE) {
+            const chunk = operations.slice(i, i + PURGE_BATCH_SIZE);
+            await this.client.write({
+                writes: chunk.filter((o) => o.write).map((o) => o.write),
+                deletes: chunk.filter((o) => o.delete).map((o) => o.delete),
+            }, {
+                conflict: {
+                    onDuplicateWrites: ClientWriteRequestOnDuplicateWrites.Ignore,
+                    onMissingDeletes: ClientWriteRequestOnMissingDeletes.Ignore,
+                },
+            });
+            progress.writes += 1;
+        }
+    }
+    /**
+     * **`settleRoleVisibility`** — el punto de paso de L13. Decide con el store (`decideRoleVisibility`), y si alguna
+     * arista no está como tiene que estar, aplica la diferencia y VUELVE A LEER; termina cuando una lectura POSTERIOR a su
+     * última escritura ve el store coherente (punto fijo: «borro una vez» deja CLOSED persistente al entrar, R1-entrar).
+     *
+     * **Cota** (resolución 7): tras `SETTLE_MAX_ROUNDS` aplicaciones sin converger (un churn que mueve el árbol en cada
+     * relectura) se RINDE: borra las aristas de los pares que NO convergieron —y, en el mismo `Write`, `giveUpDeletes` (el `assignee` de un
+     * `grant` que CREÓ la asignación: vuelta a «no ocurrió»)— y lanza 409 `E_AUTHZ_WRITE_CONFLICT` marcado PARCIAL
+     * (`indeterminate: true`). Fail-CLOSED declarado e intra-tenant; en un re-grant el 409 NO significa «no asignado».
+     *
+     * Devuelve los pares cuyo rol el catálogo ya no conoce (`known: false`): el `grant` que los CREÓ deshace su asignación.
+     */
+    async settleRoleVisibility(pairs, progress, options = {}) {
+        if (pairs.length === 0)
+            return { unknownRoles: [] };
+        try {
+            return await this.settleRounds(pairs, progress, options);
+        }
+        catch (first) {
+            // **Asentar · cierre 1 (🟡 4 del auditor; medido)**: un settle que FALLA tras una carrera dejaba la arista rancia
+            // —OPEN persistente— y la letra solo declaraba «si el proceso muere» (fallo ∥ carrera, campaña `racefault` de
+            // `loteC-asentar-cierre1.ts`: 188 corridas OPEN de 26 464 en línea, 139 con el relay). Ahora, ante un fallo que no
+            // sea la cota (409 que ya decidió) ni un error del propio catálogo/arnés: UNA segunda vuelta completa (relee y
+            // corrige: un 503 suelto no deja nada); si también falla, sale el error ORIGINAL con el segundo como causa. NO se
+            // borra «por si acaso»: un error no es «no visible» (inv. 5, 🟠-3 del tester) y un borrado en bloque cerraría el
+            // subárbol entero de un `moved` por un parpadeo. Lo que queda DECLARADO (letra del paso 8): un backend que falla
+            // DOS veces seguidas dentro de la ventana deja lo que hubiera —la clase de «una caída dentro de la ventana»—, y lo
+            // repara el relay (si era un cambio de árbol con outbox) o lo ve la red (`authz:reconcile --dry-run`, exit ≠ 0).
+            if (isWriteConflictLike(first))
+                throw first;
+            try {
+                return await this.settleRounds(pairs, progress, options);
+            }
+            catch (second) {
+                if (isWriteConflictLike(second))
+                    throw second;
+                throw withSettleCause(first, second);
+            }
+        }
+    }
+    /** Las vueltas del settle (lo que hasta el cierre 1 era el cuerpo de `settleRoleVisibility`). */
+    async settleRounds(pairs, progress, options) {
+        /**
+         * El `finally` del PROPIO settle (auditor 🟡 5 (iii)): si su `Write` vence el deadline —pudo confirmarse
+         * (invariante 13)—, la vuelta siguiente relee y corrige igual; si TAMBIÉN falla, manda el error del `Write` (el de la
+         * relectura va como causa). Una vez convergido tras un timeout del `Write`, el store quedó asentado: no se lanza.
+         */
+        let applyError;
+        let decisions;
+        for (let round = 0;; round++) {
+            try {
+                decisions = await this.decideRoleVisibility(pairs);
+            }
+            catch (error) {
+                throw applyError ? withSettleCause(applyError.error, error) : error;
+            }
+            const writes = [];
+            const deletes = [];
+            const unknownRoles = [];
+            for (const pair of pairs) {
+                const decision = decisions.get(settlePairId(pair));
+                if (!decision.known)
+                    unknownRoles.push(pair);
+                if (decision.want === decision.has)
+                    continue;
+                const edge = factsScopeBindingTuple(pair.scope, pair.role);
+                if (decision.want)
+                    writes.push(edge);
+                else
+                    deletes.push(edge);
+            }
+            if (writes.length === 0 && deletes.length === 0)
+                return { unknownRoles };
+            if (round >= SETTLE_MAX_ROUNDS)
+                break;
+            try {
+                await this.writeBindingEdges(writes, deletes, progress);
+            }
+            catch (error) {
+                // Solo un `Write` INDETERMINADO (deadline vencido: pudo confirmarse) se vuelve a verificar; cualquier otro fallo
+                // no escribió nada (FGA aplica cada `Write` entero) y se propaga tal cual.
+                if (applyError || !(error instanceof AuthorizationBackendTimeoutError))
+                    throw applyError ? withSettleCause(applyError.error, error) : error;
+                applyError = { error };
+            }
+        }
+        // Asentar · cierre 1 (🟡 2 del auditor): la rendición borra SOLO las aristas de los pares que NO convergieron en la
+        // última lectura (`want ≠ has`). Con el subárbol de un `moved` alto (varias orgs) o un reconcile (toda la flota), borrar
+        // las de TODOS los pares dejaba CLOSED persistente a tenants que no hacían churn: el «intra-tenant» de la resolución 7
+        // no se cumplía. Un par con `want` y sin arista ya está cerrado; uno con arista y sin `want` se borra.
+        const edges = pairs
+            .filter((pair) => {
+            const decision = decisions.get(settlePairId(pair));
+            return decision.want !== decision.has;
+        })
+            .map((pair) => factsScopeBindingTuple(pair.scope, pair.role));
+        await this.writeBindingEdges([], [...edges, ...(options.giveUpDeletes ?? [])], progress);
+        throw markPartialWrite(new WriteConflictError(`La visibilidad de ${pairs.length} asignación(es) de rol local no convergió en ${SETTLE_MAX_ROUNDS} vueltas: el árbol ` +
+            `del store cambia en cada relectura (otro escritor mueve estos scopes en bucle). Se han BORRADO sus aristas ` +
+            `scope#binding (fail-closed): el rol no concede ahí hasta la siguiente escritura que lo asiente (un grant, un ` +
+            `moved del nodo o authz:reconcile). La escritura es PARCIAL: si era un re-grant, la asignación sigue existiendo.`));
+    }
     // ── Catálogo local (compartido entre drivers), desde el memo (2A) ──────
     // Una carga por driver/proceso en vez de una o dos consultas SQL por
     // pregunta, más una revalidación por operación (2D · F1). Un fallo de
@@ -578,6 +969,7 @@ export class OpenFgaAuthorizationDriver {
     // ── Contrato ──────────────────────────────────────────────────────────
     async authorize(subject, permission, scope) {
         assertIdentity({ subject, permission, scope });
+        await this.assertModel('authorize');
         // Una foto del catálogo por pregunta: el permiso sale de la misma versión
         // (y se paga una sola revalidación). Es lo ÚNICO local que queda.
         const catalog = await this.catalog.view();
@@ -635,6 +1027,7 @@ export class OpenFgaAuthorizationDriver {
             assertIdentity({ scope });
         if (scopes.length === 0)
             return [];
+        await this.assertModel('authorizeMany');
         const catalog = await this.catalog.view();
         const perm = catalog.permission(permission);
         if (!perm)
@@ -694,13 +1087,15 @@ export class OpenFgaAuthorizationDriver {
     async grant(subject, role, scope, options = {}) {
         this.rejectTransaction('grant', options);
         assertIdentity({ subject, role, scope, expiresAt: options.expiresAt });
+        await this.assertModel('grant');
         // El binding lleva la identidad canónica del árbol (K1), nunca la forma
         // del llamante, y el uuid del rol, nunca su slug (3A · A1). El rol tiene
         // que EXISTIR en ese scope (3B · B2: global, o local a un ancestro-o-igual)
         // con una composición legal (B5).
         const chain = await this.knownScope(scope, 'grant');
         const [target] = chain;
-        const catalog = await this.catalog.view();
+        // K4 (lote C · carreras, resolución 2): el catálogo de una ESCRITURA se contrasta en fresco, con ventana o sin ella.
+        const catalog = await this.writeCatalog();
         const declared = resolveRoleQuery(catalog, role, target, chainKeysFrom(chain)[0]);
         assertRoleAssignableAt(catalog, declared);
         const roleUuid = declared.uuid;
@@ -709,6 +1104,64 @@ export class OpenFgaAuthorizationDriver {
             relation: 'assignee',
             object: `role_binding:${scopeKey(target)}|${roleUuid}`,
         };
+        const structure = factsBindingTuples(scopeKey(target), roleUuid);
+        // Un rol GLOBAL no depende del árbol (su nivel es inmutable por uuid): sus tres tuplas, en UN `Write`, sin settle.
+        if (declared.owner === GLOBAL_OWNER_KEY)
+            return this.writeGrant(key, structure, options);
+        // **L13 · un rol LOCAL** (lote C · carreras, opción C firmada; injerto del analista): la visibilidad se decide con el
+        // STORE antes de escribir (`decideRoleVisibility`, HIGHER) — durante el lag del relay al ENTRAR en el owner el `grant`
+        // ya no concede (🟡 4: fail-CLOSED, como `attached`) — y la arista solo va en el `Write` si el store la exige. Después,
+        // pase lo que pase con el `Write` (un timeout pudo confirmarse, invariante 13), el SETTLE relee y corrige hasta un punto
+        // fijo (R2: un `moved` que barrió antes de que este `grant` escribiera).
+        const pair = { scope: scopeKey(target), role: roleUuid };
+        const pre = (await this.decideRoleVisibility([pair], { liveness: false })).get(settlePairId(pair));
+        const progress = { writes: 0, attempted: 0 };
+        let outcome;
+        let failure;
+        try {
+            outcome = await this.writeGrant(key, pre.want ? structure : structure.filter((t) => t.relation !== FACTS_BINDING_RELATION), options, progress);
+        }
+        catch (error) {
+            failure = { error };
+        }
+        const created = outcome?.existed === false;
+        let settled = { unknownRoles: [] };
+        if (failure === undefined || progress.attempted > 0) {
+            try {
+                // Rendición de la cota con una asignación RECIÉN creada: el `assignee` se va en el MISMO `Write` que la arista.
+                settled = await this.settleRoleVisibility([pair], progress, { giveUpDeletes: created ? [key] : [] });
+            }
+            catch (settleError) {
+                // El error ORIGINAL manda (el del settle va como causa); sin original, el del settle —ya escribimos: PARCIAL—.
+                if (failure)
+                    throw withSettleCause(progress.writes > 0 ? markPartialObject(failure.error) : failure.error, settleError);
+                throw markPartialObject(settleError);
+            }
+        }
+        if (settled.unknownRoles.length > 0) {
+            // **Hallazgo 2 del panel TREE (ORPHAN)**: el rol se PURGÓ mientras se asignaba (`purgeRole` concurrente). Una
+            // asignación de un rol que ya no existe no se deja: se borran sus TRES tuplas en UN `Write` (vuelta a «no ocurrió»;
+            // con el rol purgado, `role_binding#role` no es de nadie más) y 409 marcado parcial. **Asentar · cierre 1 (🟡 3 del
+            // auditor)**: también en un RE-grant (`existed: true`: el `replaceAssignment` repone `assignee` y `role_binding#role`
+            // DESPUÉS del repaso de la purga) y también si el `Write` lanzó tras confirmarse (antes, `if (failure) throw` salía
+            // primero): con el rol purgado no hay nada que preservar. El error original, si lo hay, manda.
+            await this.client.write({ writes: [], deletes: [key, ...structure] }, { conflict: { onDuplicateWrites: ClientWriteRequestOnDuplicateWrites.Ignore, onMissingDeletes: ClientWriteRequestOnMissingDeletes.Ignore } });
+            if (failure)
+                throw markPartialObject(failure.error);
+            throw markPartialWrite(new WriteConflictError(`grant: el rol ${roleUuid} se purgó del catálogo mientras se asignaba en ${scopeKey(target)}; la asignación se ` +
+                `ha deshecho (no ocurrió). Si el rol se vuelve a crear, repite el grant.`));
+        }
+        if (failure)
+            throw progress.writes > 0 ? markPartialObject(failure.error) : failure.error;
+        return outcome;
+    }
+    /**
+     * El cuerpo de ESCRITURA del `grant` (sin la decisión de visibilidad): lee la asignación, decide entre no-op, write o
+     * delete+write, y re-aplica ante una carrera. `structure` son las aristas que van con el `assignee` en el MISMO `Write`
+     * (las tres para un rol global; sin la `scope#binding` si el store dice que el rol local no es visible ahí). `progress`
+     * cuenta los `Write` INTENTADOS (el settle del `grant` local corre si hubo alguno, también si falló: invariante 13).
+     */
+    async writeGrant(key, structure, options, progress = { attempted: 0 }) {
         // **La forma nueva de los objetos (3b-2c), en UNA sola escritura
         // (3b-2f · R3).** En (c2) la asignación no es alcanzable con el
         // `assignee` a secas: el binding tiene que colgar del scope
@@ -722,7 +1175,6 @@ export class OpenFgaAuthorizationDriver {
         // mismo hecho, que es peor que perder la escritura. Ahora las TRES van
         // en el mismo `Write` (transaccional en FGA): o están las tres o no está
         // ninguna.
-        const structure = factsBindingTuples(scopeKey(target), roleUuid);
         /** El write COMPLETO de una asignación: su estructura y ella. */
         const writeSet = (tuple) => [...structure, tuple];
         const tupleFor = (expiresAt) => expiresAt
@@ -751,14 +1203,20 @@ export class OpenFgaAuthorizationDriver {
             if (options.expiresAt === undefined)
                 throw withPreserveRecipe(current.error);
             const expiresAt = options.expiresAt;
+            progress.attempted += 1;
             const existed = await this.writeAssignment(key, tupleFor(expiresAt), structure);
             return { existed, expiresAt };
         }
         if (current.kind === 'present') {
+            // L11 · H8: la asignación YA existe con una condición que el paquete no escribe o no sabe leer: ni «sin
+            // caducidad» (no-op mudo) ni «vencida» (reescritura a ciegas). 409, cero escrituras, receta.
+            if (current.invalid !== undefined)
+                throw RenewalUnsafeError.foreignCondition('grant', `${key.object}#${key.relation}@${key.user}`, current.invalid);
             const expiresAt = resolveGrantExpiry(current.validUntil, options.expiresAt, this.now());
             if (sameInstant(current.validUntil, expiresAt)) {
                 return { existed: true, previousExpiresAt: current.validUntil, expiresAt };
             }
+            progress.attempted += 1;
             await this.replaceAssignment(key, tupleFor(expiresAt), structure);
             return { existed: true, previousExpiresAt: current.validUntil, expiresAt };
         }
@@ -775,7 +1233,8 @@ export class OpenFgaAuthorizationDriver {
         //    a la vez: la asignación sigue sin existir, así que se repite el
         //    MISMO write ignorando duplicados (las aristas no llevan condición,
         //    así que un duplicado suyo es idéntico por construcción). Sigue
-        //    siendo UNA escritura y sigue siendo atómica.
+        //    siendo UNA escritura y sigue siendo atómica PARA EL ESCRITOR (para
+        //    un lector, `can_<P>` exige las tres: una mezcla es fail-closed).
         //
         // Cuál de los dos fue lo dice la RELECTURA, no el error: el conflicto
         // transaccional de FGA (`Aborted`, HTTP 409) no nombra ninguna tupla.
@@ -791,6 +1250,7 @@ export class OpenFgaAuthorizationDriver {
         const expiresAt = options.expiresAt ?? null;
         for (let attempt = 0;; attempt++) {
             try {
+                progress.attempted += 1;
                 await this.client.writeTuples(writeSet(tupleFor(expiresAt)), attempt === 0 ? undefined : IGNORE_DUPLICATE_WRITES);
                 return { existed: false, expiresAt };
             }
@@ -803,8 +1263,11 @@ export class OpenFgaAuthorizationDriver {
                 }
                 const raced = await this.readAssignment(key);
                 if (raced.kind === 'present') {
+                    if (raced.invalid !== undefined)
+                        throw RenewalUnsafeError.foreignCondition('grant', `${key.object}#${key.relation}@${key.user}`, raced.invalid);
                     const target = resolveGrantExpiry(raced.validUntil, options.expiresAt, this.now());
                     if (!sameInstant(raced.validUntil, target)) {
+                        progress.attempted += 1;
                         await this.replaceAssignment(key, tupleFor(target), structure);
                     }
                     return { existed: true, previousExpiresAt: raced.validUntil, expiresAt: target };
@@ -814,6 +1277,7 @@ export class OpenFgaAuthorizationDriver {
                     // preservar, y el error de lectura va como causa.
                     if (options.expiresAt === undefined)
                         throw withPreserveRecipe(raced.error);
+                    progress.attempted += 1;
                     const existed = await this.writeAssignment(key, tupleFor(options.expiresAt), structure);
                     return { existed, expiresAt: options.expiresAt };
                 }
@@ -857,7 +1321,16 @@ export class OpenFgaAuthorizationDriver {
         await this.client.deleteTuples([key], {
             conflict: { onMissingDeletes: ClientWriteRequestOnMissingDeletes.Ignore },
         });
-        await this.client.writeTuples([...structure, tuple], IGNORE_DUPLICATE_WRITES);
+        // Cierre 3 de D2 · ⚪ C2-5 (gemelo de roles del N1 (b) de relaciones): el delete YA entró — si el write falla, el
+        // `assignee` quedó BORRADO (el grant se perdió: fail-closed) y la escritura es PARCIAL, no «no escrita»: el error va
+        // marcado (`markPartialWrite`) y el manager notifica `indeterminate: true` (invariante 13). Hasta el cierre 3 era un
+        // 503 sin marca y sin evento, con el grant ya revocado.
+        try {
+            await this.client.writeTuples([...structure, tuple], IGNORE_DUPLICATE_WRITES);
+        }
+        catch (error) {
+            throw error !== null && typeof error === 'object' ? markPartialWrite(error) : error;
+        }
     }
     /**
      * Estado actual de una asignación, con TRES resultados posibles y no dos.
@@ -870,15 +1343,15 @@ export class OpenFgaAuthorizationDriver {
      */
     async readAssignment(key) {
         try {
-            const response = await this.client.read(key, { consistency: this.consistency });
+            // Hallazgo 3 TREE: la lectura decide la ESCRITURA del `grant` (omitido = preservar) ⇒ HIGHER siempre.
+            const response = await this.client.read(key, { consistency: WRITE_CONSISTENCY });
             // ⚪ N5 (cierre 2 del lote B): un 200 sin `tuples` no es «ausente», es
             // «no se sabe» (503 de `tuplesOrThrow` como causa): sin objetivo explícito
             // `grant` no escribe a ciegas sobre una caducidad que no ha podido ver.
             const tuple = this.tuplesOrThrow(response, 'readAssignment')[0];
             if (!tuple)
                 return { kind: 'absent' };
-            const validUntil = tuple.key?.condition?.context?.valid_until;
-            return { kind: 'present', validUntil: toExpiryDate(validUntil) };
+            return { kind: 'present', ...storedCondition(tuple.key?.condition) };
         }
         catch (error) {
             return { kind: 'unknown', error };
@@ -887,10 +1360,14 @@ export class OpenFgaAuthorizationDriver {
     async revoke(subject, role, scope, options) {
         this.rejectTransaction('revoke', options);
         assertIdentity({ subject, role, scope });
+        await this.assertModel('revoke');
         // Rol fuera del catálogo para ese nivel ⇒ 422, como en `grant` (D10). Se
         // quitan los bindings de TODOS los roles con ese nombre en el scope
         // exacto (3B): a lo sumo uno es visible ahí; quitar nunca concede.
-        const named = rolesToRevoke(await this.catalog.view(), role, scope);
+        // Asentar · cierre 1 (🟡 5 del auditor, K4): el catálogo de una ESCRITURA, con la versión en fresco. Con el memo de
+        // `{ everyMs }` un local recién definido en otro proceso que ensombrece al global no salía en `rolesNamed`: el delete
+        // con `Ignore` era un no-op y la asignación local seguía concediendo (un «revocado» falso, mudo).
+        const named = rolesToRevoke(await this.writeCatalog(), role, scope);
         // Sin cadena, TODAS las ortografías de las que el uuid puede ser alias
         // (3b-8 · A4): con una sola, el alias hacía del delete un no-op
         // silencioso (`onMissingDeletes: Ignore`) y el hecho canónico seguía ahí.
@@ -900,6 +1377,7 @@ export class OpenFgaAuthorizationDriver {
     }
     async hasRole(subject, role, scope) {
         assertIdentity({ subject, role, scope });
+        await this.assertModel('hasRole');
         const user = this.fgaSubject(subject);
         const chain = await this.chain(scope, 'hasRole');
         if (!chain)
@@ -926,6 +1404,7 @@ export class OpenFgaAuthorizationDriver {
     async deny(subject, permission, scope, options) {
         this.rejectTransaction('deny', options);
         assertIdentity({ subject, permission, scope });
+        await this.assertModel('deny');
         const perm = await this.findPermission(permission);
         if (!perm)
             throw new UnknownPermissionError(permission);
@@ -937,6 +1416,7 @@ export class OpenFgaAuthorizationDriver {
     async removeDeny(subject, permission, scope, options) {
         this.rejectTransaction('removeDeny', options);
         assertIdentity({ subject, permission, scope });
+        await this.assertModel('removeDeny');
         const perm = await this.findPermission(permission);
         if (!perm)
             throw new UnknownPermissionError(permission);
@@ -969,6 +1449,7 @@ export class OpenFgaAuthorizationDriver {
      */
     async listSubjects(role, scope) {
         assertIdentity({ role, scope });
+        await this.assertModel('listSubjects');
         // Un rol que el catálogo no declara para ese nivel (en ningún owner) no
         // tiene holders (D5): nada que leer, ni árbol ni store. Un scope que el
         // árbol no conoce no existe para el motor (D8, K1): nada; uno que conoce
@@ -1032,7 +1513,10 @@ export class OpenFgaAuthorizationDriver {
             user: this.fgaSubject(subject),
             relation: factsRelationsOf(slug).denied,
             object: `${FACTS_SCOPE_TYPE}:`,
-        }, { at });
+        }, 
+        // Cierre de L11 (🟡-3 del tester, gemelo de `#carriedDeny`): el deny con una condición que el paquete no escribe
+        // cuenta VIVO donde NIEGA — `listScopes` lista de menos, nunca de más.
+        { at, includeInvalid: true });
         return new Set(tuples.map((t) => t.object.slice(FACTS_SCOPE_TYPE.length + 1)));
     }
     /**
@@ -1088,6 +1572,7 @@ export class OpenFgaAuthorizationDriver {
     }
     async listRoles(subject, scope) {
         assertIdentity({ subject, scope });
+        await this.assertModel('listRoles');
         // Un scope que el árbol no conoce no existe para el motor (D8): nada.
         const chain = await this.chain(scope, 'listRoles');
         if (!chain)
@@ -1117,6 +1602,7 @@ export class OpenFgaAuthorizationDriver {
             assertScope(scope);
         if (chain.length === 0)
             return [];
+        await this.assertModel('rolesInChain');
         const catalog = await this.catalog.view();
         const keysFrom = chainKeysFrom(chain);
         const wanted = new Map(chain.map((s, i) => [scopeKey(s), { scope: s, keys: keysFrom[i] }]));
@@ -1142,6 +1628,7 @@ export class OpenFgaAuthorizationDriver {
     }
     async listRoleScopes(subject, scopeType) {
         assertIdentity({ subject, scopeType });
+        await this.assertModel('listRoleScopes');
         const catalog = await this.catalog.view();
         const byScope = new Map();
         for (const binding of await this.listBindings(subject)) {
@@ -1168,6 +1655,7 @@ export class OpenFgaAuthorizationDriver {
     }
     async listScopes(subject, permission) {
         assertIdentity({ subject, permission });
+        await this.assertModel('listScopes');
         const catalog = await this.catalog.view();
         const perm = catalog.permission(permission);
         if (!perm)
@@ -1205,6 +1693,7 @@ export class OpenFgaAuthorizationDriver {
      */
     async listDenies(subject, scope) {
         assertIdentity(scope ? { subject, scope } : { subject });
+        await this.assertModel('listDenies');
         const chain = scope ? await this.chain(scope, 'listDenies') : null;
         if (scope && !chain)
             return [];
@@ -1255,8 +1744,12 @@ export class OpenFgaAuthorizationDriver {
      * borrar una tupla inexistente—, la cadena del padre NUEVO en el store
      * (3b-8 · A5: el anti-ciclos del consumidor no ve un store
      * desincronizado) y **UN solo `Write`** con el delete del padre viejo y el
-     * write del nuevo, que es atómico dentro de la request. O(profundidad)
-     * requests, UNA mutación.
+     * write del nuevo, que es atómico PARA EL ESCRITOR (el store nunca guarda
+     * los dos padres ni ninguno) pero NO para un lector concurrente: un `Check`
+     * que dura lo que el `Write` puede leer la arista vieja por una rama del
+     * modelo y la nueva por otra (lector rasgado, fila «torn read» de Limits del
+     * README; medido 1,2–7,1 %, decisión del dueño 6b). O(profundidad) requests;
+     * con roles locales, además el barrido F4 (ver `reparent`).
      */
     async onScopeMoved(child, newParent) {
         await this.reparent(child, newParent, 'scopes.moved');
@@ -1326,9 +1819,10 @@ export class OpenFgaAuthorizationDriver {
         if (child.type === APP_SCOPE_TYPE) {
             throw new InvalidIdentityError('scopes.detached: la raíz `app` no se puede borrar ni purgar');
         }
+        await this.assertModel('scopes.detached');
         const scope = await this.canonicalOrSelf(child, 'scopes.detached');
         const object = factsScopeObject(scopeKey(scope));
-        const current = await this.readAllTuples({ object, relation: FACTS_PARENT_RELATION }, { includeExpired: true });
+        const current = await this.readForWrite({ object, relation: FACTS_PARENT_RELATION }, { includeExpired: true });
         // Aquí NO se exige un solo padre: el nodo se va entero y llevarse las dos
         // aristas de una deriva es lo correcto (a diferencia de `moved`, donde
         // habría que elegir cuál sobrevive).
@@ -1360,58 +1854,115 @@ export class OpenFgaAuthorizationDriver {
      * impide esa carrera es el ESCRITOR ÚNICO del relay (`ScopeOutbox.acquire`).
      */
     async reparent(child, parent, operation) {
+        // Cierre de L11 (⚪ A3.4 del auditor): la puerta ANTES de resolver la arista (`assertEdge` lee la cadena del
+        // CONSUMIDOR), como en el resto de métodos — la desviación 3 del informe («antes del catálogo y del resolutor») era
+        // falsa aquí. Consecuencia, fail-closed: con un modelo distinto un `attached`/`moved` es 500 aunque la arista fuera 422.
+        await this.assertModel(operation);
         const { childKey, parentKey } = await this.assertEdge(child, parent, operation);
         const wanted = factsParentTuple(childKey, parentKey);
-        for (let attempt = 0;; attempt++) {
-            const current = await this.readAllTuples({ object: wanted.object, relation: FACTS_PARENT_RELATION }, { includeExpired: true });
-            this.assertOneParent(wanted.object, current);
-            if (current.length === 1 && current[0].user === wanted.user) {
-                // **El atajo idempotente TAMBIÉN barre** (3b-8 · A3). El relay
-                // reintenta: un `moved` cuyo primer intento escribió la arista y
-                // murió ANTES del barrido vuelve a entregarse, cae aquí, y hasta
-                // 3b-8 el `return` a secas se saltaba `sweepLocalRoleBindings` — el
-                // rol local del tenant A seguía concediendo en el subárbol del B
-                // para siempre, con el relay en verde (invariante 18 roto por
-                // COMPOSICIÓN de dos piezas correctas: la idempotencia y el barrido).
-                // Coste: cero requests sin roles locales, como el propio barrido.
-                await this.sweepLocalRoleBindings(childKey);
+        // Lote «antes de RC» · F4 (invariante 13): cuántos `Write` YA entraron. Un error tras ≥ 1 sale marcado PARCIAL (el
+        // barrido previo o la arista ya cambiaron respuestas); antes del primero, no. Lote C (L13): `attempted` cuenta los
+        // INTENTADOS —un `Write` que vence el deadline pudo confirmarse—, y con ≥ 1 el SETTLE corre también si la operación
+        // lanza (`finally` lógico de la resolución del juez; el error ORIGINAL manda).
+        const progress = { writes: 0, attempted: 0 };
+        /** El settle ya corrió (o está corriendo): un error SUYO no lo vuelve a lanzar desde el `catch`. */
+        let settling = false;
+        const settle = async () => {
+            settling = true;
+            await this.settleSubtree(childKey, progress);
+        };
+        try {
+            for (let attempt = 0;; attempt++) {
+                // Hallazgo 3 del panel TREE: la lectura del padre ALIMENTA el `Write` de la arista (y su atajo idempotente) ⇒
+                // HIGHER. Con una foto atrasada el atajo veía «ya está ahí» y volvía sin escribir: el store se quedaba con OTRO
+                // padre que el consumidor, sin concurrencia (`churnC` solo, en `minimize`).
+                const current = await this.readForWrite({ object: wanted.object, relation: FACTS_PARENT_RELATION }, { includeExpired: true });
+                this.assertOneParent(wanted.object, current);
+                if (current.length === 1 && current[0].user === wanted.user) {
+                    // **El atajo idempotente TAMBIÉN barre** (3b-8 · A3). El relay
+                    // reintenta: un `moved` cuyo primer intento escribió la arista y
+                    // murió ANTES del barrido vuelve a entregarse, cae aquí, y hasta
+                    // 3b-8 el `return` a secas se saltaba `sweepLocalRoleBindings` — el
+                    // rol local del tenant A seguía concediendo en el subárbol del B
+                    // para siempre, con el relay en verde (invariante 18 roto por
+                    // COMPOSICIÓN de dos piezas correctas: la idempotencia y el barrido).
+                    // Desde F4 es el barrido COMPLETO de después; desde el lote C, el SETTLE del subárbol.
+                    // Coste: cero requests sin roles locales, como el propio barrido.
+                    await settle();
+                    return;
+                }
+                // **El ciclo se mira también en el árbol DEL STORE** (3b-8 · A5).
+                // `assertEdge` valida contra la cadena del CONSUMIDOR, pero quien
+                // decide en `facts` es el store, y una outbox aplicada en desorden (un
+                // `moved` aparcado + el move inverso posterior) lo deja desincronizado:
+                // la arista nueva —legal para el consumidor— puede cerrar un ciclo
+                // REAL, que FGA acepta y evalúa en los dos sentidos (cruce 3:
+                // fail-open mudo). `storeChain` del barrido solo lanzaba DESPUÉS de
+                // escribir y no deshacía nada. Se sube por la cadena del PADRE en el
+                // store antes del `Write`; el coste es O(profundidad) lecturas por
+                // cambio de árbol, fuera del camino caliente.
+                const parentChain = await this.storeChain(parentKey);
+                if (parentChain.includes(childKey)) {
+                    throw new ScopeCycleError(`${operation}: en el árbol del STORE ${factsScopeObject(parentKey)} desciende de ${childKey} ` +
+                        `(o es él mismo); escribir la arista cerraría un ciclo real que FGA evalúa en los dos ` +
+                        `sentidos. El árbol del store está desincronizado del consumidor (una outbox aplicada en ` +
+                        `desorden, una entrada aparcada): reconstrúyelo con authz:reconcile.`);
+                }
+                // **F4 — el barrido PREVIO** (lote «antes de RC», decisión del dueño 6b-estudio, opción E; linaje L10): ANTES de
+                // escribir la arista se BORRAN las aristas `scope#binding` de los roles locales que la regla del invariante 18
+                // prohíbe con la cadena NUEVA (la del padre en el store + el hijo). Hasta F4 el orden era arista → barrido, y el
+                // estado intermedio «hijo bajo el padre nuevo con el binding del owner viejo visible» era un estado REAL del store
+                // que concedía —saltándose un deny del owner— en el 15,9 % de los `Check` concurrentes (🟠 del auditor del
+                // estudio 6b). Con el barrido previo ese prefijo falla CERRADO: el usuario pierde el rol local antes de tiempo,
+                // nunca lo gana. Solo BORRA: escribir aquí lo que la cadena nueva exige concedería bajo el padre VIEJO (entrar en
+                // el owner con un deny en el owner: mutante `writes-before-edge`). Las escrituras van en el SETTLE de después. Lo
+                // que NO elimina: un `Check` que dura los dos `Write` (lee el binding antes del primero y la arista después del
+                // segundo) — el residuo «dos escrituras en un Check» de la fila «torn read» (medido con c2r por el auditor de F4:
+                // ~1,8·10⁻³ en un DESCENDIENTE al salir del owner, ~10⁻⁵ en el nodo movido). Las carreras entre ESCRITORES
+                // (`projectCatalogRole`/`grant` concurrentes con el move) las cierra el settle (lote C, L13).
+                await this.sweepLocalRoleBindings(childKey, progress, { phase: 'pre', chain: [childKey, ...parentChain] });
+                try {
+                    progress.attempted += 1;
+                    await this.client.write({ writes: [wanted], deletes: current });
+                    progress.writes += 1;
+                }
+                catch (error) {
+                    if (!isTreeWriteRace(error))
+                        throw error;
+                    if (attempt >= TREE_WRITE_ATTEMPTS - 1) {
+                        throw new WriteConflictError(`${operation}: ${TREE_WRITE_ATTEMPTS} intentos y el árbol del store sigue en conflicto sobre ` +
+                            `${wanted.object}: otro escritor toca las mismas tuplas (otra escritura del árbol fuera del relay, o dos ` +
+                            `pasadas a la vez sin lease en tu outbox). Es contención, no una entrada irreparable: en el relay NO ` +
+                            `consume intento y la pasada siguiente relee y re-aplica.`, { cause: error });
+                    }
+                    continue;
+                }
+                // **El SETTLE del subárbol** (lote C · L13; sustituye al barrido COMPLETO de F4): con la arista ya escrita, relee
+                // el store (HIGHER) y deja cada `scope#binding` de rol local del subárbol como dice la cadena DEL STORE, hasta un
+                // punto fijo. Escribe lo que la cadena nueva exige y vuelve a borrar lo que prohíbe: borrar otra vez no es
+                // redundante — un `grant` del rol local que aterrice ENTRE el barrido previo y la arista deja su `scope#binding`
+                // visible fuera del owner, y solo esta pasada lo limpia (mutante `post-writes-only`) —; y un `projectCatalogRole` o
+                // un `moved` del padre que corran a la vez se ven en la relectura (R1/R3/K2).
+                await settle();
                 return;
             }
-            // **El ciclo se mira también en el árbol DEL STORE** (3b-8 · A5).
-            // `assertEdge` valida contra la cadena del CONSUMIDOR, pero quien
-            // decide en `facts` es el store, y una outbox aplicada en desorden (un
-            // `moved` aparcado + el move inverso posterior) lo deja desincronizado:
-            // la arista nueva —legal para el consumidor— puede cerrar un ciclo
-            // REAL, que FGA acepta y evalúa en los dos sentidos (cruce 3:
-            // fail-open mudo). `storeChain` del barrido solo lanzaba DESPUÉS de
-            // escribir y no deshacía nada. Se sube por la cadena del PADRE en el
-            // store antes del `Write`; el coste es O(profundidad) lecturas por
-            // cambio de árbol, fuera del camino caliente.
-            if ((await this.storeChain(parentKey)).includes(childKey)) {
-                throw new ScopeCycleError(`${operation}: en el árbol del STORE ${factsScopeObject(parentKey)} desciende de ${childKey} ` +
-                    `(o es él mismo); escribir la arista cerraría un ciclo real que FGA evalúa en los dos ` +
-                    `sentidos. El árbol del store está desincronizado del consumidor (una outbox aplicada en ` +
-                    `desorden, una entrada aparcada): reconstrúyelo con authz:reconcile.`);
-            }
-            try {
-                await this.client.write({ writes: [wanted], deletes: current });
-            }
-            catch (error) {
-                if (!isTreeWriteRace(error))
-                    throw error;
-                if (attempt >= TREE_WRITE_ATTEMPTS - 1) {
-                    throw new WriteConflictError(`${operation}: ${TREE_WRITE_ATTEMPTS} intentos y el árbol del store sigue en conflicto sobre ` +
-                        `${wanted.object}. El relay es escritor ÚNICO: si hay dos pasadas a la vez, dale un lease a tu outbox.`, { cause: error });
+        }
+        catch (error) {
+            let final = error;
+            if (!settling && progress.attempted > 0) {
+                try {
+                    await settle();
+                }
+                catch (settleError) {
+                    final = withSettleCause(error, settleError);
                 }
-                continue;
             }
-            await this.sweepLocalRoleBindings(childKey);
-            return;
+            throw progress.writes > 0 && final !== null && typeof final === 'object' ? markPartialWrite(final) : final;
         }
     }
     /**
-     * **El barrido del rol local** (3b-2e · E1; decisión del dueño del
-     * 2026-08-30, opción 1).
+     * **El barrido PREVIO del rol local** (3b-2e · E1; decisión del dueño del
+     * 2026-08-30, opción 1; F4: solo borra).
      *
      * En (c2) el modelo no tiene `owner`, así que `authorize` NO vuelve a
      * decidir con el árbol de hoy si un rol LOCAL sigue siendo visible: un
@@ -1421,11 +1972,12 @@ export class OpenFgaAuthorizationDriver {
      * un **fail-open** — y encima uno que solo se ve comparando drivers.
      *
      * Lo que se toca es la arista `scope#binding`, que es lo que hace
-     * ALCANZABLE la asignación: se BORRA donde el owner del rol ya no está en
-     * la cadena y se REESCRIBE donde vuelve a estarlo (invariante 18: volver la
-     * unit a su sitio restaura). No se toca el `assignee` —el hecho de la
-     * asignación no cambia porque el árbol se mueva, igual que en `database`—
-     * ni nada de un rol GLOBAL, cuya visibilidad no depende del árbol.
+     * ALCANZABLE la asignación: el barrido previo la BORRA donde el owner del
+     * rol no estará en la cadena NUEVA; las ALTAS (volver a su sitio restaura)
+     * son del settle de después (`settleSubtree`), el punto de paso único de
+     * L13. No se toca el `assignee` —el hecho de la asignación no cambia porque
+     * el árbol se mueva, igual que en `database`— ni nada de un rol GLOBAL, cuya
+     * visibilidad no depende del árbol.
      *
      * **Por subárbol, no por nodo** (consecuencia 2): los descendientes del
      * nodo movido también cambian de cadena.
@@ -1434,24 +1986,43 @@ export class OpenFgaAuthorizationDriver {
      * que no usa delegación— son **cero** requests y `moved` sigue siendo el
      * `Read` + `Write` del cruce 8. Con roles locales: una lectura por rol local
      * (sus bindings, por `role_binding#role`), la bajada del subárbol y un
-     * `Write` por lote.
+     * `Write` por lote (el coste O(roles locales) por `moved` es el 🟡 6, declarado hasta 2.6).
      */
-    async sweepLocalRoleBindings(movedKey) {
-        const catalog = await this.catalog.view();
+    async sweepLocalRoleBindings(movedKey, progress, options) {
+        const { catalog, pairs, subtree } = await this.localBindingsBelow(movedKey, options.chain);
+        if (pairs.length === 0)
+            return;
+        const writes = [];
+        const deletes = [];
+        for (const pair of pairs) {
+            this.classifyBindingEdge(catalog, { scope: scopeFromKey(pair.scope), uuid: pair.role }, subtree.get(pair.scope), writes, deletes);
+        }
+        // F4: el previo solo BORRA (lo que la cadena nueva prohíbe); las altas, del settle de después.
+        await this.applyBindingSweep(deletes, progress);
+    }
+    /**
+     * Los bindings de roles LOCALES que cuelgan del subárbol de `movedKey` en el STORE (HIGHER), con la cadena de cada
+     * scope del subárbol. El catálogo es el de una ESCRITURA (K4: en fresco), y un uuid que el store tiene y el catálogo no
+     * conoce fuerza una recarga (`writeCatalogKnowing`); los roles se enumeran por el catálogo (el amarillo 6 —enumerar
+     * desde el store— es de 2.6). `chain` es la cadena que el nodo TENDRÁ (barrido previo) o, sin ella, la del store.
+     */
+    async localBindingsBelow(movedKey, chain) {
+        const catalog = await this.writeCatalog();
         const locals = catalog.localRoles();
+        const subtree = new Map();
         if (locals.length === 0)
-            return;
+            return { catalog, pairs: [], subtree };
         // La cadena del nodo movido y su subárbol se leen del STORE, no del
         // consumidor: el árbol que decide en `facts` es el del store, y con la
         // outbox el relay aplica esto MÁS TARDE, cuando el árbol del consumidor
-        // puede haber seguido moviéndose.
-        const chainOfMoved = await this.storeChain(movedKey);
-        /** `scopeKey` → claves de su cadena (él incluido), con el árbol de AHORA. */
-        const subtree = new Map([[movedKey, chainOfMoved]]);
+        // puede haber seguido moviéndose. En el barrido PREVIO de F4 la arista
+        // nueva aún no está escrita: la cadena es la que TENDRÁ (`chain`:
+        // el hijo + la cadena del padre nuevo en el store), nunca la vieja.
+        subtree.set(movedKey, chain ?? (await this.storeChain(movedKey)));
         const pending = [movedKey];
         while (pending.length) {
             const key = pending.pop();
-            const children = await this.readAllTuples({ user: factsScopeObject(key), relation: FACTS_PARENT_RELATION, object: `${FACTS_SCOPE_TYPE}:` }, { includeExpired: true });
+            const children = await this.readForWrite({ user: factsScopeObject(key), relation: FACTS_PARENT_RELATION, object: `${FACTS_SCOPE_TYPE}:` }, { includeExpired: true });
             for (const edge of children) {
                 const childKey = edge.object.slice(FACTS_SCOPE_TYPE.length + 1);
                 if (subtree.has(childKey))
@@ -1460,21 +2031,28 @@ export class OpenFgaAuthorizationDriver {
                 pending.push(childKey);
             }
         }
-        const writes = [];
-        const deletes = [];
+        const pairs = [];
         for (const role of locals) {
             // Los bindings de ESTE rol, esté donde esté: `role_binding:…#role@role:<uuid>`.
             // El filtro lleva `user`, que es lo que el servidor real exige cuando el
             // objeto es solo un tipo (lección del 2c).
-            const bindings = await this.readAllTuples({ user: `${FACTS_ROLE_TYPE}:${role.uuid}`, relation: FACTS_ROLE_RELATION, object: `${FACTS_BINDING_TYPE}:` }, { includeExpired: true });
+            const bindings = await this.readForWrite({ user: `${FACTS_ROLE_TYPE}:${role.uuid}`, relation: FACTS_ROLE_RELATION, object: `${FACTS_BINDING_TYPE}:` }, { includeExpired: true });
             for (const binding of this.parseBindings(FACTS_BINDING_TYPE, bindings.map((t) => t.object))) {
-                const chainKeys = subtree.get(scopeKey(binding.scope));
-                if (!chainKeys)
-                    continue;
-                this.classifyBindingEdge(catalog, binding, chainKeys, writes, deletes);
+                const key = scopeKey(binding.scope);
+                if (subtree.has(key))
+                    pairs.push({ scope: key, role: binding.uuid });
             }
         }
-        await this.applyBindingSweep(writes, deletes);
+        return { catalog, pairs, subtree };
+    }
+    /**
+     * **El settle del subárbol de un cambio de árbol** (lote C · L13): los bindings de roles locales del subárbol de
+     * `movedKey` (en el store, HIGHER, catálogo en fresco) pasan por `settleRoleVisibility`. Lo llaman `reparent` tras la
+     * arista, su atajo idempotente y su `finally`.
+     */
+    async settleSubtree(movedKey, progress) {
+        const { pairs } = await this.localBindingsBelow(movedKey);
+        await this.settleRoleVisibility(pairs, progress);
     }
     /**
      * **El barrido por NIVEL** (3b-2g · R1; decisión del dueño del 2026-08-30
@@ -1486,46 +2064,29 @@ export class OpenFgaAuthorizationDriver {
      * —donde `declaredRoleAt` se evalúa en cada pregunta— y **sigue
      * concediendo** en `facts`, que es la divergencia R1 del lote 2e.
      *
-     * Se cierra igual que el owner: barriendo la arista `scope#binding` de los
-     * bindings de ESE rol con la regla única de visibilidad. Lo llama
+     * Se cierra igual que el owner: dejando la arista `scope#binding` de los
+     * bindings de ESE rol como dice la regla única de visibilidad. Lo llama
      * `projectCatalogRole`, que es el hook de «una escritura de catálogo cambió
      * este rol»: el manager lo dispara tras `defineScopedRole`/`updateScopedRole`
      * y un escritor «a mano» de `authz_*` tiene el mismo deber que ya tenía con
      * el espejo de permisos (sin él, en `facts` un rol recién definido no
      * concedería nada y quitarle un permiso seguiría concediéndolo).
      *
-     * Coste: una lectura (los bindings del rol) y, **solo si el rol es LOCAL y
-     * tiene bindings**, la cadena del store de cada scope distinto donde cuelga
-     * uno; un `Write` por lote si hay algo que barrer. Un rol sin bindings —el
-     * caso de todo `defineScopedRole`— son 0 escrituras.
+     * **Desde el lote C pasa ENTERO por el settle** (L13; 🟠 1 de F4-carreras: este barrido leía `storeChain` y escribía
+     * DESPUÉS, y un `moved` que barriera entre medias quedaba pisado — fail-OPEN persistente entre tenants). El catálogo es
+     * el de una escritura (K4, hallazgo 4 del panel TREE): con un memo rancio un rol recién definido en otro proceso se
+     * ignoraba. Un rol que el catálogo ya no declara —tras la recarga— no tiene visibilidad que decidir: sus aristas se BORRAN
+     * («rol ausente ⇒ borra», K4); el resto de sus hechos son de `purgeRole`/`authz:reconcile`.
+     *
+     * Coste: una lectura (los bindings del rol) y un `batchCheck` (HIGHER) por vuelta del settle; un `Write` por lote solo
+     * si hay algo que corregir. Un rol sin bindings —todo `defineScopedRole`— son 0 escrituras.
      */
-    async sweepRoleVisibility(roleUuid) {
-        const catalog = await this.catalog.view();
-        // Un rol que el catálogo ya no declara no tiene visibilidad que decidir:
-        // sus hechos son de `purgeRole` (que los borra enteros) y de
-        // `authz:reconcile`, no de este barrido.
-        const role = catalog.roleByUuid(roleUuid);
-        if (!role)
-            return;
-        const bindings = await this.readAllTuples({ user: `${FACTS_ROLE_TYPE}:${roleUuid}`, relation: FACTS_ROLE_RELATION, object: `${FACTS_BINDING_TYPE}:` }, { includeExpired: true });
+    async sweepRoleVisibility(roleUuid, progress) {
+        const bindings = await this.readForWrite({ user: `${FACTS_ROLE_TYPE}:${roleUuid}`, relation: FACTS_ROLE_RELATION, object: `${FACTS_BINDING_TYPE}:` }, { includeExpired: true });
         if (bindings.length === 0)
             return;
-        const writes = [];
-        const deletes = [];
-        /** `scopeKey` → su cadena en el árbol del STORE, una vez por scope. */
-        const chains = new Map();
-        for (const binding of this.parseBindings(FACTS_BINDING_TYPE, bindings.map((t) => t.object))) {
-            const key = scopeKey(binding.scope);
-            let chainKeys = chains.get(key);
-            if (!chainKeys) {
-                // La cadena solo decide para un rol LOCAL: la visibilidad de un
-                // global no depende del árbol, así que no se paga por leerlo.
-                chainKeys = role.owner === GLOBAL_OWNER_KEY ? [key] : await this.storeChain(key);
-                chains.set(key, chainKeys);
-            }
-            this.classifyBindingEdge(catalog, binding, chainKeys, writes, deletes);
-        }
-        await this.applyBindingSweep(writes, deletes);
+        const pairs = this.parseBindings(FACTS_BINDING_TYPE, bindings.map((t) => t.object)).map((b) => ({ scope: scopeKey(b.scope), role: b.uuid }));
+        await this.settleRoleVisibility(pairs, progress);
     }
     /**
      * La arista `scope#binding` de un binding, a escribir o a borrar según la
@@ -1534,7 +2095,7 @@ export class OpenFgaAuthorizationDriver {
      * NIVEL de ese scope (3b-2g · R1) y ser global o tener a su owner en la
      * cadena (3b-2e · E1). Visible ⇒ la arista se (re)escribe; no visible ⇒ se
      * borra. El `assignee` no se toca: la asignación existe igual, lo que
-     * cambia es dónde se la ve.
+     * cambia es dónde se la ve. (Desde el lote C solo lo usa el barrido PREVIO, que solo borra.)
      */
     classifyBindingEdge(catalog, binding, chainKeys, writes, deletes) {
         const edge = factsScopeBindingTuple(scopeKey(binding.scope), binding.uuid);
@@ -1544,31 +2105,11 @@ export class OpenFgaAuthorizationDriver {
             deletes.push(edge);
     }
     /**
-     * Aplica el barrido en lotes ≤ 100 (el límite del `Write`).
-     *
-     * `Ignore` en las dos direcciones: el barrido dice el estado que DEBE
-     * quedar, no el delta — borrar lo que ya no está y reescribir lo que ya
-     * estaba son no-ops, no errores (invariante 6).
+     * Aplica los BORRADOS de un barrido (lote C · L13: `applyBindingSweep` ya no da ALTAS; las altas de `scope#binding` de
+     * rol local solo salen del settle). Borrar nunca concede, así que va directo, en lotes ≤ 100 con `Ignore`.
      */
-    async applyBindingSweep(writes, deletes) {
-        if (!writes.length && !deletes.length)
-            return;
-        const operations = [
-            ...deletes.map((tuple) => ({ delete: tuple })),
-            ...writes.map((tuple) => ({ write: tuple })),
-        ];
-        for (let i = 0; i < operations.length; i += PURGE_BATCH_SIZE) {
-            const chunk = operations.slice(i, i + PURGE_BATCH_SIZE);
-            await this.client.write({
-                writes: chunk.filter((o) => o.write).map((o) => o.write),
-                deletes: chunk.filter((o) => o.delete).map((o) => o.delete),
-            }, {
-                conflict: {
-                    onDuplicateWrites: ClientWriteRequestOnDuplicateWrites.Ignore,
-                    onMissingDeletes: ClientWriteRequestOnMissingDeletes.Ignore,
-                },
-            });
-        }
+    async applyBindingSweep(deletes, progress = { writes: 0 }) {
+        await this.writeBindingEdges([], deletes, progress);
     }
     /**
      * `[key, ...ancestros]` según el ÁRBOL DEL STORE (3b-2e · E1), subiendo por
@@ -1576,14 +2117,15 @@ export class OpenFgaAuthorizationDriver {
      * tiene que gobernar el barrido; el resolutor del consumidor no participa.
      * Un nodo con más de un padre es deriva y se dice (`assertOneParent`), y el
      * recorrido está acotado por el mismo tope de páginas que las
-     * enumeraciones: un ciclo escrito a mano no cuelga el proceso.
+     * enumeraciones: un ciclo escrito a mano no cuelga el proceso. Alimenta
+     * escrituras (anti-ciclos de `reparent`, barrido, caída del settle) ⇒ HIGHER (hallazgo 3 TREE).
      */
     async storeChain(key) {
         const chain = [key];
         const seen = new Set([key]);
         for (let hop = 0; hop < MAX_SCOPE_CHAIN_HOPS; hop++) {
             const object = factsScopeObject(chain[chain.length - 1]);
-            const parents = await this.readAllTuples({ object, relation: FACTS_PARENT_RELATION }, { includeExpired: true });
+            const parents = await this.readForWrite({ object, relation: FACTS_PARENT_RELATION }, { includeExpired: true });
             this.assertOneParent(object, parents);
             if (parents.length === 0)
                 return chain;
@@ -1614,6 +2156,7 @@ export class OpenFgaAuthorizationDriver {
         if (purged.type === APP_SCOPE_TYPE) {
             throw new InvalidIdentityError('purgeScope: la raíz `app` no se purga');
         }
+        await this.assertModel('purgeScope');
         // La identidad canónica si el árbol aún lo conoce (K1); tal cual si ya no.
         const scope = await this.canonicalOrSelf(purged, 'purgeScope');
         const key = scopeKey(scope);
@@ -1630,15 +2173,35 @@ export class OpenFgaAuthorizationDriver {
         const objects = [...roles.map((r) => `role_binding:${key}|${r.uuid}`), scopeObject];
         /** Lo purgable de un objeto: todo, salvo la arista `parent` del scope. */
         const purgeable = async (object) => {
-            const keys = await this.readAllTuples({ object }, { includeExpired: true });
+            const keys = await this.readForWrite({ object }, { includeExpired: true });
             return object === scopeObject ? keys.filter((k) => k.relation !== FACTS_PARENT_RELATION) : keys;
         };
-        /** Borra en lotes ≤ 100 (límite del `Write`), sin quejarse de lo que ya no está. */
-        const deleteKeys = async (keys) => {
+        /**
+         * Cierre 4 de D2 · ⚪ C3-4 (gemelo de `#partialIfDeleted` de relaciones): cuántos `Write` de borrado YA entraron. La
+         * purga son varios `Write` (estructura, hechos por objeto, denies; lotes de 100): un fallo después del primero llega
+         * con parte ya borrada y se marca `markPartialWrite` (el manager notifica `indeterminate: true`, invariante 13). Un
+         * lote que falla no borró nada (FGA aplica cada `Write` entero).
+         */
+        const progress = { deleted: 0, unconfirmed: false };
+        /**
+         * Borra en lotes ≤ 100 (límite del `Write`), sin quejarse de lo que ya no está. Cierre 5 de D2 · ⚪ D4-5: el contador
+         * suma lo que el lote BORRA DE VERDAD (`effective`, por defecto todo: las fases 2-4 borran lo que acaban de LEER), no
+         * lo pedido — la fase 1 borra la estructura a CIEGAS con `Ignore` y hasta el cierre 5 contaba claves que no existían
+         * (un fallo posterior salía `indeterminate: true` sin haber borrado nada).
+         */
+        const deleteKeys = async (keys, effective = () => true) => {
             for (let i = 0; i < keys.length; i += PURGE_BATCH_SIZE) {
-                await this.client.deleteTuples(keys.slice(i, i + PURGE_BATCH_SIZE), {
+                const batch = keys.slice(i, i + PURGE_BATCH_SIZE);
+                await this.client.deleteTuples(batch, {
                     conflict: { onMissingDeletes: ClientWriteRequestOnMissingDeletes.Ignore },
                 });
+                progress.deleted += batch.filter(effective).length;
+                // Cierre 6 de D2 · ⚪ D5-4: una clave pedida a ciegas que la lectura previa NO vio puede haberla escrito un
+                // `grant` concurrente entre esa lectura y este borrado: entonces este lote SÍ borró algo que no se contó. Hasta
+                // que la fase 2 termine (borra —y cuenta— el `assignee` de ese grant) el efecto es INCIERTO, y un fallo en ese
+                // tramo sale marcado parcial: preferir sobre-notificar a sub-notificar.
+                if (batch.some((k) => !effective(k)))
+                    progress.unconfirmed = true;
             }
         };
         /** Las dos aristas de (c2): estructura, no hechos (`#role` y `#binding`). */
@@ -1671,36 +2234,55 @@ export class OpenFgaAuthorizationDriver {
         // el residuo es justo lo que la demostración de cero reporta. La arista
         // `parent` sigue sin tocarse: la borra `scopes.detached` DESPUÉS de que
         // esta purga demuestre cero (S6, cruce 9).
-        await deleteKeys(roles.flatMap((r) => factsBindingTuples(key, r.uuid)));
-        for (const object of objects) {
-            if (object === scopeObject)
-                continue;
-            await deleteKeys((await purgeable(object)).filter((k) => !isStructure(k)));
-        }
-        // **Las aristas `#binding` de roles que el catálogo YA NO declara en este
-        // nivel también se purgan** (3b-8 · C2). El barrido no es atómico con el
-        // catálogo: un rol cuya fila se borró (o cambió de `scope_type`) entre el
-        // commit y esta purga dejaba una arista que el paso 1 no ve —solo mira
-        // `authz_roles WHERE scope_type = <este>`— y que la demostración de cero
-        // SÍ cuenta ⇒ `E_AUTHZ_PURGE_INCOMPLETE` en TODOS los intentos y
-        // `detached` bloqueado para siempre. Borrarla nunca concede (es la arista
-        // de visibilidad, y su rol ya no existe en este nivel), y la arista de un
-        // rol DEL catálogo que un `grant` concurrente reescribió no se toca
-        // (`known` la protege): esa sigue saliendo como residuo, que es lo
-        // correcto — se reintenta.
-        const known = new Set(roles.map((r) => `role_binding:${key}|${r.uuid}`));
-        await deleteKeys((await purgeable(scopeObject)).filter((k) => k.relation === FACTS_BINDING_RELATION && !known.has(k.user)));
-        await deleteKeys((await purgeable(scopeObject)).filter((k) => k.relation.startsWith(FACTS_DENIED_PREFIX)));
-        // Demostrar cero: lo que no se puede demostrar, se reporta.
-        const residue = [];
-        for (const object of objects) {
-            const left = await purgeable(object);
-            if (left.length)
-                residue.push(`${object} (${left.length})`);
-        }
-        if (residue.length) {
-            throw new PurgeIncompleteError(`purgeScope ${key}: quedan tuplas tras el borrado — ${residue.join('; ')}. ` +
-                `No confirmes el borrado del scope; reintenta la purga.`);
+        // Los pasos (estructura → hechos → denies → demostrar cero), en una función LOCAL (no un método `#`: el driver
+        // puede llegar envuelto en un Proxy y un campo privado exige el receptor real), para marcar el corte a medias.
+        const steps = async () => {
+            // ⚪ D4-5 (cierre 5 de D2): qué estructura EXISTE antes del borrado a ciegas — UNA lectura del scope (sus aristas
+            // `#binding`). Solo la arista `scope#binding` hace visible (y por tanto observable) un rol aquí: un `role_binding#role`
+            // sin su `#binding` (lo que deja el barrido de roles locales) no cambia ninguna respuesta al borrarse, así que no
+            // cuenta como escritura hecha. Ventana declarada: una arista que un `grant` concurrente escribe ENTRE esta lectura y
+            // el borrado se borra sin contarse; la fase 2 borra después su `assignee`, que sí cuenta, y HASTA que la fase 2
+            // termina el error va marcado parcial igual (`unconfirmed`, ⚪ D5-4 del cierre 6: sobre-notificar, nunca sub-).
+            const visible = new Set((await purgeable(scopeObject)).filter((k) => k.relation === FACTS_BINDING_RELATION).map((k) => k.user));
+            await deleteKeys(roles.flatMap((r) => factsBindingTuples(key, r.uuid)), (k) => visible.has(k.relation === FACTS_BINDING_RELATION ? k.user : k.object));
+            for (const object of objects) {
+                if (object === scopeObject)
+                    continue;
+                await deleteKeys((await purgeable(object)).filter((k) => !isStructure(k)));
+            }
+            // ⚪ D5-4: la fase 2 terminó — el `assignee` de un grant que se coló antes de la fase 1 ya se borró y se contó.
+            progress.unconfirmed = false;
+            // **Las aristas `#binding` de roles que el catálogo YA NO declara en este
+            // nivel también se purgan** (3b-8 · C2). El barrido no es atómico con el
+            // catálogo: un rol cuya fila se borró (o cambió de `scope_type`) entre el
+            // commit y esta purga dejaba una arista que el paso 1 no ve —solo mira
+            // `authz_roles WHERE scope_type = <este>`— y que la demostración de cero
+            // SÍ cuenta ⇒ `E_AUTHZ_PURGE_INCOMPLETE` en TODOS los intentos y
+            // `detached` bloqueado para siempre. Borrarla nunca concede (es la arista
+            // de visibilidad, y su rol ya no existe en este nivel), y la arista de un
+            // rol DEL catálogo que un `grant` concurrente reescribió no se toca
+            // (`known` la protege): esa sigue saliendo como residuo, que es lo
+            // correcto — se reintenta.
+            const known = new Set(roles.map((r) => `role_binding:${key}|${r.uuid}`));
+            await deleteKeys((await purgeable(scopeObject)).filter((k) => k.relation === FACTS_BINDING_RELATION && !known.has(k.user)));
+            await deleteKeys((await purgeable(scopeObject)).filter((k) => k.relation.startsWith(FACTS_DENIED_PREFIX)));
+            // Demostrar cero: lo que no se puede demostrar, se reporta.
+            const residue = [];
+            for (const object of objects) {
+                const left = await purgeable(object);
+                if (left.length)
+                    residue.push(`${object} (${left.length})`);
+            }
+            if (residue.length) {
+                throw new PurgeIncompleteError(`purgeScope ${key}: quedan tuplas tras el borrado — ${residue.join('; ')}. ` +
+                    `No confirmes el borrado del scope; reintenta la purga.`);
+            }
+        };
+        try {
+            await steps();
+        }
+        catch (error) {
+            throw (progress.deleted > 0 || progress.unconfirmed) && error !== null && typeof error === 'object' ? markPartialWrite(error) : error;
         }
     }
     /**
@@ -1744,7 +2326,7 @@ export class OpenFgaAuthorizationDriver {
      */
     async ensureFactsRoot() {
         const wanted = factsRootTuples(this.holderTypes);
-        const current = await this.readAllTuples({ object: factsScopeObject(APP_SCOPE_TYPE), relation: FACTS_ROOTED_RELATION }, { includeExpired: true });
+        const current = await this.readForWrite({ object: factsScopeObject(APP_SCOPE_TYPE), relation: FACTS_ROOTED_RELATION }, { includeExpired: true });
         const have = new Set(current.map((tuple) => tuple.user));
         const missing = wanted.filter((tuple) => !have.has(tuple.user));
         if (missing.length)
@@ -1761,6 +2343,7 @@ export class OpenFgaAuthorizationDriver {
      * catálogo escribe CERO tuplas.
      */
     async projectCatalog(snapshot) {
+        await this.assertModel('catalogProjection.project');
         await this.ensureFactsRoot();
         const wanted = new Map();
         for (const tuple of factsCatalogTuples(snapshot.roles, this.holderTypes)) {
@@ -1778,7 +2361,7 @@ export class OpenFgaAuthorizationDriver {
         // otro user sobre `role:` no es de esta proyección y no se toca.
         const current = new Map();
         for (const holderType of Object.values(this.holderTypes)) {
-            for (const key of await this.readAllTuples({ user: `${holderType}:*`, object: `${FACTS_ROLE_TYPE}:` }, { includeExpired: true })) {
+            for (const key of await this.readForWrite({ user: `${holderType}:*`, object: `${FACTS_ROLE_TYPE}:` }, { includeExpired: true })) {
                 // Solo la familia del catálogo: si el modelo crece con otras
                 // relaciones sobre `role`, no son de esta proyección.
                 if (!key.relation.startsWith(FACTS_PERMITS_PREFIX))
@@ -1825,14 +2408,24 @@ export class OpenFgaAuthorizationDriver {
      */
     async purgeRole(roleUuid) {
         assertCatalogUuid('rol', roleUuid);
+        await this.assertModel('purgeRole');
         const existing = await this.sql('purgeRole.role', () => db.from('authz_roles').where('uuid', roleUuid).select('uuid'));
         if (!existing.length)
             throw new UnknownRoleError(roleUuid);
         const roleObject = `${FACTS_ROLE_TYPE}:${roleUuid}`;
-        /** Los objetos `role_binding` de este rol, por su arista `#role`. */
+        /**
+         * Los objetos `role_binding` de este rol, por su arista `#role` — **y todos los que ya se vieron** (lote C · hallazgo 2
+         * del panel TREE, ORPHAN): el borrado se lleva la arista `#role`, así que la demostración de cero y el repaso que
+         * enumeraban SOLO por ella no veían el `assignee` que un `grant` concurrente escribió en un binding ya enumerado
+         * (estructura compartida: `Ignore` de duplicados) — la purga «demostraba» cero y ese hecho quedaba huérfano para
+         * siempre. Con la unión, ese hecho sale como residuo (500 `E_AUTHZ_PURGE_INCOMPLETE`, se reintenta) o lo borra el repaso.
+         */
+        const seenBindings = new Set();
         const bindingsOf = async () => {
-            const edges = await this.readAllTuples({ user: roleObject, relation: FACTS_ROLE_RELATION, object: `${FACTS_BINDING_TYPE}:` }, { includeExpired: true });
-            return [...new Set(edges.map((edge) => edge.object))];
+            const edges = await this.readForWrite({ user: roleObject, relation: FACTS_ROLE_RELATION, object: `${FACTS_BINDING_TYPE}:` }, { includeExpired: true });
+            for (const edge of edges)
+                seenBindings.add(edge.object);
+            return [...seenBindings];
         };
         /** El scope del que cuelga un binding, según su propio id (`<scopeKey>|<roleUuid>`). */
         const scopeOf = (binding) => {
@@ -1840,37 +2433,63 @@ export class OpenFgaAuthorizationDriver {
             const separator = id.lastIndexOf('|');
             return separator > 0 ? id.slice(0, separator) : null;
         };
-        /** Todo lo purgable del rol: sus bindings enteros, las aristas del scope y su proyección. */
+        /** Los HECHOS purgables del rol: sus bindings enteros y las aristas del scope (sin la proyección: ver `projection`). */
         const purgeable = async () => {
             const keys = [];
             for (const binding of await bindingsOf()) {
-                keys.push(...(await this.readAllTuples({ object: binding }, { includeExpired: true })));
+                keys.push(...(await this.readForWrite({ object: binding }, { includeExpired: true })));
                 const key = scopeOf(binding);
                 if (!key)
                     continue;
                 // La arista vive en el objeto `scope`, así que se lee de ahí (y solo
                 // la que apunta a ESTE binding: el scope tiene las de otros roles).
-                const scopeEdges = await this.readAllTuples({ user: binding, relation: FACTS_BINDING_RELATION, object: factsScopeObject(key) }, { includeExpired: true });
+                const scopeEdges = await this.readForWrite({ user: binding, relation: FACTS_BINDING_RELATION, object: factsScopeObject(key) }, { includeExpired: true });
                 keys.push(...scopeEdges);
             }
-            // La proyección del catálogo del rol: `role:<uuid>#permits_<P>@<holder>:*`.
+            return keys;
+        };
+        /** La proyección del catálogo del rol: `role:<uuid>#permits_<P>@<holder>:*`. */
+        const projection = async () => {
+            const keys = [];
             for (const holderType of Object.values(this.holderTypes)) {
-                keys.push(...(await this.readAllTuples({ user: `${holderType}:*`, object: roleObject }, { includeExpired: true })));
+                keys.push(...(await this.readForWrite({ user: `${holderType}:*`, object: roleObject }, { includeExpired: true })));
             }
             return keys;
         };
-        const keys = await purgeable();
-        for (let i = 0; i < keys.length; i += PURGE_BATCH_SIZE) {
-            await this.client.deleteTuples(keys.slice(i, i + PURGE_BATCH_SIZE), {
-                conflict: { onMissingDeletes: ClientWriteRequestOnMissingDeletes.Ignore },
-            });
-        }
-        const residue = await purgeable();
-        if (residue.length) {
-            throw new PurgeIncompleteError(`purgeRole ${roleUuid}: quedan ${residue.length} tuplas tras el borrado ` +
-                `(${residue.slice(0, 3).map((k) => `${k.user}#${k.relation}@${k.object}`).join('; ')}…). ` +
-                `El rol NO se borra del catálogo: reintenta la purga.`);
-        }
+        /** Borrar y RELEER hasta cero, con cota; devuelve lo que sobrevive a la última relectura. */
+        const deleteUntilZero = async (read) => {
+            let residue = await read();
+            for (let round = 0; residue.length > 0 && round < PURGE_ROLE_ROUNDS; round++) {
+                for (let i = 0; i < residue.length; i += PURGE_BATCH_SIZE) {
+                    await this.client.deleteTuples(residue.slice(i, i + PURGE_BATCH_SIZE), {
+                        conflict: { onMissingDeletes: ClientWriteRequestOnMissingDeletes.Ignore },
+                    });
+                }
+                residue = await read();
+            }
+            return residue;
+        };
+        const incomplete = (residue, what) => new PurgeIncompleteError(`purgeRole ${roleUuid}: quedan ${residue.length} tuplas ${what} tras el borrado ` +
+            `(${residue.slice(0, 3).map((k) => `${k.user}#${k.relation}@${k.object}`).join('; ')}…). ` +
+            `El rol NO se borra del catálogo: reintenta la purga.`);
+        // Lote C (hallazgo 2, ORPHAN): borrar y RELEER hasta cero, con cota. Un escritor concurrente (el settle de un `moved`
+        // o de un `grant` que decidió con `role_binding#role` vivo) puede dejar una arista en un binding ya enumerado entre la
+        // lectura y el borrado; la vuelta siguiente la ve (los bindings vistos se recuerdan) y la borra. Antes, una vuelta y la
+        // demostración: ese residuo salía como `E_AUTHZ_PURGE_INCOMPLETE`, y el reintento ya NO lo veía (la arista `#role` se
+        // había ido con la primera pasada): una `scope#binding` resucitada para siempre.
+        //
+        // **Asentar · cierre 1, desviación 2 = (b) (firma del dueño 2026-10-21): la proyección `permits_*` se borra DESPUÉS de
+        // demostrar cero en los HECHOS.** Antes iban juntos, y una purga que fallaba (500 `E_AUTHZ_PURGE_INCOMPLETE` o un 503)
+        // dejaba el rol en el catálogo SIN conceder lo que aún tenía asignado (CLOSED hasta el reintento; la propiedad lo
+        // eximía con la atribución `purge-incomplete`, que tapaba síntomas reales del mutante `purgeRole.one-round`). Ahora
+        // una purga que falla en los hechos deja el rol entero (lo que queda asignado sigue concediendo, reintentable); con
+        // los hechos a cero ya no hay asignación a la que la proyección conceda, así que su borrado no cierra nada.
+        const residue = await deleteUntilZero(purgeable);
+        if (residue.length)
+            throw incomplete(residue, 'de hechos');
+        const projected = await deleteUntilZero(projection);
+        if (projected.length)
+            throw incomplete(projected, 'de la proyección permits_*');
         try {
             await this.sql('purgeRole', () => withAuthzCatalogWrite(async (trx) => {
                 // `authz_assignments` es del driver `database` y aquí está vacía,
@@ -1886,6 +2505,25 @@ export class OpenFgaAuthorizationDriver {
         finally {
             this.catalog.invalidate();
         }
+        // **Hallazgo 2 del panel TREE (ORPHAN), la pata Dekker de `purgeRole`**: un `grant` del rol que se coló entre la
+        // demostración de cero y el DELETE SQL (leyó el catálogo con el rol vivo) dejó sus tuplas —incluida la arista
+        // `scope#binding`, que ya ninguna regla gobierna— DESPUÉS de la purga. Con el rol ya fuera de la base, se repasa lo
+        // purgable y se BORRA lo reaparecido. No lanza: la purga del rol ya ocurrió (el catálogo lo dice), y lo que un `grant`
+        // —nuevo o RE-grant: desde el cierre 1 del asentar, sin mirar `created`— escriba después de ESTA lectura lo deshace él
+        // mismo: su settle ve el rol ausente tras recargar y el `grant` borra sus tres tuplas. Un fallo de esta pasada (503) tampoco revierte nada: lo que quede no concede (no hay `permits_*` ni rol en
+        // el catálogo) y lo recoge `authz:reconcile --prune`.
+        try {
+            const reappeared = [...(await purgeable()), ...(await projection())];
+            for (let i = 0; i < reappeared.length; i += PURGE_BATCH_SIZE) {
+                await this.client.deleteTuples(reappeared.slice(i, i + PURGE_BATCH_SIZE), {
+                    conflict: { onMissingDeletes: ClientWriteRequestOnMissingDeletes.Ignore },
+                });
+            }
+        }
+        catch (error) {
+            this.warn(`authz(openfga): purgeRole ${roleUuid}: el repaso tras borrar el rol del catálogo falló (${String(error?.message ?? error)}); ` +
+                'lo que reapareció no concede y lo recoge authz:reconcile --prune.');
+        }
     }
     /**
      * Cuántos hechos VIGENTES tiene cada rol, en todos los scopes (3b-2j).
@@ -1919,12 +2557,15 @@ export class OpenFgaAuthorizationDriver {
     async countRoleAssignments(roleUuids) {
         for (const uuid of roleUuids)
             assertCatalogUuid('rol', uuid);
+        await this.assertModel('countRoleAssignments');
         const counts = [];
         for (const roleUuid of roleUuids) {
             const edges = await this.readAllTuples({ user: `${FACTS_ROLE_TYPE}:${roleUuid}`, relation: FACTS_ROLE_RELATION, object: `${FACTS_BINDING_TYPE}:` }, { includeExpired: true });
             let total = 0;
             for (const binding of new Set(edges.map((edge) => edge.object))) {
-                total += (await this.readAllTuples({ relation: FACTS_ASSIGNEE_RELATION, object: binding })).length;
+                // Cierre de L11 (🟡 A2(a) / 🟠-2 del tester, clase 3b-2j): un `assignee` `foreign`/`unparseable` CUENTA —puede estar
+                // vivo en el servidor y contarlo de menos es decir «no concede» sobre algo que sí, justo antes de un purgeRole—.
+                total += (await this.readAllTuples({ relation: FACTS_ASSIGNEE_RELATION, object: binding }, { includeInvalid: true })).length;
             }
             counts.push(total);
         }
@@ -1949,8 +2590,25 @@ export class OpenFgaAuthorizationDriver {
      */
     async projectCatalogRole(roleUuid) {
         assertCatalogUuid('rol', roleUuid);
-        await this.sweepRoleVisibility(roleUuid);
-        const catalog = await this.catalog.view();
+        await this.assertModel('projectCatalogRole');
+        // Lote C · L13: la visibilidad pasa por el settle (punto de paso único); un fallo tras ≥ 1 `Write` sale PARCIAL.
+        const progress = { writes: 0 };
+        try {
+            await this.sweepRoleVisibility(roleUuid, progress);
+            await this.projectRolePermits(roleUuid);
+        }
+        catch (error) {
+            throw progress.writes > 0 ? markPartialObject(error) : error;
+        }
+    }
+    /**
+     * La proyección `permits_<P>` de UN rol (la otra mitad de `projectCatalogRole`). **Hallazgo 4 del panel TREE (K4)**: el
+     * catálogo es el de una ESCRITURA (`writeCatalog`, versión en fresco) — con un memo `{ everyMs }` que todavía no conoce
+     * un rol recién definido en otro proceso, `rolePermissionsOf` devolvía `[]` y esto BORRABA sus `permits_*` (fail-closed
+     * medido: `dave@C`). Mutante `project.memo-catalog`.
+     */
+    async projectRolePermits(roleUuid) {
+        const catalog = await this.writeCatalogKnowing([roleUuid]);
         const permissions = [...catalog.rolePermissionsOf(roleUuid)].sort();
         const object = `${FACTS_ROLE_TYPE}:${roleUuid}`;
         const wanted = new Map();
@@ -1959,7 +2617,7 @@ export class OpenFgaAuthorizationDriver {
         }
         const current = new Map();
         for (const holderType of Object.values(this.holderTypes)) {
-            for (const key of await this.readAllTuples({ user: `${holderType}:*`, object }, { includeExpired: true })) {
+            for (const key of await this.readForWrite({ user: `${holderType}:*`, object }, { includeExpired: true })) {
                 if (!key.relation.startsWith(FACTS_PERMITS_PREFIX))
                     continue;
                 current.set(factsTupleId(key), key);
@@ -2019,7 +2677,9 @@ export class OpenFgaAuthorizationDriver {
         const prune = options.prune === true;
         const batchSize = reconcileBatchSize(options.batchSize);
         const maxTuples = reconcileMaxTuples(options.maxTuples);
-        const catalog = await this.catalog.view();
+        await this.assertModel('reconcile');
+        // K4 (lote C · carreras): la pasada que ESCRIBE decide con el catálogo contrastado en fresco.
+        const catalog = await this.writeCatalog();
         const now = this.now();
         /** Lo que el destino DEBE tener, por id de tupla. */
         const wanted = new Map();
@@ -2170,6 +2830,8 @@ export class OpenFgaAuthorizationDriver {
          */
         const foreignTypes = new Map();
         let foreignTuples = 0;
+        /** Cierre de L11: los denies que el origen quiere y el destino tiene con una condición ajena (niegan la pasada). */
+        const blockedDenies = [];
         for (const tuple of current) {
             const id = factsTupleId(tuple);
             const family = familyOfTuple(tuple);
@@ -2179,6 +2841,25 @@ export class OpenFgaAuthorizationDriver {
                 foreignTypes.set(type, (foreignTypes.get(type) ?? 0) + 1);
                 continue;
             }
+            // L11 · H8: una tupla del DESTINO con una condición que el paquete no escribe es PRESENTE e INTOCABLE: ni se
+            // borra (tampoco con `--prune`) ni se reescribe encima lo que el origen quiere en esa clave; se lista y es deriva.
+            if (tuple.invalid !== undefined) {
+                const target = wanted.get(id);
+                if (target)
+                    seen.add(id);
+                note('tuple', 'invalid-condition', `${id} (${tuple.invalid})`);
+                // Cierre de L11 (⚪ A2(b) del auditor; gemelo de relaciones, donde el deny bloqueado por una clave ajena del destino
+                // NIEGA la pasada): un DENY que el origen quiere y el destino tiene con una condición que el paquete no escribe NO
+                // queda «presente» — el servidor puede ignorarlo (una restricción sin condición, M-a(1)) y los grants que la
+                // pasada escribe concederían. Ante la duda, lo que nunca concede de más: la pasada que escribe se NIEGA (abajo).
+                // Cierre-2 (C1): en MANTENIMIENTO el origen ES este store, así que ese deny lo emitió él mismo (marcado): la pasada
+                // no escribe hechos alrededor, negarla solo bloquearía lo DERIVADO (marcador, árbol, barrido `roleVisibility` del
+                // invariante 18). Se deja intocable y se reporta (la nota de arriba), sin negar.
+                if (target && !originIsSelf && target.tuple.relation.startsWith(FACTS_DENIED_PREFIX)) {
+                    blockedDenies.push(`${id} (${tuple.invalid})`);
+                }
+                continue;
+            }
             if (tuple.relation === FACTS_ASSIGNEE_RELATION)
                 storeBindings.add(tuple.object);
             if (tuple.relation === FACTS_PARENT_RELATION && tuple.object.startsWith(`${FACTS_SCOPE_TYPE}:`)) {
@@ -2237,6 +2918,13 @@ export class OpenFgaAuthorizationDriver {
         // que devuelve N filas y las N se descartan (caducadas, scopes que ya no
         // resuelven) sigue sin respaldar NADA de lo que --prune va a borrar.
         const massDelete = prune && factsDeleted > 0 && facts.usable === 0;
+        if (blockedDenies.length > 0 && !dryRun) {
+            throw new DenyMigrationRefusedError(`deny NO migrable: authz:reconcile --to=openfga se NIEGA — ${blockedDenies.length} deny(s) que el origen quiere y el ` +
+                `DESTINO tiene con una condición que el paquete no escribe ni sabe leer (L11): ${blockedDenies.slice(0, 5).join('; ')}` +
+                `${blockedDenies.length > 5 ? '; …' : ''}. El servidor puede ignorar ese deny (su restricción no admite condición) y ` +
+                'escribir los grants alrededor concedería lo que el origen niega. No se ha escrito nada. Receta: borra esa tupla del ' +
+                'destino a mano (SDK/CLI de OpenFGA) y repite; --dry-run la lista como invalid-condition.');
+        }
         if (massDelete && !dryRun && options.allowMassDelete !== true) {
             throw new MassReconcileRefusedError(`authz:reconcile --to=openfga --prune borraría ${factsDeleted} tupla(s) de hechos del store y el ` +
                 `ORIGEN no ha aportado NI UN hecho utilizable (${facts.rows} leídos, todos descartados — mira ` +
@@ -2247,10 +2935,27 @@ export class OpenFgaAuthorizationDriver {
                 `--allow-mass-delete.`);
         }
         if (!dryRun) {
+            // **Lote C · L13 (resolución 10 del juez): las ALTAS de `scope#binding` de un rol LOCAL pasan por el settle.** La
+            // pasada las decide con una foto de toda la pasada (segundos o minutos) sin relectura, y el freeze no para las
+            // escrituras en vuelo ni `manager.driver()`: escritas a ciegas, un `moved` que barriera entre medias quedaba
+            // pisado. Se sacan de `writes` y, con el árbol y la estructura ya escritos, el settle las relee y las asienta con el
+            // STORE. Las de roles globales (su visibilidad no depende del árbol) y todo lo demás van como siempre.
+            const settlePairs = [];
+            for (let i = writes.length - 1; i >= 0; i--) {
+                const tuple = writes[i];
+                if (tuple?.relation !== FACTS_BINDING_RELATION || !String(tuple.object).startsWith(`${FACTS_SCOPE_TYPE}:`))
+                    continue;
+                const binding = parseBindingId(String(tuple.user).slice(FACTS_BINDING_TYPE.length + 1));
+                if (!binding || catalog.roleByUuid(binding.uuid)?.owner === GLOBAL_OWNER_KEY)
+                    continue;
+                settlePairs.push({ scope: scopeKey(binding.scope), role: binding.uuid });
+                writes.splice(i, 1);
+            }
             // Los DELETES primero: si la pasada muere entre medias, lo que queda es
             // de MENOS (fail-closed), nunca una tupla vieja conviviendo con la nueva.
             await this.applyReconcileWrites(deletes, []);
             await this.applyReconcileWrites([], writes);
+            await this.settleRoleVisibility(settlePairs.reverse(), { writes: 0 });
         }
         const totals = sumPhases(phases);
         return {
@@ -2284,18 +2989,9 @@ export class OpenFgaAuthorizationDriver {
      * el modelo que sí sirve (fail-closed sobre un permiso vivo).
      */
     async modelPermissions() {
-        // `readAuthorizationModel()` sin argumentos usa el `authorizationModelId`
-        // con el que se construyó el cliente (el mismo de cada `Write`/`Check`).
-        const response = this.modelId
-            ? await this.client.readAuthorizationModel()
-            : await this.client.readLatestAuthorizationModel();
-        const model = response?.authorization_model;
-        if (!model?.type_definitions)
-            return null;
-        const role = model.type_definitions.find((definition) => definition.type === FACTS_ROLE_TYPE);
-        if (!role?.relations)
-            return null;
-        return new Set(Object.keys(role.relations).filter((name) => name.startsWith(FACTS_PERMITS_PREFIX)));
+        // L11: la MISMA lectura (memorizada) que la puerta; `P_M` son las bases de `role#permits_*` del modelo FIJADO.
+        const { permissions } = await this.modelGate();
+        return new Set(permissions.map((permission) => `${FACTS_PERMITS_PREFIX}${permission}`));
     }
     /**
      * El árbol del ORIGEN, paginado (`scopes.enumerateEdges`), con los ciclos
@@ -2579,6 +3275,12 @@ export class OpenFgaAuthorizationDriver {
                     ctx.discard('deny', 'unknown-permission', fact.detail);
                     continue;
                 }
+                // Cierre-2 de L11 (C1): un deny MARCADO del origen se quiere igual (fail-closed: se escribe sin condición, niega);
+                // si el origen es OTRO store, se declara aquí. En mantenimiento la clave es la misma tupla del destino y la cuenta
+                // el bucle del destino (una sola nota por tupla).
+                if (fact.invalidCondition !== undefined && source.factsOrigin?.self !== true) {
+                    ctx.note('deny', 'invalid-condition', `${fact.detail} (${fact.invalidCondition})`);
+                }
                 if (this.wantDeny(ctx, {
                     holder: fact.holder,
                     scope: fact.scope,
@@ -2722,6 +3424,9 @@ export class OpenFgaAuthorizationDriver {
         if (!Number.isFinite(limit) || limit < 1) {
             throw new AuthorizationConfigError(`enumerateFacts: limit debe ser un entero >= 1 (llegó ${String(page.limit)})`);
         }
+        // L11: el ORIGEN de una migración pasa SOLO la parte `conditions` (tiene que poder rescatar un store con deriva de
+        // reglas; la vigencia de lo que emite sí depende de la condición del modelo).
+        await this.assertModel('enumerateFacts', 'conditions');
         const catalog = await this.catalog.view();
         const permissionByRelation = new Map();
         for (const slug of catalog.permissionSlugs) {
@@ -2766,12 +3471,19 @@ export class OpenFgaAuthorizationDriver {
                     skipped.push({ kind: 'tuple', reason: 'unknown-holder-type', detail: id });
                     continue;
                 }
+                // L11: una condición que el paquete no escribe o no sabe leer NO es «permanente»: no se migra (fail-closed: el
+                // destino no concede lo que el origen quizá no concedía) y se cuenta.
+                const condition = storedCondition(key.condition);
+                if (condition.invalid !== undefined) {
+                    skipped.push({ kind: 'tuple', reason: 'invalid-condition', detail: `${id} (${condition.invalid})` });
+                    continue;
+                }
                 facts.push({
                     kind: 'assignment',
                     holder,
                     scope: binding.scope,
                     roleUuid: binding.uuid,
-                    expiresAt: toExpiryDate(key.condition?.context?.valid_until),
+                    expiresAt: condition.validUntil,
                     detail: id,
                 });
                 continue;
@@ -2794,7 +3506,18 @@ export class OpenFgaAuthorizationDriver {
                     skipped.push({ kind: 'tuple', reason: 'unknown-holder-type', detail: id });
                     continue;
                 }
-                facts.push({ kind: 'deny', holder, scope, permission, detail: id });
+                // Cierre-2 de L11 (C1 del auditor; gemelo del `assignee` de arriba): un deny con una condición que el paquete no
+                // escribe se MARCA en vez de salir como deny limpio. No se salta (hacia `database` perderlo sería fail-OPEN): el
+                // destino lo migra como deny y lo declara, y la pasada de MANTENIMIENTO lo deja donde está y lo reporta.
+                const condition = storedCondition(key.condition);
+                facts.push({
+                    kind: 'deny',
+                    holder,
+                    scope,
+                    permission,
+                    detail: id,
+                    ...(condition.invalid !== undefined ? { invalidCondition: condition.invalid } : {}),
+                });
                 continue;
             }
             // **El deny del modo `resolver` de 2.2 ES un hecho y se emite** (3b-8 ·
@@ -2853,7 +3576,7 @@ export class OpenFgaAuthorizationDriver {
         const seenTokens = new Set();
         let pages = 0;
         do {
-            const response = await this.client.read({}, { pageSize: READ_PAGE_SIZE, continuationToken, consistency: this.consistency });
+            const response = await this.client.read({}, { pageSize: READ_PAGE_SIZE, continuationToken, consistency: WRITE_CONSISTENCY });
             pages += 1;
             for (const tuple of this.tuplesOrThrow(response, 'reconcile.readEveryTuple')) {
                 const key = tuple?.key;
@@ -2863,12 +3586,7 @@ export class OpenFgaAuthorizationDriver {
                         `no se puede comparar (total: ${this.diagnostics.unparseableBindings})`);
                     continue;
                 }
-                out.push({
-                    user: key.user,
-                    relation: key.relation,
-                    object: key.object,
-                    validUntil: toExpiryDate(key.condition?.context?.valid_until),
-                });
+                out.push({ user: key.user, relation: key.relation, object: key.object, ...storedCondition(key.condition) });
                 if (out.length > maxTuples) {
                     throw new ReconcileTooLargeError(`authz:reconcile --to=openfga: el store pasa de maxTuples (${maxTuples}) tuplas y la pasada ` +
                         `necesita la foto ENTERA del destino para saber qué sobra (que es la mitad del trabajo: ` +
@@ -2938,6 +3656,14 @@ export class OpenFgaAuthorizationDriver {
         }
         return tuples;
     }
+    /**
+     * **`readAllTuples` para una lectura que ALIMENTA UNA ESCRITURA** (lote C · carreras, resolución 8; hallazgo 3 TREE):
+     * con `HIGHER_CONSISTENCY` siempre (`WRITE_CONSISTENCY`). Es el helper ÚNICO: la guardia de fuente de
+     * `tests/visibility_settle.spec.ts` exige que los métodos que escriben lean por aquí (o por `checkForWrite`).
+     */
+    readForWrite(filter, options = {}) {
+        return this.readAllTuples(filter, { ...options, consistency: WRITE_CONSISTENCY });
+    }
     async readAllTuples(filter, options = {}) {
         // El instante con el que se filtra: el de la operación si lo trae (K9), o
         // el de esta lectura.
@@ -2950,7 +3676,7 @@ export class OpenFgaAuthorizationDriver {
             const response = await this.client.read(filter, {
                 pageSize: READ_PAGE_SIZE,
                 continuationToken,
-                consistency: this.consistency,
+                consistency: options.consistency ?? this.consistency,
             });
             pages += 1;
             for (const tuple of this.tuplesOrThrow(response, `Read ${JSON.stringify(filter)}`)) {
@@ -2963,8 +3689,22 @@ export class OpenFgaAuthorizationDriver {
                     continue;
                 }
                 if (!options.includeExpired) {
-                    const validUntil = toExpiryDate(k.condition?.context?.valid_until);
-                    if (validUntil && validUntil <= now)
+                    const condition = storedCondition(k.condition);
+                    // L11: una condición que el paquete no escribe o no sabe leer no es un hecho vigente que enumerar (sería
+                    // «permanente» por defecto): se avisa y se cuenta, como una tupla malformada. Las purgas leen con
+                    // `includeExpired` y la borran igual.
+                    // Cierre de L11 (criterio: ante la duda, lo que nunca concede de más): donde la tupla NIEGA o CUENTA
+                    // (`includeInvalid`: los denies de `listScopes`, el conteo de `countRoleAssignments`) se toma VIVA —un
+                    // `not_expired` con `current_time` congelado lo está en el servidor, H2—, con el mismo aviso.
+                    if (condition.invalid !== undefined) {
+                        this.diagnostics.unparseableBindings += 1;
+                        this.warn(`authz(openfga): tupla con una condición que el paquete no escribe en Read ${JSON.stringify(filter)} (${k.user}#${k.relation}@${k.object}: ${condition.invalid}); ${options.includeInvalid ? 'se cuenta VIVA (niega o cuenta: lo conservador)' : 'se ignora en la enumeración'} (total: ${this.diagnostics.unparseableBindings})`);
+                        if (!options.includeInvalid)
+                            continue;
+                        keys.push({ user: k.user, relation: k.relation, object: k.object });
+                        continue;
+                    }
+                    if (condition.validUntil && condition.validUntil <= now)
                         continue;
                 }
                 keys.push({ user: k.user, relation: k.relation, object: k.object });
@@ -3088,6 +3828,16 @@ function foreignReport(tuples, types, relationTypes) {
             relations += count;
     return { tuples, types: byType, relations, unknown: tuples - relations };
 }
+/** Una tupla tal como está HOY en el store (con su caducidad). */
+/** La condición de una tupla leída (L11): el ÚNICO paso por `fgaTupleExpiry` de este driver. */
+function storedCondition(condition) {
+    const expiry = fgaTupleExpiry(condition);
+    if (expiry.kind === 'expiry')
+        return { validUntil: expiry.at };
+    if (expiry.kind === 'none')
+        return { validUntil: null };
+    return { validUntil: null, invalid: `${expiry.kind}: ${expiry.detail}` };
+}
 /** La clave sola: un `delete` de FGA no lleva condición. */
 function bareTuple(tuple) {
     return { user: tuple.user, relation: tuple.relation, object: tuple.object };
@@ -3129,4 +3879,3 @@ function walkUpTo(parentOf, from, target) {
     }
     return null;
 }
-//# sourceMappingURL=openfga_driver.js.map