+ );
+}
+```
+
+> Ajustar imports al alias real del proyecto (`@/` vs `src/`). Ajustar el shape de props de `AttendanceTable`/`AttendanceSummaryChips` a la API real de los componentes extraídos en Task 24.
+
+- [ ] **Step 2: Verificar typecheck**
+
+Run: `docker compose exec frontend npm run typecheck`
+Expected: sin errores.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add frontend/src/pages/admin/AdminAttendancePage.tsx
+git commit -m "feat(ta-01): add AdminAttendancePage for contingency attendance"
+```
+
+---
+
+### Task 27: Ruta y sidebar admin
+
+**Files:**
+- Modify: archivo de rutas (probablemente `frontend/src/routes.tsx` o `frontend/src/App.tsx`)
+- Modify: sidebar admin (probablemente `frontend/src/components/admin/Sidebar.tsx`)
+
+- [ ] **Step 1: Identificar archivos**
+
+Run: `Glob "frontend/src/**/Sidebar*.tsx"` y `Glob "frontend/src/**/routes*.tsx"`.
+
+- [ ] **Step 2: Agregar la ruta**
+
+```tsx
+import AdminAttendancePage from "@/pages/admin/AdminAttendancePage";
+
+// ... dentro de las rutas admin
+} />
+```
+
+- [ ] **Step 3: Agregar item al sidebar admin**
+
+```tsx
+{ to: "/admin/attendance", label: "Asistencia por contingencia", icon: },
+```
+
+- [ ] **Step 4: Smoke browser**
+
+Login admin → click "Asistencia por contingencia" → elegir sección → marcar uno → guardar. Verificar que la marca persiste (re-abrir la sección y ver el chip "presente").
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add frontend/src/routes.tsx frontend/src/components/admin/
+git commit -m "feat(ta-01): wire /admin/attendance route and sidebar item"
+```
+
+---
+
+## Phase 7 — Verificación final
+
+### Task 28: Suite completa + smoke manual
+
+- [ ] **Step 1: Suite backend**
+
+Run: `docker compose exec backend pytest backend/tests/ -v`
+Expected: TODA la suite verde, incluyendo:
+- `backend/tests/storage/`
+- `backend/tests/services/`
+- `backend/tests/api/test_admin_attendance.py`
+- `backend/tests/api/test_users_photo_upload.py`
+- `backend/tests/api/test_teacher_attendance_gate_decouple.py`
+- Las suites preexistentes (sex aggregations, present summary, etc).
+
+- [ ] **Step 2: Smoke manual**
+
+Levantar todo: `docker compose up -d`.
+
+Checklist en navegador:
+- [ ] Login admin → ir a un usuario → subir una foto JPG grande (>1MB). Verificar que la foto se muestra (URL nueva, no Base64) y el archivo en `/data/photos/...` existe (`docker compose exec backend ls /data/photos`).
+- [ ] Subir un GIF. Verificar 422 con mensaje claro.
+- [ ] Subir una foto sin rostro. Verificar que se guarda igual y el warning aparece.
+- [ ] Login admin → "Asistencia por contingencia" → elegir sección → marcar a un estudiante que NO hizo check-in en gate → guardar → verificar que la marca quedó (re-fetch).
+- [ ] Login teacher → marcar a un estudiante sin gate check-in → verificar que SÍ se marca presente y el chip de gate es gris/info.
+- [ ] DB: `docker compose exec db psql -U postgres -d talos -c "SELECT id, user_id, marked_by_role, marked_by_user_id FROM attendances ORDER BY id DESC LIMIT 5;"` — debe mostrar valores de admin/teacher según corresponda.
+
+- [ ] **Step 3: Reporte al usuario**
+
+> Sprint TA-01 implementado y verificado localmente. Tests verdes, smoke OK.
+> Pendiente: vos pushea cuando confirmes. Para el bloque A en prod hace falta que pongas `PHOTO_STORAGE_BACKEND=supabase` y las 3 vars de Supabase como Secrets en HF cuando tengas las credenciales.
+
+---
+
+## Notas para quien implemente
+
+- **Convenciones del proyecto:**
+ - `datetime.now(timezone.utc)` SIEMPRE en escrituras a columnas timezone-aware (TZ del container = `America/Caracas`).
+ - Tests directos con pytest, NO tocar `init.sh`.
+ - Commits locales OK, NO `git push` automático.
+ - Postgres en dev y prod, no mezclar motores.
+
+- **Fixtures requeridos (agregar a `backend/tests/conftest.py` si no existen):**
+ - `admin_token`, `teacher_token`, `other_account_admin_token`
+ - `admin_user_id`, `demo_student_id`, `demo_section_id`
+ - `demo_student_without_entrance_log`, `foreign_section_id`
+ - `db_session`, `demo_account`, `demo_section`, `demo_student`, `demo_admin`
+ - Patrón a copiar: `backend/tests/test_seed_demo_scoping.py`.
+
+- **Si surge ambigüedad sobre `app/face_utils.py`:** leer el archivo y adaptar la llamada en Task 10 a la firma real. El objetivo es: `(processed_bytes) → str | None`. Si la utilidad existente solo trabaja con paths o `PIL.Image`, hacer la conversión inline en el endpoint.
+
+- **Si el router principal usa un patrón distinto:** Task 11 y Task 20 dan instrucciones genéricas (registrar `include_router`); ajustar al archivo real (probablemente `backend/app/api/v1/router.py` o `backend/app/main.py`).
diff --git a/docs/superpowers/specs/2026-06-05-ta01-storage-and-attendance-design.md b/docs/superpowers/specs/2026-06-05-ta01-storage-and-attendance-design.md
new file mode 100644
index 0000000000000000000000000000000000000000..d64e47eb8c5f3281a177829c4709cf30f1a1aced
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-05-ta01-storage-and-attendance-design.md
@@ -0,0 +1,357 @@
+# TA-01 — Storage de fotos + asistencia administrativa + flexibilidad gate
+
+**Fecha:** 2026-06-05
+**Sprint:** TA-01
+**Estado:** Diseño aprobado, pendiente plan de implementación
+**Fuente requisitos:** `docs/sprints/2026-06-05_TA-01.md`
+
+## Resumen
+
+Sprint con tres bloques independientes pero entregados como una sola unidad:
+
+- **Bloque A — Fotos:** migrar fotos de usuarios de Base64 en BD a archivos comprimidos (WebP) en un storage externo (Supabase Storage en prod, disco local en dev), detrás de una interfaz `PhotoStorage` con adapters intercambiables.
+- **Bloque B — Asistencia administrativa:** nueva vista y endpoints para que los administradores pasen lista por aula cuando un docente está ausente, con trazabilidad de quién marcó cada asistencia.
+- **Bloque C — Flexibilidad gate ↔ aula:** desacoplar la asistencia de aula del registro de entrada al plantel para tolerar fallas técnicas del kiosco (OpenCV, electricidad, internet).
+
+## Motivación
+
+1. Las fotos en Base64 dentro de la columna `face_encodings.photo` están afectando rendimiento y crecimiento de la BD; el patrón estándar es guardar archivos en un storage y solo la ruta en la BD.
+2. Cuando un docente falta, hoy no existe forma de que un administrador pase lista por aula desde el sistema — debe hacerse manualmente o quedar sin registrar.
+3. El acoplamiento actual (un estudiante no puede ser marcado presente en clase si no hizo check-in en el gate) era intencional como invariante de negocio, pero la operación real tiene cortes de electricidad / internet / fallas de cámara que dejan al docente sin poder marcar asistencia legítima. La contingencia técnica gana prioridad sobre la invariante.
+
+**Reversión consciente:** este sprint revierte la guía previa de mantener acoplados `EntranceLog` y asistencia de aula. La motivación es contingencia técnica documentada arriba.
+
+## Decisiones de diseño tomadas
+
+| # | Pregunta | Decisión |
+|---|----------|----------|
+| 1 | Alcance del sprint | Un único spec con los 3 bloques. |
+| 2 | Abstracción de storage | Interfaz `PhotoStorage` con adapters `LocalDiskStorage` (dev) y `SupabaseStorage` (prod). Switch por env var. |
+| 3 | Ubicación de la URL/path de foto en BD | Cambiar el tipo de `face_encodings.photo` de `Text` a `VARCHAR(500)`. No agregar columna nueva en `users`. |
+| 4 | Migración de datos existentes | No automática. El admin re-sube manualmente las pocas fotos existentes. La migración Alembic solo cambia el tipo. |
+| 5 | Perfil de compresión | WebP lossy q=85, máximo 800×800 px manteniendo aspect ratio. |
+| 6 | Scope del admin en asistencia | Cualquier sección de su cuenta. Sin tabla de asignación admin-sección. |
+| 7 | Trazabilidad de quién marcó | Agregar `attendances.marked_by_role` y `attendances.marked_by_user_id`. También se popula en marcas hechas por docente y por kiosco. |
+| 8 | Grado de desacople gate | Desacople total: nunca bloquear. El chip `entrance_logged` se sigue calculando como información en la UI. |
+| 9 | Ubicación de la UI admin | Página nueva `/admin/attendance` reutilizando componentes extraídos de `TeacherAttendancePage`. |
+
+## Cambios de base de datos
+
+Migración Alembic: `backend/migrations/versions/028_ta01_storage_and_attendance_attribution.py`
+
+```sql
+-- Bloque A: foto pasa de Base64 a URL/path corto + permitir encoding NULL
+ALTER TABLE face_encodings
+ ALTER COLUMN photo TYPE VARCHAR(500) USING NULL, -- vacía las filas viejas; admin re-sube
+ ALTER COLUMN encoding DROP NOT NULL; -- permite foto sin rostro detectado
+
+-- Bloque B: trazabilidad de origen de la marca
+ALTER TABLE attendances
+ ADD COLUMN marked_by_role VARCHAR(20), -- 'teacher' | 'admin' | 'kiosco'
+ ADD COLUMN marked_by_user_id BIGINT NULL,
+ ADD CONSTRAINT fk_attendances_marked_by_user
+ FOREIGN KEY (marked_by_user_id) REFERENCES users(id);
+
+CREATE INDEX ix_attendances_marked_by_user_id ON attendances(marked_by_user_id);
+```
+
+**Justificación de `encoding NULL`:** el endpoint de upload de Bloque A intenta extraer encoding facial vía `face_utils`. Si la foto no tiene rostro detectable (ej. foto carnet con lente o ángulo), guardamos la foto igualmente con `encoding=NULL` para no perder la foto de identidad del usuario. El kiosco facial filtra `WHERE encoding IS NOT NULL` al hacer matching.
+
+**Downgrade:**
+
+```sql
+DROP INDEX ix_attendances_marked_by_user_id;
+ALTER TABLE attendances
+ DROP CONSTRAINT fk_attendances_marked_by_user,
+ DROP COLUMN marked_by_user_id,
+ DROP COLUMN marked_by_role;
+ALTER TABLE face_encodings
+ ALTER COLUMN photo TYPE TEXT;
+```
+
+**Modelos SQLAlchemy:**
+
+- `app/models/face_encoding.py` → `photo = Column(String(500), nullable=True)`
+- `app/models/attendance.py` → agregar `marked_by_role = Column(String(20), nullable=True)` y `marked_by_user_id = Column(BigInteger, ForeignKey("users.id"), nullable=True)`
+
+## Bloque A — Storage de fotos
+
+### 1. Capa de abstracción (`backend/app/storage/`)
+
+Estructura nueva del paquete:
+
+```
+backend/app/storage/
+ __init__.py # factory: get_storage() lee env var
+ base.py # Protocol PhotoStorage
+ local_disk.py # LocalDiskStorage
+ supabase.py # SupabaseStorage (stub inicial)
+ in_memory.py # InMemoryStorage (solo tests)
+```
+
+`base.py`:
+
+```python
+from typing import Protocol
+
+class PhotoStorage(Protocol):
+ def upload(self, account_id: int, user_id: int, content: bytes, ext: str) -> str:
+ """Persiste el archivo y devuelve la ruta/URL canónica que se guarda en BD."""
+ def delete(self, path_or_url: str) -> None:
+ """Borra el archivo. Best-effort, no levanta si no existe."""
+ def get_url(self, path_or_url: str) -> str:
+ """Devuelve la URL pública o firmada con la que el frontend lo consume."""
+```
+
+`__init__.py`:
+
+```python
+def get_storage() -> PhotoStorage:
+ backend = os.getenv("PHOTO_STORAGE_BACKEND", "local").lower()
+ if backend == "local":
+ return LocalDiskStorage(root=os.getenv("LOCAL_PHOTO_ROOT", "/data/photos"))
+ if backend == "supabase":
+ return SupabaseStorage(
+ url=os.getenv("SUPABASE_URL"),
+ key=os.getenv("SUPABASE_SERVICE_KEY"),
+ bucket=os.getenv("SUPABASE_PHOTO_BUCKET", "user-photos"),
+ )
+ raise ValueError(f"Unknown PHOTO_STORAGE_BACKEND: {backend}")
+```
+
+`LocalDiskStorage`:
+
+- Path en disco: `{root}/{account_id}/{user_id}/{uuid4}.{ext}`
+- `get_url` devuelve `/api/v1/photos/{path}` (endpoint sirve el archivo con `FileResponse`)
+- `delete` ignora `FileNotFoundError`
+
+`SupabaseStorage` (inicial: stub que tira `NotImplementedError` con mensaje claro hasta que lleguen credenciales; las firmas y tests fakeados ya quedan listos).
+
+### 2. Pipeline de procesamiento de imágenes (`backend/app/services/photo_pipeline.py`)
+
+```python
+from io import BytesIO
+from PIL import Image, ImageOps
+import magic
+
+ALLOWED_MIME = {"image/png", "image/jpeg", "image/webp"}
+MAX_INPUT_BYTES = 5 * 1024 * 1024 # 5 MB
+TARGET_MAX_DIM = 800
+WEBP_QUALITY = 85
+
+def process_user_photo(raw: bytes) -> bytes:
+ if len(raw) > MAX_INPUT_BYTES:
+ raise ValueError("photo exceeds 5 MB")
+ mime = magic.from_buffer(raw, mime=True)
+ if mime not in ALLOWED_MIME:
+ raise ValueError(f"unsupported mime: {mime}")
+ img = Image.open(BytesIO(raw))
+ img = ImageOps.exif_transpose(img) # corrige rotación
+ img.thumbnail((TARGET_MAX_DIM, TARGET_MAX_DIM), Image.LANCZOS)
+ if img.mode in ("RGBA", "P"):
+ img = img.convert("RGB")
+ out = BytesIO()
+ img.save(out, format="WEBP", quality=WEBP_QUALITY, method=6)
+ return out.getvalue()
+```
+
+Librerías nuevas en `backend/requirements.txt`: `Pillow` (verificar versión actual), `python-magic`. En Windows dev, `python-magic-bin`.
+
+### 3. Endpoint de upload
+
+`POST /api/v1/users/{user_id}/photo` (admin-only):
+
+```
+1. multipart/form-data con campo `file` (max 5 MB; png|jpg|jpeg|webp)
+2. processed = process_user_photo(raw) # WebP 800×800 q=85
+3. Intentar extract_encoding(processed) vía face_utils:
+ - éxito → encoding_str
+ - sin rostro detectable → encoding_str = None, warning_flag = True
+4. storage = get_storage()
+5. Buscar último face_encoding del user; si existe y tiene photo:
+ storage.delete(old.photo) # best-effort
+6. new_path = storage.upload(account_id, user_id, processed, "webp")
+7. INSERT face_encodings (user_id, account_id, encoding=encoding_str, photo=new_path)
+8. Respuesta:
+ 200 { "photo_url": storage.get_url(new_path),
+ "encoding_extracted": bool,
+ "warning": "no se detectó rostro; el reconocimiento facial no
+ funcionará hasta resubir una foto con rostro visible"
+ if not encoding_extracted else None }
+```
+
+**Mapeo en responses de usuarios:** En `users.py:72-99` (y cualquier otro lugar que devuelva `face_photo`), la columna `face_encodings.photo` ahora contiene un path/URL. Antes de devolverlo al frontend, pasa por `storage.get_url(path)` para que el frontend reciba siempre una URL servible (sea local `/api/v1/photos/...` o Supabase firmada). El campo `face_photo` en `UserResponse` schema mantiene su nombre y tipo `Optional[str]`.
+
+### 4. Endpoint para servir foto local
+
+`GET /api/v1/photos/{account_id}/{user_id}/{filename}` con `FileResponse` y verificación de pertenencia a cuenta (auth + scope). Solo activo cuando `PHOTO_STORAGE_BACKEND=local`.
+
+## Bloque B — Asistencia administrativa
+
+### 1. Refactor previo (extracción de servicio)
+
+Mover la lógica de marca de asistencia desde `app/api/v1/endpoints/teacher.py` a `app/services/attendance.py`:
+
+```python
+def record_attendance(
+ db, *, account_id, user_id, section_id, subject_id, action,
+ marked_by_role: str, marked_by_user_id: int, when: datetime,
+) -> Attendance: ...
+
+def list_section_roster(
+ db, *, account_id, section_id, on_date,
+) -> list[StudentRosterItem]: ...
+```
+
+`teacher.py` y los nuevos endpoints admin pasan a llamar al servicio. Esto elimina duplicación y deja el cambio del Bloque C en un solo lugar.
+
+### 2. Endpoints admin (`app/api/v1/endpoints/admin_attendance.py`)
+
+```
+GET /api/v1/admin/sections
+GET /api/v1/admin/sections/{section_id}/subjects?on_date=YYYY-MM-DD
+GET /api/v1/admin/sections/{section_id}/roster?subject_id=&on_date=YYYY-MM-DD
+POST /api/v1/admin/attendance/swipe
+POST /api/v1/admin/attendance/batch-toggle
+```
+
+Schemas: mismos de `teacher` con renombre cosmético. Auth: `require_role("admin")`. Scope: filtrado por `current_user.account_id` en todas las queries.
+
+### 3. Frontend
+
+Componentes nuevos / reusados:
+
+- Extraer de `frontend/src/pages/teacher/TeacherAttendancePage.tsx` los componentes presentacionales: `AttendanceTable`, `StudentRow`, `AttendanceSummaryChips`. Mover a `frontend/src/components/attendance/`.
+- Nueva página: `frontend/src/pages/admin/AdminAttendancePage.tsx`
+ - Header: selector `Section` → `Subject` → `Date` (default hoy).
+ - Body: `` con datos del endpoint admin.
+ - Footer: contadores presente/ausente y botón "Guardar".
+- Nuevo servicio: `frontend/src/services/adminAttendanceService.ts` espejo de `teacherService.ts`.
+- Ruta: `/admin/attendance` agregada al router y al sidebar admin con el item "Asistencia por contingencia".
+
+## Bloque C — Desacople gate ↔ aula
+
+### Cambios
+
+En `app/api/v1/endpoints/teacher.py` (y, después del refactor del Bloque B, en `app/services/attendance.py`):
+
+- Eliminar el cálculo de `entrance_logged_ids` como **filtro** en `submit_swipe` (`teacher.py:470-496`) y en `batch-toggle` (`teacher.py:580-…`).
+- Eliminar las acumulaciones de `skipped_ids` derivadas del check de gate.
+- Eliminar las ramas `if rec.student_id not in entrance_logged_ids: skipped_ids.append(...)`.
+- Grep adicional antes de implementar: `entrance_logged_ids` en todo el backend para asegurar que no quedó otro punto bloqueante (también revisar `services/attendance.py` post-refactor del Bloque B).
+
+El `entrance_logged` que se devuelve en el roster (`GET /students` y similares) sigue calculándose; solo cambia su rol: ya no es bloqueante.
+
+**Marcas desde el kiosco:** en `app/api/v1/endpoints/facial.py`, donde se inserta una `Attendance` desde reconocimiento facial, agregar `marked_by_role='kiosco'` y `marked_by_user_id=None`. Es un cambio de una línea para preservar consistencia del Bloque B.
+
+### Documentación de UI
+
+En `TeacherAttendancePage` y `AdminAttendancePage`: el chip `entrance_logged` cambia de tono de "advertencia bloqueante" a "informativo" (gris). Tooltip: "Este estudiante no registró entrada en el gate hoy. Podés marcar asistencia igualmente."
+
+## Arquitectura de archivos (cambios)
+
+```
+backend/
+ app/
+ models/
+ attendance.py [edit: +marked_by_role, +marked_by_user_id]
+ face_encoding.py [edit: photo = String(500)]
+ storage/ [NEW]
+ __init__.py
+ base.py
+ local_disk.py
+ supabase.py
+ in_memory.py
+ services/ [NEW or grow]
+ attendance.py [NEW: record_attendance, list_section_roster]
+ photo_pipeline.py [NEW]
+ api/v1/endpoints/
+ teacher.py [edit: usa services/attendance + quita gate filter]
+ admin_attendance.py [NEW]
+ users.py [edit: photo endpoint + mapea path → URL en responses]
+ photos.py [NEW: GET local file]
+ migrations/versions/
+ 028_ta01_storage_and_attendance_attribution.py [NEW]
+ tests/
+ storage/ [NEW: test_local_disk, test_supabase, test_in_memory]
+ services/ [NEW: test_photo_pipeline, test_attendance_service]
+ api/
+ test_admin_attendance.py [NEW]
+ test_teacher_attendance_gate_decouple.py [NEW: regresión Bloque C]
+ test_users_photo_upload.py [NEW]
+
+frontend/
+ src/
+ components/attendance/ [NEW: extracción]
+ AttendanceTable.tsx
+ StudentRow.tsx
+ AttendanceSummaryChips.tsx
+ pages/
+ teacher/TeacherAttendancePage.tsx [edit: usa componentes extraídos]
+ admin/AdminAttendancePage.tsx [NEW]
+ services/
+ adminAttendanceService.ts [NEW]
+ routes.tsx [edit: +/admin/attendance]
+```
+
+## Variables de entorno nuevas
+
+```
+PHOTO_STORAGE_BACKEND=local # local | supabase
+LOCAL_PHOTO_ROOT=/data/photos # solo si backend=local
+SUPABASE_URL= # solo si backend=supabase
+SUPABASE_SERVICE_KEY= # solo si backend=supabase
+SUPABASE_PHOTO_BUCKET=user-photos # opcional, default mostrado
+```
+
+En `docker-compose.yml` montar volumen `/data/photos` para el backend (dev). En `.env.example` agregar las cinco variables con valores de dev.
+
+## Plan de testing
+
+- **Storage**
+ - `LocalDiskStorage`: upload escribe archivo, delete lo borra (y es idempotente), get_url devuelve el path correcto.
+ - `InMemoryStorage`: smoke en memoria para tests rápidos del pipeline.
+ - `SupabaseStorage`: stub levanta `NotImplementedError` con mensaje claro hasta integración real.
+- **Photo pipeline**
+ - Rechaza tamaños > 5 MB.
+ - Rechaza mime no permitido (probar gif).
+ - Acepta png, jpeg, webp.
+ - Output siempre es WebP de ≤ 800×800.
+ - EXIF rotation se aplica (foto verticalmente girada queda derecha).
+- **Endpoint upload**
+ - Admin de otra cuenta no puede subir foto de un user.
+ - Sube foto, llamada GET la devuelve.
+ - Subir segunda foto borra la anterior del storage.
+- **Servicio de asistencia**
+ - `record_attendance` setea `marked_by_role` y `marked_by_user_id` correctamente.
+ - Idempotencia: misma marca dos veces no duplica.
+- **Endpoints admin**
+ - Admin puede listar todas las secciones de su cuenta.
+ - Admin de otra cuenta recibe 404 al pedir una sección ajena.
+ - `swipe` y `batch-toggle` se comportan como los de teacher pero con `marked_by_role='admin'`.
+- **Regresión Bloque C**
+ - Estudiante sin `EntranceLog` del día ahora SÍ se marca presente en `teacher/attendance/swipe` y en `teacher/attendance/batch-toggle`.
+ - El roster sigue devolviendo `entrance_logged: false` para ese estudiante (información preservada).
+
+## Out of scope
+
+- Migración automática de fotos Base64 existentes (admin re-sube manualmente).
+- UI para que el admin "confirme ausencia de docente" o se asigne a una sección (admin tiene scope completo).
+- Reportes diferenciados por `marked_by_role` (la columna queda lista pero los reports no la consumen en este sprint).
+- Soporte para Supabase Storage real funcionando — el adapter queda con stub. La integración efectiva se hará cuando lleguen credenciales (sprint posterior).
+
+## Riesgos y mitigaciones
+
+| Riesgo | Mitigación |
+|--------|------------|
+| Volumen local `/data/photos` en dev no persiste entre `docker compose down -v` | Documentar; el admin re-sube en dev. |
+| `python-magic` requiere libmagic; en Windows usar `python-magic-bin` | Documentar en `requirements.txt` y `README` con condición de OS. |
+| Reverter el filtro del gate podría permitir marcar a un estudiante que ni siquiera vino al colegio | Aceptado por requisito de contingencia. Trazabilidad retroactiva queda en `attendances.marked_by_user_id` (quién marcó) + flag `entrance_logged=false` ya almacenado, suficiente para auditar después. |
+| Extraer componentes del frontend puede romper la UI de docente | Test manual de TeacherAttendancePage post-refactor antes de mergear. |
+
+## Convenciones del proyecto a respetar
+
+- TZ: usar `datetime.now(timezone.utc)` para escrituras a columnas timezone-aware. El contenedor está en `America/Caracas`.
+- Tests: pytest directo, **no** tocar `init.sh`.
+- Commits locales OK durante el sprint, **NO** push automático a producción.
+- Un mismo motor de BD en dev y prod (PostgreSQL).
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 516c3eabb491c75de3506eebb752188d55f29305..757fe38f5bcee32033b8c2ecba0ecf73045deda5 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -9,6 +9,7 @@ import EnrollmentsPage from './pages/EnrollmentsPage'
import AttendanceReportsPage from './pages/AttendanceReportsPage'
import SettingsPage from './pages/SettingsPage'
import TeacherAttendancePage from './pages/TeacherAttendancePage'
+import AdminAttendancePage from './pages/AdminAttendancePage'
import TeacherSubjectsPage from './pages/TeacherSubjectsPage'
import TeacherSectionsPage from './pages/TeacherSectionsPage'
import PublicCheckInPage from './pages/PublicCheckInPage'
@@ -48,6 +49,7 @@ export default function App() {
} />
} />
} />
+ } />
} />
} />
} />
diff --git a/frontend/src/components/AuthImage.tsx b/frontend/src/components/AuthImage.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..71e4e1282e501cd638d1c600d58baf6133104ecd
--- /dev/null
+++ b/frontend/src/components/AuthImage.tsx
@@ -0,0 +1,76 @@
+import { useEffect, useState, type ImgHTMLAttributes, type ReactNode } from 'react';
+import { Loader2 } from 'lucide-react';
+import api from '../services/api';
+
+interface AuthImageProps extends Omit, 'src'> {
+ src: string | null | undefined;
+ fallback?: ReactNode;
+}
+
+/**
+ * Renders an authenticated image. The `` tag cannot send our JWT
+ * Authorization header, so a direct URL to a protected endpoint (e.g.
+ * `/api/v1/photos/...`) returns 401 and shows broken in the browser.
+ * AuthImage fetches the bytes through the axios instance (which injects
+ * the auth header), converts the response to a blob URL, and renders that.
+ *
+ * For dataURLs and blob URLs we render directly without fetching.
+ */
+export default function AuthImage({ src, fallback = null, ...imgProps }: AuthImageProps) {
+ const [blobUrl, setBlobUrl] = useState(null);
+ const [error, setError] = useState(false);
+
+ useEffect(() => {
+ if (!src) {
+ setBlobUrl(null);
+ setError(false);
+ return;
+ }
+
+ // Pass-through for data: and blob: URLs.
+ if (src.startsWith('data:') || src.startsWith('blob:')) {
+ setBlobUrl(src);
+ setError(false);
+ return;
+ }
+
+ let cancelled = false;
+ let createdUrl: string | null = null;
+ setError(false);
+
+ // Strip our axios baseURL prefix so the path doesn't double up.
+ const relative = src.replace(/^\/api\/v1/, '');
+
+ api
+ .get(relative, { responseType: 'blob' })
+ .then((res) => {
+ if (cancelled) return;
+ createdUrl = URL.createObjectURL(res.data);
+ setBlobUrl(createdUrl);
+ })
+ .catch(() => {
+ if (!cancelled) setError(true);
+ });
+
+ return () => {
+ cancelled = true;
+ if (createdUrl) URL.revokeObjectURL(createdUrl);
+ };
+ }, [src]);
+
+ if (error || !src) return <>{fallback}>;
+ if (!blobUrl) {
+ const { className = '', ...rest } = imgProps;
+ return (
+