> Source: https://clickhouse.github.io/loom/es/architecture/cells/ (Markdown: https://clickhouse.github.io/loom/es/architecture/cells.md)

<!-- i18n: source=docs/architecture/cells.md blob=78e1d4c689a18b65208ce7c9b2d1a0593744a238 model=claude-sonnet-5-5 -->
> Esta página es una traducción automática de la [página en inglés](https://clickhouse.github.io/loom/architecture/cells/), que prevalece.
> Machine-translated from the [English page](https://clickhouse.github.io/loom/architecture/cells/), which is authoritative.

<a id="cells"></a>

# Celdas

La memoria de un despliegue puede crecer más allá de un primario de Postgres y un servicio de ClickHouse, y una organización puede querer su memoria en servicios propios. Una **celda** es un despliegue completo de Loom tal como lo describe esta documentación: sus réplicas y workers, una unidad de Postgres (un primario con sus standbys), un servicio de ClickHouse, un prefijo de bucket de documentos, su propio host público, y sus propias claves de firma, concesiones, workers y borrado. Un **router** en el host compartido del despliegue envía cada solicitud a la celda que contiene lo que esta direcciona. Una organización vive en exactamente una celda, la que la colocó, y nunca la abandona. Una organización se coloca al hacer attach (las organizaciones que la celda contenía y sus organizaciones configuradas), con `loom cell update` (una organización configurada que cambió) o `loom cell place`, o en la primera solicitud verificada de un principal limitado a ella. Un despliegue con una sola celda y sin router funciona como un despliegue único.

Las celdas necesitan la autoridad de Postgres (`LOOM_STORAGE_AUTHORITY=postgres`) y una autenticación que todos los transportes apliquen (`auth_actually_required()`, y que `LOOM_MCP_AUTH_MODE` no sea `open`): `loom cell attach` se niega a continuar sin ellas, y un proceso con `LOOM_CELL` definido se niega a arrancar sin ellas. [Autoridad de almacenamiento](https://github.com/ClickHouse/loom/blob/main/docs/architecture/storage-authority.md) describe qué contiene una celda y cómo concuerdan sus dos almacenes.

<a id="why-whole-deployments"></a>

## Por qué despliegues completos

Una celda no comparte almacén, clave, lease ni worker con otra. Todas las garantías que ofrece un despliegue individual (aislamiento entre tenants, una revocación que se aplica de inmediato, cobertura de borrado, un lease de worker, una cadena de auditoría, una restauración) se cumplen por celda sin cambios, y los datos, las concesiones y el borrado de una organización nunca abarcan varias celdas. El router añade el directorio y las reglas de enrutamiento que se describen más abajo; cada celda añade una comprobación de que contiene la organización a la que se dirige una solicitud.

Lo que abarca varias organizaciones pasa a ser por celda:

- un token es válido en la celda que lo emitió y en ninguna otra;
- las filas de todo el despliegue son por celda: la lista negra global (`org='*'`), la configuración y las sobrescrituras en tiempo de ejecución, las reglas de políticas, las sobrescrituras de límites de tasa y de presupuesto, la rotación de claves de firma y la revocación de un sujeto. `loom cell each -- <command>` ejecuta un comando de administración sin organización en cada celda con una credencial de corta duración por celda, registra el resultado de cada celda, reanuda las celdas que fallaron y falla hasta que todas tengan éxito; `loom doctor` compara la configuración de las celdas y las huellas de configuración e indica qué difiere;
- las organizaciones de código y de tracker (`LOOM_CODE_ORG`, `LOOM_TRACKER_ORG`) son propias de cada celda: cada celda indexa sus propios repositorios, con el costo de ingesta de cada uno;
- la vista de plataforma de un operador y el panel son por celda, en el host de la celda.

<a id="the-router"></a>

## El router

El router es un proxy HTTP sin estado, que se ejecuta como varias réplicas detrás del host compartido del despliegue, se publica por separado y admite celdas de las compilaciones N-1 y N. Guarda el directorio en su propia base de datos Postgres:

- `cells`: la celda, su host público, los emisores de tokens bearer que solo ella acepta (su propio `LOOM_JWT_ISSUER`, sus `LOOM_JWT_TRUSTED_ISSUERS`, sus emisores de usuarios finales), sus almacenes (su id de despliegue y el nombre y prefijo del bucket), su estado (`attaching`, `serving`), cuándo empezó el attach (`attach_started_at`, que attach escribe bajo el bloqueo del directorio solo después de superar todas sus negativas, antes de escribir cualquier fila en la celda que no sea sus sondeos y las revocaciones de `--revoke-unprovisioned`, y que un attach reanudado lee), su modo de tenencia y cuándo se fijó (prepare escribe el primero, y attach registra cada uno que sube o intenta subir), si está cerrada a nuevas organizaciones y su cuota de ubicaciones (`placements_max`), el SHA-256 de la credencial con la que llama al router (`current` y, durante una rotación, `next`), la huella de su secreto raíz (`keys_fp`), su `probe_url` (la del propio router para la primera celda), los nombres y huellas de clave de sus bots de emergencia (break-glass), y la huella de su configuración (`current` y, durante un cambio, `next`; los campos nombrados en «Comprobado de forma continua»), que attach y `loom cell update` escriben junto con la copia propia de la celda de esa huella (`loom.cell_self`);
- `placements`: organización, celda. Una fila por organización, escrita una sola vez y nunca borrada;
- `hosts`: el host de cada celda y los alias del host compartido (abajo).

El router tiene su propia credencial de operador, definida en su configuración y nunca en el directorio; todo cambio del directorio por parte del operador se hace con ella, y todo cambio, incluidas las ubicaciones, se escribe en el registro de auditoría del router. Adjuntar una celda requiere además una credencial de administrador de la plataforma de la celda que se adjunta. El router informa de su propia liveness y readiness, aparte de las de cualquier celda.

El router se coloca primero delante del despliegue existente, al que pasa todas las solicitudes; ese despliegue se convierte en la primera celda cuando se adjunta, y conserva el host compartido como host propio, de modo que sus clientes, tokens, tokens de actualización, clientes OAuth y callbacks registrados siguen funcionando. El router responde por sí mismo en sus propias rutas (`/cells/`, `/livez`, `/readyz`) y enruta todo lo demás, incluidas las rutas `/v1/health` de una celda, tanto a celdas `attaching` como `serving`, en este orden:

1. **Por host.** Una solicitud al host propio de otra celda va a esa celda. El host compartido, y cualquier alias suyo registrado en `hosts`, son configuración propia del router y se tratan con las reglas 2 a 4 (la celda de la regla 4 es el upstream de paso, antes de registrar la primera celda y después, ya que prepare la registra en esa dirección), sin responder nunca 421; cualquier otro host que ninguna fila de `cells` nombre responde 421. Cada URL que entrega una celda nombra su propio host: sus endpoints OAuth y OIDC, el URI de verificación del device flow, el callback de inicio de sesión (`LOOM_OAUTH_ISSUER`, registrado en el proveedor de identidad por celda), su JWKS, las páginas y recursos del panel, y los metadatos de recurso MCP. Los clientes MCP de una celda distinta de la primera usan el host de la celda, que imprimen las líneas de configuración de la celda.
2. **SCIM** se enruta por host, como la regla 1: la aplicación del proveedor de identidad de cada celda lo aprovisiona en su propio host (abajo); SCIM en el host compartido es el de la primera celda, salvo una solicitud `/scim/v2/Groups` con un JWT, que va por su emisor como en la regla 3. Las rutas de Groups se comprueban contra la tenencia (escriben `loom.principal_groups` de la organización).
3. **Por emisor.** Una solicitud con token al host compartido va a la única celda que acepta su claim `iss`, leído sin verificar; la celda verifica. Un emisor que ninguna celda acepta responde 401. Hasta que la primera celda esté `serving`, las reglas 2 a 4 envían toda solicitud del host compartido a la celda de la regla 4, que la verifica, de modo que el despliegue detrás del router atiende las organizaciones que contiene como antes durante prepare, el despliegue de `LOOM_CELL` y attach; desde el despliegue hasta `serving`, una organización nueva necesita además el directorio en cada proceso con `LOOM_CELL` definido (responde 503 ahí mientras el directorio no se pueda leer). Esto cubre MCP y toda op, sea cual sea la organización que nombre un cuerpo, y los tokens de los emisores federados y de usuarios finales de las integraciones.
4. **Todo lo demás en el host compartido va a la primera celda**: sus flujos OAuth y de dispositivo, las actualizaciones, los callbacks, las solicitudes de contraseña y de autorregistro, los sondeos de salud y la página de inicio de sesión; la revocación de un token (`/oauth/revoke`) de un JWT va por su emisor, como en la regla 3, y la de un token de actualización opaco va a la primera celda, ya que solo los clientes de la primera celda usan el host compartido (`loom logout` revoca en el host en el que inició sesión). Los documentos de descubrimiento del host compartido son los de la primera celda.

El router llega a una celda en el `upstream_url` que registra su fila del directorio, una dirección dentro de la red del despliegue (la de la primera celda es `LOOM_ROUTER_UPSTREAM_URL`, escrita por prepare, de modo que registrarla no cambia ninguna ruta; la de una celda posterior la escribe su attach), nunca en el host público de la celda, que nombra al propio router; antes de registrar la primera celda, la celda de la regla 4 es el despliegue delante del cual se colocó (`LOOM_ROUTER_UPSTREAM_URL`). El host compartido es `LOOM_ROUTER_SHARED_HOST`, el host propio de la primera celda y los alias de esa celda en `hosts`. Reenvía cada solicitud tal como la envió el cliente (su ruta y consulta en bruto, su propio `Host`) con la vista propia del router de la dirección, el esquema y el host del cliente en `X-Forwarded-For`, `-Proto` y `-Host`, reemplazando lo que el cliente afirme ahí (por eso cada celda lista las direcciones del router en `LOOM_TRUSTED_PROXIES`, o cuenta a cada cliente como el router para sus límites de inicio de sesión y lee el esquema como el del router), descarta las cabeceras que describen una sola conexión (y las que nombra `Connection`), conserva cada línea de cabecera de la respuesta (incluido un segundo `Set-Cookie`), transmite ambos cuerpos en streaming (incluido un flujo de eventos enviados por el servidor), responde 502 cuando no se puede llegar a la celda, y nunca reenvía una ruta bajo `/cells/` (la que no sirve responde 404). Una primera celda registrada sin dirección upstream responde 503, como la de cualquier celda. Lee las celdas, sus emisores y hosts una vez por `LOOM_ROUTER_DIRECTORY_CACHE_S`, respondiendo desde la última tabla mientras se vuelve a leer una obsoleta en segundo plano, de modo que un directorio que se cuelga o no se puede leer no retrasa ninguna solicitud; antes de su primera lectura, responde 503. Un emisor que dos celdas listan (lo que attach rechaza) no se enruta a ninguna.

Un cliente encuentra la celda de una organización con `GET /cells/lookup?org=<org>`, sin autenticación y con límite de tasa; una organización sin ubicación responde la primera celda con el mismo cuerpo que una organización ubicada allí (solo se almacena en caché la respuesta de una organización ubicada, así que los tiempos y una caída aún pueden distinguirlas: el nombre de una organización no es un secreto), y antes de registrar ninguna celda la búsqueda responde 503 con el código `NO_CELL`; un directorio que no puede leer para una organización que no tiene en caché responde 503 con `BACKEND_UNAVAILABLE`. Un cliente compara el código, nunca el mensaje: ante `NO_CELL`, y ante un 404 de un despliegue sin router, `loom login --org` conserva el host que se le dio (el host compartido, atendido como antes por la regla 4, o el despliegue único); ante un 429 espera el `Retry-After` y pregunta de nuevo, durante un máximo de `--wait` (2 minutos por defecto), y luego se niega como rechazo por tasa; ante cualquier otra respuesta se niega, nombrando al router, de modo que ningún flujo comienza en una celda que quizá no contenga la organización. La celda de una organización es pública, como la URL de un espacio de trabajo: la búsqueda revela que existe una organización fuera de la primera celda. `loom login --org`, la página de inicio de sesión de la primera celda (que pide primero la organización) y las líneas de configuración inician cada flujo OAuth, de dispositivo y de inicio de sesión en el host de la celda de la organización, de modo que ningún flujo cruza celdas; un navegador solo se redirige al inicio de un flujo nuevo.

Solo la primera celda está alguna vez en `recording`: una celda cuya fila `first` es `(false, …)` trata cualquier modo que no sea `enforced` como `enforced` en sus triggers de organización, su caché de modo y su CLI, de modo que la fila de modo de una celda posterior fijada en `recording` no registra nada. Una celda en `recording` lee su propio estado con `GET /cells/v1/cells/<cell>`, con su credencial del router, que solo se responde para la celda que el índice único del directorio nombra primero y solo se acepta cuando el SHA-256 de la credencial es uno de los hashes que el directorio registra para `<cell>`, dentro de `LOOM_CELL_ROUTER_TIMEOUT_S` (5 s por defecto, el tiempo de espera de la llamada de ubicación); una respuesta rechazada, fallida o tardía cuenta como ilegible.

Con el directorio inaccesible, las reglas 1 a 4 enrutan desde las celdas en caché del router; una búsqueda de una organización que no tiene en caché y una ubicación responden 503.

Las rutas del operador, cada una con la credencial de operador del router, están bajo `/cells/v1/operator/cells/<cell>`: `limit`, `credential` y `register` (el de prepare), la propia fila (`GET`, con el nombre de cualquier otra fila, que attach lee para sus negativas, su comprobación de finalización y su reanudación), el attach de la primera celda (`attach/begin`, `attach/place`, `attach/enforced` y `attach/serving`, en ese orden) y `DELETE`. Cada una salvo `register` responde 404 con el código `NO_SUCH_CELL` a una celda que el directorio no contiene, de modo que un 404 sin él indica una réplica del router de una compilación anterior. Toda llamada que tiene éxito, la lectura incluida, se escribe en el registro de auditoría (la repetición de un registro, que no cambia nada, no escribe ninguna), y toda llamada ejecuta un número fijo de sentencias, cada una acotada por el statement timeout del directorio (aplicado también en el servidor del directorio); la lectura y la eliminación llevan los límites derivados que espera `loom cell`. Todo cambio toma el bloqueo del directorio y luego el bloqueo de fila de la celda (el orden que siguen el registro, los cambios del operador y la eliminación). Cada réplica del router ejecuta una compilación con estas rutas antes de que comience el attach de una primera celda: la ubicación de una compilación anterior choca con la de un lote de attach como un 503 transitorio, y su registro puede añadir una celda posterior a mitad de un attach, algo que toda llamada de attach rechaza entonces hasta que se elimina. Cada llamada de attach se niega salvo que la fila sea la de la primera celda, esté `attaching`, y registra el id de despliegue que nombra la llamada, y mientras exista cualquier otra fila (el registro rechaza una celda posterior hasta que la primera esté `serving`, y una réplica del router de una compilación anterior aún podría registrar una):

- `attach/begin` lleva las huellas de la celda exactamente como las almacena `loom.cell_self`, la huella de su secreto raíz, las listas de permitidos con las que attach juzgó los almacenes y nonces nuevos. Rechaza una huella cuyo id de despliegue, bucket, prefijo, host público o host del emisor difieran de los de la fila (se rechaza un host del emisor distinto del propio de la celda), y una cuyo cuerpo de ubicación en vivo, con un nombre de organización en su longitud máxima, superaría el límite de cuerpo del router, nombrando los campos más grandes. Fuera de toda transacción del directorio ejecuta el sondeo del registro en el `probe_url` de la fila y pide al `upstream_url` de la fila el id de despliegue, de modo que los almacenes que lee attach son los desde los que sirve la celda en vivo. Luego, bajo los bloqueos, escribe `attach_started_at` una sola vez, las huellas solo mientras la fila no tenga ninguna (otras huellas ahí responden 409: cambian con `loom cell update`) y `keys_fp` en cada llamada, y audita las listas de permitidos. Es idempotente. Su cuerpo tiene su propio límite, 256 KiB, a partir del cual responde 413.
- `attach/place` ubica un lote de como máximo 500 organizaciones (dentro del límite de cuerpo de 64 KiB) una vez que `begin` se ha ejecutado y el modo del directorio es `enforced`, más allá de la marca de cierre y la cuota de la celda: el lote contiene organizaciones que la celda ya atiende, así que se cuenta pero nunca se rechaza por el estado de cerrada ni por la cuota, a diferencia de una ubicación en vivo o la de una celda posterior. Ejecuta un número fijo de sentencias: una inserción del lote que omite una organización ya ubicada, una lectura que rechaza el lote (revertido, nombrando la organización) cuando una organización está ubicada en otra celda, un recuento, y una fila de auditoría por organización que ubicó y una por la llamada. Una ubicación en vivo de la misma organización se ejecuta en paralelo una vez que el modo es `enforced`; ambas mantienen el bloqueo de fila de la celda, una ubicación en vivo vuelve a leer al ganador una vez que lo tiene, y cada inserción omite una organización ya ubicada y cuenta solo lo que escribió, de modo que la organización se ubica y se cuenta una sola vez.
- `attach/enforced` registra el modo `enforced` del directorio, tras lo cual la primera celda ubica las organizaciones nuevas en vivo; es idempotente.
- `attach/serving` vuelve a ejecutar el sondeo y la comprobación del upstream y luego, bajo los bloqueos, calcula los emisores de la fila a partir de sus huellas (`bearer_issuers` de `current` y `next`) y marca la celda como `serving`; en una celda `serving` responde de inmediato, con auditoría. `begin`, `place` y `enforced` en una celda `serving` responden 409.

`DELETE` elimina la fila de una celda que está `attaching` sin ubicaciones, sea cual sea su modo de directorio, junto con sus filas de hosts, con auditoría: una primera celda se deshace hasta su primera ubicación, y una celda posterior registrada por una compilación anterior deja de bloquear el primer attach. Una ubicación en curso o bien se confirma primero y la eliminación se rechaza, o bien no encuentra fila. El router no puede leer los almacenes de la celda, por lo que `loom cell remove`, que lo llama, comprueba primero el Postgres de una primera celda ([Operaciones](#operations)).

<a id="scim-and-sign-in-across-cells"></a>

## SCIM e inicio de sesión entre celdas

Cada celda es su propia aplicación en el proveedor de identidad: un cliente OIDC para el inicio de sesión en
su host y una aplicación SCIM que aprovisiona su `/scim/v2`, ambas asignadas al mismo
grupo de personas, las personas de las organizaciones de esa celda. Una persona que el proveedor de identidad
desactiva, elimina o desasigna se desaprovisiona en cada celda a cuya aplicación estuviera
asignada; Loom no puede ver una aplicación configurada para admitir a personas sin asignar u omitir
la desactivación al desasignar, por lo que el operador configura cada aplicación para
exigir asignación y desactivar al desasignar. Cada celda conserva sus usuarios SCIM,
desactivaciones y tombstones exactamente igual que un despliegue único ([SSO y
SCIM](https://github.com/ClickHouse/loom/blob/main/docs/operations/sso.md)); el router no guarda ninguna identidad.

Una celda en `enforced` con SCIM activado exige SCIM: una persona actúa en la celda solo mientras
su SCIM tenga una fila activa para ella. La comprobación se hace sobre la cuenta de la persona, no sobre cómo
se escriba un sujeto: `scim.refuses_subject(subject)` toma las grafías de correo propias del sujeto y los correos de contacto y verificados de las cuentas activas que posee, incluidas las cuentas con contraseña, y rechaza si alguno de ellos no tiene una fila activa (la fila cuyo id es
`scim.user_id(email)`; una fila inactiva o eliminada con ese id siempre rechaza, y un
correo sin fila propia solo pasa como dirección de trabajo de una fila activa cuyo
correo principal sea una de las grafías propias del sujeto). Un principal fuera de SCIM es uno de
una lista cerrada: un bot (un sujeto cuyo `sa:<name>` anterior a cualquier `:` posterior nombra una
fila de `loom.machine_identities`: el bot y sus agentes, tal como lo analiza `check_acted_for`),
un sujeto de máquina o de carga de trabajo, un usuario final (`user:`). Cualquier otro sujeto `sa:`, una
cuenta de servicio personal, se comprueba a través de su creador (`service_accounts.sa_creator`)
y de cada sujeto que liste el `lineage` de su fila, de modo que actuar en su nombre es actuar por la persona
que la creó; cualquier otro sujeto en estas rutas es una persona, y se rechaza a menos que
tenga una grafía de correo o posea una cuenta con una. Una lectura de SCIM que falla lanza
`SignInUnavailable`, igual que `scim.deactivated`, nunca un `OAuthError`, de modo que un refresh
devuelve su token y ninguna sesión termina por una caída. Todas las rutas que admiten a una persona
lo usan:

- un inicio de sesión SSO, antes de encontrar o crear la cuenta (JIT), con el correo que el proveedor de identidad
  verificó;
- cada refresh de una sesión (`_refresh_session`), con el correo verificado que guarda el grant
  o, para un grant sin él, las cuentas del sujeto;
- una actuación en nombre de una persona (`authz.check_acted_for`), sea cual sea la grafía del
  sujeto;
- el sujeto de un token de gateway, comprobado al verificarse y recordado igual que las demás respuestas de la verificación;
- el creador de un token delegado o de una cuenta de servicio personal (`authz._check_creator`),
  almacenado en caché igual que la comprobación de actuación en nombre de otro, de modo que un token creado por una persona nunca aprovisionada se
  rechaza una vez que la celda está en `enforced`.

SCIM activado ya cierra el inicio de sesión con contraseña y el autorregistro (`oauth_login_provider=oidc`),
y el device flow inicia sesión mediante SSO, por lo que pasa por la misma comprobación. Los principales sin
correo quedan fuera de SCIM y los desaprovisiona quien los creó: los bots y los tokens emitidos
por un operador, los usuarios de emisores de usuarios finales por el servicio que firma por ellos, la confianza de carga de trabajo por su regla.

**Break-glass.** Cada celda tiene un bot de administrador de plataforma con prueba de clave
(`loom bot create --platform-admin`), que no tiene correo y que SCIM nunca revoca,
y un segundo, independiente, para attach y `loom cell each`. Sus claves permanecen en el
almacén de secretos del operador, leídas en cada uso; el directorio registra solo el nombre de cada bot
y la huella de su clave, de modo que el router no guarda ninguna credencial de celda, y cada uso del
bot break-glass queda en el registro de auditoría de la celda y lo señala `loom doctor`. Los operadores están
asignados a las aplicaciones de todas las celdas para el panel, y llegan a una celda cuya aplicación
del proveedor de identidad esté rota a través de su bot.

**Los tokens SCIM de una celda son suyos por construcción.** El nombre de una celda coincide con
`[a-z0-9-]{1,32}` (sin `_`, comparado exactamente; se impone en prepare, attach y arranque, y
es único en el directorio). Un token que empieza por `lsc_` nombra una celda y debe coincidir por completo con
`lsc_[a-z0-9-]{1,32}_[0-9a-f]{32,}`, o todas las celdas lo rechazan; solo un token
sin ese prefijo no nombra ninguna celda. Con `LOOM_CELL` definido, un token SCIM tiene la forma
`lsc_<cell>_<secret>`, tal como lo genera `loom cell scim-token new --cell <name>` (se ejecuta
sin conexión): exactamente tres campos separados por `_`, el del medio igual a `LOOM_CELL`, y un
secreto de al menos 32 caracteres hexadecimales en minúscula (128 bits).

Un analizador junto a `scim.tokens()` devuelve el nombre de celda de un token o nada, y quienes lo llaman comparan eso con `LOOM_CELL` y con la fila `first` de la celda (más abajo).
`scim_settings_problem` recibe ambos, de modo que el arranque y `loom doctor` rechazan mediante una sola
función, y con `LOOM_CELL` definido rechazan un tercer token configurado (dos permiten una
rotación). Una función, `scim.authorized(presented)`, contiene la comparación en tiempo constante
para ambas rutas SCIM (`_authorized`, `scim_groups._caller`). Con `LOOM_CELL`
sin definir compara con los tokens configurados como lo hace un despliegue único y no lee
nada. Con él definido compara con los tokens que el analizador admite para `LOOM_CELL`
y la fila `first`; mientras esa fila no se haya leído lanza una excepción como `AuthUnavailable`, de modo que
las rutas responden 503 con `Retry-After` y el proveedor de identidad reintenta.

- Un proceso se niega a arrancar con un token SCIM que nombra otra celda, y `/scim/v2`
  responde 401 ante uno.
- Una celda posterior rechaza un token que no nombra ninguna celda. La primera celda, que conserva
  el host compartido, también acepta sus tokens existentes sin nombre, solo mientras su fila `first` sea
  `(true, LOOM_CELL)`, de modo que su SCIM sigue funcionando durante el cambio sin rotación.
- Un token copiado en la configuración de otra celda, o una aplicación del proveedor de identidad
  apuntada al host de la celda equivocada, por tanto falla de forma cerrada, y ninguna celda compara nunca
  sus tokens con los de otra.

<a id="preparing-a-cell"></a>

## Preparar una celda

`loom cell prepare` registra una celda en el directorio y escribe las filas que leen los procesos de la celda. La comprobación de tenencia (más abajo) indica qué escribe y cómo se reanuda; esta sección indica cómo demuestra que se le dio la celda correcta.

**Cuál es la primera celda** nunca es un ajuste ni el orden de preparación. Prepare lo concede solo a la celda cuyo host es el host compartido del router y cuyo id de despliegue es el que informa el upstream de paso del router en la dirección de sondeo del upstream. Esa dirección es la configuración propia del router (`LOOM_ROUTER_UPSTREAM_PROBE_URL`) y el `probe_url` de la primera celda, nunca uno de los argumentos de prepare: el router la lee ahí en cada prepare y cada reejecución, y rechaza una respuesta con otro id de despliegue o sin ninguno. El router también consulta el puerto principal de su upstream de paso (`LOOM_ROUTER_UPSTREAM_URL`, que el registro copia en la fila) y rechaza uno que informe otro id de despliegue, de modo que la fila nunca nombre dos despliegues. Prepare rechaza cualquier otra celda hasta que la primera esté registrada y en `serving`, bajo el bloqueo del directorio, de modo que ninguna celda posterior aparezca mientras la primera se adjunta.

**Los almacenes son los activos.** Antes de escribir nada, prepare escribe un nonce aleatorio en el Postgres de destino, bajo una clave reservada de `loom._migration_lock` del ClickHouse de destino, y como objeto de sondeo bajo el prefijo del bucket de destino. La ruta de sondeo de la celda debe devolver cada uno tal como lo lee desde su propia conexión al primario en esa petición. Después los nonces se eliminan; sus filas no contienen memoria ni organización y están clasificadas como tales. Se rechaza una copia con el mismo id de despliegue. Prepare envía al router los tres nonces junto con el registro (`POST /cells/v1/operator/cells/<cell>/register`, con la credencial de operador); el router lee por sí mismo el listener de sondeo y registra la celda solo cuando este responde el id de despliegue de la celda, esos nonces, y el bucket y el prefijo que nombra el registro (de modo que uno que no nombre bucket no pueda pasar por una celda que lo tiene). El router responde un listener que excede su tasa (429) como `PROBE_BUSY`, y uno al que no puede llegar o que no puede leer un almacén, o un puerto principal de upstream de la primera celda al que aún no puede llegar, como `PROBE_UNREACHABLE`, ambos 503, y prepare espera por ellos dentro de `--wait`. Una reejecución cuyas direcciones difieran de las de la fila se rechaza antes del sondeo.

**La ruta de sondeo**, `GET /v1/health/deployment`, no requiere credencial y queda fuera de la compuerta de huella:

- En el puerto principal responde solo el id de despliegue que cada proceso verificó al arrancar, guardado en memoria, sea cual sea el Host de la petición. No lee ningún almacén y no tiene límite de tasa, de modo que ninguna avalancha en el puerto principal bloquea la comprobación de host de attach.
- Completa, con los valores bajo las claves de nonce reservadas de prepare, se sirve solo en un puerto de listener de sondeo aparte (`LOOM_CELL_PROBE_PORT`, `0` para desactivarlo; necesita la autoridad de Postgres y la autenticación activadas, y se enlaza a todas las direcciones del host): la fila de Postgres `loom.cell_probe` y la clave de KeeperMap, ambas llamadas `cell-probe`, y el objeto `<prefix>/_cell_probe`; también nombra el bucket y el prefijo bajo los que almacena. Ninguno de estos valores es secreto. Responde 429 pasada una tasa fija por proceso en ese listener.
- Solo la dirección de sondeo de la celda (`probe_url`) apunta al listener: una dirección interna que ningún ingress expone y a la que el router nunca enruta, que el despliegue envía a todo proceso vivo, esté listo o no, de modo que prepare y attach alcancen un proceso que la compuerta mantiene como no listo.
- El listener de sondeo del chart está desactivado por defecto y se activa, también en el despliegue existente, antes del primer `loom cell prepare`. Genera un Service en ese puerto que publica direcciones no listas y no cambia ninguna NetworkPolicy. Quién puede alcanzar el puerto lo decide la política de red del operador, como en el caso de ClickHouse: con la política propia del chart activada, que admite solo el puerto `http`, el operador añade una política que admita el puerto de sondeo desde los pods del router (el router sondea el registro de prepare) y desde donde se ejecuta la CLI (las políticas se suman), y sin ella cualquier pod puede alcanzarlo. Del mismo modo, la salida de la celda hacia la dirección de ubicación del router y hacia Postgres corresponde al operador, mediante `networkPolicy.extraEgress` donde la política del chart está activada.
- Prepare reintenta los `PROBE_BUSY` y `PROBE_UNREACHABLE` del router (un listener que está arrancando no es alcanzable durante un tiempo), y attach y `loom cell update --probe-url` reintentan un 429 del listener que sondean, durante `--wait` como máximo (10 minutos por defecto), y luego lo nombran.

El `probe_url` de una celda posterior se entrega a prepare, normalizado (`http` o `https`, sin userinfo), y se acepta solo cuando informa el id de despliegue que prepare lee de los almacenes de destino; después attach comprueba que el host propio de la celda informe el mismo id. Prepare rechaza un argumento de dirección de sondeo para la primera celda. `loom cell update --probe-url` reemplaza el de una celda posterior bajo el bloqueo del directorio tras la misma comprobación y un nuevo eco de nonce. Las direcciones de sondeo y de upstream de la primera celda se copian de la configuración del router en el registro, y `loom cell update` las reemplaza desde ella, una vez que todas las réplicas del router ejecutan los valores nuevos, tras el mismo sondeo y una comprobación de que el nuevo upstream informa el id de despliegue de la celda. Una reejecución de prepare nunca mueve una dirección: se rechaza mientras la réplica del router a la que llega esté configurada con otras.

**La fila `first`.** Prepare escribe una fila `first` explícita e inmutable en el Postgres de cada celda (`loom.cell_first`: un trigger de fila rechaza su update y delete y un trigger de sentencia su truncate, ambos creados `ENABLE ALWAYS` y comprobados por attach y `loom doctor` igual que los triggers de organización), `(true, <cell>)` para la primera celda y `(false, <cell>)` para cualquier otra, en la misma transacción que el modo de tenencia, de modo que ninguna exista sin la otra. Leídas juntas, las dos filas dan uno de cuatro estados. Ambas ausentes sin fila de tenencia ni propia: abierto, el de un despliegue único, sin comprobación; un proceso con `LOOM_CELL` definido permanece no listo ahí (sin fila de modo). En una celda que el directorio registra, esto ocurre solo cuando su Postgres se restaura a un punto anterior a su prepare (se cierra con `loom cell restore`) o un prepare se detiene entre su registro y la escritura de su fila (se cierra con una reejecución de prepare), y entretanto los triggers y los procesos con `LOOM_CELL` sin definir permanecen abiertos, como en un despliegue nunca preparado, ya que el Postgres de la celda, que guarda su estado, no puede distinguir ambos casos (ClickHouse no guarda estado de celda: añadirlo haría que la ruta de escritura leyera un segundo almacén para la tenencia) y tal proceso nunca lee el directorio; donde todos los procesos tienen `LOOM_CELL` sin definir, que `loom doctor` lo nombre (lo cual lee el directorio y se entrega con attach) es la única señal. Una fila `(true, …)` con `recording` y la fila propia: la primera celda en grabación. Ambas presentes con la fila propia en otro caso: `enforced`, y el modo de una celda posterior se lee como `enforced` diga lo que diga su fila (sus triggers, su caché de modo y la CLI lo tratan así, y `loom cell prepare` nombra una fila que no lo sea). Una sola fila, ambas sin la fila propia, o ambas ausentes junto a una fila de tenencia o propia (los estados `partial`: alguna fila de estado presente pero no todas las filas `first`, de modo y propia), que prepare nunca deja: los triggers de organización, donde una celda los tiene, actúan como en `enforced` (un arranque no crea ninguno en ella), todo proceso queda con compuerta como ante una fila no leída, `loom doctor` lo nombra, y una reejecución de `loom cell prepare` reescribe las filas que faltan desde el directorio mientras la celda sigue en marcha. Un índice único en el directorio permite una sola primera celda, y el valor no contiene contenido de memoria y está clasificado como tal. Attach vuelve a comprobar el host y el id de despliegue. Un proceso lee el valor junto con el modo, y «aún no leído», «ausente» y «falso» son distintos: solo una fila que se ha leído deja listo a un proceso, y una fila cuya celda no es `LOOM_CELL` lo deja con compuerta (más abajo) y la informa `scim_settings_problem`. El arranque se rechaza solo por los ajustes (`scim_settings_problem` con la fila sin leer comprueba únicamente la forma del token frente a `LOOM_CELL`); la comparación con la fila `first` se ejecuta por petición una vez leída la fila, y `loom doctor` lee el valor del Postgres de la celda o lo informa como desconocido.

<a id="the-cells-own-row"></a>

## La fila propia de la celda

**Se comprueba de forma continua, no solo al hacer attach.** Cada proceso calcula la huella de su configuración: campos con nombre bajo una versión de esquema (los hosts de su `LOOM_PUBLIC_BASE_URL` y del `LOOM_OAUTH_ISSUER` resuelto, su emisor OIDC y su client id, si SCIM está activado, los emisores bearer que acepta (`trusted_issuers()` y sus emisores de usuario final), sus orgs configuradas, las `orgs` de su `jwt_end_user_issuers_json`, el id de despliegue que verificó al arrancar, y el nombre y el prefijo del bucket). Su Postgres y su ClickHouse llevan ambos el id de despliegue (la comprobación de emparejamiento que ya ejecuta un despliegue único). El bucket, cuando hay uno configurado, se identifica por su nombre y prefijo (una celda sin bucket no participa en ninguna comprobación de bucket), y ningún par de celdas los comparte en ningún endpoint: el prefijo de ninguna celda en un bucket del mismo nombre queda anidado dentro del de otra ni lo contiene, de modo que un endpoint tomado del entorno no puede caer en el prefijo de otra celda. Ningún almacén se identifica por su dirección, así que un standby reemplazado, una conmutación por error, una dirección tomada del entorno o una restauración a un nuevo endpoint no cambian nada de lo que la celda comprueba. El id de despliegue, el nombre del bucket y el prefijo nunca cambian después de prepare: `loom cell update` rechaza un cambio en cualquiera de ellos, incluido añadir un bucket a una celda preparada sin él, y mover los datos de una celda a otros almacenes, o añadir uno, es un diseño aparte (Operaciones). Los bots no forman parte de ella: `loom bot create` los añade en tiempo de ejecución, cada uno con una org, y la ubicación ya los acota. La fila propia de la celda en `loom.cell_self` contiene una huella aceptada, `current`, y durante un cambio una segunda, `next`. Sus filas, y el heartbeat de la celda (`loom.cell_heartbeats`, con clave en la fila `loom.instances` del proceso y escrito junto con ella, ya que una tabla KeeperMap no admite columnas nuevas: el `LOOM_CELL` con el que se ejecuta, el estado que produce su última lectura, su huella y [las claves que la acompañan](#the-heartbeats-keys)), no contienen contenido de memoria y se clasifican así para el borrado. Un proceso coincide con un valor cuando todos los campos que ambos conocen son iguales, y un campo que falta en el valor cuenta como igual solo en su valor por defecto, de modo que las compilaciones N y N+1 con la misma configuración coinciden con una sola fila. Con `LOOM_CELL` definido, mientras la fila propia de su celda, la fila `first` o la fila de modo no se hayan leído, las filas de estado estén en estado `partial` (la regla de la fila `first`, arriba), la fila propia de la celda no exista o no coincida con ninguno de los dos valores, o la fila `first` nombre a otra celda, toda solicitud que reciba, salvo sus sondas de salud y la ruta de sondeo, responde 503 `AuthUnavailable`: las solicitudes bearer (la primera comprobación en `verify_token`, antes de la rama del emisor de usuario final), SCIM, y toda ruta que inicie sesión, emita, renueve o intercambie un token, incluidos el registro, los endpoints de OAuth y de dispositivo y el callback de inicio de sesión. También se declara no listo y se aparta de los workers como lo hace un proceso desviado: detiene sus pasadas, cede el lease y no nombra ningún lease en su fila de instancia, en todos los modos de `LOOM_BACKGROUND_WORKERS` (incluido `on`: sin lease que conservar, un proceso `on` de una celda ejecuta el bucle del lease, que inicia y detiene el supervisor según la puerta en un plazo de `LOOM_TENANCY_MODE_CACHE_S` más un periodo del bucle), y su fila de instancia no lo cuenta como en servicio, de modo que una compilación anterior a su lado mantiene los workers en marcha. Una lectura fallida conserva las últimas filas durante a lo sumo `LOOM_JWT_REVOCATION_MAX_STALE_SECONDS`, igual que el llavero de firma y la instantánea de revocación; pasado ese plazo el proceso queda bloqueado hasta que una lectura tenga éxito. El modo (más abajo) tiene el mismo límite. Una celda configurada para aceptar el emisor de otra celda, un host con el que no se hizo attach o un patrón de orgs que no se le concedió, por tanto, no sirve nada con ello, llegue la solicitud adonde llegue. Su heartbeat informa de la huella, el router rechaza una llamada de ubicación cuyos campos no coinciden con ninguno de los dos valores de la fila del directorio, y `loom doctor` señala una discrepancia, una celda cuyo cliente OIDC comparte otra celda, y una celda con SCIM desactivado junto a celdas con SCIM activado.

`loom cell prepare` escribe `current` en `loom.cell_self` junto con las filas `first` y de modo. Hasta que la fila del directorio contiene una huella (antes de attach), escribe, cuando falta la fila propia, la huella que informan en su heartbeat todos los procesos vivos, y se niega mientras algún proceso vivo ejecute una compilación anterior a N, que no informa ninguna, o mientras las huellas informadas difieran; una fila propia existente se mantiene, y un proceso vivo que ejecute ni su `current` ni su `next` provoca un rechazo; en cada ejecución, antes de registrarse, rechaza un proceso vivo cuyo id de despliegue, nombre de bucket o prefijo difiera de la configuración propia de prepare (un campo que no informa se lee en su valor por defecto). Una vez que la fila del directorio contiene una huella, una nueva ejecución escribe `current` y `next` a partir de ella, como hace `loom cell restore`, y rechaza solo mientras la huella de un proceso vivo no coincida con ninguna. En ambos casos la celda sigue lista durante el despliegue de `LOOM_CELL`. Un cambio de configuración posterior, mientras la celda está en `attaching` o `serving`, pasa por `loom cell update`; antes de que attach haya escrito la huella de la celda en la fila del directorio, escribe `next` solo en `loom.cell_self`, sin reservar nada (y `--finish` y `--revert` tocan entonces solo `loom.cell_self`), y un attach reanudado ejecuta sus rechazos por solapamiento sobre ambos valores de `loom.cell_self`, y los escribe en el directorio. Los emisores y patrones de orgs de una celda preparada no se reservan en ningún lugar: el router no le dirige ningún emisor ni toma ninguna ubicación de ella hasta que attach haya ejecutado sus rechazos por solapamiento y escrito su fila del directorio.

Un cambio en lo que acepta una celda pasa por `loom cell update --config <file>`, bajo el mismo bloqueo de directorio que attach; calcula `next` a partir de esa configuración con la misma función que usan los procesos, y se niega mientras haya un `next` distinto pendiente; volver a ejecutarlo con la misma configuración, o `--finish`, escribe primero `next` donde falte. Vuelve a ejecutar los rechazos por solapamiento de attach contra la fila del directorio de cada otra celda, contando ambos valores de cada una, escribe la nueva huella como `next` en el directorio y luego en `loom.cell_self`, de modo que los procesos antiguos y nuevos sirven a la vez mientras se despliega la nueva configuración. `loom cell update --finish` espera, como máximo `--wait` (por defecto 10 minutos), hasta que todos los procesos vivos informen `next` y haya pasado el plazo de solicitud más largo; cuando el cambio activa SCIM o cambia el cliente OIDC de la celda, ejecuta entonces la precondición de SCIM de attach (se niega, o aplica `--revoke-unprovisioned`); solo entonces convierte `next` en el único valor, primero en `loom.cell_self` y por último en el directorio. Un emisor o patrón ampliado se reserva en el directorio antes de que cualquier proceso lo acepte, y uno reducido se libera solo después de que ninguno lo acepte. Un rechazo o una espera que se agota conserva ambos valores e imprime los procesos que aún no informan `next`; volver a ejecutar reanuda, y `loom cell update --revert` espera del mismo modo hasta que ningún proceso vivo coincida solo con `next` (rechazando cuando `--wait` se agota), y luego descarta `next`, primero en `loom.cell_self`, bajo el mismo bloqueo; una org configurada que la actualización ubicó permanece ubicada en la celda (una ubicación nunca se elimina).

Un nuevo token de SCIM no cambia ninguna huella y no necesita `loom cell update`. Una celda cambia su aplicación del proveedor de identidad igual que un despliegue único ([SSO y SCIM](https://github.com/ClickHouse/loom/blob/main/docs/operations/sso.md)), con los mismos límites; nada de eso es particular de las celdas.

<a id="the-heartbeats-keys"></a>

### Las claves del heartbeat

El heartbeat de celda de un proceso informa, junto con el `LOOM_CELL` con el que se ejecuta, de su modo de tenencia: el estado que produce su última lectura de las filas de estado (`open`, `recording`, `enforced` o `partial`, y el `recording` de una celda posterior se lee como `enforced`), y `''` solo antes de que llegue una lectura o en un proceso que nunca las lee. Su JSON `fingerprint` contiene la versión y los campos de la huella, y junto a ellos claves que ninguna huella compara: nunca están en `loom.cell_self`, en las huellas del directorio ni en el cuerpo de una ubicación, y una fila KeeperMap no necesita columna para ellas (`server.core.instances.cell_row`). Su presencia demuestra la compilación que las informa; no hay clave de generación.

- `serves`: `LOOM_SERVES_TRAFFIC`.
- `marked`: si las sesiones de Postgres agrupadas de este proceso conservan el marcador de tenencia (`loom.tenancy_checked`). El refresco de la celda lo lee junto con las filas de estado, después de `RESET ALL` en la misma transacción: un valor de arranque sobrevive al reset, un `SET` no, de modo que un pooler, que una celda no debe tener ([Postgres](https://github.com/ClickHouse/loom/blob/main/docs/operations/postgres.md)), se lee como no marcado tanto si elimina los parámetros de arranque como si los envía de nuevo con `SET`, y la lectura se ejecuta en la conexión al servidor en la que se ejecutó el reset. Cuesta tres viajes de ida y vuelta más por refresco (`BEGIN`, `RESET ALL` y `COMMIT`), y todo proceso informa un valor reciente sin necesidad de sondeo. Una sesión que el pooler despojó, o un proceso con `LOOM_CELL` sin definir bajo la autoridad de Postgres, se lee como `false`; `null` significa solo que no ha llegado ninguna lectura (un arranque con migraciones de Postgres omitidas cuya primera lectura falló, o la autoridad de ClickHouse, donde no se lee nada). La comprobación de preparación `cell_marker` de un proceso con `LOOM_CELL` definido lee el mismo valor: falla en `enforced` y `partial`, donde los triggers rechazan las escrituras de una sesión sin marcar para una org que la celda no tiene y la fila de tenencia de cada org recién ubicada, y pasa con una advertencia en `recording`, de modo que una primera celda detrás de un pooler así no detiene su despliegue antes de attach, que rechaza el proceso ([solución de problemas](https://github.com/ClickHouse/loom/blob/main/docs/operations/troubleshooting.md#the-cell_marker-readiness-check-names-the-tenancy-marker)).
- `router` y `router_why`: con `LOOM_CELL` definido, `router` es `null` y `router_why` indica por qué hasta que se lee la fila `first`, y después ambos están presentes solo en una primera celda (la ruta de estado de una celda posterior responde 404, así que ni pregunta ni los informa). `router` indica si la última lectura de este proceso de `GET /cells/v1/cells/<cell>` con su propia credencial respondió 200 nombrando la celda: `null` hasta que responde la primera lectura (aún arrancando), `true` ante tal respuesta, y `false` para una configuración que nunca funciona: un ajuste del router sin definir (el proceso nunca pregunta), una URL que no se puede solicitar, un 404, una respuesta para otra celda, o un 401 que persiste más allá de un `LOOM_ROUTER_DIRECTORY_CACHE_S`. Ese es el ajuste del router, que los procesos de la celda también llevan: los hashes de credenciales en caché de una réplica del router responden 401 para un token rotado hace un momento, así que hasta entonces se mantiene el último valor y `router_why` dice "401, possibly a rotation" (un router ejecutado con una caché más larga puede hacer que attach se rechace durante una rotación; volver a ejecutar lo resuelve). Un fallo transitorio (un timeout, un error de conexión, un 503, un 200 que no es un objeto JSON que nombre la celda) conserva el último valor, y mientras `router` es `null`, `router_why` nombra la última causa de ese tipo.

Un lector en segundo plano por proceso de servidor consulta la ruta cada `min(LOOM_INSTANCE_HEARTBEAT_SECONDS, LOOM_TENANCY_MODE_CACHE_S)` en una primera celda hasta que ha leído `serving` (`server/core/cell_router.py`); nada lo espera, de modo que un router lento no retrasa ningún latido ni ninguna solicitud, y el latido informa lo último que leyó, con una antigüedad de a lo sumo un periodo más `LOOM_CELL_ROUTER_TIMEOUT_S` cuando un latido lo escribe. Cada proceso uvicorn ejecuta uno, así que mil pods de ocho workers preguntan hasta 1,600 veces por segundo. Cada réplica del router responde la ruta a partir de su propia lectura de la fila de la celda, hecha como máximo una vez por `LOOM_ROUTER_DIRECTORY_CACHE_S`, de modo que el directorio ve una lectura por réplica y ventana; una lectura fallida responde 503 durante su ventana, así que un directorio caído no se consulta más a menudo y sigue respondiendo 503. Un proceso sin heartbeat (una CLI, el proceso hijo de los workers) pregunta bajo demanda, como máximo una vez cada `LOOM_TENANCY_MODE_CACHE_S`.

El lector conserva también la última respuesta del directorio para la comprobación de tenencia, como una de cuatro: `attaching`, `serving`, otro estado, o desconocido mientras no haya llegado ninguna lectura, la última haya fallado, se haya respondido para ningún estado de esta celda (un 401, un 404 o una respuesta para otra celda), o llegue tarde (más antigua que el periodo con el que este proceso lee, el del lector en segundo plano o la ventana bajo demanda, más `LOOM_CELL_ROUTER_TIMEOUT_S`). Una vez que un proceso ha leído `serving` lo conserva durante toda su vida y no pregunta más: solo `loom cell restore` lo rebaja, y eso reinicia los procesos. Una primera celda en `recording` registra una nueva org solo en `attaching`. Un principal de plataforma o de org `*`, o una llamada sin principal, no ubica ninguna org: en una primera celda cuyo directorio responde `attaching`, o no puede leerse antes de que haya leído `serving`, tal llamada para una org que la celda no tiene responde 503 ("attach in progress" o directorio ilegible), ya que los datos de la org pueden estar en esta celda hasta que attach la ubique; una vez `serving`, y en una celda posterior, responde 409 `WRONG_CELL`. Un proceso que arranca después de `serving` mientras el router está caído responde esas llamadas con 503 hasta que llegue su primera lectura.

Con `LOOM_CELL` definido, un `LOOM_CELL_ROUTER_URL` no vacío que no sea una URL http(s) con host, con un puerto de como máximo 65535 y sin `?` ni `#` rechaza el arranque (`cell.settings_problem`); uno vacío está permitido, para pods solo de workers (`LOOM_SERVES_TRAFFIC=false`), cuyo heartbeat informa entonces `router` como `false` con los ajustes sin definir en `router_why`, sin registrar nada en el log.

<a id="the-tenancy-check-and-placement"></a>

## La verificación de tenencia y la ubicación

Un proceso con `LOOM_CELL` sin definir no ejecuta ninguna verificación de tenencia. Bajo la autoridad de Postgres
(`LOOM_STORAGE_AUTHORITY=postgres`, la única que ejecuta una celda) un proceso servidor sigue leyendo,
en una sola sentencia, la fila de modo, la fila `first` y si existe alguna fila de `loom.tenancy` o
`loom.cell_self`, con las reglas de la caché de modo (más abajo). Un comando de la CLI que
declara una organización lee lo mismo en una sesión acotada propia: si todas las tablas de estado están ausentes
(según `to_regclass`, de modo que un rol al que le falta un permiso sigue siendo rechazado) se lee como `open`, y una
lectura fallida se rechaza. Un comando sin organización, como la revocación de un token, `loom migrate` o
`loom doctor`, no está condicionado por el modo y se ejecuta, incluso con Postgres caído. Si ambas filas
están ausentes y no hay fila de tenencia ni propia, como en un despliegue nunca preparado, o en la primera celda en
`recording`, el proceso sigue sirviendo como un despliegue único; todo estado que la regla de la fila `first`
(más arriba) cuenta como `enforced`, o como estado `partial`, lo condiciona igual que `enforced`.
`enforced` (que attach establece en la primera celda cuando todos los procesos activos tienen `LOOM_CELL` definido,
y prepare en una celda posterior, cuyos procesos lo ejecutan así desde su primer arranque) hace que un proceso servidor
no esté listo, no ejecute ningún worker y no responda nada salvo sus sondas de salud y la ruta de sondeo
(para que una nueva ejecución de prepare pueda alcanzarlo), y hace que el comando de la CLI se rechace; el motivo de
disponibilidad y el rechazo nombran `LOOM_CELL`. Así, un pod o una CLI de operador que pierde
`LOOM_CELL` en una celda `enforced` no escribe para ninguna organización; uno que además pierde `LOOM_PG_DSN` o
`LOOM_STORAGE_AUTHORITY` es rechazado por la verificación de autoridad que el despliegue ya ejecuta
(el registro `loom.storage_authority` de ClickHouse). Los comandos `loom cell` que se conectan a los almacenes de una
celda (prepare, attach, place, restore, update) se rechazan sin `LOOM_CELL` y, una vez que el directorio
tiene una fila para `LOOM_CELL`, rechazan los almacenes cuyo id de despliegue no sea el que esa fila registra.
Un despliegue iniciado con `LOOM_CELL` sin definir es un despliegue único hasta que se prepara, y apuntarlo
al prefijo de bucket de otro despliegue es la configuración errónea que es para cualquier despliegue. En la primera
celda, `loom cell prepare` se ejecuta antes de desplegar `LOOM_CELL`; una celda posterior se ejecuta con `LOOM_CELL`
definido desde su primer arranque, así que sus procesos están condicionados y se mantienen al margen de los workers
(incluido su barrido de blobs) hasta que prepare escribe su fila, y prepare rechaza una celda posterior mientras el
heartbeat de algún proceso activo carezca de `LOOM_CELL` o nombre otra celda. Prepare hace tres cosas, en orden:

1. **Rechaza una celda cuyos almacenes ya llevan la identidad de otra celda**: un
   id de despliegue que el directorio registra, o un estado que el directorio no ha ubicado allí.
   El router lo comprueba, en la propia transacción del registro, a partir de los recuentos que
   envía prepare: una celda para la que el directorio no tiene fila no puede contener filas de tenencia, `first`, de modo
   ni propia, y una posterior no puede tener ningún objeto bajo su prefijo salvo la sonda de prepare ni ningún
   proceso activo sin su `LOOM_CELL`. Una nueva ejecución cuenta como propios las filas de tenencia y de estado y
   los objetos del prefijo; los procesos de una celda posterior se ejecutan con su `LOOM_CELL` en
   cada ejecución, lo que prepare comprueba por sí mismo.
2. **Registra la celda** en el directorio como `attaching`, bajo el bloqueo del directorio:
   su host, el id de despliegue leído de la celda, el SHA-256 de la credencial con la que
   llama al router, y el nombre y el prefijo de su bucket, comparados con los de cualquier otra
   celda, preparada o adjuntada. La credencial es `lcr_` seguido de 128 caracteres hexadecimales en minúscula
   (512 bits), tal como la genera `loom cell credential new` sin conexión, imprimiendo la
   credencial y su hash; el arranque y `loom doctor` rechazan un `LOOM_CELL_ROUTER_TOKEN` de
   cualquier otra forma. Prepare recibe el hash como argumento, 64 caracteres hexadecimales en minúscula,
   de modo que ninguna CLI necesita el secreto; cualquier otro valor, incluidas la credencial o su secreto de
   128 caracteres, se rechaza, nombrando `loom cell credential new`, y no se almacena en ningún sitio.
   Ninguna otra fila de celda puede contener el hash, ni como actual ni como siguiente.
3. **Escribe las filas de la celda**: el modo (`recording` en la primera celda, `enforced` en
   una posterior), la fila `first` y `current`.

Prepare es reanudable. Una nueva ejecución para la fila del directorio con el mismo nombre, id de despliegue y
host escribe la que falte entre la fila `first` y la fila de modo, a partir del estado del
directorio, y `loom.cell_self` como se indicó (antes de attach, a partir de los heartbeats cuando
falta; una vez que el directorio guarda la huella, `current` y `next` a partir de ella,
sobrescribiendo un valor presente que difiera); antes de attach, una fila propia presente se mantiene, y
un proceso activo que no ejecute ni su `current` ni su `next` se rechaza. El estado del directorio
es el valor `first` que nombra el índice único y el modo más alto que registra para
la celda: `recording` para la primera celda o `enforced` para una posterior en el registro,
en la misma transacción que la fila, y luego cada modo que attach eleva, registrado en el
directorio antes de que attach lo establezca en la fila de modo de la celda (un rechazo informa de la fila de modo
tal como attach la lee de vuelta tras cualquier retorno a `recording`, y nunca baja el
registro del directorio). Una nueva ejecución rechaza una fila de modo por encima del estado del directorio y la fila
`recording` de una celda posterior, al no ser ninguna de la celda en cuestión, y deja la fila de una primera celda por debajo
de él para que attach la termine. Una nueva ejecución rechaza un hash de credencial que no sea ni el `current` ni el
`next` de la fila (la rotación corresponde a `loom cell credential`), cuenta como propias las filas de tenencia
ubicadas o registradas desde su propio registro, y omite las comprobaciones del registro que ya ha superado
(el prefijo vacío y el solapamiento de prefijos), de modo que se ejecuta en una celda `serving` cuyo prefijo contiene datos.

Un proceso con `LOOM_CELL` definido y sin fila de modo no pasa a estar listo. Con él definido, el Postgres de cada
celda contiene `loom.tenancy` (org, since) y `loom.tenancy_mode` (`recording`,
`enforced`); un proceso lee el modo a través de una caché de como máximo
`LOOM_TENANCY_MODE_CACHE_S` (por defecto 5 s), conserva el último modo leído cuando no puede
leerlo, y sigue sirviendo las organizaciones que posee, durante como máximo
`LOOM_JWT_REVOCATION_MAX_STALE_SECONDS`, pasado lo cual queda condicionado hasta que una lectura se complete.
Todo proceso servidor bajo la autoridad de Postgres, con `LOOM_CELL` definido o no, lee las
filas justo después de que sus almacenes se abran y migren, antes de su primer heartbeat y de su decisión de arrendamiento; una
primera lectura fallida hace fallar su arranque (con migraciones de Postgres pendientes arranca
condicionado y no listo hasta que una lectura se complete). Después, un proceso con `LOOM_CELL` definido mantiene
el límite de obsolescencia anterior, y uno con él sin definir mantiene su veredicto a través de lecturas fallidas
sin límite de obsolescencia, igual que un despliegue único supera una caída de Postgres (la primera
excepción en Invariantes). El proceso hijo de workers de una celda lee sus propias filas y queda condicionado hasta que
una lectura se complete. Con `LOOM_CELL` sin definir, la ausencia de filas de modo y `first` sin fila de tenencia
ni propia es un despliegue nunca preparado, y una lectura fallida nunca se toma por una fila ausente; un proceso que no lee
estado (el hijo de workers y una CLI con
`LOOM_CELL` sin definir, y todo proceso bajo la autoridad de ClickHouse) no está condicionado por
ello. En `enforced`, una celda sirve exactamente las organizaciones para las que tiene una fila; una organización que un proceso
leyó como no poseída, para un llamante que actúa en otra organización, se vuelve a leer tras
`LOOM_TENANCY_MODE_CACHE_S`. Una fila `recording` se escribe con una sentencia que la inserta
solo mientras el modo es `recording`, leyendo la fila de modo con `FOR SHARE`; se ejecuta en
`READ COMMITTED` en su propia transacción y se confirma antes de que la solicitud continúe.
La escritura de `enforced` por parte de attach y estas inserciones nunca se cruzan: una inserción que ya se ejecuta cuando
attach escribe el modo la ubica el paso 4, una que empieza después lee `enforced`, un flujo de
inserciones no puede retener la escritura, una solicitud de nueva organización espera a attach unos pocos segundos
como máximo, y un attach que se atasca reteniendo el bloqueo de la escritura lo libera en cuestión de segundos.
Attach toma `LOCK TABLE loom.tenancy_mode IN EXCLUSIVE MODE` (que espera a las inserciones en curso y pone en cola
a las posteriores detrás de él) en intentos cortos, en una transacción con
tiempos de espera del lado del servidor, luego escribe el modo y confirma; tras cualquier error en esa
transacción termina el backend de esa sesión (`pg_terminate_backend`, el backend nombrado por
el pid y el `backend_start` que attach capturó al conectarse) y espera hasta que haya
salido de `pg_stat_activity`, luego lee el modo de vuelta antes de reintentar o informar; un modo
leído de vuelta como `enforced` se escribe de nuevo en una transacción nueva, cuya confirmación espera
al standby, antes de que attach continúe, ya que una confirmación terminada mientras esperaba está solo en el primario.
El comando attach fija esos tiempos de espera, y sus pruebas cubren cada uno de
estos casos. La caché de modo lee el modo con un `SELECT` simple, que no toma ningún bloqueo de fila
y nunca espera a attach. Una inserción que encuentra `enforced` (un proceso cuya caché
aún lee `recording`) no escribe nada: la solicitud pasa a la llamada de ubicación como en
`enforced`, y un comando de la CLI se rechaza como en `enforced`, nombrando la organización. Un proceso cuya
caché aún lee `enforced` después de que el paso 3 o el paso 4 devuelva la celda a `recording` ubica
a través de la puerta del router hasta que su caché expire.
`loom doctor` lista cualquier fila de tenencia que el directorio no ubique.

- **Se ejecuta después de la verificación y antes de escribir nada para la organización.** La puerta de operaciones
  (`gates.authorize`) comprueba primero la organización que resuelve el transporte (`gates.resolve_org`, con
  sus valores por defecto del llamante y las organizaciones de plano), antes de `check_acted_for` y del
  aprovisionamiento del espacio de nombres personal, tanto para HTTP como para MCP (por MCP una llamada para la
  organización de otra celda responde `isError`, de modo que un lote conserva sus otras respuestas, y una llamada en la
  propia organización del token, tal como la resuelve `gates.resolve_org`, se comprueba antes de leer los valores
  por defecto del llamante, ya que viven en esa organización). Las rutas fuera del registro comprueban
  mediante `check_authorized`, `admit_org` o la propia comprobación, y un middleware comprueba
  la propia organización del bearer verificado en las que actúan en ella (las rutas que el censo marca
  `token`; para un token de toda la organización o sin organización en las rutas del llamante que recurren a
  ella, la organización de registro, comprobada sin principal, de modo que se registra o se rechaza, nunca
  se ubica). Un principal que no puede actuar en la organización (un token de otra organización) es rechazado
  primero, con el 403 de la puerta, de modo que no registra, no ubica y no aprende nada: ni si
  la celda posee la organización, ni dónde está ubicada. Una operación cuyo campo de organización se llama de otro modo
  (`from_org`) llega a la misma comprobación mediante `check_authorized`, y una prueba de censo
  lista cada uno de esos campos. Un rechazo escrito antes de la comprobación (JSON mal formado, un argumento
  desconocido, un fallo de validación) no nombra en su telemetría ni en su traza de código ninguna organización que la celda
  no posea. Una prueba unitaria lista todas las rutas de la aplicación y falla a menos que estén marcadas
  como con tenencia comprobada o sin organización.
- **La CLI declara sus organizaciones.** Todo comando de la CLI que se conecta pasa por
  `run_connected`, `connect_checked` o `connect_declared` (`server/cli/_ch.py`), que reciben las
  organizaciones en las que escribe el comando, o por qué no escribe para ninguna. Un comando que declara una organización
  comprueba primero su despliegue (`check_configured`), de modo que bajo la autoridad de Postgres necesita
  `LOOM_PG_DSN`. En una celda, antes de comprobar una organización declarada, leen las filas de la celda y
  rechazan el comando a menos que la fila `first` nombre su celda y sus almacenes (`deployment_id`,
  `bucket`, `bucket_prefix`) coincidan con un valor de la fila propia de la celda: una CLI no verifica ningún token
  y su huella nunca llega al router, así que puede ejecutarse donde los transportes rechazan
  por otro campo de la huella. Con `LOOM_CELL` sin definir, el comando se rechaza en una celda más allá de
  `recording` (más arriba). Una organización que la celda no posee se registra en la primera celda en
  `recording`, igual que la organización de una solicitud (leyendo el estado de la celda con la credencial de router
  de la celda, `LOOM_CELL_ROUTER_TOKEN`, en la configuración de la CLI de la primera celda mientras su modo
  es `recording`, y solo mientras el directorio responda `attaching`), y se rechaza en
  `enforced`; nunca se ubica. Un comando del índice de código declara la organización en la que escribe: su
  `--org`, o si no `LOOM_CODE_ORG`. Una pasada sobre todos los repositorios configurados no declara ninguna,
  ya que attach, o el `loom cell update` que cambia uno, ubica las organizaciones configuradas, y un
  comando de solo lectura o una ejecución en seco no declara ninguna, ya que una lectura no registra nada. Un comando sin organización
  dice qué hace con los almacenes: lee, escribe (`loom ch-setup`, `secrets`, un
  cambio de ajustes, prepare y el resto; una ejecución en seco lee) o revoca (`loom revoke-token`, la
  revocación de un usuario SQL, `loom signing-key retire`, `loom bot disable`, `loom sso unlink`;
  uno que pueda devolver el acceso es una escritura), por subcomando cuando una conexión sirve a varios
  (`loom signing-key`: `list` lee, `retire` revoca, `rotate` y `record-root` escriben).
  Con `LOOM_CELL` definido, una escritura o una revocación comprueba su ClickHouse contra su Postgres
  (`check_configured`), lee la fila `first` en una sesión acotada propia y rechaza
  cuando nombra otra celda, lo que siempre ocurre con una CLI apuntada a los almacenes de otra celda,
  o cuando la lectura falla; una fila ausente, o tablas de estado aún sin migrar, pasa, de modo que una
  celda posterior ejecuta esto antes de estar preparada. Una revocación se ejecuta durante una caída (la cuarta
  excepción en Invariantes); una escritura se rechaza durante una; una lectura no está condicionada.
  `loom ch-setup`, que configura ClickHouse con un cliente propio, ejecuta la misma puerta
  antes de escribir, y un ClickHouse sin registro todavía pasa; `loom migrate` y
  `loom provider-lock clear` escriben a través del cliente propio del ejecutor de esquemas y no están condicionados.
  Una prueba de censo falla ante una conexión que no declara ninguna de las dos cosas, ante una sin organización que no
  diga de qué tipo es, ante una conexión bajo `server/cli/` fuera de `_ch.py`, y ante un
  comando `loom code` que resuelve su organización sin conectarse para ello. Un titular de la
  credencial de router de la celda puede ubicar organizaciones para la celda, dentro de la tasa de la celda y de
  `placements_max`, igual que la credencial de operador que usa `loom cell place` puede hacerlo para cualquier celda
  dentro de su `placements_max` (una llamada de operador no tiene límite de tasa ni cuenta para la
  tasa de la celda), y una ubicación es permanente, de modo que un nombre de organización que toma se pierde para todas las
  demás celdas: un poder sobre el directorio compartido del que carecen las credenciales de almacén de la celda. Por eso
  los pods la tienen, y una CLI solo para la única lectura que la necesita, mientras el modo de la primera celda
  es `recording`: un comando de la CLI que declara una organización se niega a ejecutarse con ella definida, nombrándola,
  a menos que la celda sea la primera y su modo lea `recording`, y un comando sin organización
  nunca la usa; una filtrada se detiene con `loom cell limit --closed`, que no necesita ninguno de
  los almacenes de la celda, y se reemplaza con `loom cell credential` (más abajo).
  `loom cell place --org <org>` (declarado sin organización: escribe la ubicación de la organización y
  la fila de tenencia, que es como una organización pasa a ser poseída), con la credencial de operador del router,
  ubica una organización para un comando que escribe una nueva (un bot, una importación), a través de la
  API de ubicación del router y en su orden, igual que la ubicación de organizaciones configuradas por attach: inserta
  la ubicación y lee de vuelta la ganadora, escribe la fila de tenencia de la celda solo si la ganadora
  es esta celda (de lo contrario se rechaza y no escribe nada), e informa del éxito solo una vez que la
  fila está escrita, de modo que una nueva ejecución es idempotente. Para una organización que el directorio aún no ubica
  pasa la puerta de la API de ubicación (más abajo): se rechaza mientras el directorio no está disponible, para una
  celda que la puerta no acepta, cerrada, o cuando la huella de la propia
  configuración de la CLI de la celda (con el id de despliegue leído de los almacenes a los que se conecta)
  no coincide con ningún valor de la fila de la celda, o más allá de `placements_max`, y cuenta para él.
- **Los escritores anteriores a la verificación son rechazados por los almacenes en los que escriben.** Una sesión que
  ejecutó la verificación de tenencia se marca con `loom.tenancy_checked = 'on'`: toda sesión
  de un proceso con `LOOM_CELL` definido lo envía como parámetro de inicio (de modo que el `RESET ALL`
  del pool lo conserva), y la sesión de migración lo establece tras tomar el bloqueo de migración,
  ya que los pasos de datos de una migración solo copian o reescriben filas ya almacenadas. En cada
  tabla ordinaria de la autoridad con una columna `org` (no la propia `loom.tenancy`, ni
  `loom.idempotency` ni `loom.idempotency_fences`, con clave en la organización del token del llamante) un
  trigger a nivel de fila `AFTER INSERT` y `AFTER UPDATE`, habilitado como trigger de origen, omite una sesión
  marcada en su `WHEN` (el de update también omite una actualización que deja intacta la organización de la fila, de modo que un
  `ON CONFLICT DO UPDATE` que alcanza una fila existente no se rechaza) y
  llama a una función (migración 011). La función sigue la regla de estado (más arriba): deja pasar
  todas las filas mientras el estado es open o una primera celda está en recording, y en todos los
  demás estados rechaza, con SQLSTATE `LT001` (503 `TENANCY_REFUSED` para un llamante), una fila de una
  organización sin fila de tenencia (nunca `''`, `'-'` ni `'*'`); lee el estado una vez que la fila
  está escrita, sin bloqueo de fila, de modo que ninguna escritura queda en cola detrás de attach, y el paso 4 (más abajo) espera
  a que termine toda transacción que pudiera haber leído `recording`. Un arranque con migraciones activadas
  crea los triggers, en cada tabla de ese tipo que encuentra en el catálogo, solo en una celda totalmente
  preparada en `enforced`, y, allí, restablece a origen cualquiera que encuentre no en origen;
  el DDL de cada tabla espera 100 ms por intento su bloqueo, tres intentos separados un segundo (unos 2.3
  s para una tabla ocupada, de modo que un arranque que encuentra ocupadas todas las tablas protegidas espera ese tiempo en
  cada una por turno, reteniendo el bloqueo de migración que esperan otros pods en arranque), y el arranque
  sigue sirviendo más allá de una tabla cuyo bloqueo no puede tomar, registrado con los titulares de sus bloqueos, o
  una que el rol no puede alterar, registrado como tal (la tercera excepción en Invariantes). Una
  primera celda está en `recording` hasta que attach establece `enforced` mientras se ejecuta, de modo que ningún arranque puede
  haberlos creado: attach los crea él mismo con la misma pasada
  (`cell_triggers.ensure`) una vez que ha establecido `enforced`, y la celda pasa a `serving` solo
  cuando `cell_triggers.missing` no nombra ningún defecto. Una celda posterior está en `enforced` desde prepare
  y los obtiene en su primer arranque con migraciones tras prepare, lo que su attach exige
  del mismo modo. `loom doctor` nombra uno deshabilitado o alterado en cualquier estado, uno ausente en
  una celda `enforced`, y una tabla particionada con una columna `org` como no admitida, ya que
  no recibe trigger. Los triggers de origen no se disparan en la aplicación de la replicación lógica ni con
  `session_replication_role = replica`, que los scripts de una celda no usan. La marca no es
  una frontera de privilegios: un escritor que la establece a propósito pasa; los triggers detienen a
  los escritores que no la conocen, una CLI más antigua, un pod degradado más allá de la verificación, o un script,
  para que no añadan una fila de una organización que la celda no posee ni muevan una fila a una; una actualización
  que conserva la organización de una fila, y un borrado, no se rechazan. El coste de los triggers de organización es una
  consulta de ajuste por fila marcada, y una lectura del estado y una consulta de `loom.tenancy` por
  fila no marcada; la puerta con la que se publican es un aumento del p99 de `memory.set` de como máximo 10 ms y una
  tasa de filas por segundo de una pasada de entrega a `LOOM_PG_DELIVERY_BATCH_ROWS` como máximo un 10% menor, en
  `enforced` con las organizaciones poseídas. Toda escritura de Loom en una celda está marcada, así que paga
  solo la consulta de ajuste, medida sobre las sentencias con los triggers activados y desactivados (ningún coste
  distinguible de cero: seis rondas van de −0.36 a 0.49 µs por fila, [resultados de
  benchmark](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md)), lo que predice que la puerta se cumple con
  un amplio margen. La puerta en sí es una medición de extremo a extremo de `memory.set` y de una pasada de entrega en una celda, que
  necesita attach y se comprueba con él; hasta entonces los triggers, que una celda posterior obtiene del
  siguiente arranque con migraciones de prepare, se publican con la medición a nivel de sentencia. `loom.tenancy`
  tiene su propia protección, ya que una fila de tenencia hace que una organización sea poseída: `tenancy_record`, un
  trigger de origen a nivel de fila `AFTER INSERT OR UPDATE OF org` con el mismo `WHEN` de marca,
  llama a `loom.tenancy_refuse_unmarked()` (migración 012), que rechaza, `LT001`, la fila de tenencia de una
  sesión no marcada, o una actualización que la mueve a otra organización, en todos los estados
  salvo una primera celda aún en recording (también `open`, ya que la propia fila haría que el estado fuera
  `partial`), de modo que un script no puede hacer poseída una organización que el directorio no ubica. Los arranques
  y attach lo crean y lo reparan como a los triggers de organización. Con attach, `loom doctor`
  lista también cualquier fila de tenencia que el directorio no ubique, lo que nombra una escrita antes de la
  protección o por un escritor que estableció la marca, y cualquier organización en una tabla de Postgres con clave de organización
  sin fila de tenencia, lo que nombra filas escritas antes de los triggers de organización, por un escritor que
  estableció la marca, o dejadas por una fila de tenencia borrada. Antes del primer attach, el
  operador rota las credenciales de escritor de ClickHouse de la celda (crea el nuevo usuario, lo despliega
  en las configuraciones de las compilaciones que comprueban, elimina el antiguo), y attach se rechaza mientras
  algún usuario de ClickHouse con `INSERT` sobre `loom.*` (`system.grants`, siguiendo los permisos de base de datos, globales y
  de rol a través de `system.role_grants`, y contando los usuarios de archivos de configuración o
  con `ALL` implícito) no sea uno que informe un proceso activo de una compilación que comprueba o el usuario
  configurado de la CLI, de modo que solo los titulares de la credencial rotada escriban en ClickHouse; una
  CLI más antigua a la que se dé esa credencial sigue escribiendo sin comprobar, y con attach `loom doctor`
  lista lo que escribió: cualquier organización hallada en una tabla de ClickHouse con clave de organización sin fila
  de tenencia, a partir de la misma lista de esquemas que el paso 2 de attach.
- **Una organización que la celda no posee se ubica allí o se rechaza.** Para un principal verificado
  con alcance a la organización (un token de esa organización, o un principal de un emisor o bot cuya
  organización es esa), la celda llama a la API de ubicación del router (`POST /cells/v1/placements` en
  `LOOM_CELL_ROUTER_URL`, respondida con la celda ganadora y su id de despliegue) con su
  propia credencial (`LOOM_CELL_ROUTER_TOKEN`), y la celda que nombra la llamada debe ser aquella
  cuyo hash registrado coincide con la credencial (un hash nombra una celda): el router ubica
  una organización a la vez (un bloqueo con alcance de transacción sobre la organización, que toda ruta que ubica
  toma), responde con su celda a una organización ya ubicada, y en otro caso juzga a la celda
  solicitante según su fila bloqueada, inserta la ubicación y lee de vuelta la ganadora, que la
  celda compara por su nombre y su id de despliegue registrado. Si la ganadora es esta celda, la
  celda escribe la fila de tenencia y sirve la solicitud; el nombre de esta celda bajo otro id de despliegue
  que el que verificó el proceso responde 503 y no escribe nada; si es el nombre de otra
  celda, la solicitud responde 409 `WRONG_CELL` y no se escribe nada. Esta es la
  única vía por la que una solicitud lleva una organización a una celda, sea cual sea lo que la creó: una emisión, el token
  de una pasarela o de un emisor federado, una organización `prefix*` de un emisor de usuarios finales, un bot. Un
  principal de organización `*` o de plataforma actúa solo en organizaciones que la celda ya posee y nunca
  ubica una (en una primera celda antes de `serving`, véase [las claves del
  heartbeat](#the-heartbeats-keys)). Para una organización que el directorio aún no ubica, el router
  acepta una llamada de ubicación solo de una celda `serving` (o de la primera celda mientras está en
  `attaching` una vez que el directorio registra `enforced`, que el paso 3 de attach escribe antes de que
  establezca el modo de la celda), y solo con la huella de configuración del proceso que llama,
  cuyos campos deben coincidir con un valor de la fila de directorio de la celda; la fila de una celda preparada no contiene
  emisores ni patrones de organización hasta que attach los escribe. Una llamada fallida, una sin respuesta dentro de
  `LOOM_CELL_ROUTER_TIMEOUT_S`, una celda aún no adjuntada o cerrada a nuevas organizaciones, o una
  huella que no coincide con ningún valor responde 503 y no escribe nada; un reintento es
  seguro, ya que la lectura de vuelta lo hace idempotente. Para una organización que el directorio ya
  ubica, la llamada de una celda se comprueba solo por su credencial (contra los hashes de las celdas
  que el router guarda en caché durante `LOOM_ROUTER_DIRECTORY_CACHE_S`, por defecto 5 s) y por la tasa
  de la celda, y un `loom cell place` solo por la credencial de operador; ambos responden con la ganadora
  sea cual sea el estado, la cuota o la huella de la celda, sin añadir ubicación (la ganadora es
  pública de todos modos mediante la consulta); una solicitud rechazada por superar la tasa de su celda responde 503
  con `Retry-After` (como máximo un minuto), y su reintento lo admite la réplica que
  la responde una vez que las llamadas de la celda allí están por debajo de la tasa. Una organización que la celda ya
  posee no necesita llamada, de modo que servirla nunca depende del router.
- **Las ubicaciones están acotadas por celda.** Cada réplica del router limita la tasa de las llamadas de ubicación
  de cada celda por minuto (`LOOM_ROUTER_PLACEMENTS_PER_MINUTE`), lo que acota su
  ritmo a esa tasa multiplicada por las réplicas, y la fila de directorio de una celda puede llevar una cuota de ubicaciones
  (`placements_max`, sin definir por defecto), que una vez definida acota su total, contado
  e insertado bajo un bloqueo sobre la fila de directorio de la celda, de modo que las llamadas concurrentes entre
  réplicas del router nunca la superan; superada la tasa, toda llamada de ubicación de la celda responde
  503 con `Retry-After`; superada la cuota, una llamada para una organización que el directorio aún no ubica
  responde 503 como para una celda cerrada (un `loom cell place` de operador está exento de
  la tasa, como se indicó); y las ubicaciones de cada celda se informan en
  `/v1/health?include=capacity` y por `loom doctor`, que nombra una celda sin cuota.
  Toda organización que ubica el attach de la primera celda (la instantánea del paso 2, incluidas sus organizaciones configuradas,
  y las del paso 4) se cuenta pero nunca se rechaza por cuota ni por celda cerrada, ya que la celda
  ya la sirve y rechazarla dejaría sus datos varados (una que supere `ORG_MAX_BYTES` la rechaza el
  directorio, más abajo); toda otra ubicación de una organización que el directorio aún no ubica,
  incluidas las organizaciones configuradas de una celda posterior en attach y una modificada en `loom cell update`,
  pasa la puerta, incluidas una celda cerrada y `placements_max`, de modo que una celda posterior
  cerrada o llena antes de attach rechaza el attach, nombrando la organización.
- **La primera celda registra hasta `enforced` como lo hace un despliegue único.** En
  `recording`, que dura hasta que el paso 3 escribe `enforced` en el modo de la celda (y de nuevo
  siempre que el paso 3 o el paso 4 la devuelve a ese modo), una solicitud verificada para una nueva organización
  escribe una fila de tenencia sin llamada de ubicación, de modo que la tasa del router, `placements_max`
  y `loom cell limit --closed` no se aplican: las nuevas organizaciones llegan como en un despliegue
  único, acotadas por sus propios ajustes de registro, emisor y JIT, y el paso 2 o el paso 4
  las ubica sin rechazo. `loom doctor` lista las organizaciones registradas que no contienen datos, para que el
  operador vea lo que attach ubicará.
- **Las organizaciones configuradas se ubican en attach.** El `oidc_jit_org` de la celda, el
  `self_signup_org` de una celda con registro activado, y sus organizaciones de código (`LOOM_CODE_ORG` y la
  organización de cada entrada de `LOOM_CODE_REPOS_JSON` que conserva la configuración de código) y la organización del tracker se
  ubican como propias cuando se adjunta: las de la primera celda en la instantánea del paso 2, las de una celda
  posterior antes de marcarla `serving`. JIT y el registro propio pasan la verificación de tenencia como
  cualquier solicitud, y nada se rechaza en el arranque: en `recording` de la primera celda registran su organización
  mientras el directorio responde `attaching`, y en otro caso una organización configurada que la celda no posee
  responde 503 hasta que se ubica (422 para una que supere
  `ORG_MAX_BYTES`, que el directorio rechaza), lo que `loom doctor` nombra; todo attach,
  primero o posterior, nuevo o reanudado, ejecuta los rechazos por solapamiento y ubica las
  organizaciones configuradas de ambos valores de `loom.cell_self`, de modo que una que una actualización puso en `next` antes de attach se
  ubica con las demás; una vez que attach ha escrito la fila de directorio de la celda, `loom cell update`
  ubica una modificada en la transacción de directorio que escribe `next`, a través de la
  puerta de la API de ubicación para una organización que el directorio aún no ubica (incluidas las celdas cerradas y
  `placements_max`), rechazando, nombrándola, cuando otra celda la posee, y luego
  escribe su fila de tenencia en la celda; para una celda posterior aún `attaching` tras su transacción
  de directorio, `loom cell update` rechaza un cambio de organización configurada hasta que la celda está
  `serving`. En `enforced`, un worker escribe para una organización solo una vez que la celda la posee (la
  verificación de tenencia sin principal), de modo que una celda posterior no indexa, importa ni barre nada
  bajo sus organizaciones configuradas antes de que attach las ubique; en `recording`, los workers se ejecutan como
  antes, y la instantánea del paso 2 y la segunda lectura del paso 4 encuentran todas las organizaciones en las que escriben.
- **Las filas nunca se borran.** Una fila de tenencia y una ubicación nombran una organización, no su memoria:
  ambas se clasifican para el borrado como sin contenido de memoria, igual que la reclamación de un espacio de nombres,
  y permanecen tras cualquier borrado, de modo que un nombre de organización nunca queda libre para otra celda. Un
  proceso conserva las organizaciones que ha visto poseídas, y servir una conservada nunca es erróneo.
- **Un único límite de nombre de organización.** Una celda no registra ni ubica ninguna organización nueva de más de
  `ORG_MAX_BYTES` (2048 bytes UTF-8, `server/core/cell.py`, por debajo del límite de entrada de índice de Postgres): la
  verificación de tenencia de una celda en recording rechaza una con 422 y no escribe nada,
  y el directorio rechaza una con 400 (`ORG_TOO_LONG`) antes de escribir una ubicación, para
  toda ruta que ubica, lo que la ubicación de una celda convierte en el mismo 422 (por MCP, un
  error de herramienta contado como del llamante). Así, toda organización que registra una celda puede ubicarse, y una
  organización poseída o ubicada antes del límite conserva su celda.
- **Una organización ubicada sin fila** (una restauración a un momento anterior a su ubicación) recupera su fila
  con `loom cell restore`, antes de que la celda restaurada arranque ([Qué ejecuta cada
  celda](#what-each-cell-runs)).

<a id="attaching-a-cell"></a>

## Adjuntar una celda

`loom cell attach`, ejecutado contra el router, registra una celda, un attach a la vez, y se niega ante cualquier fallo, nombrándolo:

- la celda responde en su propio host con el id de despliegue que informa su `probe_url`, cada proceso activo tiene `LOOM_CELL` establecido con su nombre, ejecuta la autoridad de Postgres con un standby síncrono (`LOOM_PG_DURABILITY=synchronous`) y autenticación obligatoria, y registra un id de despliegue que ninguna otra celda registra;
- en la primera celda, el rol de Postgres de attach puede leer el estado de transacción de cada backend (`pg_read_all_stats`) y el Postgres de la celda no permite transacciones preparadas (`max_prepared_transactions = 0`), de modo que el paso 4 ve todas las transacciones abiertas;
- sus claves son propias: ningún emisor que acepta para tokens bearer es aceptado por otra celda, y la huella de su secreto raíz (`keys_fp`) no coincide con la de ninguna otra celda. Los proveedores de identidad upstream y los emisores de cargas de trabajo pueden compartirse, ya que una celda emite su propio token a partir de ellos; un gateway (`LOOM_IDENTITY_PROVIDER=gateway`) emite para una sola celda, por lo que un despliegue ejecuta un gateway por celda;
- ningún proceso activo de otra celda informa una huella que no coincida con ninguno de los dos valores de su fila del directorio, y cada proceso activo de la celda que se adjunta coincide con su `current` o `next` de `loom.cell_self` (attach nombra cualquiera que no lo haga);
- ninguna otra celda registra el mismo par (emisor OIDC, id de cliente) (la fila del directorio los registra, y `loom cell update` los cuenta en sus rechazos por solapamiento);
- con SCIM activado, cada token SCIM que posee la nombra (`lsc_<cell>_…`) o, solo en la primera celda, no nombra a ninguna; una celda posterior no posee ninguna fila de usuario SCIM ni lápida (sus personas se aprovisionan después de attach, en el orden `LOOM_CELL`, un token con nombre y luego la asignación de la aplicación);
- su `LOOM_PUBLIC_BASE_URL` está establecida (un proceso con `LOOM_CELL` establecido se niega a arrancar sin ella, de modo que ninguna URL que entrega proviene del Host de una solicitud), y los hosts de ella y de `LOOM_OAUTH_ISSUER` (si está vacío se resuelve a la URL base pública) son iguales a su host registrado: para la primera celda, cuyo host registrado es el host compartido, son el host compartido o un alias registrado de él; el host de ninguna celda posterior es el host compartido ni un alias, lo que impone la tabla `hosts` del directorio (host como clave primaria, normalizado por una sola función, `normalise_host`: minúsculas, IDNA a ASCII, sin punto final ni puerto por defecto, con los corchetes conservados en IPv6, usada por `hosts`, la regla 1, attach y la comprobación de preparación; propiedad de una celda, con un alias perteneciente a la primera celda), escrita en la misma transacción que cada comprobación, y a partir de la cual la regla 1 enruta; `LOOM_JWT_ISSUER` es una cadena opaca que solo necesita ser única; prepare comprueba lo mismo;
- sus orgs configuradas no colisionan con ninguna org ubicada en otra celda, y ningún patrón de org en el que confía (los `orgs` de sus emisores de usuarios finales) se solapa con los patrones u orgs configuradas de otra celda, ni el patrón de otra celda coincide con sus orgs configuradas, según la regla de solapamiento que un despliegue único aplica a sus propios emisores de usuarios finales;
- sus almacenes no son los de otra celda: una clave de sondeo escrita en un nombre reservado de su KeeperMap `loom._migration_lock` no es visible para ninguna otra celda y el sondeo de cada otra celda le es invisible (un ClickHouse sin Keeper se niega); su prefijo de bucket no es prefijo de ruta del de otra celda en un bucket del mismo nombre, en ningún endpoint, ni tiene uno, y los objetos de sondeo no se listan en ninguna dirección;
- cada proceso activo de cada celda ejecuta una build cuya predecesora también ejecuta la comprobación de tenencia (abajo), y un heartbeat que informa su modo de tenencia, su huella y el `LOOM_CELL` con el que se ejecuta;
- con SCIM activado, ninguna cuenta activa tiene un contacto o correo verificado sin una fila SCIM activa (incluidas cuentas con contraseña, sesiones de refresco vivas y cuentas de servicio personales), y ninguna cadena de creador de una cuenta de servicio viva termina en una cuenta sin correo (tokens de registro de agente creados antes de SSO): attach las lista y se niega, o con `--revoke-unprovisioned` finaliza sus tokens emitidos antes del attach bajo el propio prefijo de revocación de SCIM, de modo que una persona que el proveedor de identidad aprovisione después sea admitida, ya que nunca desaprovisionará a una persona que no cuenta como asignada.

El primer attach convierte el despliegue existente en la primera celda, en orden:

1. comprobar que el modo es `recording`, como lo dejó prepare: cada solicitud verificada ha escrito la fila de tenencia de su org si faltaba mientras el directorio respondía que la celda estaba `attaching`;
2. en una transacción del directorio, escribir `attach_started_at`, los emisores, patrones y huella de la celda (ambos valores de `loom.cell_self`), y las ubicaciones, luego las filas de tenencia, de cada org que la celda contiene, a partir de un snapshot, directamente en el directorio (todavía no existe otra celda): sus orgs configuradas (de ambos valores), el `org` distinto de cada tabla de ambos esquemas (generado a partir del esquema, como lo es la clasificación de tablas del borrado) y las orgs de los objetos de bucket catalogados; nunca `''`, `'-'` ni `'*'`;
3. establecer `enforced` como arriba, dentro de `--wait`, que la espera siguiente comparte, sin iniciar ningún intento que pudiera confirmar el modo con menos tiempo restante que el mínimo de esa espera (la vida de la caché del modo más el plazo de solicitud más largo): attach se niega entonces, informando el modo que lee de vuelta (`recording`, y una nueva ejecución reanuda desde el paso 1), o el modo como desconocido cuando no puede leerlo, y una nueva ejecución reanuda según el modo que lea; luego esperar, dentro de lo que quede de `--wait` (por defecto 10 minutos, después se niega y vuelve a establecer `recording`), hasta que cada proceso activo informe `enforced` y hayan pasado la vida de la caché del modo más el plazo de solicitud más largo; luego ejecutar de nuevo la precondición SCIM (otra vez `--revoke-unprovisioned` si se dio), para las cuentas creadas antes de que `enforced` surtiera efecto; si se niega, la celda permanece `enforced` y `attaching`, y ejecutar attach otra vez reanuda desde la espera, como hace un attach reanudado (abajo);
4. esperar, dentro de lo que quede de `--wait`, hasta que no quede abierta ninguna transacción que pudiera haber leído `recording`, juzgado a partir de un snapshot de Postgres que attach toma una vez que ha leído `enforced` de vuelta en esta ejecución (no a partir de un reloj): cuenta como abierta una transacción en la base de datos de la celda que empezó antes de él, desde cualquier cliente, worker en segundo plano o conexión de replicación lógica, incluidas las de solo lectura; una transacción de escritura en otra base de datos del mismo servidor que lo hizo (retiene el horizonte de cada snapshot, y se nombra como tal); una transacción preparada (que se niega de inmediato); o una cuyo estado attach no puede leer; y no cuentan los procesos de mantenimiento propios de Postgres, las conexiones de replicación física (las de cada standby y de un base backup, que no ejecutan SQL) ni las conexiones propias de attach. Pasado `--wait`, attach se niega, nombrando lo que esperaba, y deja la celda `enforced`, de modo que una nueva ejecución reanuda desde la espera del paso 3. El comando attach fija la consulta exacta, y sus pruebas cubren cada tipo de transacción. Una vez superada la espera, ubicar las filas de tenencia escritas desde el snapshot y cada org que las fuentes del paso 2 producen al leerlas de nuevo (el `org` distinto de cada tabla de ambos esquemas y las orgs de los objetos de bucket catalogados; también se ubica una fila o un objeto que un escritor sin comprobación, como una CLI antigua o un worker, escribió en `recording` después del snapshot), comprobar de nuevo que cada proceso activo informa `enforced` (negándose y volviendo a `recording` como hace el paso 3 si alguno no lo hace), y marcar la celda como `serving`. El directorio registra el modo más alto que attach ha subido o intentado subir, que `loom cell restore` escribe de vuelta solo hacia arriba: una celda cuyo paso 3 fue rechazado en el bloqueo se restaura a `enforced`, y su attach reanudado se ejecuta entonces desde la espera del paso 3.

Una celda posterior se adjunta solo cuando la primera está `serving`. No debe contener datos de orgs (attach se niega en caso contrario) y comienza en `enforced`. Su attach ejecuta, en orden: los rechazos; una transacción del directorio, bajo el bloqueo del directorio y con los rechazos por solapamiento ejecutados de nuevo dentro de ella, que escribe `attach_started_at`, las ubicaciones de sus orgs configuradas y sus emisores, patrones y huella (ambos valores de `loom.cell_self`), negándose y sin escribir nada cuando una lectura de vuelta nombra a otra celda (nombra la org); las filas de tenencia de sus orgs configuradas y de su `loom.cell_self`, en la celda; la precondición SCIM (`--revoke-unprovisioned` si se dio); y `serving`. Un attach posterior reanudado vuelve a ejecutar los rechazos distintos de los de una celda nueva y continúa desde el primero de estos pasos no realizado; las ubicaciones son idempotentes gracias a la lectura de vuelta. Sus personas son aprovisionadas por su propia aplicación del proveedor de identidad antes de iniciar sesión. Los servicios propios de una org se adjuntan como una celda propia. Una nueva org de personas comienza con `loom cell place --org`, y luego la asignación de sus personas a las aplicaciones de esa celda; una celda con SCIM activado no admite a nadie hasta que se haya ejecutado su primer ciclo de aprovisionamiento. Una celda que se acerca a los límites de sus almacenes se cierra a nuevas orgs: sus llamadas de ubicación responden 503, de modo que las nuevas orgs de sus emisores esperan capacidad en lugar de derramarse a otra parte.

Un primer attach reanudado, para una celda cuya fila del directorio tiene `attach_started_at`, vuelve a ejecutar cada rechazo de la lista anterior que se aplique a la primera celda. Luego continúa según el modo de la celda: en `recording` desde el paso 1; en `enforced`, desde la espera del paso 3 (cada proceso activo informa `enforced`, luego pasan la vida de la caché y el plazo de solicitud más largo) y después su precondición SCIM, de modo que la comprobación SCIM que cierra un attach detenido tras establecer `enforced`, sea cual sea la causa, siempre se ejecuta después de que `enforced` haya surtido efecto.

<a id="what-each-cell-runs"></a>

## Qué ejecuta cada celda

Todo lo que ejecuta un despliegue, sin cambios: sus pools, migraciones, workers y sus
leases, health y readiness (la readiness de un pod es la de su celda), el borrado y su censo,
los checkpoints de auditoría, los backups y las restauraciones. La restauración de una celda es la de un único despliegue
([copias de seguridad y recuperación](https://github.com/ClickHouse/loom/blob/main/docs/operations/backup-and-recovery.md)), con los mismos límites:
lo que contiene el backup (sus claves, revocaciones, sesiones, bots y filas de SCIM) vuelve
tal como estaba. Una celda añade un paso después de la restauración del almacén y antes de cualquier otro paso de esa
página: `loom cell restore`, con la celda detenida, ejecutado donde el operador ejecuta
`loom cell place` y attach, con la credencial de operador del router, que ninguna configuración de celda contiene (un comando de CLI declarado sin organización: escribe las filas propias de la celda),
reescribe desde el directorio las filas que una restauración puede recuperar, de modo que los borrados y las redacciones de `loom reconcile`
pasen la comprobación de tenencia, y una restauración de ambos almacenes,
que `loom reconcile` rechaza, aun así recupera las filas de su celda. Se rechaza mientras el
directorio no está disponible, y escribe:

- una fila de tenencia por cada organización que el directorio ubica en ella;
- la que falte entre la fila `first` y la fila de modo, tomada del directorio, como hace un prepare reanudado; una fila `first` presente que difiere de la del directorio se rechaza, y
  una que coincide se conserva;
- una vez recuperadas las filas de tenencia, el modo registrado en el directorio sobre la fila de modo, solo
  hacia arriba (`recording` a `enforced`), nunca hacia abajo;
- una vez que la fila del directorio contiene la huella de la celda (la escribe attach), su
  `loom.cell_self` a partir de ella (`current` y `next`); antes de attach el directorio no contiene
  ninguna, y el `loom.cell_self` restaurado queda como lo contiene el backup (un `current` ausente
  lo escribe una nueva ejecución de `loom cell prepare` cuando la celda arranca, un `next` perdido, volviendo a ejecutar
  `loom cell update --config`).

Una primera celda restaurada a un punto anterior a su prepare, y todavía no conectada, no sirve nada en el
host compartido en sus procesos con `LOOM_CELL` definido (uno sin definir sirve como un único
despliegue, como antes del despliegue gradual) hasta esa nueva ejecución de `loom cell prepare`, que es el
paso inmediatamente posterior a su arranque.

La readiness de una celda nunca espera al directorio, así que una caída de este no detiene el rollout de ninguna celda. Un proceso que lee `recording` registra una organización nueva solo mientras el directorio responde
que su celda está en `attaching` ([las claves del heartbeat](#the-heartbeats-keys)); mientras el
directorio no se puede leer o marca la celda como `serving`, una organización nueva recibe 503 y las organizaciones que la
celda contiene siguen sirviéndose. Por tanto, una restauración a un punto anterior al paso 3 del primer attach cuyo
`loom cell restore` se omitió no sirve ninguna organización que no contenga; `loom doctor`
nombra esa celda, y `loom cell restore` eleva su modo.

**El directorio es un almacén de alta disponibilidad.** Su Postgres funciona con un standby síncrono
y recuperación a un punto en el tiempo hasta su último commit, igual que el de una celda, de modo que una conmutación por error o una corrupción
no pierde nada confirmado. Perderlo por completo es una interrupción que falla en modo cerrado:
cada celda sigue sirviendo las organizaciones que contiene, el enrutamiento continúa desde la instantánea firmada de cada réplica del router de su última caché (escrita en almacenamiento compartido en cada
cambio del directorio), y las ubicaciones, las búsquedas de organizaciones no almacenadas en caché, los comandos `loom cell` que
leen o escriben el directorio y las lecturas de estado de las celdas en modo recording responden 503 o
se rechazan hasta que el directorio vuelva, mientras que `loom doctor` informa de sus comprobaciones del directorio como
no ejecutadas y, con `LOOM_CELL` definido, termina con código distinto de cero; reconstruir un directorio perdido
a partir de las celdas es un diseño aparte.

Cada celda conserva, en su propio Postgres, una copia de la huella de configuración de la fila de su directorio
(`loom.cell_self`), con la que sus procesos comparan su configuración y que
escriben attach y `loom cell update` ([La fila propia de la celda](#the-cells-own-row)).
`loom cell restore` reescribe su `loom.cell_self` desde el directorio; los almacenes restaurados
conservan el id de despliegue de la celda, así que una restauración a un nuevo endpoint solo necesita la nueva
dirección en la configuración de la celda. Cerrar una celda o fijar su `placements_max` es
un solo comando,
`loom cell limit --cell <cell> [--closed | --open] [--placements-max (<n> | none)]`,
que escribe solo en el directorio, con la credencial de operador del router y sin ninguno de los
almacenes de la celda, así que funciona mientras la celda está caída; el router juzga una ubicación a partir de la fila del directorio.

<a id="operations"></a>

## Operaciones

- `loom cell restore`, después de cualquier restauración de almacenes y antes de `loom reconcile`, vuelve a escribir las filas de la celda desde el directorio ([Qué ejecuta cada celda](#what-each-cell-runs)).
- `loom cell which --org <org>` indica la celda de una organización (el borrado, la restauración y el soporte empiezan ahí); para una organización sin asignación indica la primera celda, y la búsqueda no distingue ese caso.
- `loom cell limit --cell <cell> --closed` cierra una celda a nuevas organizaciones, `--open` la reabre y `--placements-max <n>` fija su cuota de asignaciones (`--placements-max none` la elimina).
- `loom cell remove --cell <cell>` elimina la fila del directorio de una celda que está en `attaching` sin ninguna asignación (`--cell` es el `LOOM_CELL` de la celda, que para entonces ya no está definido). Para la primera celda lee únicamente el Postgres de la celda, en una sola sesión desde `LOOM_PG_DSN` y sin ClickHouse, y se niega a continuar a menos que lea `open` y registre el id de despliegue de la fila, lo que impone el orden de retroceso: quitar `LOOM_CELL` en cada proceso (cada uno funciona como en `recording`), después la limpieza completa del estado y por último la eliminación
  ([solución de problemas](https://github.com/ClickHouse/loom/blob/main/docs/operations/troubleshooting.md#a-process-with-loom_cell-unset-is-gated)).
  Si se elimina primero la fila, cada organización nueva recibe 503; si se limpia primero el estado, se bloquea cada proceso que tenga `LOOM_CELL` definido. Una primera celda con una asignación avanza, nunca retrocede. Los almacenes de una celda eliminada conservan las filas de estado que contengan, así que la limpieza completa del estado se ejecuta antes de volver a prepararlos.
- La credencial de operador del router es `lco_` seguida de 128 caracteres hexadecimales en minúscula (un router sin `LOOM_ROUTER_OPERATOR_SHA256` responde 503 a la API de operador con `NO_OPERATOR_CREDENTIAL`), que genera `loom cell credential new --operator`; el router solo guarda su SHA-256. Las negativas de la API de operador no tienen límite de frecuencia: un límite por dirección permitiría que un desconocido detrás de un ingress compartido bloqueara a todos los operadores, y 512 bits no se adivinan en línea. Un comando de operador solo conoce su resultado cuando la conexión nunca se abrió o cuando respondió el propio router, salvo `BACKEND_UNAVAILABLE` (un COMMIT puede completarse después de su límite de tiempo); tras un tiempo de espera agotado, una conexión interrumpida o la página de una pasarela, indica que el cambio puede haberse realizado y qué muestra un reintento. La credencial de operador se rota definiendo el nuevo hash en `LOOM_ROUTER_OPERATOR_SHA256` y reiniciando el router; mientras se renuevan sus réplicas, algunas siguen rechazando la nueva credencial con 401, y el operador vuelve a ejecutar el comando hasta que todas las réplicas la acepten. Los comandos llaman al router en `--router`, o si no en `LOOM_CELL_ROUTER_URL`, en su raíz (se rechaza una ruta ahí, porque el router reenvía una a una celda), y envían la credencial de operador solo por https (http en loopback), de modo que una dirección de router `http` dentro de la red sirve a una celda pero no a estos comandos.
- `loom cell credential new` genera una credencial de router sin conexión y la imprime con su SHA-256; `loom cell credential --cell <cell> --next <sha256>` registra el SHA-256 de una nueva credencial de router como el hash `next` de la celda; igual que prepare, recibe el hash como argumento, en la misma forma. Usa la credencial de operador del router, escribe solo en el directorio y mantiene el bloqueo del directorio; se rechaza cuando alguna celda registra ese hash como actual o como siguiente, y mientras haya un `next` pendiente. El router acepta ambos en las llamadas de asignación y en las lecturas de estado, cada réplica dentro de `LOOM_ROUTER_DIRECTORY_CACHE_S` desde `--next`, por lo que la nueva credencial se incorpora a los pods solo después de ese plazo; `loom router migrate` se ejecuta antes de un router que lee el hash `next`, y una rotación empieza cuando todas las réplicas del router lo hacen. Un router revertido a una versión que lee solo el hash actual rechaza a un pod con el siguiente: revierte sin ningún `next` pendiente (primero `--revert`), y no entre `--finish` y el momento en que la credencial antigua sale de los pods. Cuando la nueva credencial está en los pods de la celda y, mientras el modo de la primera celda es `recording`, en su configuración de la CLI, `loom cell credential --cell <cell> --finish` convierte `next` en el actual y descarta el anterior; no comprueba nada que no pueda ver (el router no sabe qué credencial tiene un pod), y una celda finalizada demasiado pronto falla en modo cerrado: sus llamadas de asignación y lecturas de estado responden 401, como muy tarde cuando caduca la caché del router con los hashes de la celda (`LOOM_ROUTER_DIRECTORY_CACHE_S`), hasta que sus pods tengan la nueva credencial o hasta que el hash antiguo se registre de nuevo con `--next` y se finalice. `loom cell credential --cell <cell> --revert` descarta un `next` pendiente, de modo que uno equivocado o filtrado nunca tenga que finalizarse; `--finish` y `--revert` se rechazan si no hay ningún `next` pendiente.
- La configuración de una celda nueva indica `LOOM_CELL`, su host público (`LOOM_PUBLIC_BASE_URL`, `LOOM_OAUTH_ISSUER`, `LOOM_JWT_ISSUER`), sus claves, su prefijo de bucket, sus organizaciones configuradas, el cliente OIDC y el token SCIM de su proveedor de identidad, y su credencial de router (`LOOM_CELL_ROUTER_URL`, `LOOM_CELL_ROUTER_TOKEN`, que mantienen sus pods, y `LOOM_CELL_ROUTER_TIMEOUT_S`).
- Cada celda informa de escrituras por segundo, filas por espacio de nombres y bytes por clave en `/v1/health?include=capacity`, frente a unos 13.6 KB por clave en ClickHouse y 6.8 KB en Postgres ([Memoria a escala](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md#memory-at-scale)).
- **Una organización permanece en su celda.** Mover una organización entre celdas es un diseño aparte: requiere aislar las escrituras de la organización en cada proceso de la celda, una copia de cada almacén que no cuente nada dos veces y una eliminación verificada.
- **Los datos de una celda permanecen en sus almacenes.** Moverlos a otros almacenes (otro id de despliegue, nombre de bucket o prefijo), o añadir un bucket a una celda preparada sin uno, es un diseño aparte: durante cualquier despliegue gradual los procesos antiguos y los nuevos escribirían en almacenes distintos, así que requiere aislar las escrituras de la celda, como en el traslado de una organización.
- **Una celda permanece conectada.** Retirar una celda es un diseño aparte: requiere una prueba, obtenida de los propios almacenes, de que no queda ninguna copia de los datos de sus organizaciones, antes de que nada pueda responder que así es. Hasta entonces, una celda que está caída sigue siendo una celda: sus organizaciones responden 503, y sus nombres, emisores, hosts y asignaciones siguen reservados.

<a id="failure-modes"></a>

## Modos de fallo

| Fallo                                                                    | Qué ocurre                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| El directorio está caído                                                 | se enrutan las solicitudes por host, por emisor y a la primera celda; las organizaciones nuevas y las búsquedas no almacenadas en caché responden 503                                                                                                                                                                                                                                                                                |
| Falla la llamada de colocación del enrutador                             | la solicitud responde 503 y no se escribe nada; se sirven las organizaciones que la celda contiene                                                                                                                                                                                                                                                                                                                                   |
| El emisor de una celda coloca organizaciones en avalancha                | desde `enforced`, sus llamadas de colocación responden 503 con `Retry-After` por encima de su tasa, y sus llamadas para organizaciones nuevas responden 503 por encima de su cuota si hay una definida; las demás celdas colocan como antes                                                                                                                                                                                          |
| Un token SCIM de otra celda, o una aplicación en el host de la celda equivocada | el proceso no arranca, o `/scim/v2` responde 401 y no escribe nada                                                                                                                                                                                                                                                                                                                                                                   |
| El Postgres o el ClickHouse de una celda                                 | esa celda falla igual que una implementación única ([autoridad de almacenamiento](https://github.com/ClickHouse/loom/blob/main/docs/architecture/storage-authority.md#failure)); las demás celdas siguen sirviendo                                                                                                                                                                                                                    |
| Las filas propias de una celda o su modo de tenencia no se pueden leer   | con `LOOM_CELL` definido, un proceso conserva sus últimas filas y su último modo dentro del límite de obsolescencia y después queda bloqueado; un proceso de servidor cuya primera lectura falla no arranca (bloqueado y no listo con migraciones de Postgres pendientes), y un hijo de workers que nunca las leyó queda bloqueado; sin definirlo, un proceso de servidor conserva su veredicto sin límite, y una primera lectura fallida hace fallar su arranque (bloqueado hasta que una lectura tenga éxito con migraciones de Postgres pendientes) |
| Se elimina una fila `first` o de modo, o ambas junto a una fila de tenencia o propia | los disparadores de organización, donde una celda los tiene, actúan como en `enforced` y todos los procesos quedan bloqueados; `loom doctor` lo señala y volver a ejecutar prepare las escribe de nuevo                                                                                                                                                                                                                              |
| Ninguna fila de estado, de tenencia o propia en una celda que el directorio registra | abierto; `loom doctor` lo señala; `loom cell restore` lo cierra tras una restauración, y volver a ejecutar prepare lo cierra tras un prepare interrumpido                                                                                                                                                                                                                                                                            |
| Aún no se lee el valor `first` de una celda                              | toda solicitud, salvo las sondas de salud y la ruta de sondeo, responde 503 (SCIM con `Retry-After`); el proceso no está listo y no ejecuta ningún worker (un hijo de workers, o un proceso de servidor con migraciones de Postgres pendientes; cualquier otro proceso de servidor falla en el arranque)                                                                                                                              |
| Una solicitud para la organización de otra celda                         | 409 `WRONG_CELL` tras la verificación, sin escribir nada                                                                                                                                                                                                                                                                                                                                                                             |
| Una llamada de plataforma, de organización `*` o sin principal para una organización no contenida | en una primera celda, 503 mientras el directorio responde `attaching` o no se puede leer antes de una respuesta `serving`; 409 `WRONG_CELL` una vez en `serving` y en una celda posterior                                                                                                                                                                                                                                            |
| Un pooler que elimina el marcador de tenencia de las sesiones de una celda | la comprobación de preparación `cell_marker` falla en `enforced` y `partial` y avisa en `recording`; el latido informa `marked` en false y attach rechaza el proceso                                                                                                                                                                                                                                                                 |
| Una celda restaurada a un momento anterior                               | `loom cell restore` vuelve a escribir las filas de las organizaciones colocadas antes de iniciarse                                                                                                                                                                                                                                                                                                                                   |
| Una primera celda restaurada a antes de su prepare, aún sin adjuntar     | en los procesos con `LOOM_CELL` definido, toda solicitud salvo las sondas de salud y la ruta de sondeo responde 503 hasta que prepare se vuelve a ejecutar                                                                                                                                                                                                                                                                           |
| El directorio perdido                                                    | cada celda sirve las organizaciones que contiene; las colocaciones y las búsquedas no almacenadas en caché responden 503 y los comandos del directorio se rechazan, hasta que vuelva                                                                                                                                                                                                                                                 |
| Una celda en `recording`, con el directorio ilegible                     | una organización nueva responde 503; las organizaciones que contiene siguen sirviéndose                                                                                                                                                                                                                                                                                                                                              |
| Un proceso atascado durante el primer attach                             | attach se rechaza tras `--wait` y la celda vuelve a `recording`                                                                                                                                                                                                                                                                                                                                                                      |
| Un insert de recording retenido abierto durante el primer attach         | attach deja de intentarlo cuando queda muy poco de `--wait` para la espera e informa del modo que lee de vuelta; volver a ejecutarlo lo reanuda                                                                                                                                                                                                                                                                                      |
| Attach se detiene mientras retiene el bloqueo de la tabla de modo        | Postgres termina su sesión en pocos segundos y libera el bloqueo; las organizaciones nuevas responden dentro de su plazo                                                                                                                                                                                                                                                                                                             |
| Una transacción abierta desde antes de la instantánea del paso 4         | attach se rechaza cuando se agota `--wait` (una preparada, de inmediato), indica qué esperaba y deja `enforced`                                                                                                                                                                                                                                                                                                                      |
| Un comando de la CLI con `LOOM_CELL` sin definir, iniciado antes del paso 3 de attach | leyó el estado mientras la primera celda estaba en `recording` y sigue escribiendo en ClickHouse después de `serving`; el runbook define `LOOM_CELL` en cada CLI antes de attach                                                                                                                                                                                                                                                      |
| Una CLI de una compilación anterior a la lectura del estado             | no se rechaza en una celda `enforced`; cada imagen de CLI y de CI ejecuta una compilación con la lectura antes de attach ([actualizaciones](https://github.com/ClickHouse/loom/blob/main/docs/operations/upgrades.md#upgrade-procedure))                                                                                                                                                                                              |

<a id="rolling-upgrades"></a>

## Actualizaciones progresivas

La comprobación de tenencia, la llamada de colocación y la lectura del estado de la celda, las
declaraciones de organización de la CLI, `LOOM_CELL`, `loom cell prepare`, `scim.refuses_subject`, el correo electrónico que
almacena una concesión, `loom.cell_self`, la compuerta de solicitudes y la comprobación de preparación de la huella de un proceso
frente a su propia fila, el rechazo del token SCIM de otra celda, el requisito de SCIM, y el modo, la huella y `LOOM_CELL` del heartbeat se publican en una misma
versión. La compuerta sobre un proceso con `LOOM_CELL` sin definir, el marcador de sesión y los
triggers de organización se publican juntos en una misma versión; el prepare de una primera celda admite un proceso de la
versión anterior, que atiende mientras la celda está en `recording`, y `loom cell attach`,
que se publica en una versión posterior y lee su propia clave de heartbeat, se niega hasta que todos los procesos activos
ejecuten esa versión, de modo que el único rollback admitido desde una celda adjunta
llega a una compilación que envía el marcador. La migración de los triggers de organización es aditiva, y
los triggers no hacen nada en un despliegue que nunca se preparó (sin filas de estado, la regla de
la fila `first`). Con `LOOM_CELL` sin definir, un proceso lee solo las filas de modo y `first` y
si existe una fila de tenencia o propia, y solo bajo la autoridad de Postgres, donde un
despliegue que nunca se preparó no tiene ninguna (las tablas se crean vacías), de modo que las compilaciones N-1 y N
atienden lado a lado sin cambios. El router enruta por host, emisor y la primera celda,
nunca por las ops de una celda, de modo que la versión de una celda no espera a la del router, salvo por la
que nombra el párrafo siguiente.

Las claves junto a la huella de un heartbeat ([las claves del heartbeat](#the-heartbeats-keys)) son
las claves de heartbeat propias de la versión de attach: una compilación anterior a ellas lee solo la versión y los campos de una huella,
por lo que acepta tal cual el heartbeat de una compilación más reciente, y attach rechaza un
proceso que no reporta ninguna. Esa versión espera a la de los routers: cada réplica del router la ejecuta
antes que los procesos de cualquier celda, ya que una primera celda preparada consulta la ruta de estado desde su
primera lectura del estado de la celda hasta que lee `serving`, y solo un router de esa versión la responde desde
su caché ([actualizaciones](https://github.com/ClickHouse/loom/blob/main/docs/operations/upgrades.md#upgrade-procedure)).

<a id="invariants"></a>

## Invariantes

- Un org es atendido por exactamente una celda, la que nombra su ubicación (placement), y su ubicación nunca se elimina ni se modifica.
- Un proceso con `LOOM_CELL` definido no responde nada salvo sus sondas de salud y la ruta de sondeo, y no ejecuta ningún worker, a menos que su configuración coincida con un valor de la fila propia de su celda, que las negativas por solapamiento del directorio ya han comprobado; un proceso con `LOOM_CELL` sin definir en una celda cuyas filas de estado cuentan como `enforced` o están en un estado `partial` (la regla de la fila `first`) no responde nada salvo sus sondas de salud y la ruta de sondeo, y no ejecuta ningún worker.
- Ninguna celda acepta el mismo emisor de bearer token, host, cliente OIDC, patrón de org o prefijo de bucket que otra, y ningún id de despliegue ni credencial de router es poseído por dos celdas.
- Toda ruta de seguridad falla de forma cerrada, con cuatro excepciones. Primera, un proceso de servidor con `LOOM_CELL` sin definir mantiene su veredicto ante lecturas fallidas de las filas de estado sin límite de obsolescencia: abierto en `open` y `recording`, como lo es la interrupción parcial de un despliegue único, y bloqueado en cualquier otro estado; si falla la primera lectura, falla su arranque, o, con migraciones de Postgres pendientes, queda bloqueado hasta que una lectura tenga éxito. Segunda, una celda registrada sin fila de estado, de tenencia (tenancy) ni propia (su Postgres restaurado a un punto anterior a su prepare, o un prepare detenido antes de escribir su fila), que está abierta hasta que se ejecute `loom cell restore` (tras una restauración) o se repita el prepare (tras un prepare detenido) y que `loom doctor` nombra mientras tanto: una fila, un modo o un valor de `first` ilegibles se rechazan; con el directorio inaccesible, las ubicaciones, las búsquedas no almacenadas en caché, los comandos `loom cell` que lo leen o escriben y las lecturas de estado de las celdas en modo recording se rechazan, mientras cada celda sigue atendiendo los orgs que posee. Tercera, un arranque con migración que no puede crear o habilitar un trigger de org o la guarda `loom.tenancy` en una tabla, o devolver a always los triggers de `loom.cell_first` (su bloqueo no se obtiene en tres intentos de 100 ms, o una tabla que el rol no puede alterar), lo registra y sigue sirviendo, dejando esa tabla sin guarda hasta que un arranque posterior tenga éxito: los triggers son solo un respaldo frente a escritores que no envían marcador, rechazar el arranque dejaría caída una celda por un respaldo, y attach rechaza un trigger ausente. Cuarta, un comando de revocación sin org que no puede devolver el acceso (un `loom revoke-token` simple, no uno que restringe o hace caducar, la revocación de un usuario SQL, `loom signing-key retire`, `loom bot disable`, `loom sso unlink`) con `LOOM_CELL` definido, cuya lectura de la fila `first` de la celda falla porque Postgres no responde, se ejecuta e imprime que la celda no fue comprobada, ya que una revocación debe funcionar durante una interrupción; cualquier otra lectura fallida, incluida la falta de un permiso (grant), se rechaza.

<a id="source-entry-points"></a>

## Puntos de entrada del código fuente

- `server/core/cell_probe.py`: la ruta de sondeo y el listener de sondeo, que todo proceso web acepta y que el proceso hijo de los workers nunca abre;
- `server/core/cell.py`: el estado propio de la celda (`loom.cell_first`, `loom.tenancy_mode`, `loom.cell_self`), la regla de estado del despliegue (`state`, sobre las filas que lee `refresh`, incluido si `loom.tenancy` contiene alguna fila entre ellas), su huella y `gate_reason`, la compuerta en los procesos con `LOOM_CELL` definido o sin definir, que el middleware de solicitudes (`server/transport/model_maintenance.py`), `verify_token`, la disponibilidad (readiness), el lease de los workers y la lectura del heartbeat; `start_cell_gate` de `server/boot.py` es la lectura de arranque de un proceso del servidor;
- `server/core/cell_triggers.py`: el marcador de los triggers de la organización, `ensure` (la creación y reparación de los triggers y de la protección de `loom.tenancy` que hace un arranque con migración) y `missing` (lo que `loom doctor` nombra), con sus funciones en `schemas/pg_migrations/011_tenancy_triggers.sql` y `012_tenancy_guard.sql`; `server/cli/doctor_cell.py`: las comprobaciones de celda de `loom doctor`;
- `server/cli/cell_scan.py`: el escaneo de organizaciones del primer attach, una biblioteca que ningún comando invoca: las tablas de ambos almacenes con una columna `org`, juzgadas por motor y según la clasificación del borrado, con todos los hosts de un clúster listando lo mismo, y las organizaciones distintas de cada tabla fuera de `LOG_TABLES`; `server/cli/cell_writers.py`: la comprobación de escritores de ClickHouse (los usuarios, directorios de usuarios, objetos y réplicas que quedan fuera de las listas permitidas del operador); `server/cli/cell_ch.py`: lo que ambos comparten (los hosts del clúster, las lecturas por host);
- `schemas/pg_migrations/008_cells.sql`, `schemas/pg_migrations/009_cell_probe.sql` y `schemas/migrations/094_cell_heartbeats.sql`: las tablas de la celda;
- `server/auth/tenancy.py` (`ensure_held`): la comprobación de tenancy y la llamada de ubicación (placement), ejecutadas por la compuerta de ops (`server/transport/gates.py`), `check_authorized`, `admit_org` y las rutas que nombran una organización; `server/transport/tenancy_gate.py` comprueba la organización propia del token en las rutas fuera del registro que actúan en ella, y `tests/unit/test_cell_tenancy.py` contiene el censo de todas las rutas;
- `server/router/app.py` (`loom router serve`): la API de ubicación, la lectura de estado de la primera celda (que `server/core/cell_router.py` realiza sobre una primera celda), el enrutamiento por las reglas 1 a 4 (`server/router/routing.py`, que decide, y el reenvío), la consulta de organización con su caché de organizaciones ubicadas (que `loom login --org`, `loom.credentials.org_server`, consulta), sus límites de tasa (`server/router/limits.py`) y las comprobaciones que supera una ubicación; su API de operador, con las rutas de attach de la primera celda, que `loom cell limit`, `loom cell credential` y `loom cell remove` (`server/cli/cell.py`, con `loom cell which`) invocan con la credencial de operador del router (`LOOM_ROUTER_OPERATOR_TOKEN`; el router solo conserva `LOOM_ROUTER_OPERATOR_SHA256`); `server/router/directory.py` y `schemas/router_migrations/`: el directorio, en la base de datos Postgres propia del router (`LOOM_ROUTER_PG_DSN`, `loom router migrate`).

El resto del código de la celda lo añaden los pull requests que implementan esta página. Se apoya en:

- `server/auth/jwt.py` (`verify_token`, `AuthUnavailable`): donde la compuerta de huella se ejecuta primero;
- `server/auth/scim.py` (`tokens`) y `server/auth/scim_routes.py` (`scim_settings_problem`, `_authorized`): el analizador de tokens SCIM y sus comprobaciones;
- `server/core/instances.py`: el heartbeat que informa del modo, la huella, `LOOM_CELL` y las claves junto a la huella;
- `server/workers/leader.py`: el lease del que se aparta un proceso bloqueado por la compuerta;
- `server/core/pg.py` (`same_deployment`): el id de despliegue que llevan ambos almacenes;
- `server/transport/gates.py` (`resolve_org`, `authorize`): donde se ejecuta la comprobación de tenancy;
- `server/cli/_ch.py` (`run_connected`, `connect_checked`, `connect_declared`): las declaraciones de organización de la CLI, que `tests/unit/test_cell_cli_orgs.py` exige a cada conexión;
- `server/auth/authz.py` (`check_acted_for`, `_check_creator`) y `server/auth/oauth.py` (`_refresh_session`): las comprobaciones SCIM al actuar y al refrescar;
- `server/identity/app/scim_groups.py` (`_caller`): la segunda ruta SCIM.

<a id="rejected"></a>

## Rechazado

- **Un plano de control compartido por las celdas** (un único conjunto de claves, permisos y workers, con los datos divididos por organización): una comprobación de seguridad, un lease de worker, un borrado, una generación de políticas y la cadena de auditoría abarcarían varios almacenes, y cada división necesitaría un protocolo propio.
- **Asignar una organización en su primera solicitud, antes de la verificación**: cualquiera podría elegir la celda de una organización, y un token emitido en una celda podría dirigirse a una organización asignada a otra.
- **Una lista de las rutas que crean una organización, cada una asignándola**: las organizaciones surgen por más rutas de las que una lista puede mantener al día (tokens de gateway y federados, bots, importaciones); la comprobación verificada es el único punto por el que pasa toda solicitud.
- **Redirigir un flujo de una celda a otra a mitad de camino**: el cliente, los códigos y los refresh tokens de un flujo viven en la celda que lo inició.
- **Que el router guarde los usuarios del proveedor de identidad para todas las celdas**: el alcance de cada correo electrónico en cada celda, una versión que sobreviva a la pérdida del directorio, los envíos y las recepciones serían cada uno un protocolo propio, cuando el proveedor de identidad ya desaprovisiona todas las aplicaciones asignadas a una persona.
- **Que cada réplica acceda a los almacenes de todas las celdas**: un pool por réplica y por celda, el coste que rechaza [Una base de datos por tenant](https://github.com/ClickHouse/loom/blob/main/docs/architecture/storage-authority.md#a-database-per-tenant).
- **Enrutar por espacio de nombres dentro de una organización**: una operación que afecta a toda la organización (su borrado, los ids resueltos entre espacios de nombres, el uso compartido) abarcaría varias celdas; una organización grande obtiene su propia celda.

<a id="tests"></a>

## Pruebas

Una prueba de integración con dos celdas y un router en el job de Postgres de CI:

- una solicitud verificada de una org nueva en cada celda la coloca una sola vez bajo solicitudes concurrentes, y la otra celda responde `WRONG_CELL`; una org emitida por un gateway, una org `prefix*` del emisor de un usuario final y la org de un bot se colocan del mismo modo tras `enforced`, y la solicitud de un principal de plataforma por una org no retenida no coloca nada;
- cada ruta, incluidas las entradas de lote de MCP y todos los comandos de la CLI, rechaza la org de otra celda y no escribe nada en su Postgres ni en su ClickHouse (los censos de rutas, de campos de op y de la CLI cubren el resto);
- el primer attach coloca todas las orgs con una fila en cualquier tabla; una org vista por primera vez durante el attach se coloca en el paso 4, y también la que escribió una inserción directa en Postgres entre la instantánea del paso 2 y `enforced`, una fila de ClickHouse escrita entonces por una CLI más antigua y un objeto de bucket catalogado entonces; un proceso que supera `LOOM_JWT_REVOCATION_MAX_STALE_SECONDS` de lecturas fallidas de sus propias filas o de su modo queda bloqueado y vuelve a servir cuando una lectura se completa; un pod con `LOOM_CELL` sin definir queda no listo, nombrando el ajuste, responde 503 a una solicitud con bearer, pasa su sonda de salud, responde a la ruta de sonda y no ejecuta ningún worker en una celda adjuntada y en una celda posterior entre prepare y attach, sigue sirviendo en una primera celda en `recording` y conserva el último modo que leyó pese a una lectura fallida, `recording` incluido tras el paso 3 o el paso 4 que devolvió la celda a ese modo; un comando de la CLI que declara una org con ese valor sin definir se rechaza en una celda `enforced` o `partial`, uno sin org (una revocación de token) se ejecuta, también con Postgres caído en un despliegue nunca preparado, y un comando de almacén `loom cell` se rechaza; `loom cell limit --closed` tiene éxito con el Postgres de la celda caído; tras `loom cell credential --cell <cell> --next` ambas credenciales colocan y leen estado, `--finish` rechaza la credencial antigua, para una celda finalizada antes de que sus pods tengan la nueva el router rechaza sus llamadas con 401, su solicitud responde 503 sin escribir nada y se recupera registrando de nuevo el hash antiguo, `--revert` descarta un `next` pendiente, que entonces se rechaza, y la credencial antigua sigue colocando, y se rechazan un segundo `--next` mientras hay uno pendiente y un hash que otra celda registra como current o next; `loom cell limit` y `loom cell credential --next`, `--finish` y `--revert` se rechazan mientras el directorio no está disponible; las colocaciones concurrentes con uno por debajo de `placements_max` en dos réplicas del router escriben una; un comando de la CLI que declara una org con `LOOM_CELL_ROUTER_TOKEN` definido se rechaza, nombrándolo, en una primera celda una vez `enforced` (`attaching` incluido) y en una celda posterior, y en una primera celda en `recording` se ejecuta y registra la org; el attach con `placements_max` por debajo de las orgs que retiene la primera celda las coloca todas, y el attach de una celda posterior que supera su cuota o está cerrada se rechaza, nombrando la org; una primera celda con `--closed` y `placements_max` definidos antes del paso 2 se adjunta, y una org que una solicitud registra entre el paso 2 y `enforced` la coloca el paso 4 sin 503; tras la escritura del modo de la celda en el paso 3, un proceso cuya caché aún lee `recording` envía la solicitud de una org nueva a la llamada de colocación, que una celda cerrada responde con 503; un comando de la CLI cuya inserción encuentra `enforced` se rechaza, nombrando la org, y no hace ninguna llamada de colocación; después de que la espera rechazada del paso 3 o la nueva comprobación del paso 4 devuelva la celda a `recording`, una org nueva se registra sin llamada de colocación, y una en un proceso cuya caché aún lee `enforced` se coloca a través de la puerta hasta que la caché expira; cada orden de la escritura del modo por el attach con una inserción de registro se mantiene como se indicó arriba (en ejecución, iniciándose durante la escritura, un flujo de inserciones solapadas cada una más corta que un intento, con el attach definiendo `enforced` en uno o dos intentos, retenida durante varios intentos, retenida hasta que queda muy poco de `--wait`, un attach detenido, una confirmación cortada por su timeout, una confirmación cuya conexión se pierde mientras espera al standby, leída de nuevo solo cuando ese backend ha desaparecido y escrita otra vez de forma duradera si lee `enforced`); una transacción `REPEATABLE READ` cuya primera sentencia se ejecutó antes de que `enforced` se confirmara, con el rol del attach o un segundo rol, retiene el paso 4 hasta que termina y su escritura de una org no retenida se coloca entonces, una cuya primera sentencia se ejecutó después se rechaza por el trigger, una transacción que empieza después de que el attach toma el bloqueo pero antes de que su confirmación sea visible retiene el paso 4, una transacción abierta en `recording` que sobrevive al `--wait` de una ejecución retiene el paso 4 de la repetición, tras un rechazo y tras `loom cell restore` que elevó el modo, un worker de autovacuum sobre una tabla de loom no retiene el paso 4 y un background worker con una transacción abierta desde `recording` sí, una transacción preparada (tras un reinicio con `max_prepared_transactions` elevado durante la espera) hace que el paso 4 se rechace de inmediato, nombrándola, con el modo todavía `enforced` y una repetición rechazada hasta que se resuelva y el ajuste vuelva a 0, una transacción de escritura abierta en una segunda base de datos del mismo servidor retiene el paso 4 y se nombra, una lectura larga en el standby síncrono, o en un segundo standby, con `hot_standby_feedback` activado no lo retiene, ni tampoco una copia de seguridad base que se ejecuta durante él, una escritura retenida abierta en una conexión `replication=database` retiene el paso 4, y también una transacción `REPEATABLE READ` en una, abierta en `recording` y sin escribir nada antes de `enforced`, un volcado lógico largo (una transacción de solo lectura `REPEATABLE READ`) en la base de datos de la celda que supera `--wait` hace que el paso 4 se rechace, nombrándolo, con la celda dejada en `enforced`, y el attach de la primera celda sin `pg_read_all_stats` o con `max_prepared_transactions` por encima de 0 se rechaza antes del paso 1 con el modo todavía `recording`, mientras que el attach de una celda posterior no exige ninguna de las dos cosas; un trigger de org ausente o deshabilitado lo rechaza el attach y lo nombra `loom doctor`, una escritura para una org no retenida en una celda `enforced` cuya fila de modo se eliminó se rechaza y `loom doctor` nombra el estado; en esa celda un pod con `LOOM_CELL` sin definir queda no listo y no ejecuta ningún worker, y un comando de la CLI que declara una org con ese valor sin definir se rechaza, igual que un pod; actualizar, eliminar o truncar la fila `first` en una celda `enforced` se rechaza, también bajo `session_replication_role = replica`, y un trigger de la fila `first` ausente o deshabilitado lo rechaza el attach y lo nombra `loom doctor`; un proceso en ejecución con `LOOM_CELL` definido en una celda cuya fila de modo se elimina responde 503 a una solicitud con bearer y no ejecuta ninguna pasada de worker, y vuelve a servir después de que una repetición de `loom cell prepare` vuelva a escribir la fila mientras se ejecuta; una celda que el directorio registra sin fila de estado, de tenencia o propia la nombra `loom doctor`, sus procesos con `LOOM_CELL` definido siguen no listos, un proceso con él sin definir sirve como despliegue único, y `loom cell restore` vuelve a escribir ambas filas, con una celda adjuntada sirviendo de nuevo y una no adjuntada tras una repetición de prepare; una celda con ambas filas ausentes junto a una fila de tenencia, y una junto a solo su propia fila, hace que la función rechace una org no retenida (un arranque no crea ningún trigger allí), todos los procesos bloqueados y `loom doctor` la nombra, y una repetición de prepare vuelve a escribir las filas; una restauración solo de Postgres de una primera celda adjuntada a un punto anterior a su prepare la nombra `loom doctor` y la cierra `loom cell restore`; una repetición de prepare durante un `loom cell update` pendiente en una celda adjuntada, con procesos en ambos valores y `loom.cell_self` perdido, vuelve a escribir ambos valores y mantiene sirviendo ambos conjuntos de procesos, y una antes del attach rechaza las dos configuraciones; una repetición de prepare en una celda adjuntada cuyo `current` falta y cuya configuración de pods difiere de la fila del directorio se rechaza, y una antes del attach cuyos heartbeats informan de otro prefijo de bucket se rechaza; una repetición de prepare con un hash de credencial que no es ni el `current` ni el `next` de la fila se rechaza; una repetición de prepare en una celda posterior `serving` cuyo prefijo contiene datos vuelve a escribir una fila de modo eliminada; una celda con fila de modo y sin fila `first` hace que la función rechace una org no retenida (un arranque no crea ningún trigger allí), todos los procesos bloqueados y `loom doctor` la nombra, y una repetición de prepare vuelve a escribir la fila; una celda posterior cuya fila de modo se define en `recording` no registra nada, su trigger rechaza una org no retenida, un proceso con `LOOM_CELL` definido allí sirve como en `enforced`, un pod con `LOOM_CELL` sin definir allí queda no listo y no ejecuta ningún worker, `loom cell prepare` nombra la fila, un comando de la CLI que declara una org con `LOOM_CELL_ROUTER_TOKEN` definido se rechaza, nombrándolo, y el router rechaza su lectura de estado; el `memory.set` y la pasada de entrega de un proceso de la compilación N-1 en un despliegue nunca preparado tras la migración de N tienen éxito y no escriben ninguna fila de tenencia, y en la primera celda en `recording` un arranque no crea ningún trigger de org, y uno creado a mano lee el estado y no busca nada, una escritura bajo `session_replication_role = replica` para una org no retenida se omite (triggers de origen), un `INSERT ... ON CONFLICT DO UPDATE` que inserta una fila para una org no retenida se rechaza y uno que alcanza una fila existente de ella no, todas las escrituras de una sesión marcada pasan, y los triggers de una celda `enforced` cubren todas las tablas que erasure clasifica con una columna `org` salvo las tres exclusiones; y una escritura con clave de org mientras el attach retiene el bloqueo de la tabla de modo vuelve de inmediato, con las solicitudes de org nueva respondiendo dentro de su plazo y las lecturas de la caché de modo volviendo de inmediato durante todo el proceso; `loom cell restore` tras un rechazo en el bloqueo del paso 3 deja la celda `enforced`, y el attach reanudado se ejecuta desde la espera del paso 3; un `LOOM_CELL_ROUTER_TOKEN` que no tiene la forma `lcr_` se rechaza en el arranque y lo nombra `loom doctor`; `loom cell credential new` imprime una credencial de esa forma y su SHA-256, con el directorio y los almacenes inalcanzables; prepare y `--next` rechazan un argumento que no sean 64 caracteres hexadecimales en minúsculas, incluidos la credencial y su secreto desnudo de 128 caracteres, sin almacenar nada; las orgs que una primera celda registra en `recording` sin datos las lista `loom doctor`; una avalancha de colocaciones sin cuota definida queda limitada por el límite de tasa en cada réplica del router, `loom doctor` nombra la celda como una sin cuota, y una llamada rechazada por encima de él en una réplica responde 503 con un `Retry-After` de como máximo 60 s, tras el cual su reintento en esa réplica, sin que se admita entre medias ninguna otra llamada de la celda, se admite; el primer prepare de una celda, sin fila de directorio todavía, pasa la comprobación del id de despliegue; un pod o CLI que perdió `LOOM_PG_DSN` o `LOOM_STORAGE_AUTHORITY` en una celda es rechazado por la comprobación de autoridad; los tokens, refresh tokens y clientes OAuth existentes de la primera celda siguen funcionando durante el cambio, un cierre de sesión a través del host compartido revoca su refresh token;
- el attach rechaza un emisor compartido, un secreto raíz, una ruta de Keeper, un prefijo de bucket anidado o una org configurada compartidos, una segunda celda que contiene datos y un segundo attach mientras se ejecuta uno;
- un inicio de sesión OIDC, la autorización de un cliente MCP y un device flow para una org de la segunda celda se completan en el host de esa celda tras una consulta; `loom login --org` mantiene su host ante `NO_CELL` y en un despliegue sin router, reintenta tras el `Retry-After` de un 429 hasta agotar `--wait` y entonces se rechaza como rechazo por tasa, y, mientras el directorio está caído, inicia su flujo en el host de celda de una org que el router tiene en caché y se rechaza, sin iniciar ningún flujo, para una que no;
- con SCIM activado, una persona que el proveedor de identidad nunca asignó a una celda no puede iniciar sesión, refrescar, ser suplantada ni usar un token de gateway allí, una desactivación enviada a la aplicación de una celda termina a la persona allí, un bot administrador de plataforma sigue alcanzando una celda cuyo SCIM desactivó a todos, y el attach rechaza una celda con sujetos vivos sin aprovisionar o que comparte el cliente OIDC de otra;
- un attach detenido en el paso 3 después de definir `enforced`, antes de que pasara la espera, se reanuda con la espera antes de la precondición de SCIM, y uno rechazado por la precondición de SCIM se reanuda también desde la espera, con el modo todavía `enforced`; un attach posterior rechazado antes de su transacción de directorio deja `attach_started_at` vacío, de modo que una repetición vuelve a comprobar los rechazos de una celda nueva, y un primer attach reanudado encuentra sus orgs configuradas colocadas en esta celda y continúa;
- una celda restaurada a un punto anterior al `enforced` del primer attach recupera su modo con `loom cell restore`; una cuyo `loom cell restore` se omitió responde 503 para una org que no retiene, la org de otra celda incluida, no escribe ninguna fila de tenencia para ella y `loom doctor` la nombra; una caída del directorio durante el despliegue de `LOOM_CELL` y entre prepare y attach deja la primera celda sirviendo las orgs que retiene, con una org nueva respondiendo 503 en cada proceso con `LOOM_CELL` definido; la lectura de estado se acepta de una primera celda que está `attaching` antes del paso 2 del attach, y solo con la credencial propia de la celda nombrada, y una respuesta rechazada o tardía cuenta como ilegible;
- un grant refrescado en N que se escribió en N-1 se comprueba contra la fila de la persona, un refresh mientras SCIM es ilegible responde 503 y conserva la sesión, y un proceso con `LOOM_CELL` definido antes de `loom cell prepare` sigue no listo;
- un token delegado durante el primer attach por una persona nunca aprovisionada se rechaza tras `enforced`; un gateway que actúa por un bot se atiende y por un handle desnudo se rechaza;
- con el directorio no disponible, cada celda sirve las orgs que retiene, las colocaciones responden 503, y `loom doctor` en una celda informa de sus comprobaciones de directorio como no ejecutadas y sale con código distinto de cero;
- `LOOM_CELL` se despliega después de `loom cell prepare` con todos los pods listos, antes del attach;
- preparar una celda vacía antes del despliegue del host compartido se rechaza, y una celda restaurada desde la instantánea de otra celda se rechaza en prepare;
- un prepare interrumpido entre la escritura del directorio y la escritura de la celda, con `LOOM_CELL` ya desplegado, se repite a través de `probe_url` contra procesos bloqueados; una repetición de prepare antes del attach cuyos heartbeats no coinciden ni con el `current` ni con el `next` presentes se rechaza; una repetición de prepare adjuntada con solo `next` perdido lo vuelve a escribir, y una cuyo `current` presente difiere del directorio lo sobrescribe; una repetición de prepare en solitario tras una restauración solo de Postgres de una primera celda adjuntada a un punto anterior a su prepare deja a `loom doctor` nombrando las filas de tenencia ausentes, y un pod con `LOOM_CELL` sin definir sirve todas las orgs allí hasta la repetición y queda bloqueado después, mientras que con `LOOM_CELL` definido una org recupera su fila de tenencia a través de la llamada de colocación; una repetición de prepare contra pods con `LOOM_CELL` sin definir en estado `partial` alcanza su ruta de sonda y vuelve a escribir la fila ausente; prepare rechaza el `probe_url` de una celda posterior que informa de un id distinto del de sus almacenes, attach rechaza una celda cuyo host informa de un id distinto del de su `probe_url`, y prepare rechaza un argumento de dirección de sonda para la primera celda, y el router solo sondea `LOOM_ROUTER_UPSTREAM_PROBE_URL`; el primer prepare de una celda posterior tiene éxito; `loom cell update --probe-url` rechaza una dirección que informa de otro id de despliegue o falla el eco del nonce, y rechaza la primera celda; `loom cell update` mueve las direcciones de sonda y upstream de la primera celda solo cuando todas las réplicas del router las ejecutan, tras su sonda y la comprobación de id del upstream, y una repetición de prepare a través de una réplica todavía con los valores antiguos (o los nuevos, antes del cambio) se rechaza, nombrando la dirección de la fila; un `probe_url` con userinfo u otro esquema se rechaza; el puerto principal responde solo el id en memoria, con cualquier Host, sin leer ningún almacén; el router sondea un `probe_url` https cuyo certificado firma una CA de su `SSL_CERT_FILE`; el listener de sonda responde 429 por encima de su tasa; y un prepare con una copia de los almacenes de la primera celda se rechaza por el nonce;
- la primera celda por defecto (`LOOM_JWT_ISSUER=loom`, un `LOOM_OAUTH_ISSUER` vacío) se adjunta; una celda redesplegada con el host compartido como su URL pública queda no lista;
- una colocación insertada en la cuota de una celda cuya llamada agotó el tiempo se reintenta y responde a su ganadora, y la celda escribe la fila de tenencia; lo mismo en una celda cerrada entretanto, y para una repetición de `loom cell place`;
- un attach que muere entre su escritura de directorio y su escritura de `loom.cell_self` se reanuda hasta `serving`, y sus emisores permanecen reservados mientras tanto; un `loom cell place` para una org que otra celda retiene no escribe ninguna fila, y uno para una org que el directorio no coloca se rechaza, sin escribir ninguna fila, para una celda cerrada, por encima de `placements_max`, para una celda posterior todavía `attaching`, para una primera celda antes de que el directorio registre `enforced`, con una configuración cuya huella no coincide con ningún valor de la fila de la celda, y mientras el directorio no está disponible, y no se rechaza una vez agotada la tasa de la celda ni cuenta para ella (las llamadas de colocación propias de la celda siguen admitiéndose tras una serie de place del operador); uno para una org que el directorio coloca en esta celda escribe su fila de tenencia en una celda cerrada o llena; `loom bot create` para una org nueva en una primera celda en `recording` registra la org mientras el directorio responde `attaching` y se rechaza mientras responde `serving` o no puede leerse;
- un host de emisor OAuth que difiere del host público de la celda se rechaza en prepare, y el host compartido enruta antes de que se adjunte ninguna celda; un `loom cell place` sin otras escrituras mantiene la org en su celda;
- una primera celda restaurada a un punto entre los pasos 1 y 3 del attach después de estar `serving` queda lista en `enforced` una vez ejecutado `loom cell restore`;
- una celda restaurada a un punto anterior a un `loom cell update --finish` sirve de nuevo una vez que `loom cell restore` ha reescrito su propia fila, una celda cuyos dos almacenes se restauran recupera sus filas solo con `loom cell restore`, y una celda preparada y no adjuntada conserva su propia fila restaurada;
- una primera celda restaurada a un punto anterior a su prepare recupera sus filas, responde 503 en el host compartido en los procesos con `LOOM_CELL` definido hasta que se repite `loom cell prepare`, y entonces sirve; SCIM en un despliegue con `LOOM_CELL` sin definir funciona como antes en N, durante prepare, el despliegue de `LOOM_CELL` y el attach;
- el SCIM de la primera celda sigue respondiendo a su token sin nombre durante el cambio, una celda posterior rechaza un token sin nombre, ninguna celda acepta el token de otra, `lsc_b_…` y un token `lsc_` mal formado se rechazan en la primera celda, y una celda posterior con una fila de SCIM escrita antes de `LOOM_CELL` se rechaza en el attach; un token de la celda `a-b` se rechaza en la celda `a`, y un nombre de celda con `_` se rechaza;
- una celda posterior con `oidc_jit_org` definido arranca y reinicia sus pods entre prepare y attach, con JIT para esa org respondiendo 503 hasta que el attach la coloca; el autoregistro de una primera celda en una org que ninguna solicitud ha registrado, entre prepare y attach, la registra y completa el registro; una celda posterior con repositorios indexados no escribe ninguna fila de código antes del attach y luego se adjunta; una primera celda en `recording` mantiene sus pasadas de worker para una org que ninguna solicitud ha tocado desde el despliegue; el attach de una celda posterior detenido tras `attach_started_at` se reanuda con sus orgs configuradas colocadas y retenidas; una actualización entre prepare y attach que cambia la org de código hace que el attach coloque esa org, y tras `--finish` indexa; una actualización posterior al attach rechaza una org configurada modificada que otra celda retiene, nombrándola, y, para una org que el directorio aún no coloca, se rechaza para una celda cerrada y por encima de `placements_max`; una actualización que cambia una org configurada de una celda posterior todavía `attaching` tras su transacción de directorio se rechaza hasta que la celda esté `serving`; `--revert` conserva una org configurada que la actualización colocó; las orgs de código y de tracker de una celda posterior sirven e indexan una vez que está `serving`, incluida una op `code.*` de un miembro de otra org, y también una org configurada que `loom cell update` cambia; un attach posterior que compite con la actualización de otra celda que amplía un emisor rechaza a una de las dos; una org configurada que otra celda coloca entre los rechazos del attach y su colocación hace que el attach se rechace, nombrándola, y no escribe nada; prepare rechaza una credencial de router que otra celda registra; una llamada de colocación que nombra a otra celda con una credencial válida de esta no coloca nada en la otra;
- la llamada de colocación de una celda preparada y no adjuntada para una org que el directorio no coloca responde 503, una para una org que sí coloca responde a la ganadora incluso con la credencial antigua todavía en caché tras `loom cell credential --finish` o con una huella que no coincide con ningún valor, una ganadora con el nombre de esta celda bajo otro id de despliegue responde 503 y no escribe ninguna fila de tenencia, y un proceso cuya configuración difiere de la fila de su celda no coloca nada;
- una celda adjuntada con SCIM desactivado y activado por `loom cell update` se rechaza mientras hay un token de registro de agente vivo, incluido uno emitido mientras la actualización se despliega, y un proceso configurado con el emisor de otra celda responde 503 a toda solicitud con bearer, alcanzada a través del router o directamente;
- durante un `loom cell update`, los procesos con la configuración antigua y la nueva sirven ambos, `--finish` libera un emisor reducido solo cuando ningún proceso lo acepta, una actualización que muere tras su escritura de directorio mantiene reservado el emisor ampliado, y las compilaciones N y N+1 con una configuración coinciden con la misma fila;
- rotar un token de SCIM no cambia ninguna huella; un proceso se niega a arrancar con el token de SCIM de otra celda, un proveedor de identidad apuntado al host de la celda equivocada recibe 401 y no escribe nada, y una celda revertida a N sigue bloqueando según su propia fila y rechaza el token de SCIM de otra celda; una avalancha de colocaciones del emisor de una celda se rechaza por encima de su cuota;
- un gateway que actúa por la cuenta de servicio personal de una persona nunca aprovisionada se rechaza, y una celda que empieza a aceptar el emisor de otra celda no admite colocaciones;
- un proceso que no coincide con ninguno de los dos valores de su fila responde 503 al inicio de sesión, el refresh, los endpoints de token y device de OAuth, el callback de inicio de sesión y el registro, y su ruta de sonda sigue devolviendo el nonce de prepare; `--revert` espera a los procesos que coinciden solo con `next`; `update --config` se rechaza mientras hay un `next` distinto pendiente, y una actualización que murió antes de su escritura de `loom.cell_self` se reanuda hacia delante; prepare se rechaza mientras hay un proceso anterior a N vivo; un cambio de configuración durante `attaching` pasa por `loom cell update` y el attach reanudado reserva ambos valores; un proceso cuyos almacenes configurados difieren de la fila de su celda responde 503 y se aparta de los workers, de modo que una compilación más nueva bloqueada junto a una más antigua sin bloquear deja los workers ejecutándose y borrando; `loom cell update` rechaza un cambio del id de despliegue, del nombre del bucket o del prefijo, añadir un bucket incluido; un proceso bloqueado en modo `on` no ejecuta ninguna pasada de worker; preparar un clon con el nombre de bucket y el prefijo de la primera celda se rechaza, en su endpoint o en cualquier otro; una celda posterior cuyo prefijo contiene objetos de otro despliegue se rechaza en prepare; dos prepares concurrentes de prefijos anidados no pasan ambos; dos celdas sin bucket se preparan ambas; prepare rechaza una celda posterior cuyo proceso lleva el `LOOM_CELL` de otra celda, y un proceso cuya fila `first` nombra a otra celda responde 503 y no ejecuta ningún worker; una avalancha en la ruta de id del puerto principal no detiene el attach; y una celda restaurada en un nuevo endpoint de Postgres, ClickHouse o bucket sirve una vez que su configuración lo nombra; una solicitud con bearer en el host compartido se atiende antes de prepare, entre prepare y attach, y durante el attach;
- el chart no renderiza ningún listener de sonda por defecto, y con él activado renderiza el Service de sonda y no cambia ninguna NetworkPolicy, de modo que con la política del chart activada ninguna regla propia admite el puerto de sonda; prepare nombra `PROBE_UNREACHABLE` y `PROBE_BUSY` del router una vez agotado `--wait`; una avalancha en el puerto principal deja intacta la tasa del listener de sonda;
- una celda posterior iniciada desde el entorno de la primera celda, con su bucket y prefijo, se ejecuta bloqueada desde su primer arranque y no borra ningún original; prepare rechaza una celda posterior mientras un proceso vivo carece de `LOOM_CELL`;
- `loom cell limit --closed` hace que las llamadas de colocación de la celda respondan 503 mientras sigue sirviendo las orgs que retiene, `--open` las restaura, y `--placements-max` surte efecto en la siguiente llamada de colocación;
- una restauración de Postgres de una celda `enforced` a un punto anterior a la colocación de una org, con esa org borrada después de ese punto, se reconcilia con salida 0 tras `loom cell restore` y luego sirve la org;
- una celda restaurada desde antes de la colocación de una org la sirve una vez lista, un borrado deja la colocación de la org, y con el directorio perdido cada celda sirve las orgs que retiene.
