// Solicitudes de personal + Reclutamiento — store único compartido
// Fuente de verdad: vault/04-Modulos/M07-Reclutamiento/Requerimiento-Funcional-Seleccion-y-Reclutamiento.md
// y HU-REC-001. Sustituye los tres modelos de "solicitud" que coexistían
// (window.OrgDataStore en data-providers.jsx, window.SOLICITUDES en ats.jsx y
// la copia local de solicitudes-personal.jsx) por un único store en memoria,
// igual que window.OrgDataStore para Organigrama — no se introduce Redux ni
// arquitectura nueva.
//
// Convenciones de prototipo (donde el Vault deja la decisión abierta):
// - "Mi equipo" se resuelve desde un mini-organigrama propio de este store
//   (EQUIPO_DIRECTO_SEED), curado por jefatura, en vez de usar el organigrama
//   completo de orgchart-data.jsx (que no modela ocupantes reales por cargo).
//   Cada entrada es una posición real con código, cargo, planta y ocupante.
// - Los KPI de headcount se calculan sobre ese mismo arreglo (no son cifras
//   fijas): aprobado = posiciones activas del alcance; real = ocupadas.
// - `window.OrgDataStore.getPosiciones()` devuelve el arreglo compartido de
//   posiciones del organigrama aprobado (data-providers.jsx); esta capa NO
//   lo duplica: cuando una ampliación crea posiciones nuevas, las agrega ahí
//   mismo (mismo arreglo, misma referencia) para que Organigrama y Empleados
//   sigan viendo una sola verdad.
// - El estado de posición "reservada" no existía en ese modelo; se añade
//   aquí como tercer valor de estadoOcupacion (junto a vacante/ocupada) —
//   compatible con los filtros existentes de data-providers.jsx, que solo
//   comprueban 'vacante' u 'ocupada' explícitamente.
const { useState: _rec_useState } = React;

// ─── Catálogo cerrado de bloques (M13 — Gestor de Flujos) ─────────────────
// Reclutamiento NO define otro motor: reutiliza el catálogo cerrado de once
// bloques. Aquí solo se referencian por nombre para construir instancias de
// plantilla por tipo de solicitud.
const BLOQUES_RECLUTAMIENTO = {
  INICIO: 'Inicio y formulario',
  REVISION: 'Revisión y validación',
  APROBACION: 'Aprobación',
  FIRMA: 'Firma de documento',
  DATOS: 'Recolección o actualización de datos',
  TAREA: 'Tarea operativa',
  CONDICION: 'Decisión condicional',
  NOTIFICACION: 'Notificación interna',
  ACCION: 'Acción interna del sistema',
  RELACIONADA: 'Generación de solicitudes relacionadas',
  CIERRE: 'Cierre y resultado',
};

// ─── Los 12 tipos confirmados en el Vault (§21 del requerimiento) ─────────
// abreReclutamiento / aumentaHeadcount / esCoberturaTemporal / esDirecta son
// los únicos comportamientos que el Vault fija explícitamente por tipo; el
// resto de campos de cada formulario sigue pendiente de refinamiento y se
// representa aquí solo con ejemplos demostrativos (marcados como tal en la
// UI), no como requerimiento definitivo.
const TIPOS_SOLICITUD = [
  { id: 'reemplazo_vacante', categoria: 'Reemplazos', nombre: 'Reemplazo por vacante', abreReclutamiento: true, aumentaHeadcount: false, esCoberturaTemporal: false, esDirecta: false, requiereColaborador: true },
  { id: 'reemplazo_vacaciones', categoria: 'Reemplazos', nombre: 'Reemplazo por vacaciones', abreReclutamiento: true, aumentaHeadcount: false, esCoberturaTemporal: true, esDirecta: false, requiereColaborador: true },
  { id: 'reemplazo_incapacidad', categoria: 'Reemplazos', nombre: 'Reemplazo por incapacidad', abreReclutamiento: true, aumentaHeadcount: false, esCoberturaTemporal: true, esDirecta: false, requiereColaborador: true },
  { id: 'reemplazo_aumento_salarial', categoria: 'Reemplazos', nombre: 'Reemplazo con aumento de condiciones salariales', abreReclutamiento: true, aumentaHeadcount: false, esCoberturaTemporal: false, esDirecta: false, requiereColaborador: true, requiereRevisionSalarial: true },
  { id: 'nueva_operacion', categoria: 'Nueva operación', nombre: 'Nueva operación', abreReclutamiento: true, aumentaHeadcount: true, esCoberturaTemporal: false, esDirecta: false, requiereColaborador: false },
  { id: 'ampliacion_cargo_nuevo', categoria: 'Ampliación de nómina', nombre: 'Ampliación de nómina · Cargo nuevo', abreReclutamiento: true, aumentaHeadcount: true, esCoberturaTemporal: false, esDirecta: false, requiereColaborador: false, requiereCargoNuevo: true },
  { id: 'ampliacion_cargo_existente', categoria: 'Ampliación de nómina', nombre: 'Ampliación de nómina · Cargo existente', abreReclutamiento: true, aumentaHeadcount: true, esCoberturaTemporal: false, esDirecta: false, requiereColaborador: false },
  { id: 'cambio_centro_costo', categoria: 'Solicitudes varias', nombre: 'Cambio de centro de costo', abreReclutamiento: false, aumentaHeadcount: false, esCoberturaTemporal: false, esDirecta: false, requiereColaborador: true },
  { id: 'aumento_salarial', categoria: 'Solicitudes varias', nombre: 'Aumento de condiciones salariales', abreReclutamiento: false, aumentaHeadcount: false, esCoberturaTemporal: false, esDirecta: false, requiereColaborador: true },
  { id: 'traslado_vacante', categoria: 'Solicitudes varias', nombre: 'Traslado a vacante existente', abreReclutamiento: 'condicional', aumentaHeadcount: false, esCoberturaTemporal: false, esDirecta: false, requiereColaborador: true },
  { id: 'contratacion_directa', categoria: 'Contratación directa', nombre: 'Contratación directa', abreReclutamiento: false, aumentaHeadcount: false, esCoberturaTemporal: false, esDirecta: true, requiereColaborador: false },
  { id: 'paso_directo_compania', categoria: 'Contratación directa', nombre: 'Paso directo por compañía', abreReclutamiento: false, aumentaHeadcount: false, esCoberturaTemporal: false, esDirecta: true, requiereColaborador: true },
];
const getTipoSolicitud = (id) => TIPOS_SOLICITUD.find(t => t.id === id);

// ─── Plantillas por tipo (instancias del Gestor de Flujos) ────────────────
// Los responsables son ejemplos demostrativos (nombres reutilizados de
// Organización). "Apertura" y "RQ Temporales" del Excel histórico NO
// aparecen aquí como bloques — según el requerimiento (§10.3) se reemplazan
// por la acción de dominio "Iniciar reclutamiento" y por la sección
// operativa de Temporales/RQ dentro de la solicitud activa.
const PLANTILLA_ESTANDAR_V1 = [
  { nombre: 'Solicitud de personal', bloque: BLOQUES_RECLUTAMIENTO.INICIO, responsable: 'Solicitante' },
  { nombre: 'Revisión de Gestión Humana', bloque: BLOQUES_RECLUTAMIENTO.REVISION, responsable: 'Carolina Restrepo S. · Jefe de RRHH' },
  { nombre: 'Autorización del director del proceso', bloque: BLOQUES_RECLUTAMIENTO.APROBACION, responsable: 'Mauricio Andrés Salcedo Vargas · Director de Aprovechamiento' },
  { nombre: 'Cierre y resultado', bloque: BLOQUES_RECLUTAMIENTO.CIERRE, responsable: 'Sistema' },
];
const PLANTILLA_AMPLIACION_V2 = [
  { nombre: 'Solicitud de personal', bloque: BLOQUES_RECLUTAMIENTO.INICIO, responsable: 'Solicitante' },
  { nombre: 'Revisar escala salarial', bloque: BLOQUES_RECLUTAMIENTO.REVISION, responsable: 'Adriana Marcela Torres Villalba · Directora de Gestión Humana' },
  { nombre: 'Autorización del director del proceso', bloque: BLOQUES_RECLUTAMIENTO.APROBACION, responsable: 'Mauricio Andrés Salcedo Vargas · Director de Aprovechamiento' },
  { nombre: 'Autorización del director nacional', bloque: BLOQUES_RECLUTAMIENTO.APROBACION, responsable: 'Claudia Patricia Reyes Londoño · Directora Nacional de Operaciones' },
  { nombre: 'Autorización de la gerencia del proceso', bloque: BLOQUES_RECLUTAMIENTO.APROBACION, responsable: 'Felipe Santiago Rengifo Ortiz · Gerente COO' },
  { nombre: 'Autorización del CEO', bloque: BLOQUES_RECLUTAMIENTO.APROBACION, responsable: 'Diego · CEO' },
  { nombre: 'Creación de la posición aprobada', bloque: BLOQUES_RECLUTAMIENTO.ACCION, responsable: 'Sistema' },
  { nombre: 'Alerta a Sistemas', bloque: BLOQUES_RECLUTAMIENTO.NOTIFICACION, responsable: 'Coordinador Nacional de Tecnología' },
  { nombre: 'Cierre y resultado', bloque: BLOQUES_RECLUTAMIENTO.CIERRE, responsable: 'Sistema' },
];
const PLANTILLA_REVISION_SALARIAL_V1 = [
  { nombre: 'Solicitud de personal', bloque: BLOQUES_RECLUTAMIENTO.INICIO, responsable: 'Solicitante' },
  { nombre: 'Revisar escala salarial', bloque: BLOQUES_RECLUTAMIENTO.REVISION, responsable: 'Adriana Marcela Torres Villalba · Directora de Gestión Humana' },
  { nombre: 'Autorización del director del proceso', bloque: BLOQUES_RECLUTAMIENTO.APROBACION, responsable: 'Mauricio Andrés Salcedo Vargas · Director de Aprovechamiento' },
  { nombre: 'Autorización de la gerencia del proceso', bloque: BLOQUES_RECLUTAMIENTO.APROBACION, responsable: 'Felipe Santiago Rengifo Ortiz · Gerente COO' },
  { nombre: 'Cierre y resultado', bloque: BLOQUES_RECLUTAMIENTO.CIERRE, responsable: 'Sistema' },
];
const PLANTILLA_SIN_PIPELINE_V1 = [
  { nombre: 'Solicitud de personal', bloque: BLOQUES_RECLUTAMIENTO.INICIO, responsable: 'Solicitante' },
  { nombre: 'Actualizar datos administrativos', bloque: BLOQUES_RECLUTAMIENTO.DATOS, responsable: 'Analista de Gestión Humana' },
  { nombre: 'Autorización del director del proceso', bloque: BLOQUES_RECLUTAMIENTO.APROBACION, responsable: 'Mauricio Andrés Salcedo Vargas · Director de Aprovechamiento' },
  { nombre: 'Cierre y resultado', bloque: BLOQUES_RECLUTAMIENTO.CIERRE, responsable: 'Sistema' },
];
const PLANTILLA_DIRECTA_V1 = [
  { nombre: 'Solicitud de personal', bloque: BLOQUES_RECLUTAMIENTO.INICIO, responsable: 'Solicitante' },
  { nombre: 'Autorización del director del proceso', bloque: BLOQUES_RECLUTAMIENTO.APROBACION, responsable: 'Mauricio Andrés Salcedo Vargas · Director de Aprovechamiento' },
  { nombre: 'Firma de aceptación de oferta', bloque: BLOQUES_RECLUTAMIENTO.FIRMA, responsable: 'Candidato' },
  { nombre: 'Cierre y resultado', bloque: BLOQUES_RECLUTAMIENTO.CIERRE, responsable: 'Sistema' },
];

const PLANTILLA_POR_TIPO = {
  reemplazo_vacante: { id: 'WFT-REC-01', version: 'v3', etapas: PLANTILLA_ESTANDAR_V1 },
  reemplazo_vacaciones: { id: 'WFT-REC-02', version: 'v2', etapas: PLANTILLA_ESTANDAR_V1 },
  reemplazo_incapacidad: { id: 'WFT-REC-02', version: 'v2', etapas: PLANTILLA_ESTANDAR_V1 },
  reemplazo_aumento_salarial: { id: 'WFT-REC-03', version: 'v1', etapas: PLANTILLA_REVISION_SALARIAL_V1 },
  nueva_operacion: { id: 'WFT-REC-04', version: 'v1', etapas: PLANTILLA_AMPLIACION_V2 },
  ampliacion_cargo_nuevo: { id: 'WFT-REC-05', version: 'v1', etapas: PLANTILLA_AMPLIACION_V2 },
  ampliacion_cargo_existente: { id: 'WFT-REC-05', version: 'v2', etapas: PLANTILLA_AMPLIACION_V2 },
  cambio_centro_costo: { id: 'WFT-REC-06', version: 'v1', etapas: PLANTILLA_SIN_PIPELINE_V1 },
  aumento_salarial: { id: 'WFT-REC-03', version: 'v1', etapas: PLANTILLA_REVISION_SALARIAL_V1 },
  traslado_vacante: { id: 'WFT-REC-07', version: 'v1', etapas: PLANTILLA_SIN_PIPELINE_V1 },
  contratacion_directa: { id: 'WFT-REC-08', version: 'v1', etapas: PLANTILLA_DIRECTA_V1 },
  paso_directo_compania: { id: 'WFT-REC-08', version: 'v1', etapas: PLANTILLA_DIRECTA_V1 },
};

// ─── Pipeline de selección — 7 columnas visibles ──────────────────────
// "Contratación" representa la ruta directa operada por la contratadora.
// "Confirmación temporal" representa la ruta donde la empresa temporal
// realiza exámenes y contratación por fuera de SOMOS y GH confirma el
// resultado. La fuente del candidato no determina ninguna de las dos rutas.
const ETAPAS_PIPELINE = [
  { id: 'postulados', nombre: 'Postulados' },
  { id: 'entrevista_gh', nombre: 'Entrevista GH' },
  { id: 'entrevista_jefe', nombre: 'Entrevista jefe' },
  { id: 'pruebas', nombre: 'Pruebas de conocimiento' },
  { id: 'estudios', nombre: 'Estudios' },
  { id: 'contratacion', nombre: 'Contratación' },
  { id: 'confirmacion_temporal', nombre: 'Confirmación temporal' },
];
const idxEtapaPipeline = (id) => ETAPAS_PIPELINE.findIndex(e => e.id === id);

const FUENTES_POSTULACION = [
  { id: 'temporal', label: 'Temporal' },
  { id: 'referido', label: 'Referido' },
  { id: 'directa', label: 'Postulación directa' },
  { id: 'portal', label: 'Portal o bolsa de empleo' },
  { id: 'manual', label: 'Registro manual' },
  { id: 'otra', label: 'Otra fuente autorizada' },
];

// Temporales activas configuradas (F10/F22 abiertos: catálogo definitivo de
// temporales y empleador legal sigue pendiente — se listan aquí solo como
// ejemplo demostrativo de destinatarios de "Iniciar reclutamiento").
const TEMPORALES_ACTIVAS = [
  { nombre: 'Jiro', correo: 'reclutamiento@jiro.com.co' },
  { nombre: 'G.O.', correo: 'seleccion@gohumancapital.co' },
  { nombre: 'Soluciones Inmediatas', correo: 'rq@solucionesinmediatas.co' },
];

// ─── Mini-organigrama de "Mi equipo" por jefatura ──────────────────────────
// Convención de prototipo documentada arriba. Cada posición referencia, si
// aplica, un empleado real de window.EMPLOYEES (empleado-list.jsx).
let _teamSeq = 0;
const _posEquipo = (jefeEmpId, over) => ({
  codigo: `POS-EQ-${jefeEmpId.slice(1)}-${String(++_teamSeq).padStart(2, '0')}`,
  jefeEmpId,
  estadoEstructural: 'activa',
  estadoOcupacion: 'vacante',
  empleadoOcupanteId: null,
  sociedad: 'ECOENTORNO',
  area: 'Aprovechamiento',
  centroCosto: 'CC-APR-006',
  salarioMinimo: 1850000,
  rodamiento: 180000,
  horarioTrabajo: 'Lunes a sábado · turnos rotativos',
  ...over,
});

const EQUIPO_DIRECTO_SEED = [
  // ── Luis Miguel Marín (E0067) · Líder de Aprovechamiento ──
  _posEquipo('E0067', { cargo: 'Op. Aprovechamiento', planta: 'Planta Yumbo', estadoOcupacion: 'ocupada', empleadoOcupanteId: 'E0198', situacion: 'En incapacidad' }),
  _posEquipo('E0067', { cargo: 'Aux. Aprovechamiento', planta: 'Planta Yumbo', estadoOcupacion: 'ocupada', empleadoOcupanteId: 'E0142', situacion: 'En ejercicio' }),
  _posEquipo('E0067', { cargo: 'Aux. Aprovechamiento', planta: 'Planta Cali', estadoOcupacion: 'ocupada', empleadoOcupanteId: 'E9001', situacion: 'En vacaciones' }),
  _posEquipo('E0067', { cargo: 'Op. Aprovechamiento', planta: 'Planta Yumbo', estadoOcupacion: 'vacante' }),
  _posEquipo('E0067', { cargo: 'Aux. Aprovechamiento', planta: 'Planta Yumbo', estadoOcupacion: 'vacante', salarioMinimo: 1750000, rodamiento: 140000 }),
  _posEquipo('E0067', { cargo: 'Operario de Clasificación', planta: 'Planta Cali', estadoOcupacion: 'vacante', sociedad: 'ASEI', area: 'Operaciones', centroCosto: 'CC-OP-010', salarioMinimo: 1800000, rodamiento: 120000 }),
  // ── Carolina Restrepo (E0023) · Jefe de RRHH ──
  _posEquipo('E0023', { cargo: 'Aux. Recursos Humanos', planta: 'Cali', estadoOcupacion: 'ocupada', empleadoOcupanteId: 'E0094', situacion: 'En ejercicio', sociedad: 'ASEI', area: 'Gestión Humana', centroCosto: 'CC-GH-001', salarioMinimo: 2100000, rodamiento: 0, horarioTrabajo: 'Lunes a viernes · 8:00 a. m. a 5:00 p. m.' }),
  _posEquipo('E0023', { cargo: 'Analista de Bienestar', planta: 'Cali', estadoOcupacion: 'ocupada', empleadoOcupanteId: 'E9002', situacion: 'En ejercicio', sociedad: 'ASEI', area: 'Gestión Humana', centroCosto: 'CC-GH-001', salarioMinimo: 3200000, rodamiento: 0, horarioTrabajo: 'Lunes a viernes · 8:00 a. m. a 5:00 p. m.' }),
  _posEquipo('E0023', { cargo: 'Aux. Recursos Humanos', planta: 'Barranquilla', estadoOcupacion: 'vacante', sociedad: 'ASEI', area: 'Gestión Humana', centroCosto: 'CC-GH-002', salarioMinimo: 2100000, rodamiento: 0, horarioTrabajo: 'Lunes a viernes · 8:00 a. m. a 5:00 p. m.' }),
];

// Empleados sintéticos que completan el equipo directo (no existían en
// EMPLOYEES) — mismas convenciones de datos ficticios realistas de Atica.
const EMPLEADOS_EQUIPO_EXTRA = [
  { id: 'E9001', initials: 'VR', name: 'Valentina Ríos Cárdenas', doc: 'CC 1.098.774.220', role: 'Aux. Aprovechamiento', area: 'Aprovechamiento', site: 'Cali', contract: 'Fijo', hire: '04/02/2025', status: 'activo', country: 'CO' },
  { id: 'E9002', initials: 'PG', name: 'Patricia Gómez Lara', doc: 'CC 43.221.998', role: 'Analista de Bienestar', area: 'Administración', site: 'Cali', contract: 'Indefinido', hire: '11/03/2022', status: 'activo', country: 'CO' },
  { id: 'E9003', initials: 'JAG', name: 'Jhon Alexánder Gómez', doc: 'CC 1.094.556.221', role: 'Op. Aprovechamiento', area: 'Aprovechamiento', site: 'Cali', contract: 'Indefinido', hire: '02/06/2021', status: 'inactivo', country: 'CO', fechaRetiro: '30/06/2026', motivoRetiro: 'Renuncia voluntaria' },
];
if (typeof window !== 'undefined') {
  window.EMPLOYEES = window.EMPLOYEES || [];
  EMPLEADOS_EQUIPO_EXTRA.forEach(e => { if (!window.EMPLOYEES.some(x => x.id === e.id)) window.EMPLOYEES.push(e); });
}

// Histórico de personas que estuvieron directamente a cargo (para "Ver
// inactivos") — puede incluir personas que ya no están en la posición actual
// del jefe, aunque su registro de empleado siga existiendo en otro estado.
const EQUIPO_HISTORICO_SEED = [
  { jefeEmpId: 'E0067', empleadoId: 'E9003', cargo: 'Op. Aprovechamiento', planta: 'Planta Yumbo', fechaSalida: '30/06/2026', motivo: 'Renuncia voluntaria' },
  { jefeEmpId: 'E0023', empleadoId: 'E0011', cargo: 'Operario de Clasificación', planta: 'Cali', fechaSalida: '14/07/2026', motivo: 'Terminación de contrato' },
];

const getEmpleado = (id) => (window.EMPLOYEES || []).find(e => e.id === id);

// Busca una posición por código tanto en el mini-organigrama de equipo
// directo como en el organigrama aprobado general (data-providers.jsx) —
// una solicitud puede referenciar posiciones de cualquiera de los dos.
const getPosicionPorCodigo = (codigo) => EQUIPO_DIRECTO_SEED.find(p => p.codigo === codigo)
  || (window.OrgDataStore && window.OrgDataStore.getPosicionByCodigo(codigo)) || null;

const getEquipoDirecto = (jefeEmpId) => {
  const activos = EQUIPO_DIRECTO_SEED
    .filter(p => p.jefeEmpId === jefeEmpId && p.estadoOcupacion === 'ocupada')
    .map(p => ({ posicion: p, empleado: getEmpleado(p.empleadoOcupanteId) }))
    .filter(x => x.empleado);
  const inactivos = EQUIPO_HISTORICO_SEED
    .filter(h => h.jefeEmpId === jefeEmpId)
    .map(h => ({ historico: h, empleado: getEmpleado(h.empleadoId) }))
    .filter(x => x.empleado);
  return { activos, inactivos };
};

// Posiciones estructurales a cargo del jefe, ocupadas o vacantes. Se usa en
// solicitudes de reemplazo: la selección recae sobre la posición y no sobre
// la persona, porque una vacante también puede requerir cobertura.
const getPosicionesPorJefe = (jefeEmpId) => EQUIPO_DIRECTO_SEED
  .filter(p => p.jefeEmpId === jefeEmpId && p.estadoEstructural === 'activa')
  .map(posicion => ({ posicion, empleado: posicion.empleadoOcupanteId ? getEmpleado(posicion.empleadoOcupanteId) : null }));

// KPI calculados sobre las posiciones del alcance (no cifras decorativas).
// Supuesto de prototipo: una posición "reservada" (candidato en Contratación)
// no cuenta como aprobada adicional ni como ocupada — el Vault no cierra esta
// convención para los indicadores de Mi equipo, así que se muestra aparte.
const getHeadcountJefe = (jefeEmpId) => {
  const posiciones = EQUIPO_DIRECTO_SEED.filter(p => p.jefeEmpId === jefeEmpId && p.estadoEstructural === 'activa');
  const aprobado = posiciones.length;
  const real = posiciones.filter(p => p.estadoOcupacion === 'ocupada').length;
  const reservadas = posiciones.filter(p => p.estadoOcupacion === 'reservada').length;
  const vacantes = aprobado - real - reservadas;
  const pct = aprobado > 0 ? Math.round((real / aprobado) * 100) : 0;
  return { aprobado, real, vacantes, reservadas, pct };
};

// Agrega una posición nueva al equipo de un jefe (ampliación aprobada). Un
// reemplazo NUNCA llama esta función — reutiliza la posición existente.
const agregarPosicionEquipo = (jefeEmpId, cargo, planta) => {
  const pos = _posEquipo(jefeEmpId, { cargo, planta, estadoOcupacion: 'vacante' });
  EQUIPO_DIRECTO_SEED.push(pos);
  return pos;
};

// ═══════════════════════════════════════════════════════════════════════
// SOLICITUDES — estados generales exactos del Vault (§11). No existe "En
// creación": esa pestaña de Reclutamiento muestra casos operativos mientras
// la solicitud permanece "En contratación".
// ═══════════════════════════════════════════════════════════════════════

const ESTADOS_SOLICITUD = {
  pendiente: 'Pendiente',
  en_aprobacion: 'En aprobación',
  devuelta: 'Devuelta',
  lista_reclutamiento: 'Lista para reclutamiento',
  en_reclutamiento: 'En reclutamiento',
  en_contratacion: 'En contratación',
  finalizada: 'Finalizada',
  rechazada: 'Rechazada',
  cancelada: 'Cancelada',
};

const SOLICITUDES_STORE = [];
const POSTULACIONES_STORE = [];
const CANDIDATOS_STORE = [];
const CASOS_CONTRATACION_STORE = []; // Creación de personal
const CORREOS_SIMULADOS_STORE = []; // Bandeja demostrativa; nunca envía correo real

let _solSeq = 200;
const _nextSolicitudId = (tipo) => {
  const t = getTipoSolicitud(tipo);
  const prefijo = t && t.esDirecta ? 'DIR' : (t && t.aumentaHeadcount ? 'AMP' : (t && t.esCoberturaTemporal ? 'COB' : 'SOL'));
  _solSeq += 1;
  return `${prefijo}-2026-${_solSeq}`;
};

const _hoy = () => '28/09/2026';
const _ahora = () => '28/09/2026 ' + `${8 + Math.floor(Math.random() * 9)}:${String(Math.floor(Math.random() * 60)).padStart(2, '0')}`;

// Instancia la plantilla vigente del tipo — versión fija al crear (RN-CFG /
// ADR-0029: no hay borradores, guardar crea versión vigente; la instancia
// conserva la que existía al momento de crearse).
const _instanciarPlantilla = (tipoId) => {
  const plantilla = PLANTILLA_POR_TIPO[tipoId];
  const etapas = plantilla.etapas.map((e, i) => ({
    ...e,
    id: `ET-${Date.now()}-${i}`,
    responsableEfectivo: null,
    estado: i === 0 ? 'completada' : (i === 1 ? 'activa' : 'pendiente'),
    fechaActivacion: i <= 1 ? _hoy() : null,
    fechaFinalizacion: i === 0 ? _hoy() : null,
    resultado: i === 0 ? 'Formulario enviado' : null,
    motivo: null,
    historialRondas: [],
  }));
  return { plantillaId: plantilla.id, plantillaVersion: plantilla.version, etapas };
};

const _historial = (solicitud, accion, detalle, actor) => {
  solicitud.historialGeneral.push({ fecha: _ahora(), accion, detalle, actor: actor || solicitud.solicitanteNombre });
};

// ── Creación de solicitudes ────────────────────────────────────────────
// input: { tipoId, jefeEmpId, jefeNombre, sociedad, cargoId, cargoNombre,
//          cantidadCupos, colaboradorAfectadoId, planta, centroCosto,
//          formulario: {...campos demostrativos...}, confidencial,
//          visibleParaEmpIds: ['E0000'] }
const crearSolicitud = (input) => {
  const tipo = getTipoSolicitud(input.tipoId);
  if (!tipo) return { error: 'Tipo de solicitud no reconocido.' };
  const esReemplazo = tipo.id.startsWith('reemplazo_');
  if (esReemplazo && !input.posicionAsociadaCodigo) {
    return { error: 'Debes seleccionar una posición a reemplazar.' };
  }
  if (!esReemplazo && tipo.requiereColaborador && !input.colaboradorAfectadoId) {
    return { error: 'Este tipo de solicitud exige seleccionar un colaborador autorizado.' };
  }

  const id = _nextSolicitudId(input.tipoId);
  const { plantillaId, plantillaVersion, etapas } = _instanciarPlantilla(input.tipoId);
  const cantidad = Math.max(1, Number(input.cantidadCupos) || 1);

  const solicitud = {
    id, tipoId: tipo.id, tipoNombre: tipo.nombre, categoria: tipo.categoria,
    jefeEmpId: input.jefeEmpId, solicitanteNombre: input.jefeNombre,
    sociedad: input.sociedad, cargoId: input.cargoId || null, cargoNombre: input.cargoNombre || '(sin cargo asociado)',
    planta: input.planta || '', centroCosto: input.centroCosto || '',
    cantidadCupos: tipo.aumentaHeadcount || tipo.id.startsWith('reemplazo') ? cantidad : 1,
    colaboradorAfectadoId: input.colaboradorAfectadoId || null,
    posicionesCodigos: [], // se llenan al aprobar (ampliación) o quedan fijas (reemplazo)
    posicionAsociadaFija: input.posicionAsociadaCodigo || null,
    fechaCreacion: _hoy(),
    plantillaId, plantillaVersion,
    estadoGeneral: 'pendiente',
    formularioInicial: input.formulario || {},
    etapas,
    temporales: TEMPORALES_ACTIVAS.map(t => ({ temporal: t.nombre, correo: t.correo, rqVigente: null, estado: 'pendiente', historial: [], envio: null })),
    confidencial: !!input.confidencial,
    visibleParaEmpIds: Array.isArray(input.visibleParaEmpIds) ? [...input.visibleParaEmpIds] : [],
    motivoCierre: null,
    historialGeneral: [],
  };

  // Reemplazo: fija de una vez la posición seleccionada, incluso cuando está
  // vacante (no aumenta headcount — reutiliza la posición existente).
  if (esReemplazo && input.posicionAsociadaCodigo) {
    solicitud.posicionesCodigos = [input.posicionAsociadaCodigo];
  } else if (tipo.requiereColaborador && input.colaboradorAfectadoId && !tipo.aumentaHeadcount) {
    const posEquipo = EQUIPO_DIRECTO_SEED.find(p => p.empleadoOcupanteId === input.colaboradorAfectadoId);
    if (posEquipo) solicitud.posicionesCodigos = [posEquipo.codigo];
  }

  _historial(solicitud, 'Solicitud creada', `${tipo.nombre} · plantilla ${plantillaId} ${plantillaVersion}`, input.jefeNombre);
  SOLICITUDES_STORE.push(solicitud);
  _recalcularEstadoPorEtapas(solicitud);
  return solicitud;
};

const _recalcularEstadoPorEtapas = (solicitud) => {
  if (['rechazada', 'cancelada', 'finalizada'].includes(solicitud.estadoGeneral)) return;
  const hayDevuelta = solicitud.etapas.some(e => e.estado === 'devuelta');
  const hayError = solicitud.etapas.some(e => e.estado === 'error');
  const todasCompletas = solicitud.etapas.every(e => e.estado === 'completada');
  if (todasCompletas) {
    solicitud.estadoGeneral = 'lista_reclutamiento';
  } else if (hayDevuelta) {
    solicitud.estadoGeneral = 'devuelta';
  } else if (hayError) {
    solicitud.estadoGeneral = 'en_aprobacion';
  } else {
    const activaIdx = solicitud.etapas.findIndex(e => e.estado === 'activa');
    solicitud.estadoGeneral = activaIdx <= 1 ? 'pendiente' : 'en_aprobacion';
  }
};

// decision: 'aprobar' | 'devolver' | 'rechazar'
const decidirEtapa = (solicitudId, decision, { actor, comentario } = {}) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  if (!s) return { error: 'La solicitud ya no existe.' };
  const idx = s.etapas.findIndex(e => e.estado === 'activa' || e.estado === 'devuelta');
  if (idx === -1) return { error: 'No hay ninguna etapa activa para decidir.' };
  const etapa = s.etapas[idx];

  if ((decision === 'devolver' || decision === 'rechazar') && !comentario) {
    return { error: 'El motivo es obligatorio para devolver o rechazar.' };
  }
  // Prohibición de autoaprobación (RN M13): el responsable no puede ser el propio solicitante.
  if (decision === 'aprobar' && etapa.bloque === BLOQUES_RECLUTAMIENTO.APROBACION && etapa.responsable === s.solicitanteNombre) {
    return { error: 'El solicitante no puede autoaprobar esta etapa.' };
  }

  etapa.responsableEfectivo = actor || etapa.responsable;
  etapa.fechaFinalizacion = _hoy();

  if (decision === 'rechazar') {
    etapa.estado = 'rechazada'; etapa.motivo = comentario;
    s.estadoGeneral = 'rechazada';
    _historial(s, 'Solicitud rechazada', comentario, actor);
    return s;
  }
  if (decision === 'devolver') {
    etapa.historialRondas.push({ ronda: etapa.historialRondas.length + 1, resultado: 'devuelta', motivo: comentario, fecha: _hoy(), actor });
    etapa.estado = 'devuelta'; etapa.motivo = comentario;
    s.estadoGeneral = 'devuelta';
    _historial(s, `Etapa "${etapa.nombre}" devuelta`, comentario, actor);
    return s;
  }

  // aprobar / continuar
  etapa.estado = 'completada'; etapa.resultado = 'Aprobado'; etapa.motivo = null;
  etapa.historialRondas.push({ ronda: etapa.historialRondas.length + 1, resultado: 'aprobada', fecha: _hoy(), actor });
  const next = s.etapas[idx + 1];
  if (next) { next.estado = 'activa'; next.fechaActivacion = _hoy(); }
  _historial(s, `Etapa "${etapa.nombre}" completada`, etapa.resultado, actor);

  // Bloque de Acción interna: crear posiciones si el tipo aumenta headcount.
  if (etapa.bloque === BLOQUES_RECLUTAMIENTO.ACCION && etapa.nombre.includes('Creación de la posición')) {
    _crearPosicionesPorAmpliacion(s);
  }

  _recalcularEstadoPorEtapas(s);
  return s;
};

const _crearPosicionesPorAmpliacion = (s) => {
  if (s.posicionesCodigos.length > 0) return; // idempotente
  const tipo = getTipoSolicitud(s.tipoId);
  if (!tipo.aumentaHeadcount) return;
  for (let i = 0; i < s.cantidadCupos; i++) {
    const pos = agregarPosicionEquipo(s.jefeEmpId, s.cargoNombre, s.planta);
    pos.solicitudOrigenId = s.id;
    s.posicionesCodigos.push(pos.codigo);
  }
};

// Helper solo para sembrar ejemplos: aprueba todas las etapas restantes en
// orden, sin importar el nombre del actor (decidirEtapa no exige que el
// actor coincida con el responsable esperado, salvo la prohibición de
// autoaprobación). Se detiene si encuentra una devuelta/rechazada.
const _avanzarTodo = (solicitudId, actorGenerico) => {
  let guard = 0;
  while (guard++ < 20) {
    const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
    if (!s || s.estadoGeneral === 'lista_reclutamiento' || s.estadoGeneral === 'devuelta' || s.estadoGeneral === 'rechazada') break;
    const activa = s.etapas.find(e => e.estado === 'activa');
    if (!activa) break;
    decidirEtapa(solicitudId, 'aprobar', { actor: activa.responsable || actorGenerico });
  }
  return SOLICITUDES_STORE.find(x => x.id === solicitudId);
};

const cancelarSolicitud = (solicitudId, motivo, actor) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  if (!s) return { error: 'La solicitud ya no existe.' };
  if (!motivo) return { error: 'El motivo de cancelación es obligatorio.' };
  // ADR-0021 — punto de no retorno: tras el alta SAP exitosa de cualquier
  // cupo, no se permite cancelación ordinaria de la solicitud.
  const tieneAltaSAP = CASOS_CONTRATACION_STORE.some(c => c.solicitudId === solicitudId && c.idSAP);
  if (tieneAltaSAP) {
    return { error: 'Esta solicitud ya tiene al menos un alta SAP exitosa — después del alta no se permite cancelación ordinaria. Requiere el procedimiento de inactivación y reapertura (pendiente de definición).' };
  }
  s.estadoGeneral = 'cancelada';
  s.motivoCierre = motivo;
  _historial(s, 'Solicitud cancelada', motivo, actor);
  return s;
};

// ── Compuerta e inicio de reclutamiento (§10.2) ────────────────────────
const puedeIniciarReclutamiento = (s) => {
  const tipo = getTipoSolicitud(s.tipoId);
  if (!tipo || tipo.abreReclutamiento === false) return false;
  return s.estadoGeneral === 'lista_reclutamiento';
};

// Envía la información autorizada a las temporales activas — simulado, sin
// correo real. Cada intento se registra por destinatario; un reintento no
// duplica los envíos ya exitosos.
const _enviarATemporales = (s) => {
  s.temporales.forEach(t => {
    if (t.envio && t.envio.resultado === 'entregado') return; // no duplica éxitos
    const exito = true; // determinístico para la demo — ver reintentarEnvioTemporal para forzar fallos
    t.envio = { fecha: _ahora(), resultado: exito ? 'entregado' : 'fallido', intentos: (t.envio ? t.envio.intentos + 1 : 1) };
    CORREOS_SIMULADOS_STORE.push({
      id: `MAIL-${CORREOS_SIMULADOS_STORE.length + 1}`,
      tipo: 'apertura_solicitud', solicitudId: s.id, postulacionId: null,
      destinatario: t.correo, destinatarioNombre: t.temporal,
      asunto: `${s.id} · Nueva solicitud de personal`, fecha: t.envio.fecha,
      estado: t.envio.resultado, resumen: `${s.cargoNombre} · ${s.cantidadCupos} cupo${s.cantidadCupos === 1 ? '' : 's'} · ${s.sociedad}`,
    });
  });
};

const reintentarEnvioTemporal = (solicitudId, temporalNombre) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  if (!s) return null;
  const t = s.temporales.find(x => x.temporal === temporalNombre);
  if (!t) return null;
  t.envio = { fecha: _ahora(), resultado: 'entregado', intentos: (t.envio ? t.envio.intentos + 1 : 1) };
  return s;
};

const iniciarReclutamiento = (solicitudId, actor) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  if (!s) return { error: 'La solicitud ya no existe.' };
  if (!puedeIniciarReclutamiento(s)) return { error: 'La solicitud debe estar Lista para reclutamiento y admitir selección.' };
  s.estadoGeneral = 'en_reclutamiento';
  _enviarATemporales(s);
  _historial(s, 'Reclutamiento iniciado', 'Envío de información autorizada a temporales activas', actor);
  return s;
};

const registrarRQ = (solicitudId, temporalNombre, rq, actor) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  if (!s) return null;
  const t = s.temporales.find(x => x.temporal === temporalNombre);
  if (!t || !rq || !rq.trim()) return s;
  if (t.rqVigente) t.historial.push({ rq: t.rqVigente, reemplazadoEn: _hoy(), actor });
  t.rqVigente = rq.trim();
  t.estado = 'registrado';
  t.historial.push({ rq: rq.trim(), registradoEn: _hoy(), actor });
  return s;
};

// Cierra sin reclutamiento las solicitudes cuyo tipo no abre pipeline ni es
// contratación directa (cambio de centro de costo, aumento salarial): la
// plantilla ya terminó y no hay posiciones ni candidatos que gestionar.
const finalizarSinReclutamiento = (solicitudId, actor) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  if (!s) return { error: 'La solicitud ya no existe.' };
  const tipo = getTipoSolicitud(s.tipoId);
  if (tipo.abreReclutamiento !== false || tipo.esDirecta) return { error: 'Este tipo de solicitud sí gestiona reclutamiento o contratación directa.' };
  if (s.estadoGeneral !== 'lista_reclutamiento') return { error: 'La plantilla debe estar terminada antes de cerrar la solicitud.' };
  s.estadoGeneral = 'finalizada';
  _historial(s, 'Solicitud finalizada', 'Cambio administrativo aplicado — no requiere posiciones ni pipeline', actor);
  return s;
};

// ═══════════════════════════════════════════════════════════════════════
// CANDIDATOS Y POSTULACIONES
// ═══════════════════════════════════════════════════════════════════════

const _normDoc = (s) => (s || '').replace(/[.\s-]/g, '').toUpperCase();

const buscarCandidato = (tipoDocumento, numeroDocumento) => {
  const num = _normDoc(numeroDocumento);
  return CANDIDATOS_STORE.find(c => c.tipoDocumento === tipoDocumento && _normDoc(c.numeroDocumento) === num) || null;
};

let _candSeq = 500;
let _postSeq = 700;

// Identidad única por documento (§14.1): si ya existe, se reutiliza y solo
// se crea una nueva postulación independiente.
const _obtenerOCrearCandidato = ({ nombreCompleto, tipoDocumento, numeroDocumento, celular, email }) => {
  let candidato = buscarCandidato(tipoDocumento, numeroDocumento);
  if (candidato) return { candidato, reutilizado: true };
  candidato = {
    id: `CAND-${++_candSeq}`, nombreCompleto, tipoDocumento, numeroDocumento: numeroDocumento.trim(),
    celular: celular || '', email: email || '',
  };
  CANDIDATOS_STORE.push(candidato);
  return { candidato, reutilizado: false };
};

// input: { solicitudId, nombreCompleto, tipoDocumento, numeroDocumento, celular,
//          hojaVidaNombreArchivo, fuente, temporalNombre }
const crearPostulado = (input) => {
  const s = SOLICITUDES_STORE.find(x => x.id === input.solicitudId);
  if (!s) return { error: 'Selecciona una solicitud válida.' };
  if (!['en_reclutamiento', 'en_contratacion'].includes(s.estadoGeneral)) {
    return { error: 'La solicitud debe estar en reclutamiento para registrar postulados.' };
  }
  if (!input.nombreCompleto || !input.numeroDocumento || !input.hojaVidaNombreArchivo) {
    return { error: 'Nombre, documento y hoja de vida (Word o PDF) son obligatorios.' };
  }
  const { candidato, reutilizado } = _obtenerOCrearCandidato(input);
  const postulacion = {
    id: `POST-${++_postSeq}`, candidatoId: candidato.id, solicitudId: s.id,
    etapaActual: 'postulados', fuente: input.fuente || 'manual',
    temporalNombre: input.fuente === 'temporal' ? (input.temporalNombre || null) : null,
    hojaVidaNombreArchivo: input.hojaVidaNombreArchivo,
    fechaIngresoPipeline: _hoy(), fechaUltimoMovimiento: _hoy(),
    calificacionJefe: { estrellas: 0, observacion: '', historial: [] },
    historialMovimientos: [{ origen: null, destino: 'postulados', actor: input.actor || 'Gestión Humana', fecha: _ahora(), observacion: reutilizado ? 'Candidato existente reutilizado por documento' : 'Alta individual' }],
    reservaPosicionCodigo: null,
    modalidadVinculacion: null,
    temporalContratante: null,
    correoSeleccionId: null,
    intentosContratacion: [],
    devuelto: false,
  };
  POSTULACIONES_STORE.push(postulacion);
  return { candidato, postulacion, reutilizado };
};

// Cargue masivo — demostración explícitamente simulada (§9 del prompt): NO
// procesa un archivo Excel real. Recibe filas ya "previsualizadas" por la UI.
const cargaMasiva = (solicitudId, filas, actor) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  const resultado = { archivoOrigen: 'plantilla_postulados_demo.xlsx', usuario: actor, fecha: _ahora(), filas: [] };
  if (!s) { resultado.filas = filas.map(f => ({ ...f, ok: false, error: 'Solicitud no válida' })); return resultado; }

  filas.forEach(f => {
    if (!f.seleccionada) { resultado.filas.push({ ...f, ok: false, error: 'No seleccionada' }); return; }
    if (!f.nombreCompleto || !f.numeroDocumento) { resultado.filas.push({ ...f, ok: false, error: 'Faltan campos obligatorios' }); return; }
    if (!f.hojaVidaNombreArchivo) { resultado.filas.push({ ...f, ok: false, error: 'Falta hoja de vida adjunta' }); return; }
    const dup = filas.filter(x => _normDoc(x.numeroDocumento) === _normDoc(f.numeroDocumento));
    if (dup.length > 1 && dup.indexOf(f) > 0) { resultado.filas.push({ ...f, ok: false, error: 'Documento duplicado dentro del archivo' }); return; }
    const r = crearPostulado({ ...f, solicitudId, actor, fuente: f.fuente || 'portal' });
    if (r.error) { resultado.filas.push({ ...f, ok: false, error: r.error }); return; }
    resultado.filas.push({ ...f, ok: true, postulacionId: r.postulacion.id, reutilizado: r.reutilizado });
  });
  return resultado;
};

const calificarPostulacion = (postulacionId, estrellas, observacion, actor) => {
  const p = POSTULACIONES_STORE.find(x => x.id === postulacionId);
  if (!p) return null;
  if (p.calificacionJefe.estrellas > 0) {
    p.calificacionJefe.historial.push({ estrellas: p.calificacionJefe.estrellas, observacion: p.calificacionJefe.observacion, fecha: _hoy(), actor: 'Reemplazada' });
  }
  p.calificacionJefe.estrellas = estrellas;
  p.calificacionJefe.observacion = observacion || '';
  p.calificacionJefe.historial.push({ estrellas, observacion, fecha: _hoy(), actor });
  return p;
};

// Movimiento normal entre etapas (Postulados…Estudios). El paso a
// Contratación exige posición y se hace con reservarYMoverAContratacion.
const moverPostulacion = (postulacionId, etapaDestinoId, actor, observacion) => {
  const p = POSTULACIONES_STORE.find(x => x.id === postulacionId);
  if (!p) return { error: 'La postulación ya no existe.' };
  if (etapaDestinoId === 'contratacion') return { error: 'Usa "Pasar a Contratación" para reservar una posición.' };
  const origen = p.etapaActual;
  p.etapaActual = etapaDestinoId;
  p.fechaUltimoMovimiento = _hoy();
  p.historialMovimientos.push({ origen, destino: etapaDestinoId, actor, fecha: _ahora(), observacion: observacion || null });
  return p;
};

// ── Reservas y Contratación (§17) ──────────────────────────────────────
const getPosicionesDisponiblesSolicitud = (solicitudId) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  if (!s) return [];
  const codigos = s.posicionesCodigos.length ? s.posicionesCodigos : (s.posicionAsociadaFija ? [s.posicionAsociadaFija] : []);
  const posicionesAprobadas = codigos
    .map(c => EQUIPO_DIRECTO_SEED.find(p => p.codigo === c) || (window.OrgDataStore ? window.OrgDataStore.getPosicionByCodigo(c) : null))
    .filter(p => p && (p.estadoOcupacion === 'vacante'));
  const cuposDemo = EQUIPO_DIRECTO_SEED.filter(p => p.solicitudIdDemo === solicitudId && p.estadoOcupacion === 'vacante');
  return [...posicionesAprobadas, ...cuposDemo];
};

let _demoPosSeq = 0;
// Escape controlado para presentaciones: permite recorrer el flujo cuando
// todas las posiciones reales del caso semilla están reservadas u ocupadas.
// No se agrega a posicionesCodigos ni tiene estado estructural activo, por lo
// que no incrementa el headcount aprobado ni altera los KPI de Mi equipo.
const habilitarCupoDemostracion = (solicitudId) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  if (!s) return null;
  const disponible = EQUIPO_DIRECTO_SEED.find(p => p.solicitudIdDemo === solicitudId && p.estadoOcupacion === 'vacante');
  if (disponible) return disponible;
  const posicion = _posEquipo(s.jefeEmpId, {
    codigo: `POS-DEMO-${String(++_demoPosSeq).padStart(3, '0')}`,
    cargo: s.cargoNombre,
    planta: s.planta || 'Sede por definir',
    estadoEstructural: 'demostracion',
    estadoOcupacion: 'vacante',
    solicitudIdDemo: solicitudId,
    esDemostracion: true,
  });
  EQUIPO_DIRECTO_SEED.push(posicion);
  return posicion;
};

const pasarACierreSeleccion = (postulacionId, posicionCodigo, modalidad, temporalContratante, actor) => {
  const p = POSTULACIONES_STORE.find(x => x.id === postulacionId);
  if (!p) return { error: 'La postulación ya no existe.' };
  if (p.etapaActual !== 'estudios') return { error: 'Solo se define la vinculación al salir de Estudios.' };
  if (p.reservaPosicionCodigo) return { error: 'Esta postulación ya tiene una posición reservada.' };
  if (!['directa', 'temporal'].includes(modalidad)) return { error: 'Selecciona si la vinculación será directa o por empresa temporal.' };
  const temporal = modalidad === 'temporal' ? TEMPORALES_ACTIVAS.find(t => t.nombre === temporalContratante) : null;
  if (modalidad === 'temporal' && !temporal) return { error: 'Selecciona explícitamente la temporal que realizará la contratación.' };

  const s = SOLICITUDES_STORE.find(x => x.id === p.solicitudId);
  const posicion = EQUIPO_DIRECTO_SEED.find(x => x.codigo === posicionCodigo) || (window.OrgDataStore && window.OrgDataStore.getPosicionByCodigo(posicionCodigo));
  if (!posicion) return { error: 'La posición seleccionada ya no existe.' };
  // Revalidación inmediata en "servidor" simulado — evita doble reserva concurrente.
  if (posicion.estadoOcupacion !== 'vacante') return { error: 'Esa posición ya no está disponible — otro usuario pudo haberla reservado.' };

  posicion.estadoOcupacion = 'reservada';
  posicion.reservaPostulacionId = p.id;
  p.reservaPosicionCodigo = posicion.codigo;
  p.modalidadVinculacion = modalidad;
  p.temporalContratante = temporal ? temporal.nombre : null;
  p.estadoConfirmacionTemporal = temporal ? 'pendiente' : null;
  p.etapaActual = modalidad === 'temporal' ? 'confirmacion_temporal' : 'contratacion';
  p.fechaIngresoContratacion = _hoy();
  p.fechaUltimoMovimiento = _hoy();
  const destino = p.etapaActual;
  const detalleModalidad = modalidad === 'temporal' ? `Temporal contratante: ${temporal.nombre}` : 'Vinculación directa con sociedad Atica';
  p.historialMovimientos.push({ origen: 'estudios', destino, actor, fecha: _ahora(), observacion: `Posición reservada: ${posicion.codigo} · ${detalleModalidad}` });

  if (temporal) {
    const candidato = CANDIDATOS_STORE.find(c => c.id === p.candidatoId);
    const correo = {
      id: `MAIL-${CORREOS_SIMULADOS_STORE.length + 1}`,
      tipo: 'candidato_elegido', solicitudId: p.solicitudId, postulacionId: p.id,
      destinatario: temporal.correo, destinatarioNombre: temporal.nombre,
      asunto: `${s.id} · Candidato elegido para contratación`, fecha: _ahora(), estado: 'entregado',
      resumen: `${candidato.nombreCompleto} · ${s.cargoNombre} · posición ${posicion.codigo}`,
    };
    CORREOS_SIMULADOS_STORE.push(correo);
    p.correoSeleccionId = correo.id;
  }

  if (s) {
    s.estadoGeneral = 'en_contratacion';
    _historial(s, modalidad === 'temporal' ? 'Enviado a confirmación temporal' : 'Ingresó a Contratación', `${posicion.codigo} reservada · ${detalleModalidad}`, actor);
  }
  return { postulacion: p, posicion };
};

// Compatibilidad con llamadas anteriores del prototipo: representa la ruta
// directa. La interfaz nueva usa pasarACierreSeleccion para ambas modalidades.
const reservarYMoverAContratacion = (postulacionId, posicionCodigo, actor) =>
  pasarACierreSeleccion(postulacionId, posicionCodigo, 'directa', null, actor);

const _liberarPosicion = (posicionCodigo) => {
  const posicion = EQUIPO_DIRECTO_SEED.find(x => x.codigo === posicionCodigo) || (window.OrgDataStore && window.OrgDataStore.getPosicionByCodigo(posicionCodigo));
  if (posicion && posicion.estadoOcupacion === 'reservada') {
    posicion.estadoOcupacion = 'vacante';
    posicion.reservaPostulacionId = null;
  }
};

const declararApto = (postulacionId, actor) => {
  const p = POSTULACIONES_STORE.find(x => x.id === postulacionId);
  if (!p) return { error: 'La postulación ya no existe.' };
  if (p.etapaActual !== 'contratacion' || !p.reservaPosicionCodigo) return { error: 'Solo se declara apto un candidato con posición reservada en Contratación.' };
  const intento = { fecha: _hoy(), resultado: 'apto', actor };
  p.intentosContratacion.push(intento);
  p.devuelto = false;

  const s = SOLICITUDES_STORE.find(x => x.id === p.solicitudId);
  const caso = {
    id: `CAS-${p.id}`, postulacionId: p.id, candidatoId: p.candidatoId, solicitudId: p.solicitudId,
    posicionCodigo: p.reservaPosicionCodigo, estado: 'pendiente_alta',
    modalidadVinculacion: 'directa', temporalContratante: null,
    idSAP: null, intentos: [], fechaAptoEn: _hoy(),
  };
  const existente = CASOS_CONTRATACION_STORE.find(c => c.postulacionId === p.id);
  if (!existente) CASOS_CONTRATACION_STORE.push(caso); // idempotente
  if (s) _historial(s, 'Candidato declarado apto', `${p.reservaPosicionCodigo}`, actor);
  return { postulacion: p, caso: existente || caso };
};

const confirmarContratacionTemporal = (postulacionId, actor, observacion) => {
  const p = POSTULACIONES_STORE.find(x => x.id === postulacionId);
  if (!p) return { error: 'La postulación ya no existe.' };
  if (p.etapaActual !== 'confirmacion_temporal' || p.modalidadVinculacion !== 'temporal' || !p.reservaPosicionCodigo) {
    return { error: 'Solo puede confirmarse un candidato pendiente de la temporal y con posición reservada.' };
  }
  const existente = CASOS_CONTRATACION_STORE.find(c => c.postulacionId === p.id);
  if (p.estadoConfirmacionTemporal === 'confirmada' && existente) return { postulacion: p, caso: existente };
  const intento = { fecha: _hoy(), resultado: 'confirmado_temporal', actor, motivo: observacion || 'Proceso externo confirmado por la temporal', posicionCodigo: p.reservaPosicionCodigo };
  p.intentosContratacion.push(intento);
  p.devuelto = false;
  p.estadoConfirmacionTemporal = 'confirmada';
  p.fechaConfirmacionTemporal = _hoy();
  const s = SOLICITUDES_STORE.find(x => x.id === p.solicitudId);
  const caso = {
    id: `CAS-${p.id}`, postulacionId: p.id, candidatoId: p.candidatoId, solicitudId: p.solicitudId,
    posicionCodigo: p.reservaPosicionCodigo, estado: 'pendiente_alta',
    modalidadVinculacion: 'temporal', temporalContratante: p.temporalContratante,
    idSAP: null, intentos: [], fechaAptoEn: _hoy(),
  };
  if (!existente) CASOS_CONTRATACION_STORE.push(caso);
  if (s) _historial(s, 'Contratación temporal confirmada', `${p.temporalContratante} confirmó ${p.reservaPosicionCodigo}; enviado a Creación de personal`, actor);
  return { postulacion: p, caso: existente || caso };
};

// Alta iniciada desde Empleados: no existe solicitud, postulación ni
// candidato previo. La posición es la única fuente organizacional y los
// datos personales se diligencian desde cero en el formulario compartido.
let _altaDirectaSeq = 0;
const crearCasoAltaSinPostulacion = (posicionCodigo) => {
  const posicion = getPosicionPorCodigo(posicionCodigo);
  if (!posicion) return { error: 'La posición seleccionada ya no existe.' };
  if (posicion.estadoEstructural !== 'activa' || posicion.estadoOcupacion !== 'vacante') {
    return { error: 'La posición seleccionada ya no se encuentra disponible. Selecciona otra posición para continuar.' };
  }
  const caso = {
    id: `CAS-DIRECT-${++_altaDirectaSeq}`, postulacionId: null, candidatoId: null, solicitudId: null,
    posicionCodigo, estado: 'pendiente_alta', origen: 'empleados',
    modalidadVinculacion: 'directa', temporalContratante: null,
    idSAP: null, intentos: [], fechaAptoEn: _hoy(), datosAlta: null,
  };
  CASOS_CONTRATACION_STORE.push(caso);
  return caso;
};

const devolverAPostulados = (postulacionId, motivo, observacion, actor) => {
  const p = POSTULACIONES_STORE.find(x => x.id === postulacionId);
  if (!p) return { error: 'La postulación ya no existe.' };
  if (!['contratacion', 'confirmacion_temporal'].includes(p.etapaActual)) return { error: 'Solo se devuelve un candidato que está en Contratación o Confirmación temporal.' };
  if (!motivo) return { error: 'El motivo de devolución es obligatorio.' };

  const origen = p.etapaActual;
  if (origen === 'confirmacion_temporal' && p.estadoConfirmacionTemporal === 'confirmada') return { error: 'El candidato ya fue confirmado y enviado a Creación de personal.' };
  const intento = { fecha: _hoy(), resultado: 'devuelto', motivo, observacion: observacion || null, actor, posicionCodigo: p.reservaPosicionCodigo, origen, modalidadVinculacion: p.modalidadVinculacion, temporalContratante: p.temporalContratante };
  p.intentosContratacion.push(intento);
  _liberarPosicion(p.reservaPosicionCodigo);
  p.reservaPosicionCodigo = null;
  p.devuelto = true;
  if (origen === 'confirmacion_temporal') p.estadoConfirmacionTemporal = 'devuelta';
  p.etapaActual = 'postulados';
  p.fechaUltimoMovimiento = _hoy();
  p.historialMovimientos.push({ origen, destino: 'postulados', actor, fecha: _ahora(), observacion: `Devuelto: ${motivo}` });

  const s = SOLICITUDES_STORE.find(x => x.id === p.solicitudId);
  if (s) {
    const quedanEnContratacion = POSTULACIONES_STORE.some(x => x.solicitudId === s.id && ['contratacion', 'confirmacion_temporal'].includes(x.etapaActual));
    if (!quedanEnContratacion) s.estadoGeneral = 'en_reclutamiento';
    _historial(s, 'Candidato devuelto a Postulados', motivo, actor);
  }
  return p;
};

// Contratación directa / paso directo por compañía: omite el pipeline de
// seis etapas por completo (§21). Registra al candidato ya reservando una
// posición disponible de la solicitud, en un solo paso.
const registrarCandidatoDirecto = (solicitudId, datosCandidato, posicionCodigo, actor) => {
  const s = SOLICITUDES_STORE.find(x => x.id === solicitudId);
  if (!s) return { error: 'La solicitud ya no existe.' };
  const tipo = getTipoSolicitud(s.tipoId);
  if (!tipo.esDirecta) return { error: 'Este tipo de solicitud no es de contratación directa.' };
  if (s.estadoGeneral !== 'lista_reclutamiento') return { error: 'La plantilla debe estar terminada antes de registrar la contratación.' };
  if (!datosCandidato.nombreCompleto || !datosCandidato.numeroDocumento) return { error: 'Nombre y documento del candidato son obligatorios.' };

  const posicion = EQUIPO_DIRECTO_SEED.find(x => x.codigo === posicionCodigo) || (window.OrgDataStore && window.OrgDataStore.getPosicionByCodigo(posicionCodigo));
  if (!posicion || posicion.estadoOcupacion !== 'vacante') return { error: 'La posición no está disponible.' };

  const { candidato } = _obtenerOCrearCandidato(datosCandidato);
  const postulacion = {
    id: `POST-${++_postSeq}`, candidatoId: candidato.id, solicitudId: s.id,
    etapaActual: 'contratacion', fuente: 'directa', temporalNombre: null,
    hojaVidaNombreArchivo: datosCandidato.hojaVidaNombreArchivo || null,
    fechaIngresoPipeline: _hoy(), fechaUltimoMovimiento: _hoy(), fechaIngresoContratacion: _hoy(),
    calificacionJefe: { estrellas: 0, observacion: '', historial: [] },
    historialMovimientos: [{ origen: null, destino: 'contratacion', actor, fecha: _ahora(), observacion: 'Contratación directa — sin pipeline de selección' }],
    reservaPosicionCodigo: posicion.codigo, modalidadVinculacion: 'directa', temporalContratante: null, correoSeleccionId: null,
    intentosContratacion: [], devuelto: false,
  };
  POSTULACIONES_STORE.push(postulacion);
  posicion.estadoOcupacion = 'reservada';
  posicion.reservaPostulacionId = postulacion.id;
  s.estadoGeneral = 'en_contratacion';
  _historial(s, 'Contratación directa registrada', `${posicion.codigo} reservada para ${candidato.nombreCompleto}`, actor);
  return { candidato, postulacion, posicion };
};

// ═══════════════════════════════════════════════════════════════════════
// CREACIÓN DE PERSONAL — secuencia obligatoria SAP → IdSAP → SOMOS
// (ADR-0021). Ruta nueva e independiente de
// window.OrgDataStore.crearEmpleadoEnPosicion (que sigue el orden antiguo y
// pertenece al botón "Crear empleado" de Empleados — no se toca aquí).
// ═══════════════════════════════════════════════════════════════════════

const _separarNombre = (nombreCompleto) => {
  const partes = String(nombreCompleto || '').trim().split(/\s+/).filter(Boolean);
  if (partes.length <= 1) return { primerNombre: partes[0] || '', segundoNombre: '', primerApellido: '', segundoApellido: '' };
  if (partes.length === 2) return { primerNombre: partes[0], segundoNombre: '', primerApellido: partes[1], segundoApellido: '' };
  if (partes.length === 3) return { primerNombre: partes[0], segundoNombre: '', primerApellido: partes[1], segundoApellido: partes[2] };
  return { primerNombre: partes[0], segundoNombre: partes.slice(1, -2).join(' '), primerApellido: partes[partes.length - 2], segundoApellido: partes[partes.length - 1] };
};

const _fechaISOaCO = (fecha) => {
  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(fecha || '');
  return m ? `${m[3]}/${m[2]}/${m[1]}` : fecha;
};

const getDatosAltaInicial = (casoId) => {
  const caso = CASOS_CONTRATACION_STORE.find(c => c.id === casoId);
  if (!caso) return null;
  const post = POSTULACIONES_STORE.find(p => p.id === caso.postulacionId);
  const candidato = CANDIDATOS_STORE.find(c => c.id === caso.candidatoId);
  const solicitud = SOLICITUDES_STORE.find(s => s.id === caso.solicitudId);
  const posicion = getPosicionPorCodigo(caso.posicionCodigo);
  const fuente = post ? FUENTES_POSTULACION.find(f => f.id === post.fuente) : null;
  const nombre = _separarNombre(candidato ? candidato.nombreCompleto : '');
  const correoDemo = String(candidato ? candidato.nombreCompleto : 'persona')
    .normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '.').replace(/^\.|\.$/g, '');
  const docNormalizado = _normDoc(candidato ? candidato.numeroDocumento : '');
  const empleadoAnterior = (window.EMPLOYEES || []).find(e => _normDoc(e.doc) === docNormalizado);
  if (caso.origen === 'empleados') {
    return {
      primerNombre: '', segundoNombre: '', primerApellido: '', segundoApellido: '',
      tipoDocumento: '', numeroDocumento: '', fechaExpedicion: '', lugarExpedicion: '', fechaNacimiento: '',
      celular: '', correoPersonal: '', direccion: '', ciudad: '', departamento: '',
      fechaIngreso: '', tipoContrato: '',
      sociedad: posicion ? posicion.sociedad || '' : '', modalidadVinculacion: 'directa',
      empleadorLegal: posicion ? posicion.sociedad || '' : '',
      cargo: posicion ? posicion.cargo || '' : '', posicionCodigo: caso.posicionCodigo,
      planta: posicion ? posicion.planta || posicion.sede || '' : '',
      centroCosto: posicion ? posicion.centroCosto || '' : '',
      jefeDirecto: posicion ? posicion.parentPositionLabel || '' : '',
      canalIngreso: 'Creación directa desde Empleados', temporalPresentadora: null,
      esReingreso: false, empleadoAnteriorId: null,
      ...(caso.datosAlta || {}),
    };
  }
  return {
    ...nombre,
    tipoDocumento: candidato ? candidato.tipoDocumento : 'CC',
    numeroDocumento: candidato ? candidato.numeroDocumento : '',
    fechaExpedicion: '2018-06-15', lugarExpedicion: 'Cali', fechaNacimiento: '1994-05-18',
    celular: candidato ? candidato.celular || '+57 300 000 0000' : '+57 300 000 0000', correoPersonal: candidato ? candidato.email || `${correoDemo}@demo.atica.co` : `${correoDemo}@demo.atica.co`,
    direccion: 'Calle 10 # 25-40', ciudad: solicitud ? solicitud.planta.replace(/^Planta\s+/i, '') : 'Cali', departamento: 'Valle del Cauca',
    fechaIngreso: '2026-10-01',
    tipoContrato: caso.modalidadVinculacion === 'temporal' ? 'Obra o labor' : 'Indefinido',
    sociedad: solicitud ? solicitud.sociedad : '', modalidadVinculacion: caso.modalidadVinculacion || 'directa',
    empleadorLegal: caso.modalidadVinculacion === 'temporal' ? caso.temporalContratante : (solicitud ? solicitud.sociedad : ''),
    cargo: posicion ? posicion.cargo : (solicitud ? solicitud.cargoNombre : ''), posicionCodigo: caso.posicionCodigo,
    planta: posicion ? posicion.planta : (solicitud ? solicitud.planta : ''), centroCosto: solicitud ? solicitud.centroCosto : '',
    jefeDirecto: solicitud ? solicitud.solicitanteNombre : '', canalIngreso: fuente ? fuente.label : 'No informado',
    temporalPresentadora: post ? post.temporalNombre : null, esReingreso: !!empleadoAnterior,
    empleadoAnteriorId: empleadoAnterior ? empleadoAnterior.id : null,
    ...(caso.datosAlta || {}),
  };
};

const guardarDatosAlta = (casoId, datos, actor) => {
  const caso = CASOS_CONTRATACION_STORE.find(c => c.id === casoId);
  if (!caso) return { error: 'El caso de creación ya no existe.' };
  if (caso.idSAP) return { error: 'Los datos de alta no pueden modificarse después de obtener IdSAP.' };
  const base = getDatosAltaInicial(casoId);
  const consolidados = { ...base, ...datos };
  const requeridos = [
    ['primerNombre', 'primer nombre'], ['primerApellido', 'primer apellido'], ['tipoDocumento', 'tipo de documento'],
    ['numeroDocumento', 'número de documento'], ['fechaExpedicion', 'fecha de expedición'], ['lugarExpedicion', 'lugar de expedición'],
    ['fechaNacimiento', 'fecha de nacimiento'], ['celular', 'celular'], ['correoPersonal', 'correo personal'],
    ['direccion', 'dirección'], ['ciudad', 'ciudad'], ['departamento', 'departamento'],
    ['fechaIngreso', 'fecha de ingreso'], ['tipoContrato', 'tipo de contrato'],
  ];
  const faltantes = requeridos.filter(([key]) => !String(consolidados[key] || '').trim()).map(([, label]) => label);
  if (faltantes.length) return { error: `Completa los campos obligatorios: ${faltantes.join(', ')}.` };
  if (!/^\+?57\s?\d{10}$/.test(String(consolidados.celular).replace(/\s/g, ''))) return { error: 'Ingresa un celular colombiano válido.' };
  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(consolidados.correoPersonal)) return { error: 'Ingresa un correo personal válido.' };
  caso.datosAlta = consolidados;
  caso.datosAltaEstado = 'completo';
  caso.datosAltaActualizadosEn = _ahora();
  caso.datosAltaActualizadosPor = actor;
  return caso;
};

// escenario: 'sap_falla' | 'sap_ok_somos_falla' | 'exitoso' — control de
// demostración explícito (no aleatorio) para poder verificar los tres casos.
const iniciarAltaSAP = (casoId, escenario, actor) => {
  const caso = CASOS_CONTRATACION_STORE.find(c => c.id === casoId);
  if (!caso) return { error: 'El caso ya no existe.' };
  if (caso.idSAP) return { error: 'Este caso ya tiene un IdSAP asignado — no se repite el alta en SAP.' };

  const intento = { fecha: _ahora(), actor, escenario };
  if (escenario === 'sap_falla') {
    intento.resultado = 'error_sap';
    intento.detalle = 'SAP rechazó la creación (simulado) — no se creó empleado en SOMOS.';
    caso.estado = 'error_sap';
  } else {
    caso.idSAP = `SAP-${100000 + Math.floor(Math.random() * 899999)}`;
    intento.resultado = 'sap_ok';
    intento.detalle = `SAP asignó ${caso.idSAP}.`;
    caso.estado = 'pendiente_somos';
    if (escenario === 'sap_ok_somos_falla') {
      caso.estado = 'error_somos';
      intento.detalleSomos = 'SOMOS falló al crear la ficha del empleado (simulado) — IdSAP conservado, en cola de reintento.';
    } else {
      const result = _crearEmpleadoSomos(caso, actor);
      if (result?.error) { caso.estado = 'error_somos'; intento.detalleSomos = result.error; }
      else intento.detalleSomos = 'Empleado creado en SOMOS, inducción asignada y posición ocupada.';
    }
  }
  caso.intentos.push(intento);
  return caso;
};

// Reintentar SOMOS nunca vuelve a llamar SAP (idempotente por IdSAP ya persistido).
const reintentarAltaSOMOS = (casoId, actor, forzarFallo) => {
  const caso = CASOS_CONTRATACION_STORE.find(c => c.id === casoId);
  if (!caso) return { error: 'El caso ya no existe.' };
  if (!caso.idSAP) return { error: 'No hay IdSAP registrado — no puede reintentarse SOMOS sin un alta SAP previa.' };
  if (caso.estado === 'completado') return { error: 'Este caso ya fue creado en SOMOS.' };

  if (forzarFallo) {
    caso.intentos.push({ fecha: _ahora(), actor, resultado: 'error_somos', detalle: 'SOMOS volvió a fallar (simulado). IdSAP se conserva; no se reintenta SAP.' });
    caso.estado = 'error_somos';
    return caso;
  }
  const result = _crearEmpleadoSomos(caso, actor);
  if (result?.error) { caso.estado = 'error_somos'; caso.intentos.push({ fecha: _ahora(), actor, resultado: 'error_somos', detalle: result.error }); return caso; }
  caso.intentos.push({ fecha: _ahora(), actor, resultado: 'somos_ok', detalle: 'Empleado creado en SOMOS con el IdSAP conservado e inducción asignada.' });
  return caso;
};

const _crearEmpleadoSomos = (caso, actor) => {
  const p = POSTULACIONES_STORE.find(x => x.id === caso.postulacionId);
  const candidato = CANDIDATOS_STORE.find(c => c.id === caso.candidatoId);
  const posicion = EQUIPO_DIRECTO_SEED.find(x => x.codigo === caso.posicionCodigo) || (window.OrgDataStore && window.OrgDataStore.getPosicionByCodigo(caso.posicionCodigo));
  const s = SOLICITUDES_STORE.find(x => x.id === caso.solicitudId);
  const datos = caso.datosAlta || getDatosAltaInicial(caso.id);
  const nombreAlta = [datos.primerNombre, datos.segundoNombre, datos.primerApellido, datos.segundoApellido].filter(Boolean).join(' ');
  const persistedPeople = window.TrainingInductionStore?.get().people || [];
  const normalizeDocument = value => String(value || '').replace(/\D/g, '');
  const persistedPerson = persistedPeople.find(e => e.name === nombreAlta && normalizeDocument(e.doc) === normalizeDocument(datos.numeroDocumento));
  const occupiedIds = new Set([...(window.EMPLOYEES || []), ...persistedPeople].map(e => e.id));
  let employeeNumber = 9100 + CASOS_CONTRATACION_STORE.indexOf(caso);
  while (occupiedIds.has(`E${employeeNumber}`)) employeeNumber += 1;
  const empleado = {
    id: persistedPerson?.id || `E${employeeNumber}`, initials: (nombreAlta.match(/\b\w/g) || []).slice(0, 2).join('').toUpperCase(),
    name: nombreAlta || (candidato ? candidato.nombreCompleto : 'Nuevo empleado'),
    doc: `${datos.tipoDocumento || (candidato ? candidato.tipoDocumento : '')} ${datos.numeroDocumento || (candidato ? candidato.numeroDocumento : '')}`.trim(),
    tipoDocumento: datos.tipoDocumento || '', numeroDocumento: datos.numeroDocumento || '',
    role: posicion ? posicion.cargo : caso.posicionCodigo, area: posicion ? posicion.area || '' : '', site: posicion ? posicion.planta || posicion.sede || '' : '',
    contract: datos.tipoContrato || (caso.modalidadVinculacion === 'temporal' ? `Temporal · ${caso.temporalContratante}` : 'Indefinido'),
    hire: _fechaISOaCO(datos.fechaIngreso) || _hoy(), status: 'onboarding', country: 'CO',
    phone: datos.celular || '', email: datos.correoPersonal || '', address: datos.direccion || '', city: datos.ciudad || '', department: datos.departamento || '',
    birthDate: datos.fechaNacimiento || '', documentIssueDate: datos.fechaExpedicion || '', documentIssuePlace: datos.lugarExpedicion || '',
    sapEmployeeCode: caso.idSAP, origen: caso.origen === 'empleados' ? 'Empleados · Creación directa' : 'Reclutamiento · Creación de personal',
    positionCode: caso.posicionCodigo,
    modalidadVinculacion: caso.modalidadVinculacion || 'directa', empleadorLegal: caso.modalidadVinculacion === 'temporal' ? caso.temporalContratante : (s ? s.sociedad : datos.sociedad),
  };
  if (window.TrainingInductionStore) {
    try { window.TrainingInductionStore.assign(empleado); }
    catch (issue) { return { error: `No se pudo asignar la inducción: ${issue.message}` }; }
  }
  if (!window.EMPLOYEES.some(e => e.id === empleado.id)) window.EMPLOYEES.push(empleado);
  caso.estado = 'completado';
  caso.empleadoId = empleado.id;
  caso.fechaCreacionSomos = _hoy();

  if (posicion) { posicion.estadoOcupacion = 'ocupada'; posicion.empleadoOcupanteId = empleado.id; posicion.empleadoOcupanteNombre = empleado.name; posicion.reservaPostulacionId = null; }

  if (s) {
    _historial(s, 'Empleado creado en SOMOS', `${empleado.id} · ${caso.idSAP}`, actor);
    const cuposCubiertos = s.posicionesCodigos.length
      ? s.posicionesCodigos.every(c => {
          const pos = EQUIPO_DIRECTO_SEED.find(x => x.codigo === c) || (window.OrgDataStore && window.OrgDataStore.getPosicionByCodigo(c));
          return pos && pos.estadoOcupacion === 'ocupada';
        })
      : (posicion ? posicion.estadoOcupacion === 'ocupada' : true);
    if (cuposCubiertos) { s.estadoGeneral = 'finalizada'; _historial(s, 'Solicitud finalizada', 'Todos los cupos quedaron cubiertos', 'Sistema'); }
  }
};

// ─── Consultas de listado ──────────────────────────────────────────────
const getSolicitudes = () => SOLICITUDES_STORE;
const getSolicitudById = (id) => SOLICITUDES_STORE.find(s => s.id === id);
const getSolicitudesPorJefe = (jefeEmpId) => SOLICITUDES_STORE.filter(s =>
  s.jefeEmpId === jefeEmpId || s.visibleParaEmpIds.includes(jefeEmpId)
);
const getPostulacionesPorSolicitud = (solicitudId) => POSTULACIONES_STORE.filter(p => p.solicitudId === solicitudId);
const getPostulacionesPorCandidato = (candidatoId) => POSTULACIONES_STORE.filter(p => p.candidatoId === candidatoId);
const getCandidatoById = (id) => CANDIDATOS_STORE.find(c => c.id === id);
const getCasosContratacion = () => CASOS_CONTRATACION_STORE;
const getCasoById = (id) => CASOS_CONTRATACION_STORE.find(c => c.id === id);
const getCorreosSimulados = () => CORREOS_SIMULADOS_STORE;

// ═══════════════════════════════════════════════════════════════════════
// UI compartida entre Solicitudes de personal y Reclutamiento — misma
// convención de data-providers.jsx, que también expone DatePickerCO.
// ═══════════════════════════════════════════════════════════════════════

const ESTADO_SOLICITUD_PILL = {
  pendiente: 'amber-soft', en_aprobacion: 'navy', devuelta: 'amber-soft',
  lista_reclutamiento: 'teal', en_reclutamiento: 'blue', en_contratacion: 'blue',
  finalizada: 'green', rechazada: 'rose', cancelada: 'navy-soft',
};
const EstadoSolicitudPill = ({ estado }) => (
  <span className={`pill ${ESTADO_SOLICITUD_PILL[estado] || 'navy-soft'}`}>{ESTADOS_SOLICITUD[estado] || estado}</span>
);

const StarRatingInput = ({ value, onChange, readOnly, size = 15 }) => {
  const [hover, setHover] = _rec_useState(0);
  return (
    <span style={{ display: 'inline-flex', gap: 2 }}>
      {[1, 2, 3, 4, 5].map(n => (
        <svg key={n} width={size} height={size} viewBox="0 0 24 24"
          style={{ cursor: readOnly ? 'default' : 'pointer', color: (hover || value) >= n ? 'var(--cta-500)' : 'var(--border-strong)' }}
          fill={(hover || value) >= n ? 'currentColor' : 'none'} stroke="currentColor" strokeWidth="1.5"
          onMouseEnter={() => !readOnly && setHover(n)} onMouseLeave={() => !readOnly && setHover(0)}
          onClick={() => !readOnly && onChange && onChange(n)}>
          <path d="M12 2.5l2.95 6 6.6.96-4.78 4.66 1.13 6.58L12 17.6l-5.9 3.1 1.13-6.58L2.45 9.46l6.6-.96L12 2.5z" />
        </svg>
      ))}
    </span>
  );
};

// Tiempo transcurrido informativo — nunca se usa para SLA ni escalamiento.
const tiempoTranscurrido = (fechaActivacionCO) => {
  if (!fechaActivacionCO) return null;
  return `en esta etapa desde ${fechaActivacionCO}`;
};

const TimelineEtapas = ({ etapas }) => (
  <div className="doc-timeline">
    {etapas.map((et, i) => {
      const esActiva = et.estado === 'activa';
      const tono = et.estado === 'completada' ? 'signed' : (et.estado === 'devuelta' || et.estado === 'rechazada') ? 'pending' : 'pending';
      return (
        <div key={et.id || i} className={`doc-tl-row doc-tl-${tono}`}>
          <div className="doc-tl-rail">
            <div className="doc-tl-dot">
              {et.estado === 'completada' ? <IconCheck size={11} /> : et.estado === 'rechazada' ? <IconAlert size={11} /> : et.estado === 'devuelta' ? <IconAlert size={11} /> : <IconClock size={11} />}
            </div>
            {i < etapas.length - 1 && <div className="doc-tl-line" />}
          </div>
          <div className="doc-tl-body">
            <div className="doc-tl-label">
              {et.nombre} <span className="muted-xs" style={{ marginLeft: 6 }}>{et.bloque}</span>
            </div>
            <div className="muted" style={{ fontSize: 12, marginTop: 2 }}>
              Responsable esperado: <b>{et.responsable}</b>{et.responsableEfectivo && et.responsableEfectivo !== et.responsable ? <> · efectivo: <b>{et.responsableEfectivo}</b></> : null}
            </div>
            <div className="doc-tl-detail muted" style={{ marginTop: 2 }}>
              {et.estado === 'pendiente' && 'Sin iniciar'}
              {esActiva && tiempoTranscurrido(et.fechaActivacion)}
              {et.estado === 'completada' && `Completada el ${et.fechaFinalizacion} · ${et.resultado || 'Aprobada'}`}
              {et.estado === 'devuelta' && `Devuelta el ${et.fechaFinalizacion} · motivo: "${et.motivo}"`}
              {et.estado === 'rechazada' && `Rechazada el ${et.fechaFinalizacion} · motivo: "${et.motivo}"`}
            </div>
            {et.historialRondas && et.historialRondas.length > 1 && (
              <div className="muted-xs" style={{ marginTop: 3 }}>{et.historialRondas.length} rondas registradas — la corrección no borra el recorrido anterior.</div>
            )}
          </div>
        </div>
      );
    })}
  </div>
);

// Cierre con Escape + bloqueo de scroll — mismo patrón repetido en cada
// modal manual del prototipo, centralizado aquí para no duplicarlo.
const useEscToClose = (onClose) => {
  React.useEffect(() => {
    document.body.style.overflow = 'hidden';
    const onEsc = (e) => { if (e.key === 'Escape') onClose(); };
    window.addEventListener('keydown', onEsc);
    return () => { document.body.style.overflow = ''; window.removeEventListener('keydown', onEsc); };
  }, []);
};
window.useEscToClose = useEscToClose;

window.EstadoSolicitudPill = EstadoSolicitudPill;
window.StarRatingInput = StarRatingInput;
window.TimelineEtapas = TimelineEtapas;

window.RecruitmentStore = {
  TIPOS_SOLICITUD, getTipoSolicitud, ETAPAS_PIPELINE, idxEtapaPipeline, FUENTES_POSTULACION,
  TEMPORALES_ACTIVAS, ESTADOS_SOLICITUD, BLOQUES_RECLUTAMIENTO,
  getEquipoDirecto, getPosicionesPorJefe, getHeadcountJefe, getEmpleado, getPosicionPorCodigo,
  crearSolicitud, decidirEtapa, cancelarSolicitud, puedeIniciarReclutamiento, finalizarSinReclutamiento,
  iniciarReclutamiento, reintentarEnvioTemporal, registrarRQ,
  getSolicitudes, getSolicitudById, getSolicitudesPorJefe,
  buscarCandidato, crearPostulado, cargaMasiva, calificarPostulacion, moverPostulacion,
  getPosicionesDisponiblesSolicitud, habilitarCupoDemostracion, pasarACierreSeleccion, reservarYMoverAContratacion, declararApto, confirmarContratacionTemporal, devolverAPostulados,
  registrarCandidatoDirecto,
  getPostulacionesPorSolicitud, getPostulacionesPorCandidato, getCandidatoById,
  crearCasoAltaSinPostulacion, getDatosAltaInicial, guardarDatosAlta, iniciarAltaSAP, reintentarAltaSOMOS, getCasosContratacion, getCasoById, getCorreosSimulados,
};

// ═══════════════════════════════════════════════════════════════════════
// EJEMPLOS DE DEMOSTRACIÓN — sembrados con las mismas funciones del store
// (igual convención que simularFlujoCompletoDemo en data-providers.jsx), no
// con atajos que fabriquen estados imposibles de alcanzar por la UI.
// ═══════════════════════════════════════════════════════════════════════
(function seedRecruitmentDemo() {
  const LM = { jefeEmpId: 'E0067', jefeNombre: 'Luis Miguel Marín · Líder de Aprovechamiento' };
  const CR = { jefeEmpId: 'E0023', jefeNombre: 'Carolina Restrepo S. · Jefe de RRHH' };
  const GH = 'Carolina Restrepo S. · Jefe de RRHH';

  // 1) Reemplazo por vacante — Lista para reclutamiento (plantilla ya
  // aprobada), pinneada a la posición vacante existente de Aprovechamiento.
  const posVacanteLM = EQUIPO_DIRECTO_SEED.find(p => p.jefeEmpId === 'E0067' && p.estadoOcupacion === 'vacante');
  const solReemplazo = crearSolicitud({
    tipoId: 'reemplazo_vacante', ...LM, sociedad: 'ECOENTORNO', cargoId: 'CGO-003', cargoNombre: 'Op. Aprovechamiento',
    planta: 'Planta Yumbo', centroCosto: 'CC-APR-006', colaboradorAfectadoId: 'E9003',
    posicionAsociadaCodigo: posVacanteLM ? posVacanteLM.codigo : null,
    formulario: { motivo: 'Renuncia voluntaria del ocupante anterior', fechaRetiro: '30/06/2026' },
  });
  _avanzarTodo(solReemplazo.id, GH);

  // 2) Reemplazo por incapacidad — En reclutamiento, sin RQ registrado
  // todavía (candidato de bolsa ya postulado igual). Ejemplo "reclutamiento
  // sin RQ" y "candidato en dos solicitudes" (ver más abajo).
  const posIncapacidadLM = EQUIPO_DIRECTO_SEED.find(p => p.jefeEmpId === 'E0067' && p.empleadoOcupanteId === 'E0198');
  const solIncapacidad = crearSolicitud({
    tipoId: 'reemplazo_incapacidad', ...LM, sociedad: 'ECOENTORNO', cargoId: 'CGO-003', cargoNombre: 'Op. Aprovechamiento',
    planta: 'Planta Yumbo', centroCosto: 'CC-APR-006', colaboradorAfectadoId: 'E0198',
    posicionAsociadaCodigo: posIncapacidadLM ? posIncapacidadLM.codigo : null,
    formulario: { fechaInicioIncapacidad: '01/09/2026', fechaFinIncapacidad: '01/11/2026', dias: 61 },
  });
  _avanzarTodo(solIncapacidad.id, GH);
  iniciarReclutamiento(solIncapacidad.id, GH);
  const postDaniela = crearPostulado({
    solicitudId: solIncapacidad.id, nombreCompleto: 'Daniela Salazar Ruiz', tipoDocumento: 'CC', numeroDocumento: '1094556230',
    celular: '+57 320 887 4456', hojaVidaNombreArchivo: 'HV_Daniela_Salazar.pdf', fuente: 'portal', actor: GH,
  });

  // 3) Reemplazo por vacaciones — caso activo para que el jefe consulte el
  // pipeline y califique hojas de vida desde Mis solicitudes.
  const posVacacionesDemo = EQUIPO_DIRECTO_SEED.find(p =>
    p.jefeEmpId === 'E0067' && p.cargo === 'Aux. Aprovechamiento' && p.planta === 'Planta Cali' && p.estadoOcupacion === 'ocupada'
  );
  const solVacacionesDemo = crearSolicitud({
    tipoId: 'reemplazo_vacaciones', ...LM, sociedad: 'ECOENTORNO', cargoId: 'CGO-004', cargoNombre: 'Aux. Aprovechamiento',
    planta: 'Planta Cali', centroCosto: 'CC-APR-006', colaboradorAfectadoId: posVacacionesDemo ? posVacacionesDemo.empleadoOcupanteId : null,
    posicionAsociadaCodigo: posVacacionesDemo ? posVacacionesDemo.codigo : null,
    visibleParaEmpIds: ['E0023'],
    formulario: { fechaInicioVacaciones: '05/10/2026', fechaFinVacaciones: '20/10/2026', dias: 15 },
  });
  _avanzarTodo(solVacacionesDemo.id, GH);
  iniciarReclutamiento(solVacacionesDemo.id, GH);
  const postuladosVacacionesDemo = [
    { nombreCompleto: 'Laura Marcela Benítez', numeroDocumento: '1144098211', fuente: 'portal', archivo: 'HV_Laura_Benitez.pdf' },
    { nombreCompleto: 'Julián Esteban Córdoba', numeroDocumento: '1061785420', fuente: 'referido', archivo: 'HV_Julian_Cordoba.pdf' },
    { nombreCompleto: 'Yessica Paola Mina', numeroDocumento: '1006204751', fuente: 'temporal', temporalNombre: 'Jiro', archivo: 'HV_Yessica_Mina.pdf' },
  ].map(c => crearPostulado({
    solicitudId: solVacacionesDemo.id, nombreCompleto: c.nombreCompleto, tipoDocumento: 'CC', numeroDocumento: c.numeroDocumento,
    celular: '+57 310 555 0101', hojaVidaNombreArchivo: c.archivo, fuente: c.fuente, temporalNombre: c.temporalNombre, actor: GH,
  }).postulacion);
  moverPostulacion(postuladosVacacionesDemo[1].id, 'entrevista_gh', GH);
  moverPostulacion(postuladosVacacionesDemo[2].id, 'entrevista_gh', GH);
  moverPostulacion(postuladosVacacionesDemo[2].id, 'entrevista_jefe', GH);

  // 4) Reemplazo por vacante — segundo caso activo, asociado a una posición
  // vacía de Clasificación y con candidatos en tres momentos del pipeline.
  const posClasificacionDemo = EQUIPO_DIRECTO_SEED.find(p =>
    p.jefeEmpId === 'E0067' && p.cargo === 'Operario de Clasificación' && p.estadoOcupacion === 'vacante'
  );
  const solVacanteClasificacionDemo = crearSolicitud({
    tipoId: 'reemplazo_vacante', ...LM, sociedad: 'ASEI', cargoId: 'CGO-009', cargoNombre: 'Operario de Clasificación',
    planta: 'Planta Cali', centroCosto: 'CC-OP-010', posicionAsociadaCodigo: posClasificacionDemo ? posClasificacionDemo.codigo : null,
    visibleParaEmpIds: ['E0023'],
    formulario: { descripcion: 'Cobertura de posición vacante en línea de clasificación', requerimientos: 'Experiencia operativa deseable' },
  });
  _avanzarTodo(solVacanteClasificacionDemo.id, GH);
  iniciarReclutamiento(solVacanteClasificacionDemo.id, GH);
  const postuladosVacanteDemo = [
    { nombreCompleto: 'Óscar David Valencia', numeroDocumento: '1112486039', fuente: 'directa', archivo: 'HV_Oscar_Valencia.pdf' },
    { nombreCompleto: 'Diana Carolina Mosquera', numeroDocumento: '1004198276', fuente: 'portal', archivo: 'HV_Diana_Mosquera.pdf' },
    { nombreCompleto: 'Brayan Stiven Caicedo', numeroDocumento: '1143875210', fuente: 'temporal', temporalNombre: 'G.O.', archivo: 'HV_Brayan_Caicedo.pdf' },
  ].map(c => crearPostulado({
    solicitudId: solVacanteClasificacionDemo.id, nombreCompleto: c.nombreCompleto, tipoDocumento: 'CC', numeroDocumento: c.numeroDocumento,
    celular: '+57 315 555 0202', hojaVidaNombreArchivo: c.archivo, fuente: c.fuente, temporalNombre: c.temporalNombre, actor: GH,
  }).postulacion);
  moverPostulacion(postuladosVacanteDemo[1].id, 'entrevista_gh', GH);
  moverPostulacion(postuladosVacanteDemo[2].id, 'entrevista_gh', GH);
  moverPostulacion(postuladosVacanteDemo[2].id, 'entrevista_jefe', GH);
  moverPostulacion(postuladosVacanteDemo[2].id, 'pruebas', GH);

  // 5) Reemplazo con aumento salarial — Devuelta con corrección.
  const solDevuelta = crearSolicitud({
    tipoId: 'reemplazo_aumento_salarial', ...CR, sociedad: 'ASEI', cargoId: null, cargoNombre: 'Aux. Recursos Humanos',
    planta: 'Cali', centroCosto: 'CC-010 Administración', colaboradorAfectadoId: 'E0094',
    formulario: { salarioActual: 1600000, salarioPropuesto: 1950000, motivo: 'Ampliación de funciones' },
  });
  decidirEtapa(solDevuelta.id, 'devolver', { actor: GH, comentario: 'Falta soporte de la evaluación de desempeño que justifique el aumento.' });

  // 6) Ampliación de nómina · cargo existente — 5 posiciones. Recorre todo
  // el ciclo: aprobación completa → 5 posiciones nuevas → Iniciar
  // reclutamiento → 5 postulados → pipeline hasta Estudios → rutas mixtas:
  // directa exitosa, temporal devuelta, directa con error SAP, temporal
  // exitosa y temporal pendiente. La posición liberada por la devolución se
  // reutiliza además para demostrar SAP exitoso / SOMOS fallido.
  const solMulticupo = crearSolicitud({
    tipoId: 'ampliacion_cargo_existente', ...LM, sociedad: 'ECOENTORNO', cargoId: 'CGO-003', cargoNombre: 'Op. Aprovechamiento',
    planta: 'Planta Yumbo', centroCosto: 'CC-APR-006', cantidadCupos: 5,
    formulario: { motivo: 'Incremento sostenido del volumen de material aprovechable', proyecto: 'Ampliación línea 3' },
  });
  _avanzarTodo(solMulticupo.id, GH);
  iniciarReclutamiento(solMulticupo.id, GH);
  registrarRQ(solMulticupo.id, 'Jiro', 'RQ-2026-4471', GH);

  const candidatosMulticupo = [
    { nombreCompleto: 'Andrés Felipe Rojas Gil', doc: '1098774331', fuente: 'temporal', temporalNombre: 'Jiro' },
    { nombreCompleto: 'Katherin Muñoz Salazar', doc: '1098774332', fuente: 'referido' },
    { nombreCompleto: 'Jorge Luis Perea Mosquera', doc: '1098774333', fuente: 'portal' },
    { nombreCompleto: 'Silvia Juliana Cárdenas', doc: '1098774334', fuente: 'directa' },
    { nombreCompleto: 'Wilmer Andrés Castillo', doc: '1098774335', fuente: 'temporal', temporalNombre: 'G.O.' },
  ];
  const postsMulticupo = candidatosMulticupo.map(c => crearPostulado({
    solicitudId: solMulticupo.id, nombreCompleto: c.nombreCompleto, tipoDocumento: 'CC', numeroDocumento: c.doc,
    celular: '+57 300 000 0000', hojaVidaNombreArchivo: `HV_${c.nombreCompleto.split(' ')[0]}.pdf`,
    fuente: c.fuente, temporalNombre: c.temporalNombre, actor: GH,
  }).postulacion);
  postsMulticupo.forEach(p => {
    moverPostulacion(p.id, 'entrevista_gh', GH);
    moverPostulacion(p.id, 'entrevista_jefe', LM.jefeNombre);
    moverPostulacion(p.id, 'pruebas', GH);
    moverPostulacion(p.id, 'estudios', GH);
  });
  const posicionesMulticupo = getPosicionesDisponiblesSolicitud(solMulticupo.id);
  pasarACierreSeleccion(postsMulticupo[0].id, posicionesMulticupo[0].codigo, 'directa', null, GH); // llegó por Jiro, vinculación directa
  pasarACierreSeleccion(postsMulticupo[1].id, posicionesMulticupo[1].codigo, 'temporal', 'G.O.', GH); // referido, vinculación temporal
  pasarACierreSeleccion(postsMulticupo[2].id, posicionesMulticupo[2].codigo, 'directa', null, GH);
  pasarACierreSeleccion(postsMulticupo[3].id, posicionesMulticupo[3].codigo, 'temporal', 'Jiro', GH); // fuente directa, vinculación temporal
  pasarACierreSeleccion(postsMulticupo[4].id, posicionesMulticupo[4].codigo, 'temporal', 'Soluciones Inmediatas', GH); // presentado por G.O., contratado por otra temporal
  // Calificaciones del jefe — no mueven ni deciden nada.
  calificarPostulacion(postsMulticupo[0].id, 5, 'Excelente entrevista técnica', LM.jefeNombre);
  calificarPostulacion(postsMulticupo[1].id, 3, '', LM.jefeNombre);

  const { caso: casoApto } = declararApto(postsMulticupo[0].id, 'Patricia Gómez Lara · Contratadora');
  devolverAPostulados(postsMulticupo[1].id, 'No apto en examen médico ocupacional', 'Resultado informado por G.O.; se recomienda evaluar nuevamente en 3 meses', GH);
  const { caso: casoErrorSap } = declararApto(postsMulticupo[2].id, 'Patricia Gómez Lara · Contratadora');
  const { caso: casoTemporalExitoso } = confirmarContratacionTemporal(postsMulticupo[3].id, GH, 'Jiro confirmó exámenes, documentos y contratación completados.');
  iniciarAltaSAP(casoApto.id, 'exitoso', 'Ana María Bermúdez · Creadora de personal');
  iniciarAltaSAP(casoErrorSap.id, 'sap_falla', 'Ana María Bermúdez · Creadora de personal');
  iniciarAltaSAP(casoTemporalExitoso.id, 'exitoso', 'Ana María Bermúdez · Creadora de personal');

  // Reutiliza la posición liberada por la devolución y conserva la candidata
  // devuelta en Postulados como evidencia del intento anterior.
  const postReintento = crearPostulado({
    solicitudId: solMulticupo.id, nombreCompleto: 'Mariana Alejandra Vélez', tipoDocumento: 'CC', numeroDocumento: '1098774336',
    celular: '+57 300 000 0011', hojaVidaNombreArchivo: 'HV_Mariana_Velez.pdf', fuente: 'portal', actor: GH,
  }).postulacion;
  moverPostulacion(postReintento.id, 'estudios', GH);
  const posicionLiberada = getPosicionesDisponiblesSolicitud(solMulticupo.id)[0];
  pasarACierreSeleccion(postReintento.id, posicionLiberada.codigo, 'directa', null, GH);
  const { caso: casoSapOkSomosError } = declararApto(postReintento.id, 'Patricia Gómez Lara · Contratadora');
  iniciarAltaSAP(casoSapOkSomosError.id, 'sap_ok_somos_falla', 'Ana María Bermúdez · Creadora de personal');
  // El quinto candidato original queda en Confirmación temporal esperando
  // respuesta de Soluciones Inmediatas; su fuente sigue siendo G.O.

  // 5) Ampliación de nómina · cargo nuevo — Rechazada.
  const solRechazada = crearSolicitud({
    tipoId: 'ampliacion_cargo_nuevo', ...CR, sociedad: 'ASEI', cargoId: null, cargoNombre: 'Coordinador de Experiencia al Colaborador',
    planta: 'Cali', centroCosto: 'CC-010 Administración', cantidadCupos: 1,
    formulario: { motivo: 'Propuesta de nuevo cargo para bienestar y clima organizacional' },
  });
  decidirEtapa(solRechazada.id, 'rechazar', { actor: GH, comentario: 'No existe presupuesto aprobado para un cargo nuevo este semestre.' });

  // 6) Cambio de centro de costo — no abre reclutamiento; se finaliza directo.
  const solCambioCC = crearSolicitud({
    tipoId: 'cambio_centro_costo', ...CR, sociedad: 'ASEI', cargoId: null, cargoNombre: 'Aux. Recursos Humanos',
    planta: 'Cali', centroCosto: 'CC-010 Administración', colaboradorAfectadoId: 'E0094',
    formulario: { centroCostoDestino: 'CC-020 Compras' },
  });
  _avanzarTodo(solCambioCC.id, GH);
  finalizarSinReclutamiento(solCambioCC.id, GH);

  // 7) Contratación directa — sin pipeline de selección.
  const solDirecta = crearSolicitud({
    tipoId: 'contratacion_directa', ...CR, sociedad: 'ASEI', cargoId: 'CGO-003', cargoNombre: 'Op. Aprovechamiento',
    planta: 'Planta Yumbo', centroCosto: 'CC-APR-006', cantidadCupos: 1,
    formulario: { motivo: 'Cubrimiento inmediato por referido validado directamente por el Director de Aprovechamiento' },
  });
  _avanzarTodo(solDirecta.id, GH);
  const posDirecta = agregarPosicionEquipo('E0067', 'Op. Aprovechamiento', 'Planta Yumbo');
  solDirecta.posicionesCodigos = [posDirecta.codigo];
  const { postulacion: postDirecta } = registrarCandidatoDirecto(
    solDirecta.id,
    { nombreCompleto: 'Camilo Ernesto Zapata Ríos', tipoDocumento: 'CC', numeroDocumento: '1098774340', celular: '+57 300 111 2233', hojaVidaNombreArchivo: 'HV_Camilo_Zapata.pdf' },
    posDirecta.codigo, GH
  );
  const { caso: casoDirecto } = declararApto(postDirecta.id, 'Patricia Gómez Lara · Contratadora');
  iniciarAltaSAP(casoDirecto.id, 'exitoso', 'Ana María Bermúdez · Creadora de personal');

  // 8) Solicitud confidencial — visible solo para su jefe y GH autorizado.
  crearSolicitud({
    tipoId: 'reemplazo_vacante', ...LM, sociedad: 'ECOENTORNO', cargoId: 'CGO-004', cargoNombre: 'Operario de Clasificación',
    planta: 'Planta Cali', centroCosto: 'CC-OP-010', colaboradorAfectadoId: 'E9003', confidencial: true,
    posicionAsociadaCodigo: posClasificacionDemo ? posClasificacionDemo.codigo : null,
    formulario: { motivo: 'Reemplazo bajo reserva por proceso disciplinario en curso' },
  });

  // 9) Solicitud cancelada (antes de cualquier alta SAP).
  const solCancelada = crearSolicitud({
    tipoId: 'aumento_salarial', ...CR, sociedad: 'ASEI', cargoId: null, cargoNombre: 'Aux. Recursos Humanos',
    planta: 'Cali', centroCosto: 'CC-010 Administración', colaboradorAfectadoId: 'E0094',
    formulario: { salarioActual: 1600000, salarioPropuesto: 1750000 },
  });
  cancelarSolicitud(solCancelada.id, 'El área desistió del ajuste salarial para este ciclo.', GH);

  // Referencia global de solo lectura para inspección/depuración manual.
  window.__RECRUITMENT_SEED_IDS__ = {
    solReemplazo: solReemplazo.id, solIncapacidad: solIncapacidad.id, solDevuelta: solDevuelta.id,
    solMulticupo: solMulticupo.id, solRechazada: solRechazada.id, solCambioCC: solCambioCC.id,
    solDirecta: solDirecta.id, solCancelada: solCancelada.id,
    postDirectoExitoso: postsMulticupo[0].id, postTemporalDevuelto: postsMulticupo[1].id,
    postTemporalExitoso: postsMulticupo[3].id, postTemporalPendiente: postsMulticupo[4].id,
    postSapOkSomosError: postReintento.id,
  };
})();
