Cuatro rutas
para el mismo repositorio.
Trabajes en tu portátil, en un equipo de la sala o directamente en el navegador, aquí está el paso a paso. Todos los comandos se copian con un clic.
En los procedimientos, cada paso lleva un punto que indica cómo debería estar el pipeline en ese momento: verde si la arquitectura se respeta, rojo si está violada, azul si todavía no aplica. Si tu punto no coincide con el de la guía, algo se desvió.
En tu máquina, con VS Code y Git Bash
El recorrido completo: traer el repositorio, romperlo a propósito, ver el pipeline rechazarlo y devolverlo al estado bueno.
Lo que necesitas instalado
VS Code es solo un editor: no trae Git ni Node incluidos. Antes de empezar, comprueba qué tienes. Abre la terminal de VS Code con Ctrl + Ñ y en el desplegable de la derecha elige Git Bash.
# ¿Está Git? git --version # ¿Está Node? (opcional, ver más abajo) node --version
| Si responde… | Qué significa | Qué hacer |
|---|---|---|
git version 2.x | Git está listo | Nada, sigue |
command not found | No está instalado | Descárgalo de git-scm.com |
v20.x o superior | Node está listo | Podrás verificar la arquitectura sin subir nada |
| Node no aparece | No está instalado | Opcional: nodejs.org, versión LTS |
Después de instalar cualquiera de los dos, cierra VS Code y vuélvelo a abrir. Windows solo actualiza la lista de programas disponibles en las ventanas nuevas: si dejas la terminal abierta, va a seguir diciendo que el comando no existe.
Traer el repositorio a tu computador
Clonar es descargar el repositorio con todo su historial. En GitHub, botón verde Code → pestaña HTTPS → copiar la dirección.
# Ubícate donde quieras guardarlo cd ~/Documents # Cambia TU-USUARIO por el tuyo git clone https://github.com/TU-USUARIO/canchas-bogota.git cd canchas-bogota code .
El ciclo completo: verde, rojo, verde
Este es el recorrido que demuestra para qué sirve el pipeline. Cinco pasos.
Antes de tocar nada, confirma que la arquitectura está bien. Este es exactamente el mismo verificador que corre en GitHub.
node tools/verificar-arquitectura.js
Debe imprimir los tres [OK] y ARQUITECTURA RESPETADA.
Abre src/pagos/pagos.js en VS Code. Busca esta línea:
import { publicar } from '../nucleo/eventos.js';
Y justo debajo pega esta otra. Es una sola línea:
import { enviarCorreo } from '../notificaciones/notificaciones.js';
Guarda con Ctrl + S.
Es la solución que cualquiera escribiría si le piden «cuando se apruebe un pago, manda el correo». Funciona. Y es justo lo que la arquitectura no quiere: si el correo se cae, el cobro se cae con él.
Aquí está la ventaja de tener Node: ves el error en dos segundos, sin esperar a GitHub.
node tools/verificar-arquitectura.js
[X] R2 VIOLADA (ADR-002)
Archivo: src/pagos/pagos.js
"pagos" esta importando a "notificaciones", y no puede.
Por que existe esta regla: Si el envio de correos falla,
el cobro NO se puede caer.
Si quieres ver el número que hace fallar el pipeline:
node tools/verificar-arquitectura.js > /dev/null echo $?
Debe dar 1. Cuando la arquitectura está bien, da 0.
Si escribes node ... | tail, el echo $? te devuelve el resultado de tail, no el de node, y siempre va a decir 0. Por eso se manda a /dev/null.
git add . git commit -m "agrego envio de correo al aprobar el pago" git push
Ve a tu repositorio en GitHub, pestaña Actions. En menos de un minuto aparece una X roja en el trabajo 1. Verificar la arquitectura, y el trabajo 2. Desplegar queda en gris: nunca llegó a correr.
Tienes tres formas, según dónde estés. Si ya hiciste push, usa la primera.
Ya subiste el cambio → revierte
git revert --no-edit HEAD git push
Crea un commit nuevo que deshace el anterior. El historial conserva ambos, que es justo lo que se quiere en un equipo: queda constancia de que se intentó y se revirtió.
git revert no acepta la opción -q. Si la pones, falla con un mensaje de uso.
Hiciste commit pero no push → borra la línea y vuelve a commitear
# después de borrar la línea en VS Code
git add .
git commit -m "reverso: pagos avisa por evento segun ADR-002"
git push
Ni siquiera hiciste commit → descarta
git checkout -- src/pagos/pagos.js
Con cualquiera de las tres, node tools/verificar-arquitectura.js vuelve a dar 0 y el pipeline despliega.
El correo nunca dejó de enviarse. La línea publicar('pago.aprobado', ...) siempre estuvo ahí: pagos anuncia que hubo un pago y notificaciones, que está suscrito, manda el correo.
La diferencia es quién depende de quién. Si pagos llama a notificaciones, un correo caído tumba el cobro. Si pagos anuncia, el cobro ya ocurrió y solo se pierde el aviso. Eso es el patrón Observer, y esta es la razón por la que existe.
Por qué conviene tener Node (y por qué no es obligatorio)
El verificador de arquitectura está escrito en JavaScript y se ejecuta con Node. Pero quien lo corre de verdad es GitHub, no tu computador: el pipeline trae este paso, que instala Node en la máquina virtual de GitHub cada vez que corre.
- name: Preparar Node uses: actions/setup-node@v4
Funciona todo igual. Editas, subes, y esperas alrededor de un minuto a que GitHub te diga si pasó.
Lo mismo, pero además puedes verificar en dos segundos antes de subir. Es comodidad, no un requisito.
Los comandos de Git
Referencia para consultar. No hay que memorizarlos: hay que saber cuál buscar.
Crear un repositorio, o traer uno ajeno
Convertir una carpeta tuya en repositorio
cd mi-proyecto git init # crea el repositorio local git add . # prepara todos los archivos git commit -m "version inicial" # conectarlo con uno vacío que creaste en GitHub git remote add origin https://github.com/TU-USUARIO/mi-proyecto.git git branch -M main git push -u origin main
remote add origin le dice a tu repositorio local dónde vive su copia en internet. «origin» es solo un apodo, el nombre por convención. -u deja esa conexión guardada, para que después baste con escribir git push.
Traer el repositorio de otra persona
git clone https://github.com/USUARIO/REPOSITORIO.git cd REPOSITORIO
Clonar trae todo el historial, no solo los archivos actuales. Puedes ver cualquier versión anterior sin conexión.
Fork hace una copia en tu cuenta de GitHub: pasa a ser tuya y puedes subirle cambios. Clone baja una copia a tu computador. Si clonas el repositorio de otra persona sin hacer fork, no vas a poder hacer push: no tienes permiso. El orden correcto es fork primero, clone después.
El ciclo diario
Git tiene tres lugares, y cada comando mueve tu trabajo de uno al siguiente.
| Lugar | Qué contiene | Comando para avanzar |
|---|---|---|
| Tu carpeta | Los archivos que estás editando | git add |
| Área de preparación | Lo que va a entrar en la próxima foto | git commit |
| Repositorio local | El historial, en tu máquina | git push |
| GitHub | El historial compartido | — |
git status # qué cambió git add . # preparo TODO lo cambiado git add src/pagos/pagos.js # o solo un archivo git commit -m "mensaje que explica el porqué" git push # lo subo a GitHub git pull # bajo lo que subieron otros
Creer que commit ya subió el código. No. Hasta que no hagas push, tu trabajo vive solo en tu computador y nadie más lo ve.
Cómo se escribe un buen mensaje de commit
cambiosarreglosupdateasdf
separo catalogo de pagos segun ADR-001agrego regla R4 para reservas
El mensaje responde por qué, no qué. El «qué» ya se ve en el código; el «por qué» se pierde para siempre si nadie lo escribe.
Mirar sin cambiar nada
Estos tres comandos no modifican nada. Puedes usarlos sin miedo, siempre.
git status # qué cambió y qué está preparado git log --oneline # historial, una línea por commit git log --oneline --graph # igual, dibujando las ramas git diff # qué cambió, línea por línea git diff --stat # resumen: qué archivos y cuántas líneas git show HEAD # qué trajo el último commit
Es dónde estás parado ahora en el historial: casi siempre, el último commit de tu rama. HEAD~1 es el commit anterior, HEAD~2 el de más atrás, y así.
Por qué git log parece no mostrarlo todo
Es la queja más común, y casi siempre son dos causas distintas que se confunden entre sí.
Causa 1 · --oneline solo muestra la primera línea
Un mensaje de commit puede tener título y cuerpo. --oneline muestra el código y únicamente el título; todo el cuerpo queda oculto. No se perdió: no se está pidiendo.
1ccf1bd tercer commit con titulo
Solo el título. El cuerpo no aparece.
Muestra autor, fecha, título y todo el cuerpo del mensaje.
commit 1ccf1bd16f101c6fd3538c92613aa409be6216b8
Author: Elkin <correo@utadeo.edu.co>
Date: Sun Aug 30 18:54:27 2026
tercer commit con titulo
Y aqui va una descripcion mas larga
que ocupa varias lineas del cuerpo.
Causa 2 · el visor se traga la pantalla
git log no imprime y termina: abre un visor que muestra una pantalla a la vez. Si el historial es largo, ves solo el principio y parece que ahí se acabó.
| Tecla | Qué hace |
|---|---|
| Barra espaciadora | Avanza una pantalla |
| Flechas ↑ ↓ | Avanza o retrocede una línea |
q | Salir. Si quedaste atrapado, esta es la tecla |
/palabra | Buscar dentro del historial |
Con --no-pager imprime todo de corrido en la terminal, como cualquier otro comando.
git --no-pager log git --no-pager log --oneline
Las formas de ver el historial, según lo que necesites
git log # completo: autor, fecha y mensaje entero git log --oneline # compacto: código + título git log -5 # solo los últimos 5 git log --stat # + qué archivos cambió cada uno git log -p # + el cambio línea por línea git log --graph --oneline --all # dibuja las ramas git show 1ccf1bd # TODO el detalle de UN commit
Saca el código con git log --oneline y pásaselo a git show. Te da el mensaje entero, el autor, la fecha y todo lo que cambió ese commit.
La tercera posibilidad: el mensaje sí es corto
Si hiciste el commit con git commit -m "cambios", ese es todo el mensaje: no hay cuerpo escondido. Para escribir título y cuerpo:
# dos veces -m: el primero es el título, el segundo el cuerpo
git commit -m "agrego regla R4 para reservas" -m "Protege el aviso de reserva segun ADR-004. Descartamos la llamada directa porque acopla la reserva al correo."
Ramas y cómo se unen
Una rama es una línea de trabajo paralela. Te llevas una copia, trabajas tranquilo, y cuando está lista la juntas con la principal.
git branch # ¿qué ramas hay? la actual va con * git branch regla-r4 # crear una git switch regla-r4 # cambiarme a ella git switch -c regla-r4 # crear Y cambiarme, en un paso git switch main # volver a la principal git push -u origin regla-r4 # subir la rama la primera vez
Antes todo se hacía con git checkout, que servía para demasiadas cosas distintas y confundía. Git lo partió en dos: git switch para cambiar de rama y git restore para descartar cambios. checkout sigue funcionando, pero los nuevos son más claros.
Unir dos ramas
Regla de oro: te paras en la rama que va a recibir, y desde ahí traes la otra.
git switch main # me paro en la que recibe git merge regla-r4 # traigo el trabajo de la otra git push git branch -d regla-r4 # borro la rama ya fusionada
Si aparece un conflicto
Un conflicto ocurre cuando dos personas cambiaron la misma línea. Git no adivina cuál vale: se detiene y te pregunta. No es que se haya dañado nada.
<<<<<<< HEAD const precio = 90000; // lo que había en tu rama ======= const precio = 95000; // lo que trae la otra rama >>>>>>> regla-r4
Para resolverlo: abre el archivo, borra las tres líneas de marcas (<<<, ===, >>>), deja el código como debe quedar, y después:
git add . git commit # Git propone el mensaje solo # ¿te arrepentiste a mitad? cancela toda la fusión: git merge --abort
Cuando hay conflicto, VS Code muestra botones sobre el bloque: Accept Current, Accept Incoming y Accept Both. Un clic y limpia las marcas por ti.
Volver atrás en el tiempo: las cinco formas
Esta es la parte que más miedo da y donde más gente se enreda. La pregunta que decide todo es una: ¿ya hiciste push?
| Quiero… | Comando | ¿Reescribe el historial? |
|---|---|---|
| Descartar cambios sin commit | git restore ARCHIVO | No |
| Sacar algo del área de preparación | git restore --staged ARCHIVO | No |
| Deshacer un commit ya subido | git revert HASH | No · el recomendado |
| Deshacer commits no subidos | git reset HASH | Sí |
| Solo mirar cómo estaba antes | git checkout HASH | No |
1 · Descartar lo que aún no has confirmado
git restore src/pagos/pagos.js # un archivo git restore . # todo lo modificado git checkout -- src/pagos/pagos.js # la forma antigua, igual de válida
Los cambios descartados no están en ningún historial, porque nunca hubo commit. Se pierden de verdad.
2 · Sacar un archivo de la preparación
Hiciste git add de algo que no querías incluir. El archivo conserva tus cambios: solo sale de la lista del próximo commit.
git restore --staged src/pagos/pagos.js
3 · Revertir un commit · el recomendado
Es la forma segura, y la única correcta si ya hiciste push. No borra nada: crea un commit nuevo que deshace lo que hizo el anterior.
git revert --no-edit HEAD # deshace el último git revert --no-edit a1b2c3d # deshace uno específico git push
El historial conserva los dos commits: el que introdujo el problema y el que lo revirtió. En un equipo eso es exactamente lo que se quiere — queda constancia de que se intentó algo y se deshizo, y nadie más tiene que arreglar su copia.
4 · Reset · potente y peligroso
reset reescribe el historial: mueve tu rama hacia atrás como si los commits nunca hubieran existido. Tiene tres modos que solo se diferencian en qué pasa con tu trabajo.
| Modo | Los commits | Tus cambios |
|---|---|---|
--soft | Desaparecen | Quedan preparados, listos para commitear |
--mixed (por defecto) | Desaparecen | Quedan en los archivos, sin preparar |
--hard | Desaparecen | Se borran. No hay vuelta atrás |
Y hay dos formas de decirle hasta dónde retroceder. Se confunden mucho y significan cosas distintas.
git reset --soft HEAD~1 # deshago el ÚLTIMO commit, conservo el trabajo git reset HEAD~1 # igual, pero sin preparar git reset --hard HEAD~1 # deshago el último Y borro el trabajo
git log --oneline # copio el código, por ejemplo c0b400d git reset --soft c0b400d # vuelvo a ESE commit, trabajo preparado git reset --hard c0b400d # vuelvo a ESE commit y borro lo demás
Con HEAD~1 dices «retrocede uno»: el último commit desaparece.
Con un código del log dices «párate ahí»: ese commit se conserva y desaparece todo lo que vino después. Si apuntas al último commit del log, no pasa nada — ya estás ahí.
Qué se siente en cada modo
Partiendo de un historial con tres commits y haciendo reset al segundo:
1ccf1bd tercer commit
c0b400d segundo commit <-- voy a apuntar aquí
3ea6e19 primer commit
c0b400d segundo commit 3ea6e19 primer commit $ git status A c.txt # el archivo sigue ahí y YA PREPARADO
c0b400d segundo commit 3ea6e19 primer commit $ ls a.txt b.txt # c.txt desapareció del disco
--soft — «el commit estaba mal armado, pero el trabajo sirve». Típico: hiciste tres commits pequeños y quieres unirlos en uno solo, o pusiste un mensaje malo. Retrocedes, y vuelves a commitear bien.
--hard — «esto no sirve, bórralo». Es el único de los tres que destruye trabajo. Úsalo solo cuando estés seguro.
Si ya hiciste push y luego haces reset, tu historial y el de GitHub quedan en desacuerdo. Para arreglarlo tocaría forzar el push, y eso le rompe la copia a todos tus compañeros. Si ya subiste, usa revert.
5 · Mirar una versión anterior sin cambiar nada
git log --oneline # copio el código del commit git checkout a1b2c3d # me paro ahí a mirar git switch - # vuelvo a donde estaba
Git avisa «You are in 'detached HEAD' state». No es un error: significa que estás parado en un commit suelto, fuera de cualquier rama. Mira lo que necesites y vuelve con git switch -. Si haces commits estando ahí, se pierden al salir.
El salvavidas: reflog
Si hiciste un reset y crees que perdiste trabajo, hay una última carta. Git guarda un registro de todos los lugares donde estuviste, incluso los que ya no aparecen en el historial.
git reflog # todo por donde pasó HEAD git reset --hard 1ccf1bd # vuelvo a ese punto
c0b400d HEAD@{0}: reset: moving to c0b400d
1ccf1bd HEAD@{1}: commit: tercer commit # <-- este creía perdido
c0b400d HEAD@{2}: commit: segundo commit
Después de un --hard que borró un archivo del disco, este rescate lo devuelve completo. Git conserva el reflog unos 30 días, así que hay margen — pero no es eterno.
Tabla de referencia
| Comando | Qué hace |
|---|---|
git clone URL | Baja un repositorio con todo su historial |
git status | Qué cambió y qué está preparado |
git add . | Prepara todo lo modificado |
git commit -m "…" | Guarda una foto con su explicación |
git push | Sube tus commits a GitHub |
git pull | Baja lo que subieron otros |
git log --oneline | El historial resumido |
git diff | Qué cambió, línea por línea |
git switch -c NOMBRE | Crea una rama y se cambia a ella |
git merge NOMBRE | Trae esa rama a la actual |
git restore ARCHIVO | Descarta cambios sin confirmar |
git revert HASH | Deshace un commit dejando constancia |
git show HASH | Todo el detalle de un commit concreto |
git --no-pager log | El historial sin abrir el visor |
git reflog | Todo por donde pasaste, para recuperar |
Equipos compartidos de la universidad
Cómo trabajar con tu propia cuenta en una máquina donde ya hay otra persona registrada. Sin permisos de administrador.
Todo lo de este módulo funciona sin permisos de administrador. Ni la identidad de Git ni las credenciales guardadas necesitan instalar nada: viven en el perfil del usuario de Windows, y ahí sí puedes escribir.
Qué pasa en un equipo de la sala
Git y VS Code están instalados, pero alguien los usó antes que tú. Eso deja dos rastros distintos, y conviene no confundirlos porque se arreglan por caminos separados.
| Rastro | Qué es | Dónde vive | Síntoma |
|---|---|---|---|
| Identidad | El nombre y correo que firman cada commit | Archivo .gitconfig | Tus commits salen a nombre de otra persona |
| Credenciales | El permiso guardado para subir a GitHub | Administrador de credenciales de Windows | Al hacer push te rechaza, o sube a la cuenta ajena |
Primero: averigua quién está registrado
git config --global user.name
git config --global user.email
# ver toda la configuración y de qué archivo sale
git config --list --show-origin
Si aparece el nombre de otra persona, es lo esperado en una máquina compartida. No hay que borrar nada suyo: basta con poner lo tuyo por encima.
Poner tu identidad
Git lee la configuración en capas, y gana la más cercana al proyecto. Eso es justo lo que necesitas en un equipo compartido.
| Nivel | Dónde aplica | En una sala de cómputo |
|---|---|---|
--system | Todo el equipo | Necesita administrador. Olvídalo |
--global | Tu usuario de Windows | Funciona, pero se lo dejas al siguiente |
--local | Solo ese repositorio | Lo recomendado. No afecta a nadie más |
cd canchas-bogota
git config --local user.name "Tu Nombre"
git config --local user.email "tucorreo@utadeo.edu.co"
# comprobar que quedó
git config --local --list
La configuración local se guarda dentro de la carpeta del proyecto, en .git/config. Cuando termines la clase y borres la carpeta, se va con ella. No dejas rastro y no le cambias nada al que use el equipo mañana.
Escribe el mismo correo que tienes registrado en tu cuenta de GitHub. Si pones otro, los commits funcionan pero GitHub no los asocia a tu perfil y aparecen sin tu foto ni tu nombre de usuario. Para el proyecto eso importa: es la evidencia de quién hizo qué.
Cambiar la cuenta de GitHub
Esta es la parte que de verdad se atasca. Windows guarda el permiso de acceso a GitHub en un solo lugar, y por defecto solo guarda una cuenta. Si tu compañero de la mañana dejó la suya, tu push va a ir a nombre de él o va a ser rechazado.
Paso 1 · Borra la credencial guardada
Es la vía más confiable y no necesita administrador.
git:https://github.com → clic para desplegarla → Quitar.
Busca Credential Manager → pestaña Windows Credentials → entrada git:https://github.com → Remove.
También se puede desde la terminal, aunque el camino visual falla menos:
printf "protocol=https\nhost=github.com\n\n" | git credential-manager erase
Paso 2 · Vuelve a entrar con tu cuenta
Con la credencial borrada, el siguiente comando que necesite permiso va a pedir que te identifiques.
git push
Se abre una ventana con la opción Sign in with your browser. Dale, entra con tu usuario de GitHub, autoriza, y listo. Windows guarda tu credencial y el push continúa solo.
Puede que el equipo tenga Git muy viejo. En ese caso te va a pedir usuario y contraseña en la terminal — pero GitHub ya no acepta contraseñas para esto. Hay que generar un token: en GitHub, Settings → Developer settings → Personal access tokens → Tokens (classic) → Generate new token, marca los permisos repo y workflow, y usa ese token en lugar de la contraseña.
Limpiar al terminar · hazlo siempre
Si te vas sin limpiar, el siguiente estudiante puede subir código a tu nombre, en tus repositorios. Son treinta segundos.
- Borra tu credencial: Administrador de credenciales → Credenciales de Windows →
git:https://github.com→ Quitar. - Borra la carpeta del proyecto. Con ella se va tu configuración local, porque vivía en
.git/config. - Cierra la sesión de GitHub en el navegador, si entraste.
--global
Si en algún momento configuraste tu identidad global en vez de local, deshazlo también:
git config --global --unset user.name git config --global --unset user.email
Si el equipo se resiste o andas con afán, trabaja desde el navegador: el Módulo 4 hace exactamente lo mismo sin instalar ni configurar nada. Se edita con el lápiz de GitHub y el pipeline verifica igual. La única diferencia es que esperas un minuto en vez de dos segundos.
Desde GitHub, sin instalar nada
Todo el trabajo del proyecto se puede hacer en el navegador. Esta es la ruta del taller de clase.
Paso 1 · Haz el fork
Un fork es una copia completa del repositorio del curso que queda en tu cuenta, con todo el historial. Desde ese momento es tuyo: puedes cambiar lo que quieras sin afectar el original.
El fork lo haces tú y queda bajo tu nombre. Así funciona todo el software libre del mundo: nadie pide permiso para copiar, solo para que le acepten cambios de vuelta.
El repositorio debe ser público. GitHub Pages y Actions son gratis e ilimitados en repositorios públicos; en privados hay tope y con cuenta gratuita Pages ni siquiera está disponible.
Paso 2 · Enciende el pipeline y Pages
Son dos clics, pero están escondidos. Aquí es donde se atasca casi todo el mundo.
Por seguridad, GitHub desactiva los pipelines en los forks.
Es la opción antigua y se salta el pipeline: publicaría el sitio, pero sin pasar por la verificación de arquitectura. Se perdería el punto entero del proyecto.
Vuelve a Actions. En un minuto el flujo termina en verde. Tu URL aparece arriba, en Settings → Pages, con esta forma:
https://TU-USUARIO.github.io/canchas-bogota/
Anótala: es parte de la entrega. Ábrela en el celular para comprobar que funciona.
Paso 3 · Rompe la arquitectura a propósito
El negocio pide algo razonable: «cuando se apruebe un pago, manda el correo de confirmación». La solución obvia es que pagos llame a notificaciones. Vamos a hacerlo y ver qué pasa.
import { publicar } … y justo debajo pega la línea de abajo.
import { enviarCorreo } from '../notificaciones/notificaciones.js';
Abajo, en el mensaje del commit, escribe algo real y presiona Commit changes:
agrego envio de correo al aprobar el pago
Por eso no necesitas instalar Git para el taller. El lápiz de GitHub guarda el cambio y lo sube en un solo paso.
En menos de un minuto aparece la X roja. Entra al flujo, clic en 1. Verificar la arquitectura, y despliega el paso de la función de aptitud.
[X] R2 VIOLADA (ADR-002)
Archivo: src/pagos/pagos.js
"pagos" esta importando a "notificaciones", y no puede.
Por que existe esta regla: Si el envio de correos falla,
el cobro NO se puede caer.
ARQUITECTURA VIOLADA: 1 problema(s). El despliegue se detiene.
Fíjate también en que el trabajo 2. Desplegar quedó en gris: nunca corrió. Tu cambio no llegó a producción.
No dice «error». Dice por qué existe esa regla. Una regla que no explica su motivo es una imposición; una que lo explica es una decisión que se puede discutir.
Paso 4 · Arréglalo bien
Lo fácil sería borrar la regla de arquitectura/reglas.json para que el pipeline pase. Eso no resuelve el problema: lo esconde. El reto es resolverlo sin violar la regla.
Vuelve al lápiz en src/pagos/pagos.js y borra la línea que agregaste. El archivo debe quedar exactamente así:
// PAGOS · cobra. NO importa notificaciones (regla R2): // si el envio de correos falla, el cobro no se puede caer. // Por eso avisa publicando un evento, no llamando a nadie. import { publicar } from '../nucleo/eventos.js'; export function cobrar(reserva) { const referencia = 'PG-' + Math.random().toString(36).slice(2, 8).toUpperCase(); publicar('pago.aprobado', Object.assign({}, reserva, { referencia: referencia })); return { ok: true, referencia: referencia, valor: reserva.valor }; }
reverso: pagos avisa por evento segun ADR-002
Mira la línea resaltada en verde. Siempre estuvo ahí. El correo sí se envía: pagos anuncia que hubo un pago aprobado, y notificaciones, que está suscrita a ese anuncio, lo manda.
La diferencia es quién depende de quién. Si pagos llama a notificaciones y el servidor de correo se cae, la llamada falla y el cobro se cae con ella: el cliente no pudo pagar porque el correo estaba malo. Si pagos anuncia y sigue, el cobro ya ocurrió y solo se perdió el aviso.
Eso es el patrón Observer. No es elegancia: es que el cobro no dependa del correo.
Compruébalo tú mismo: abre tu URL desplegada, haz una reserva, y mira la sección Notificaciones recibidas. El mensaje aparece — y llegó por el evento.
Cuando algo falla
Lo primero siempre es la misma pregunta: ¿cuál de los dos trabajos falló? La respuesta cambia por completo qué hay que arreglar.
| El trabajo que falla | Qué significa | Qué hacer |
|---|---|---|
| 1 · Verificar la arquitectura | Violaste una regla | Lee el log: dice cuál, dónde y por qué existe |
| 2 · Desplegar a Pages | La arquitectura está bien. Es configuración | Casi siempre: Pages sin encender |
Error: Get Pages site failed … Not Found
GitHub Pages no se enciende solo. El pipeline intentó publicar en un sitio que todavía no existe.
El pipeline no arranca
Los flujos siguen deshabilitados. Pestaña Actions → botón verde del aviso amarillo.
Aviso: Node 20 is being deprecated
Es una advertencia, no un error. GitHub ya ejecuta las acciones en una versión más nueva por su cuenta. Ignóralo.
La URL abre en blanco
Espera un minuto y recarga con Ctrl + F5. La primera publicación tarda un poco en propagarse.
Distinguir en qué paso se rompió un pipeline es lo primero que hace alguien con experiencia. El mensaje casi siempre dice qué pasó — el problema es que nadie lo lee.