chore(metodo): reparto — familia E fundida en los siete filos

La numeracion estaba rota (un sexto antes de un tercero). Refundidos en una
lista de siete con sus cicatrices, y las TRES PUERTAS juntas en un sitio en
vez de explicadas en tres. 10.799 -> 8.001 caracteres.

Solo .metodo/ — byte a byte desde la matriz.

Sesion: superadmin

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.metodo/CHECKSUMS

@@ -1,4 +1,4 @@
-19c7343a4ff899dcacfddeef6dbd1113829a3f8740e69bdc3ce0d8bb28850e6b  metodo.md
+a5e9bb482951d163f0a26789c81dc6df0bc4abe49b7f074cc2f8861e9f4eedd8  metodo.md
 6850fa105390147de7c7dc6db63c20e26be483a66eb3ce0c7eb618857df092c3  bin/metodo
 f89b71bdf31028b05075636c1763c964e379bc37a00e0357d1c23a4dd19c09aa  workflows/README.md
 cc241bbecf9647c747b8525b3a6b527455cd50ca0312caa44bc3544342c8ac41  workflows/comunicacion-entre-sesiones.md

.metodo/metodo.md

@@ -2213,123 +2213,92 @@ pega tal cual.
   decisión, **publicarlo no la toma**: se empuja **diciéndolo** y la decisión sigue pendiente de su
   dueño. Y **antes de usarlo se comprueba que la orquestadora no está viva** — *el único testigo
   válido es «escribí y no contestó»*, jamás «no la veo en el listado».
-  ⛔⛔ **Y HAY UN SEGUNDO AGUJERO, PEOR: EL ÍNDICE TAMBIÉN ES COMPARTIDO.** `git add <ruta>` **no
-  desmonta lo que otra sesión ya dejó *staged***, así que tu commit se lleva **ficheros que ni
-  nombraste ni tocaste** — con ruta explícita, sin `-A`, y haciendo todo bien.
-  *(Cicatriz 2026-08-30, y el sitio es lo que la hace útil: la superadmin commitea **dos** ficheros
-  nombrados uno a uno; entran **tres**. El tercero era el trabajo *staged* de otra sesión, que
-  **sobrevivió íntegro** pero quedó publicado **bajo un mensaje que hablaba de otra cosa** — y con
-  él se perdió **la explicación que esa sesión estaba escribiendo en su propio mensaje**, que era lo
-  valioso. ⭐ **Y el asunto de ese commit era, literalmente, «en este árbol git no distingue
-  sesiones», con un cuerpo que decía que un commit ajeno bajo un mensaje ajeno borra la única
-  atribución que existe.** Lo cometió **mientras lo escribía**. Su propia puerta imprimió
-  `ficheros=3` habiendo nombrado 2 — y no paró: cara (c) y cara (d) a la vez.)*
-  ⇒ **El gesto que falta NO es «no uses `git add -A`»** —no se usó— **sino: si te llevaste algo
-  ajeno, DILO EN EL MENSAJE.** Es lo único que devuelve la atribución cuando `git` no distingue
-  sesiones, y **cuesta una línea**.
-  ⇒ Y el sub-raíl operativo, **con su límite dicho, que es la mitad que faltaba**: `git status
-  --porcelain` **ANTES de tu primer `git add`**. Si hay algo *staged* que no es tuyo, **no es tuyo el
-  índice**: o esperas, o lo declaras. ⛔ **Pero sólo ve lo que YA ESTABA cuando empezaste** — una
-  escritura ajena que entra **después** de tu `add` **no la caza**, y hoy se usaba como si bastara.
-  ⇒ **La que cubre esa ventana es `git diff --cached --name-only` INMEDIATAMENTE antes de commitear**,
-  leída por ojos y **no encadenada con `&&`** a lo que viene detrás. **Las dos no son redundantes:
-  cubren ventanas distintas.**
-  ⛔ **Y UN CUARTO, QUE ES DE OTRA COMPROBACIÓN: `git status` NO VE LOS COMMITS SIN EMPUJAR.** Son
-  **dos gestos distintos y ninguno implica al otro** — `git status --porcelain` dice **qué me llevo
-  DENTRO del commit**; `git log origin/main..HEAD` dice **qué PUBLICO con él**. Correr el primero y
-  dar por hecho el segundo es publicar trabajo ajeno **con el índice limpio**.
-  *(Cicatriz 2026-08-31: una sesión corre la puerta del índice —limpia— y empuja **un solo fichero
-  suyo**… publicando de paso **tres commits de otra sesión** que esperaban entre el remoto y `HEAD`.
-  Su diagnóstico, que es el raíl: **lo dio por hecho porque veinte minutos antes estaba a cero** — y
-  **un árbol compartido cambia por debajo entre dos pushes tuyos**, porque el otro **está trabajando**,
-  que es lo normal y no la excepción.)*
-  ⛔ **Y UN SEXTO, QUE ES EL ANTERIOR CON EL SIGNO CAMBIADO: EL ÍNDICE COMPARTIDO TAMBIÉN TE HACE
-  PERDER LO TUYO — Y TE LO DICE CON UN MENSAJE QUE SUENA A «YA ESTABA».** Un `git commit` puede fallar
-  con **«nothing to commit, working tree clean»** teniendo **tu cambio en el índice**: otra sesión lo
-  vació entre tu `add` y tu `commit`.
-  *(Cicatriz 2026-09-01: el fichero seguía en disco y `git status` lo daba como *staged* medio minuto
-  después. **Se cazó verificando `origin/main..HEAD` DESPUÉS del push**, no fiándose del `rc`.)*
-  ⇒ ⭐ **Lo peligroso es la redacción del mensaje**: *«nothing to commit»* **se lee como «ya estaba
-  hecho»** y se sigue adelante. ⇒ **Un `add` y un `commit` en órdenes separadas no son atómicos en un
-  working tree compartido**: entre los dos cabe otra sesión. **Verifica DESPUÉS del push, siempre** —
-  el `rc=0` de un `commit` que no commiteó nada **también es cero**.
-  ⛔⛔ **Y HAY UN TERCER FILO, EL PEOR DE LOS TRES: `git commit --amend` EN UN WORKING TREE COMPARTIDO
-  REESCRIBE EL COMMIT DE OTRA SESIÓN.** El índice compartido te hace **arrastrar** lo ajeno; el
-  `--amend` te hace **borrar y rehacer** lo ajeno — y encima lo firma con tu contenido dentro y su
-  mensaje fuera.
-  *(Cicatriz 2026-08-31: se commitea, otra sesión commitea y empuja **en el mismo working tree**, y un
-  `--amend --no-edit` posterior **no amplía el commit propio: reescribe el suyo**, añadiéndole un
-  fichero ajeno a su cambio. El `push` sale rechazado por no-fast-forward, que es **la única razón por
-  la que se vio**. Sin ese rechazo, la reescritura se habría publicado.)*
-  ⇒ **Regla: en un working tree compartido, `--amend` sólo sobre un commit que sabes que es tuyo Y que
-  no ha salido** — y saberlo exige **mirar `git log -1` antes**, no suponer que HEAD es lo último que
-  escribiste tú. ⛔ **Y el rechazo del `push` NO se resuelve forzando**: se resuelve con
-  `git reset --soft @{u}` y recommiteando **lo tuyo solo**, que deja el commit ajeno intacto.
-  ⛔⛔ **UNA INSPECCIÓN NO GANA UNA CARRERA — y todas las puertas de aquí arriba son inspección.**
-  `git status --porcelain` antes del primer `add`, `git diff --cached --name-only` justo antes de
-  commitear, predecir el diffstat: **los tres MIRAN**. Contra un competidor concurrente, mirar sólo
-  te dice **cómo iba la carrera cuando miraste** — y el resultado depende de **cuándo** mires, que es
-  precisamente lo que no controlas.
-  *(Cicatriz 2026-09-02: **cuatro colisiones sobre el mismo fichero en un día, LAS CUATRO CON LAS TRES
-  PUERTAS PUESTAS.** Una sesión publicó la fila de otra · un `awk` por número de línea borró una fila
-  viva **40 minutos** · otra partió una fila en dos · y a la cuarta, **entre dos comandos
-  consecutivos**, el índice se le llenó de un fichero ajeno **y su edición del working tree
-  desapareció**, sobrescrita; al ir a commitear, «nothing to commit»: **ya lo había publicado un
-  tercero** dentro de un commit que hablaba de otra cosa. **Cero pérdidas y la atribución cruzada
-  cuatro veces.**)*
+  ⛔⛔ **LOS SIETE FILOS DEL ÁRBOL COMPARTIDO.** *(Estaban escritos como «un segundo agujero», «un
+  cuarto», «un sexto», «un tercer filo»… **numerados por acumulación y contradiciéndose entre sí**;
+  renumerados el 2026-09-02. Ninguno se ha quitado: cada uno es un modo de fallo distinto con su
+  cicatriz.)*
+  **① El ÍNDICE es compartido: `git add <ruta>` NO desmonta lo que otra sesión dejó *staged*.** Tu
+  commit se lleva **ficheros que ni nombraste ni tocaste**, con ruta explícita, sin `-A`, y haciendo
+  todo bien. *(2026-08-30: se commitean **dos** ficheros nombrados uno a uno; entran **tres**. El
+  tercero era el trabajo *staged* de otra sesión, que sobrevivió íntegro pero quedó publicado **bajo
+  un mensaje que hablaba de otra cosa**, perdiendo la explicación que esa sesión estaba escribiendo.
+  ⭐ **El asunto de ese commit era, literalmente, «en este árbol git no distingue sesiones».** Lo
+  cometió mientras lo escribía, con su propia puerta imprimiendo `ficheros=3` habiendo nombrado 2.)*
+  ⇒ **El gesto que falta NO es «no uses `-A`»** —no se usó— **sino: si te llevaste algo ajeno, DILO
+  EN EL MENSAJE.** Es lo único que devuelve la atribución, y cuesta una línea.
+  **② La ruta explícita NO protege si el cambio ajeno está en el MISMO fichero.** Protege contra
+  arrastrar **otros** ficheros; contra **dos sesiones escribiendo en uno solo** no distingue nada —
+  la ruta es la misma. *(2026-08-29: una ejecución paró antes de commitear al ver en el `diff` 21
+  líneas que no eran suyas.)*
+  **③ `git status` NO VE LOS COMMITS SIN EMPUJAR.** Son **dos gestos y ninguno implica al otro**:
+  `--porcelain` dice **qué me llevo DENTRO**; `git log origin/main..HEAD` dice **qué PUBLICO**.
+  *(2026-08-31: una sesión corre la puerta del índice —limpia—, empuja **un fichero suyo** y publica
+  **tres commits ajenos** que esperaban entre el remoto y `HEAD`. Lo dio por hecho **porque veinte
+  minutos antes estaba a cero**: un árbol compartido cambia por debajo entre dos pushes tuyos porque
+  el otro **está trabajando**, que es lo normal y no la excepción.)*
+  **④ El índice compartido también te hace PERDER LO TUYO, con un mensaje que suena a «ya estaba».**
+  Un `commit` puede fallar con **«nothing to commit, working tree clean»** teniendo tu cambio en el
+  índice: otra sesión lo vació entre tu `add` y tu `commit`. *(2026-09-01: el fichero seguía en disco
+  y `git status` lo daba *staged* medio minuto después.)* ⇒ ⭐ **Lo peligroso es la redacción**:
+  *«nothing to commit»* **se lee como «ya estaba hecho»**. Un `add` y un `commit` en órdenes
+  separadas **no son atómicos aquí**, y **el `rc=0` de un commit que no commiteó nada también es
+  cero** ⇒ verifica **después** del push.
+  **⑤ `--amend` REESCRIBE EL COMMIT DE OTRA SESIÓN** — y no es una operación local. El índice te hace
+  **arrastrar** lo ajeno; el `--amend`, **borrarlo y rehacerlo** con tu contenido dentro y su mensaje
+  fuera. *(2026-08-31: un `--amend --no-edit` reescribió el commit de otra sesión ya empujado. **Su
+  único testigo fue un `push` rechazado por no-fast-forward** — o sea **un fallo que puede no llegar a
+  producirse**; sin él, la reescritura se habría publicado.)* ⇒ **Sólo sobre un `HEAD` que has
+  VERIFICADO que sigue siendo tuyo** (`git log -1`), nunca sobre el que recuerdas. ⛔ **Y el rechazo
+  NO se resuelve forzando**: `git reset --soft @{u}` y recommitear **lo tuyo solo**.
+  **⑥ NO HAY DOS CLONES — y creer que los hay es el error de modelo que los explica todos.** Las
+  sesiones de una máquina **comparten árbol e índice**: no son copias que sincronizar. ⇒ **`git pull`
+  entre ellas es un no-op**, y recomendarlo **da una falsa sensación de haberse protegido**.
+  *(2026-09-02: la superadmin avisó a un satélite de «haz `pull`, que hay commits de hace minutos».
+  Eran ciertos y **ya los tenía**. Lo midió el satélite: los tres rangos, vacíos.)* ⚠️ **Y no lo
+  generalices al revés**: es cierto de las sesiones **de la misma máquina**; de un agente en worktree
+  aislado o remoto, **no** — y eso **se mide**.
+  **⑦ Y uno que no es de `git` sino del shell: con el `cd` PERSISTENTE, una ruta relativa NO
+  identifica un fichero.** El mismo `doc/bitacora.md` es otro fichero según dónde quedó el comando
+  anterior — y **no falla: escribe en el sitio equivocado y calla**. *(2026-09-01: una sesión anexó
+  **168 líneas** de su bitácora **al repo de otro frente**; y el mismo desliz le hizo **leer los
+  avisos del repo equivocado**, numerando su hallazgo `A12` donde iban por `A5`: **un identificador
+  inventado que habría quedado escrito**.)* ⇒ **Rutas ABSOLUTAS y `git -C <repo>`**, nunca `cd` +
+  relativa. Y el testigo es barato: **el `tail` de lo que acabas de escribir y el `--stat` de lo que
+  vas a commitear**; si el `--stat` sale vacío, **no es que no haya cambio: está en otro sitio**.
+
+  ⇒ ⭐ **LAS TRES PUERTAS, EN UN SOLO SITIO — y no son redundantes: cubren VENTANAS DISTINTAS.**
+  `git status --porcelain` **antes del primer `add`** *(sólo ve lo que YA ESTABA cuando empezaste)* ·
+  `git diff --cached --name-only` **inmediatamente antes de commitear**, leído por ojos y **no
+  encadenado con `&&`** *(la única que caza lo que entró DESPUÉS de tu `add`)* · `git log
+  origin/main..HEAD` **antes de CADA push** *(la única que dice qué publicas)*.
+  ⛔⛔ **PERO UNA INSPECCIÓN NO GANA UNA CARRERA, Y LAS TRES SON INSPECCIÓN.** Miran. Contra un
+  competidor concurrente sólo te dicen **cómo iba la carrera cuando miraste**, y eso depende de
+  **cuándo** mires, que es lo que no controlas. *(2026-09-02: **cuatro colisiones sobre el mismo
+  fichero en un día, LAS CUATRO CON LAS TRES PUERTAS PUESTAS.** Una sesión publicó la fila de otra ·
+  un `awk` por número de línea borró una fila viva **40 minutos** · otra partió una fila en dos · y a
+  la cuarta, **entre dos comandos consecutivos**, el índice se le llenó de un fichero ajeno **y su
+  edición del working tree desapareció**; al commitear, «nothing to commit»: **ya lo había publicado
+  un tercero**. Cero pérdidas y la atribución cruzada cuatro veces.)*
   ⇒ **Lo único que no depende de cuándo mires es lo que EXCLUYE en vez de inspeccionar**:
   **`git commit -- <rutas>`** (o `-o`) commitea esas rutas **pase lo que pase en el resto del índice**.
   ⚠️ **Ojo a la sintaxis, que se falla a la primera**: el mensaje va **antes** del separador —
-  `git commit -m "…" -- <ruta>`; poner el `-m` después lo convierte en un pathspec y el commit muere.
-  ⇒ ⛔ **Y lo que ningún gesto de git arregla: que otra sesión te sobrescriba el WORKING TREE.**
-  No hay dos copias. Mover la coordinación a git **compra historial, no aislamiento** — y la única
+  `git commit -m "…" -- <ruta>`; ponerlo después lo convierte en pathspec y el commit muere.
+  ⇒ ⛔ **Y lo que NINGÚN gesto de git arregla: que otra sesión te sobrescriba el WORKING TREE.** No
+  hay dos copias. Mover la coordinación a git **compra historial, no aislamiento** — y la única
   salida real es **que dos sesiones no escriban el mismo fichero**, no una puerta mejor.
-  ⇒ ⭐ La forma general, y vale fuera de git: **ante una carrera, una comprobación no es una
-  solución.** Sirve para *saber* que perdiste, no para ganar. Lo que resuelve una carrera es
-  **eliminarla** —partir el recurso, dar turnos, excluir por construcción—; todo lo demás es
-  contar accidentes con más detalle.
+  ⇒ ⭐ **Forma general, y vale fuera de git: ante una carrera, una comprobación no es una solución.**
+  Sirve para *saber* que perdiste, no para ganar. Lo que resuelve una carrera es **eliminarla**
+  —partir el recurso, dar turnos, excluir por construcción—; lo demás es contar accidentes con más
+  detalle.
 
-  ⛔ **Y UN CUARTO FILO, QUE NO ES UN FILO SINO UN MODELO MENTAL EQUIVOCADO: NO HAY DOS CLONES.**
-  Las sesiones de una misma máquina **comparten el mismo working tree y el mismo índice** — no son
-  copias que haya que sincronizar. ⇒ **`git pull` entre ellas es un no-op**, y recomendarlo *«para no
-  diagnosticar sobre un árbol viejo»* **delata el modelo equivocado y da una falsa sensación de
-  haberse protegido**: el árbol viejo **no puede existir**, y contra el riesgo que sí existe —**el
-  índice compartido**— el `pull` **no hace absolutamente nada**.
-  *(Cicatriz 2026-09-02: la superadmin avisó a un satélite de «`git pull` antes de mirar nada, que hay
-  commits de hace minutos». Eran ciertos y **ya los tenía**. Lo corrigió el satélite midiendo:
-  `status --porcelain` vacío, `origin/main..HEAD` vacío, `HEAD..origin/main` vacío.)*
-  ⇒ **La defensa no es sincronizar, son las tres puertas del índice**: `git status --porcelain`
-  **antes del primer `add`** · `git diff --cached --name-only` **antes de commitear** ·
-  `git log origin/main..HEAD` **antes de CADA push**. ⛔ **Y no son redundantes: cubren
-  VENTANAS distintas.** El `porcelain` sólo ve lo que ya estaba al empezar; **una escritura ajena que
-  entra DESPUÉS de tu `add` sólo la caza el `--cached` justo antes de commitear.** ⚠️ Y **no lo generalices al revés**: que dos
-  sesiones compartan árbol es cierto **de las que corren en la misma máquina**; de un agente en
-  worktree aislado o en remoto, **no** — y eso **se mide, no se supone**.
-
-⛔⛔ **Y LA PROPIEDAD QUE UNE A LOS CUATRO, Y DICE CUÁNDO DEJAR DE BUSCAR UN GATE: `git` ES LA ÚNICA
+⛔⛔ **Y LA PROPIEDAD QUE UNE A LOS SIETE, Y DICE CUÁNDO DEJAR DE BUSCAR UN GATE: `git` ES LA ÚNICA
 HERRAMIENTA COMPARTIDA DEL ÁRBOL QUE NO TIENE EL CONCEPTO DE SESIÓN.** El semáforo sabe quién eres.
 El canal sabe quién eres. El linter sabe en qué repo estás. **`git` sólo ve un working tree y un
-usuario** — y en este árbol **ese usuario es el mismo para todas**.
+usuario** — y aquí ese usuario es el mismo para todas.
 ⇒ Por eso **todos los filos aparecen ahí**, y por eso **ninguno lo caza un gate: no hay dato con el
 que un gate pudiera distinguirlos.** ⭐ Y eso **no es una excusa: es el criterio para parar** —
 buscarle un gate a esto es construir un instrumento sin sujeto, que es la avería que este Método más
 persigue. **Lo que sí se puede es avisar antes y decirlo después.**
-⛔ **Corolario, y es el más traicionero: `--amend` en un árbol compartido NO es una operación local.**
-Su único testigo es **un `push` rechazado**, o sea **un fallo que puede no llegar a producirse**. ⇒
-**`--amend` sólo es seguro sobre un `HEAD` que has VERIFICADO que sigue siendo tuyo** —`git log -1`—,
-nunca sobre el que recuerdas haber hecho.
-  ⛔ **Y UN QUINTO, DE LA HERRAMIENTA Y NO DE `git`: CON EL `cd` PERSISTENTE DEL SHELL, UNA RUTA
-  RELATIVA NO IDENTIFICA UN FICHERO.** El mismo `doc/bitacora.md` es un fichero distinto según dónde
-  quedó el shell del comando anterior — y **no falla: escribe en el sitio equivocado y calla**.
-  *(Cicatriz 2026-09-01: una sesión anexa **168 líneas** de su bitácora **al repo de otro frente**
-  porque el `cd` seguía puesto. Lo cazó **careando el `tail` del fichero** —salió una entrada de tres
-  días antes— y un `git diff --stat` **vacío** donde esperaba su cambio. Y el mismo desliz le hizo
-  además **leer los avisos del repo equivocado**, así que numeró su hallazgo `A12` cuando allí iban
-  por `A5`: **un identificador inventado que habría quedado escrito**.)*
-  ⇒ **En un árbol multi-repo se trabaja con rutas ABSOLUTAS y `git -C <repo>`**, no con `cd` + ruta
-  relativa. ⭐ Y el testigo que lo caza es barato y hay que hacerlo antes de commitear: **mira el
-  `tail` de lo que acabas de escribir y el `--stat` de lo que vas a commitear.** Si el `--stat` sale
-  vacío donde esperabas tu cambio, **no es que no haya cambio: es que está en otro sitio**.
 
 ⭐⭐ **Y LA MITAD QUE SÍ SE PUEDE ATAR, PORQUE EL MENSAJE SÍ LO CONTROLAMOS: CADA COMMIT DICE QUIÉN LO
 HIZO.** `git` no tiene concepto de sesión — pero **el mensaje es nuestro**. Un *trailer* con el **ROL**