feat(F-155): completed feature

backlog/features.json

@@ -6428,6 +6428,23 @@
         "security": false,
         "qa": false
       }
+    },
+    {
+      "id": "F-155",
+      "type": "fix",
+      "title": "Infrastructure: persist PostgreSQL and Redis data across restarts",
+      "description": "Fix local/prod infrastructure so PostgreSQL and Redis data survive service restarts, container recreation and normal monolith operations; document and verify volume persistence.",
+      "priority": "high",
+      "risk": "high",
+      "status": "done",
+      "created_at": "2026-08-21",
+      "gates": {
+        "reviewer": true,
+        "security": true,
+        "qa": true,
+        "close": true
+      },
+      "completed_at": "2026-08-21T20:37:03Z"
     }
   ]
 }

project/docker-compose.yml

@@ -2,6 +2,7 @@ services:
   postgres:
     image: postgres:16-alpine
     container_name: mdv-dev-postgres
+    restart: unless-stopped
     environment:
       # Dev-only credentials. Public by design, never reuse them outside local dev.
       POSTGRES_USER: mdv
@@ -20,11 +21,24 @@ services:
   redis:
     image: redis:7-alpine
     container_name: mdv-dev-redis
+    restart: unless-stopped
+    command:
+      ['redis-server', '--appendonly', 'yes', '--appendfsync', 'everysec', '--save', '60', '1']
     ports:
       - '6379:6379'
     volumes:
       - mdv_redis_data:/data
+    healthcheck:
+      test: ['CMD', 'redis-cli', 'ping']
+      interval: 2s
+      timeout: 3s
+      retries: 30
 
 volumes:
   mdv_pg_data:
+    # Keep the existing Docker volume explicit so Compose project-name changes
+    # cannot silently create an empty PostgreSQL volume.
+    name: project_mdv_pg_data
   mdv_redis_data:
+    # Keep the existing Docker volume explicit and persist Redis AOF/RDB files.
+    name: project_mdv_redis_data

project/package.json

@@ -20,7 +20,8 @@
     "docker:down": "docker compose down",
     "db:seed": "node --env-file-if-exists=.env scripts/seed.cjs",
     "db:down": "node --env-file-if-exists=.env node_modules/node-pg-migrate/bin/node-pg-migrate.js down --migrations-dir migrations",
-    "db:status": "node --env-file-if-exists=.env scripts/db-status.mjs"
+    "db:status": "node --env-file-if-exists=.env scripts/db-status.mjs",
+    "infra:persistence-check": "node --env-file-if-exists=.env scripts/check-persistence.mjs"
   },
   "dependencies": {
     "@fastify/cookie": "^11.1.2",

project/scripts/check-persistence.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import pg from 'pg';
+
+const projectDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const envPath = resolve(projectDir, '.env');
+
+if (existsSync(envPath)) {
+  for (const line of readFileSync(envPath, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const value = trimmed.slice(eq + 1).trim();
+    if (key && process.env[key] === undefined) process.env[key] = value;
+  }
+}
+
+const databaseUrl = process.env.DATABASE_URL;
+if (!databaseUrl) throw new Error('DATABASE_URL not set');
+
+const recreate = process.argv.includes('--recreate');
+const token = process.env.PERSISTENCE_CHECK_TOKEN ?? `persistence-${Date.now()}`;
+const pgKey = 'infra.persistence_check';
+const redisKey = 'infra:persistence_check';
+
+function run(command, args, options = {}) {
+  return execFileSync(command, args, {
+    cwd: projectDir,
+    stdio: options.capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+    encoding: 'utf8',
+  });
+}
+
+function dockerCompose(args, options) {
+  return run('docker', ['compose', ...args], options);
+}
+
+function dockerExec(container, args, options) {
+  return run('docker', ['exec', container, ...args], options);
+}
+
+function waitForInfrastructure() {
+  const deadline = Date.now() + 60_000;
+  while (Date.now() < deadline) {
+    try {
+      dockerExec('mdv-dev-postgres', ['pg_isready', '-U', 'mdv', '-d', 'mercadodevida'], {
+        capture: true,
+      });
+      dockerExec('mdv-dev-redis', ['redis-cli', 'ping'], { capture: true });
+      return;
+    } catch {
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1000);
+    }
+  }
+  throw new Error('PostgreSQL/Redis did not become ready in 60s');
+}
+
+async function writePostgresMarker() {
+  const pool = new pg.Pool({ connectionString: databaseUrl });
+  try {
+    await pool.query(
+      `INSERT INTO app_meta (key, value, updated_at)
+       VALUES ($1, $2, now())
+       ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now()`,
+      [pgKey, token],
+    );
+  } finally {
+    await pool.end();
+  }
+}
+
+async function readPostgresMarker() {
+  const pool = new pg.Pool({ connectionString: databaseUrl });
+  try {
+    const result = await pool.query('SELECT value FROM app_meta WHERE key = $1', [pgKey]);
+    return result.rows[0]?.value;
+  } finally {
+    await pool.end();
+  }
+}
+
+function writeRedisMarker() {
+  dockerExec('mdv-dev-redis', ['redis-cli', 'SET', redisKey, token]);
+}
+
+function readRedisMarker() {
+  return dockerExec('mdv-dev-redis', ['redis-cli', 'GET', redisKey], { capture: true }).trim();
+}
+
+function printMounts() {
+  const pgMount = run(
+    'docker',
+    [
+      'inspect',
+      'mdv-dev-postgres',
+      '--format',
+      '{{range .Mounts}}{{.Name}} -> {{.Destination}}{{println}}{{end}}',
+    ],
+    { capture: true },
+  ).trim();
+  const redisMount = run(
+    'docker',
+    [
+      'inspect',
+      'mdv-dev-redis',
+      '--format',
+      '{{range .Mounts}}{{.Name}} -> {{.Destination}}{{println}}{{end}}',
+    ],
+    { capture: true },
+  ).trim();
+  const redisAppendOnly = dockerExec(
+    'mdv-dev-redis',
+    ['redis-cli', 'CONFIG', 'GET', 'appendonly'],
+    {
+      capture: true,
+    },
+  ).trim();
+  console.log(`PostgreSQL mount: ${pgMount}`);
+  console.log(`Redis mount: ${redisMount}`);
+  console.log(`Redis appendonly config:\n${redisAppendOnly}`);
+}
+
+console.log('[INFO] Starting infrastructure through docker compose...');
+dockerCompose(['up', '-d', 'postgres', 'redis']);
+waitForInfrastructure();
+printMounts();
+
+console.log(`[INFO] Writing persistence marker: ${token}`);
+await writePostgresMarker();
+writeRedisMarker();
+
+if (recreate) {
+  console.log('[INFO] Recreating PostgreSQL and Redis containers while keeping named volumes...');
+  dockerCompose(['stop', 'postgres', 'redis']);
+  dockerCompose(['rm', '-f', 'postgres', 'redis']);
+  dockerCompose(['up', '-d', 'postgres', 'redis']);
+} else {
+  console.log('[INFO] Restarting PostgreSQL and Redis containers...');
+  dockerCompose(['restart', 'postgres', 'redis']);
+}
+waitForInfrastructure();
+printMounts();
+
+const pgValue = await readPostgresMarker();
+const redisValue = readRedisMarker();
+if (pgValue !== token) {
+  throw new Error(`PostgreSQL marker mismatch: expected ${token}, got ${pgValue ?? '<missing>'}`);
+}
+if (redisValue !== token) {
+  throw new Error(`Redis marker mismatch: expected ${token}, got ${redisValue || '<missing>'}`);
+}
+
+console.log('[OK] PostgreSQL and Redis persistence verified');

project/scripts/monolith.sh

@@ -165,21 +165,21 @@ start_infrastructure() {
   command -v docker >/dev/null 2>&1 || { echo '[FAIL] Docker is required' >&2; exit 1; }
   echo '[INFO] Starting PostgreSQL and Redis...'
 
-  local service container
-  for service in postgres redis; do
-    container="mdv-dev-$service"
-    if docker inspect "$container" >/dev/null 2>&1; then
-      docker start "$container" >/dev/null
-    else
-      (cd "$PROJECT_DIR" && docker compose up -d "$service")
-    fi
-  done
+  # Always go through Compose instead of plain `docker start` so changes such
+  # as Redis AOF or explicit volume names are reconciled without losing named
+  # volumes. Compose recreates containers when needed but keeps
+  # project_mdv_pg_data/project_mdv_redis_data attached.
+  (cd "$PROJECT_DIR" && docker compose up -d postgres redis)
 
   local deadline=$((SECONDS + 60))
   until docker exec mdv-dev-postgres pg_isready -U mdv -d mercadodevida >/dev/null 2>&1; do
     (( SECONDS < deadline )) || { echo '[FAIL] PostgreSQL did not become ready' >&2; exit 1; }
     sleep 1
   done
+  until docker exec mdv-dev-redis redis-cli ping >/dev/null 2>&1; do
+    (( SECONDS < deadline )) || { echo '[FAIL] Redis did not become ready' >&2; exit 1; }
+    sleep 1
+  done
 }
 
 install_dependencies() {

work/artifacts/F-155/implementer.md

@@ -0,0 +1,65 @@
+# F-155 — Implementer evidence
+
+## Cambios
+
+### `project/docker-compose.yml`
+
+- PostgreSQL y Redis ahora tienen `restart: unless-stopped`.
+- Los volúmenes quedan con nombre explícito para no depender del nombre de proyecto de Docker Compose:
+  - PostgreSQL: `project_mdv_pg_data`
+  - Redis: `project_mdv_redis_data`
+- Se conservaron los nombres existentes para no apartar/perder la DB activa.
+- Redis ahora arranca con persistencia AOF:
+  - `--appendonly yes`
+  - `--appendfsync everysec`
+  - `--save 60 1`
+- Redis tiene healthcheck `redis-cli ping`.
+
+### `project/scripts/monolith.sh`
+
+- `start_infrastructure()` ya no hace `docker start` directo de contenedores existentes.
+- Ahora siempre usa `docker compose up -d postgres redis`, lo que permite reconciliar cambios de configuración sin perder volúmenes nombrados.
+- Espera readiness de PostgreSQL y Redis.
+
+### `project/scripts/check-persistence.mjs`
+
+Nuevo check operacional:
+
+- levanta infraestructura con Compose;
+- escribe marcador en `app_meta` de PostgreSQL;
+- escribe marcador en Redis;
+- reinicia o recrea contenedores manteniendo volúmenes;
+- comprueba que ambos marcadores siguen;
+- muestra mounts reales y `appendonly` de Redis.
+
+### `project/package.json`
+
+Nuevo script:
+
+```bash
+npm run infra:persistence-check
+npm run infra:persistence-check -- --recreate
+```
+
+## Verificación
+
+```text
+npm run infra:persistence-check -- --recreate  ✅
+npm run infra:persistence-check               ✅
+docker compose config                         ✅
+monolith prod status                          ✅ backend/admin/frontend/storefront 200
+DB products después de recrear contenedores   ✅ 12
+DB backoffice users después de recrear         ✅ 1
+Redis appendonly                              ✅ yes
+npm run build                                 ✅
+npm test                                      ✅ 191 passed / 56 skipped
+eslint check-persistence.mjs                  ✅
+prettier docker-compose/package/check script  ✅
+verify.sh                                     ✅
+git diff --check                              ✅
+```
+
+## Notas
+
+- No se han cambiado los datos actuales: al usar los nombres existentes `project_mdv_pg_data` y `project_mdv_redis_data`, la DB actual sigue montada.
+- Hay imágenes `uploads` untracked preexistentes en frontend/storefront; no pertenecen a F-155 y no se incluyen.

work/artifacts/F-155/leader-close.json

@@ -0,0 +1,21 @@
+{
+  "feature_id": "F-155",
+  "agent": "leader",
+  "verdict": "APPROVED",
+  "summary": "F-155 cerrado: PostgreSQL y Redis usan volúmenes Docker explícitos existentes, Redis tiene AOF/RDB, monolith reconcilia infra con Compose y existe un check reproducible de persistencia.",
+  "checks": [
+    "reviewer.json APPROVED",
+    "security.json APPROVED",
+    "qa.json APPROVED",
+    "npm run infra:persistence-check -- --recreate OK",
+    "npm run infra:persistence-check OK",
+    "docker compose config OK",
+    "monolith prod status OK",
+    "npm run build OK",
+    "npm test OK",
+    "verify.sh OK"
+  ],
+  "commit_message": "fix(F-155): persist PostgreSQL and Redis volumes",
+  "next_step": "Continue with F-152 email notifications",
+  "closed_at": "2026-08-21T20:37:10Z"
+}

work/artifacts/F-155/qa.json

@@ -0,0 +1,16 @@
+{
+  "feature_id": "F-155",
+  "agent": "qa",
+  "stage": "qa_gate",
+  "verdict": "APPROVED",
+  "summary": "Persistencia probada con restart y con recreación de contenedores. Los datos de PostgreSQL y Redis sobreviven, y la aplicación sigue sirviendo tras la operación.",
+  "acceptance_traceability": [
+    {"criterion":"PostgreSQL persiste tras recrear contenedor","ok":true,"evidence":"app_meta infra.persistence_check conserva token tras docker compose rm/up"},
+    {"criterion":"Redis persiste tras recrear contenedor","ok":true,"evidence":"redis GET infra:persistence_check conserva token tras rm/up; appendonly=yes"},
+    {"criterion":"Volúmenes correctos","ok":true,"evidence":"PostgreSQL mount project_mdv_pg_data; Redis mount project_mdv_redis_data"},
+    {"criterion":"Servicios siguen arriba","ok":true,"evidence":"monolith prod status: backend/admin/frontend/storefront HTTP 200"},
+    {"criterion":"Datos existentes siguen disponibles","ok":true,"evidence":"DB products=12, backoffice_users=1; admin proxy login y catalog products OK"},
+    {"criterion":"Regression checks","ok":true,"evidence":"docker compose config, npm run build, npm test, eslint/prettier touched files, verify.sh, git diff --check"}
+  ],
+  "issues": []
+}

work/artifacts/F-155/reviewer.json

@@ -0,0 +1,16 @@
+{
+  "feature_id": "F-155",
+  "agent": "reviewer",
+  "stage": "review_gate",
+  "verdict": "APPROVED",
+  "summary": "La persistencia de PostgreSQL y Redis queda endurecida sin apartar los volúmenes existentes. El check operacional prueba reinicio y recreación de contenedores conservando datos.",
+  "checks": [
+    {"item":"No se cambia a un volumen vacío","ok":true,"evidence":"docker-compose fija project_mdv_pg_data y project_mdv_redis_data, que son los mounts actuales"},
+    {"item":"Redis persistente","ok":true,"evidence":"Redis arranca con appendonly=yes y RDB save 60 1"},
+    {"item":"Compose reconcilia configuración","ok":true,"evidence":"monolith.sh usa docker compose up -d postgres redis en vez de docker start directo"},
+    {"item":"Recreación verificada","ok":true,"evidence":"npm run infra:persistence-check -- --recreate mantiene marcadores PG/Redis"},
+    {"item":"Servicios regresión","ok":true,"evidence":"backend/admin/frontend/storefront 200 tras recrear infra"},
+    {"item":"Build/test","ok":true,"evidence":"npm run build OK; npm test 191 passed/56 skipped"}
+  ],
+  "issues": []
+}

work/artifacts/F-155/security.json

@@ -0,0 +1,16 @@
+{
+  "feature_id": "F-155",
+  "agent": "security",
+  "stage": "security_gate",
+  "verdict": "APPROVED",
+  "summary": "El cambio no introduce credenciales nuevas ni exposición externa adicional. Redis y PostgreSQL siguen limitados a la configuración dev existente; la persistencia se limita a volúmenes locales nombrados.",
+  "checks": [
+    {"item":"No nuevas credenciales","ok":true,"evidence":"docker-compose mantiene las credenciales dev ya existentes"},
+    {"item":"Persistencia local controlada","ok":true,"evidence":"volúmenes Docker nombrados, sin bind mounts a rutas sensibles"},
+    {"item":"Redis AOF sin secretos nuevos","ok":true,"evidence":"solo activa durabilidad appendonly; no cambia auth/red"},
+    {"item":"Script de check seguro","ok":true,"evidence":"usa app_meta y una clave Redis técnica; no imprime secretos"},
+    {"item":"No borra volúmenes","ok":true,"evidence":"check --recreate elimina contenedores, no volúmenes"}
+  ],
+  "issues": [],
+  "notes": "Los puertos 5432/6379 siguen publicados como antes para dev local. Endurecimiento de red/auth de Redis queda fuera de este fix si se requiere producción real."
+}

work/runtime-status.json

@@ -1,11 +1,47 @@
 {
-  "feature_id": null,
-  "stage": "idle",
+  "feature_id": "F-155",
+  "stage": "close",
   "agent": "leader",
-  "action": "Sin ejecución activa",
-  "state": "waiting",
+  "action": "Close: PostgreSQL and Redis persistence hardened and verified",
+  "state": "running",
   "next_agent": "leader",
-  "waiting_for": "Seleccionar una feature pending y actualizar este estado",
-  "updated_at": "2026-08-21T20:14:32Z",
-  "timeline": []
+  "waiting_for": "commit",
+  "updated_at": "2026-08-21T20:36:50Z",
+  "timeline": [
+    {
+      "ts": "2026-08-21T20:33:32Z",
+      "agent": "implementer",
+      "stage": "build",
+      "state": "running",
+      "message": "Implement: harden PostgreSQL and Redis persistence and verify restart/container recreation"
+    },
+    {
+      "ts": "2026-08-21T20:36:10Z",
+      "agent": "reviewer",
+      "stage": "review_gate",
+      "state": "running",
+      "message": "Review: Docker volume names, Redis AOF and persistence check verified"
+    },
+    {
+      "ts": "2026-08-21T20:36:23Z",
+      "agent": "security",
+      "stage": "security_gate",
+      "state": "running",
+      "message": "Security: persistence does not expose new credentials; Redis/PG local dev volumes reviewed"
+    },
+    {
+      "ts": "2026-08-21T20:36:34Z",
+      "agent": "qa",
+      "stage": "qa_gate",
+      "state": "running",
+      "message": "QA: restart and recreate persistence, services and regression checks"
+    },
+    {
+      "ts": "2026-08-21T20:36:50Z",
+      "agent": "leader",
+      "stage": "close",
+      "state": "running",
+      "message": "Close: PostgreSQL and Redis persistence hardened and verified"
+    }
+  ]
 }