paperclip-plugin-autopilot-ops 0.1.20 → 0.1.22

package/dist/manifest.js

@@ -1,6 +1,6 @@
 // src/manifest.ts
 var PLUGIN_ID = "alephoo.autopilot-ops";
-var PLUGIN_VERSION = "0.1.20";
+var PLUGIN_VERSION = "0.1.22";
 var DB_NAMESPACE_SLUG = "autopilot_ops";
 var PAGE_ROUTE = "autopilot";
 var TOOL_NAMES = {
@@ -113,7 +113,7 @@ var manifest = {
     {
       name: TOOL_NAMES.abrirCaso,
       displayName: "Abrir caso",
-      description: 'Abre un caso nuevo en un workflow, en su estado inicial. Workflows: `demanda_pendiente` (referencia obligatoria `orden:<id>`, `solicitud:<id>` o `control:<persona_id>:<regla_id>`; datos: regla_id obligatorio y la regla tiene que estar activa, persona_id, tipo de origen, estudio o especialidad o prestacion, fecha_origen AAAA-MM-DD, dias; el plugin fija regla_version, canal, intentos, vence_el; nunca nombre, documento ni tel\xE9fono del paciente),`actualizacion_arancel`, `tarea_operativa`, `recupero_turno` (datos: fecha AAAA-MM-DD, hora HH:MM, profesional, especialidad del turno libre; referencia "AAAA-MM-DD HH:MM \xB7 Profesional"), `cuenta_completa` (una prestaci\xF3n pendiente de facturar con faltantes; referencia obligatoria "bono:<n\xFAmero>", datos: bono_id, bono_numero, obra_social, plan, prestacion, fecha_prestacion AAAA-MM-DD, monto_pesos, internacion_id opcional; en faltantes, `responsable` {tipo profesional, id, nombre} opcional para que el plugin avise a quien resuelve), `facturacion_pendiente` (una prestaci\xF3n sin facturar; misma referencia `bono:<n\xFAmero>` y mismos datos; el plugin calcula plazo_dias, vence_el y plazo_confirmado con los plazos por obra social de la instituci\xF3n), `credencial_profesional` (un profesional con agenda; referencia obligatoria `profesional:<id>`; datos: profesional_id, profesional (apellido y nombre, es personal de la instituci\xF3n), matricula_nacional, matricula_provincial, codigo_provincia, especialidades). `referencia` identifica el objeto real (convenio, cuenta, turno) y evita duplicados: si ya existe un caso abierto con la misma referencia, se devuelve ese. Pasar `idempotencyKey` para reintentos seguros.',
+      description: 'Abre un caso nuevo en un workflow, en su estado inicial. Workflows: `circular_aranceles` (una circular de aranceles entera; referencia obligatoria `circular:<obra social>:<hash corto del archivo>`; datos: obra_social, convenio (nombre en el HIS), archivo {nombre, hash, paginas}, vigencia_desde AAAA-MM-DD, porcentaje_declarado y filas_declaradas si la circular los dice), `demanda_pendiente` (referencia obligatoria `orden:<id>`, `solicitud:<id>` o `control:<persona_id>:<regla_id>`; datos: regla_id obligatorio y la regla tiene que estar activa, persona_id, tipo de origen, estudio o especialidad o prestacion, fecha_origen AAAA-MM-DD, dias; el plugin fija regla_version, canal, intentos, vence_el; nunca nombre, documento ni tel\xE9fono del paciente),`actualizacion_arancel`, `tarea_operativa`, `recupero_turno` (datos: fecha AAAA-MM-DD, hora HH:MM, profesional, especialidad del turno libre; referencia "AAAA-MM-DD HH:MM \xB7 Profesional"), `cuenta_completa` (una prestaci\xF3n pendiente de facturar con faltantes; referencia obligatoria "bono:<n\xFAmero>", datos: bono_id, bono_numero, obra_social, plan, prestacion, fecha_prestacion AAAA-MM-DD, monto_pesos, internacion_id opcional; en faltantes, `responsable` {tipo profesional, id, nombre} opcional para que el plugin avise a quien resuelve), `facturacion_pendiente` (una prestaci\xF3n sin facturar; misma referencia `bono:<n\xFAmero>` y mismos datos; el plugin calcula plazo_dias, vence_el y plazo_confirmado con los plazos por obra social de la instituci\xF3n), `credencial_profesional` (un profesional con agenda; referencia obligatoria `profesional:<id>`; datos: profesional_id, profesional (apellido y nombre, es personal de la instituci\xF3n), matricula_nacional, matricula_provincial, codigo_provincia, especialidades). `referencia` identifica el objeto real (convenio, cuenta, turno) y evita duplicados: si ya existe un caso abierto con la misma referencia, se devuelve ese. Pasar `idempotencyKey` para reintentos seguros.',
       parametersSchema: {
         type: "object",
         properties: {
@@ -130,7 +130,7 @@ var manifest = {
     {
       name: TOOL_NAMES.transicionar,
       displayName: "Transicionar caso",
-      description: 'Aplica una transici\xF3n del workflow al caso (p. ej. `proponer`, `aplicar`, `verificar`). El plugin valida contra la tabla de transiciones, la pol\xEDtica vigente (observa / propone / ejecuta / corte) y las reglas de negocio; si algo falla, el caso no cambia y se devuelve el motivo. Las transiciones humanas (aprobar, rechazar, corregir) no est\xE1n disponibles para agentes. Cuando una persona de la instituci\xF3n carga a mano lo aprobado, el caso queda en `aplicado`: el agente lo comprueba releyendo el sistema y llamando `verificar` con `datos.valor_leido`. En `recupero_turno`: `proponer` con solicitud_id, solicitud_estado, solicitud_especialidad, cola (la lista de espera pendiente de esa especialidad tal como se vio: [{solicitud_id, prioridad, alta}]; el plugin la ordena y exige justificaci\xF3n para no elegir la primera) y fuente; si la instituci\xF3n pide consulta previa (ops_leer_caso lo dice), `ofrecer` con canal y esperar `aceptar`/`no_acepta`; **antes de escribir en el sistema, `autorizar`** (sin esa autorizaci\xF3n no se escribe); despu\xE9s de escribir, `asignar` con accion_id; `verificar` con leido_fecha, leido_hora, leido_profesional y leido_solicitud_id; `sin_candidato` y `descartar` con motivo. En `cuenta_completa` el agente solo lee: `observar` con bono_id, bono_estado (no_confirmado, confirmado o prefacturado), faltantes [{regla, detalle, item?}] con reglas del cat\xE1logo (autorizacion_faltante, validacion_faltante, afiliado_faltante, orden_faltante, prestacion_sin_valor, epicrisis_faltante), lectura_id (la lectura registrada con ops_registrar_accion, conector "base") y fuente; `comprobar` con faltantes_leidos (lista vac\xEDa si ya est\xE1 completo), bono_estado_leido y lectura_id; `descartar` con motivo si el bono se elimin\xF3 o anul\xF3. En `facturacion_pendiente` (solo lee): `observar` con bono_id, bono_estado, fecha_prestacion, obra_social, lectura_id (conector "base") y fuente; `comprobar` con bono_estado_leido y lectura_id (facturado/refacturado \u2192 facturada; prefacturado \u2192 en prefactura; si no, sigue por presentar); `descartar` con motivo. En `demanda_pendiente`: `contactar` (nivel ejecuta; datos: canal igual al de la regla y accion_id de la escritura registrada; el plugin controla regla activa, intentos, espera entre intentos y horario), `responder` (respuesta: acepta|rechaza|no_contesta), `comprobar` (lectura_id de la relectura del HIS, turno_id y turno_estado del turno encontrado), `cerrar` (motivo; solo con los intentos agotados o el plazo vencido), `descartar` (motivo). `credencial_profesional` (solo lee): `verificar` con profesional_id, matricula y tipo_matricula (nacional|provincial) si hay matr\xEDcula, resultado = el objeto que devuelve verificar-matriculas.mjs tal cual ({sin_matricula, encontrada, coincide_nombre, situacion, sancion, profesion, provincia, emisor}), lectura_id (conector "api", la consulta al registro) y fuente; el plugin decide vigente u observada y fija la observaci\xF3n (sin_matricula, no_figura, otra_persona, inhabilitada, sancion); `descartar` con motivo si el profesional ya no est\xE1 activo.',
+      description: 'Aplica una transici\xF3n del workflow al caso (p. ej. `proponer`, `aplicar`, `verificar`). El plugin valida contra la tabla de transiciones, la pol\xEDtica vigente (observa / propone / ejecuta / corte) y las reglas de negocio; si algo falla, el caso no cambia y se devuelve el motivo. Las transiciones humanas (aprobar, rechazar, corregir) no est\xE1n disponibles para agentes. Cuando una persona de la instituci\xF3n carga a mano lo aprobado, el caso queda en `aplicado`: el agente lo comprueba releyendo el sistema y llamando `verificar` con `datos.valor_leido`. En `recupero_turno`: `proponer` con solicitud_id, solicitud_estado, solicitud_especialidad, cola (la lista de espera pendiente de esa especialidad tal como se vio: [{solicitud_id, prioridad, alta}]; el plugin la ordena y exige justificaci\xF3n para no elegir la primera) y fuente; si la instituci\xF3n pide consulta previa (ops_leer_caso lo dice), `ofrecer` con canal y esperar `aceptar`/`no_acepta`; **antes de escribir en el sistema, `autorizar`** (sin esa autorizaci\xF3n no se escribe); despu\xE9s de escribir, `asignar` con accion_id; `verificar` con leido_fecha, leido_hora, leido_profesional y leido_solicitud_id; `sin_candidato` y `descartar` con motivo. En `cuenta_completa` el agente solo lee: `observar` con bono_id, bono_estado (no_confirmado, confirmado o prefacturado), faltantes [{regla, detalle, item?}] con reglas del cat\xE1logo (autorizacion_faltante, validacion_faltante, afiliado_faltante, orden_faltante, prestacion_sin_valor, epicrisis_faltante), lectura_id (la lectura registrada con ops_registrar_accion, conector "base") y fuente; `comprobar` con faltantes_leidos (lista vac\xEDa si ya est\xE1 completo), bono_estado_leido y lectura_id; `descartar` con motivo si el bono se elimin\xF3 o anul\xF3. En `facturacion_pendiente` (solo lee): `observar` con bono_id, bono_estado, fecha_prestacion, obra_social, lectura_id (conector "base") y fuente; `comprobar` con bono_estado_leido y lectura_id (facturado/refacturado \u2192 facturada; prefacturado \u2192 en prefactura; si no, sigue por presentar); `descartar` con motivo. En `circular_aranceles`: `extraer` con extraccion_a (lo que ley\xF3 el agente) y extraccion_b (la salida de leer-circular.mjs, tal cual) como [{codigo, nombre, valor_nuevo}], actual (la salida de leer-convenio.mjs: [{codigo, nombre, componentes:[{arancel, monto}], copago, tipo_copago}]), lectura_id (lectura del convenio, conector base o api), lectura_circular_id (lectura de la circular, conector archivo) y fuente; el plugin cruza las tres fuentes y decide qu\xE9 se propone, qu\xE9 se revisa y qu\xE9 es excepci\xF3n (el agente no decide eso); `proponer` sin datos; despu\xE9s de la carga, `verificar` con leidos (la salida de leer-convenio.mjs tras la carga) y lectura_id; `cancelar` con motivo. En `demanda_pendiente`: `contactar` (nivel ejecuta; datos: canal igual al de la regla y accion_id de la escritura registrada; el plugin controla regla activa, intentos, espera entre intentos y horario), `responder` (respuesta: acepta|rechaza|no_contesta), `comprobar` (lectura_id de la relectura del HIS, turno_id y turno_estado del turno encontrado), `cerrar` (motivo; solo con los intentos agotados o el plazo vencido), `descartar` (motivo). `credencial_profesional` (solo lee): `verificar` con profesional_id, matricula y tipo_matricula (nacional|provincial) si hay matr\xEDcula, resultado = el objeto que devuelve verificar-matriculas.mjs tal cual ({sin_matricula, encontrada, coincide_nombre, situacion, sancion, profesion, provincia, emisor}), lectura_id (conector "api", la consulta al registro) y fuente; el plugin decide vigente u observada y fija la observaci\xF3n (sin_matricula, no_figura, otra_persona, inhabilitada, sancion); `descartar` con motivo si el profesional ya no est\xE1 activo.',
       parametersSchema: {
         type: "object",
         properties: {

package/dist/ui/index.js

@@ -8,7 +8,7 @@ import {
 
 // src/manifest.ts
 var PLUGIN_ID = "alephoo.autopilot-ops";
-var PLUGIN_VERSION = "0.1.20";
+var PLUGIN_VERSION = "0.1.22";
 var DB_NAMESPACE_SLUG = "autopilot_ops";
 var PAGE_ROUTE = "autopilot";
 var TOOL_NAMES = {
@@ -121,7 +121,7 @@ var manifest = {
     {
       name: TOOL_NAMES.abrirCaso,
       displayName: "Abrir caso",
-      description: 'Abre un caso nuevo en un workflow, en su estado inicial. Workflows: `demanda_pendiente` (referencia obligatoria `orden:<id>`, `solicitud:<id>` o `control:<persona_id>:<regla_id>`; datos: regla_id obligatorio y la regla tiene que estar activa, persona_id, tipo de origen, estudio o especialidad o prestacion, fecha_origen AAAA-MM-DD, dias; el plugin fija regla_version, canal, intentos, vence_el; nunca nombre, documento ni tel\xE9fono del paciente),`actualizacion_arancel`, `tarea_operativa`, `recupero_turno` (datos: fecha AAAA-MM-DD, hora HH:MM, profesional, especialidad del turno libre; referencia "AAAA-MM-DD HH:MM \xB7 Profesional"), `cuenta_completa` (una prestaci\xF3n pendiente de facturar con faltantes; referencia obligatoria "bono:<n\xFAmero>", datos: bono_id, bono_numero, obra_social, plan, prestacion, fecha_prestacion AAAA-MM-DD, monto_pesos, internacion_id opcional; en faltantes, `responsable` {tipo profesional, id, nombre} opcional para que el plugin avise a quien resuelve), `facturacion_pendiente` (una prestaci\xF3n sin facturar; misma referencia `bono:<n\xFAmero>` y mismos datos; el plugin calcula plazo_dias, vence_el y plazo_confirmado con los plazos por obra social de la instituci\xF3n), `credencial_profesional` (un profesional con agenda; referencia obligatoria `profesional:<id>`; datos: profesional_id, profesional (apellido y nombre, es personal de la instituci\xF3n), matricula_nacional, matricula_provincial, codigo_provincia, especialidades). `referencia` identifica el objeto real (convenio, cuenta, turno) y evita duplicados: si ya existe un caso abierto con la misma referencia, se devuelve ese. Pasar `idempotencyKey` para reintentos seguros.',
+      description: 'Abre un caso nuevo en un workflow, en su estado inicial. Workflows: `circular_aranceles` (una circular de aranceles entera; referencia obligatoria `circular:<obra social>:<hash corto del archivo>`; datos: obra_social, convenio (nombre en el HIS), archivo {nombre, hash, paginas}, vigencia_desde AAAA-MM-DD, porcentaje_declarado y filas_declaradas si la circular los dice), `demanda_pendiente` (referencia obligatoria `orden:<id>`, `solicitud:<id>` o `control:<persona_id>:<regla_id>`; datos: regla_id obligatorio y la regla tiene que estar activa, persona_id, tipo de origen, estudio o especialidad o prestacion, fecha_origen AAAA-MM-DD, dias; el plugin fija regla_version, canal, intentos, vence_el; nunca nombre, documento ni tel\xE9fono del paciente),`actualizacion_arancel`, `tarea_operativa`, `recupero_turno` (datos: fecha AAAA-MM-DD, hora HH:MM, profesional, especialidad del turno libre; referencia "AAAA-MM-DD HH:MM \xB7 Profesional"), `cuenta_completa` (una prestaci\xF3n pendiente de facturar con faltantes; referencia obligatoria "bono:<n\xFAmero>", datos: bono_id, bono_numero, obra_social, plan, prestacion, fecha_prestacion AAAA-MM-DD, monto_pesos, internacion_id opcional; en faltantes, `responsable` {tipo profesional, id, nombre} opcional para que el plugin avise a quien resuelve), `facturacion_pendiente` (una prestaci\xF3n sin facturar; misma referencia `bono:<n\xFAmero>` y mismos datos; el plugin calcula plazo_dias, vence_el y plazo_confirmado con los plazos por obra social de la instituci\xF3n), `credencial_profesional` (un profesional con agenda; referencia obligatoria `profesional:<id>`; datos: profesional_id, profesional (apellido y nombre, es personal de la instituci\xF3n), matricula_nacional, matricula_provincial, codigo_provincia, especialidades). `referencia` identifica el objeto real (convenio, cuenta, turno) y evita duplicados: si ya existe un caso abierto con la misma referencia, se devuelve ese. Pasar `idempotencyKey` para reintentos seguros.',
       parametersSchema: {
         type: "object",
         properties: {
@@ -138,7 +138,7 @@ var manifest = {
     {
       name: TOOL_NAMES.transicionar,
       displayName: "Transicionar caso",
-      description: 'Aplica una transici\xF3n del workflow al caso (p. ej. `proponer`, `aplicar`, `verificar`). El plugin valida contra la tabla de transiciones, la pol\xEDtica vigente (observa / propone / ejecuta / corte) y las reglas de negocio; si algo falla, el caso no cambia y se devuelve el motivo. Las transiciones humanas (aprobar, rechazar, corregir) no est\xE1n disponibles para agentes. Cuando una persona de la instituci\xF3n carga a mano lo aprobado, el caso queda en `aplicado`: el agente lo comprueba releyendo el sistema y llamando `verificar` con `datos.valor_leido`. En `recupero_turno`: `proponer` con solicitud_id, solicitud_estado, solicitud_especialidad, cola (la lista de espera pendiente de esa especialidad tal como se vio: [{solicitud_id, prioridad, alta}]; el plugin la ordena y exige justificaci\xF3n para no elegir la primera) y fuente; si la instituci\xF3n pide consulta previa (ops_leer_caso lo dice), `ofrecer` con canal y esperar `aceptar`/`no_acepta`; **antes de escribir en el sistema, `autorizar`** (sin esa autorizaci\xF3n no se escribe); despu\xE9s de escribir, `asignar` con accion_id; `verificar` con leido_fecha, leido_hora, leido_profesional y leido_solicitud_id; `sin_candidato` y `descartar` con motivo. En `cuenta_completa` el agente solo lee: `observar` con bono_id, bono_estado (no_confirmado, confirmado o prefacturado), faltantes [{regla, detalle, item?}] con reglas del cat\xE1logo (autorizacion_faltante, validacion_faltante, afiliado_faltante, orden_faltante, prestacion_sin_valor, epicrisis_faltante), lectura_id (la lectura registrada con ops_registrar_accion, conector "base") y fuente; `comprobar` con faltantes_leidos (lista vac\xEDa si ya est\xE1 completo), bono_estado_leido y lectura_id; `descartar` con motivo si el bono se elimin\xF3 o anul\xF3. En `facturacion_pendiente` (solo lee): `observar` con bono_id, bono_estado, fecha_prestacion, obra_social, lectura_id (conector "base") y fuente; `comprobar` con bono_estado_leido y lectura_id (facturado/refacturado \u2192 facturada; prefacturado \u2192 en prefactura; si no, sigue por presentar); `descartar` con motivo. En `demanda_pendiente`: `contactar` (nivel ejecuta; datos: canal igual al de la regla y accion_id de la escritura registrada; el plugin controla regla activa, intentos, espera entre intentos y horario), `responder` (respuesta: acepta|rechaza|no_contesta), `comprobar` (lectura_id de la relectura del HIS, turno_id y turno_estado del turno encontrado), `cerrar` (motivo; solo con los intentos agotados o el plazo vencido), `descartar` (motivo). `credencial_profesional` (solo lee): `verificar` con profesional_id, matricula y tipo_matricula (nacional|provincial) si hay matr\xEDcula, resultado = el objeto que devuelve verificar-matriculas.mjs tal cual ({sin_matricula, encontrada, coincide_nombre, situacion, sancion, profesion, provincia, emisor}), lectura_id (conector "api", la consulta al registro) y fuente; el plugin decide vigente u observada y fija la observaci\xF3n (sin_matricula, no_figura, otra_persona, inhabilitada, sancion); `descartar` con motivo si el profesional ya no est\xE1 activo.',
+      description: 'Aplica una transici\xF3n del workflow al caso (p. ej. `proponer`, `aplicar`, `verificar`). El plugin valida contra la tabla de transiciones, la pol\xEDtica vigente (observa / propone / ejecuta / corte) y las reglas de negocio; si algo falla, el caso no cambia y se devuelve el motivo. Las transiciones humanas (aprobar, rechazar, corregir) no est\xE1n disponibles para agentes. Cuando una persona de la instituci\xF3n carga a mano lo aprobado, el caso queda en `aplicado`: el agente lo comprueba releyendo el sistema y llamando `verificar` con `datos.valor_leido`. En `recupero_turno`: `proponer` con solicitud_id, solicitud_estado, solicitud_especialidad, cola (la lista de espera pendiente de esa especialidad tal como se vio: [{solicitud_id, prioridad, alta}]; el plugin la ordena y exige justificaci\xF3n para no elegir la primera) y fuente; si la instituci\xF3n pide consulta previa (ops_leer_caso lo dice), `ofrecer` con canal y esperar `aceptar`/`no_acepta`; **antes de escribir en el sistema, `autorizar`** (sin esa autorizaci\xF3n no se escribe); despu\xE9s de escribir, `asignar` con accion_id; `verificar` con leido_fecha, leido_hora, leido_profesional y leido_solicitud_id; `sin_candidato` y `descartar` con motivo. En `cuenta_completa` el agente solo lee: `observar` con bono_id, bono_estado (no_confirmado, confirmado o prefacturado), faltantes [{regla, detalle, item?}] con reglas del cat\xE1logo (autorizacion_faltante, validacion_faltante, afiliado_faltante, orden_faltante, prestacion_sin_valor, epicrisis_faltante), lectura_id (la lectura registrada con ops_registrar_accion, conector "base") y fuente; `comprobar` con faltantes_leidos (lista vac\xEDa si ya est\xE1 completo), bono_estado_leido y lectura_id; `descartar` con motivo si el bono se elimin\xF3 o anul\xF3. En `facturacion_pendiente` (solo lee): `observar` con bono_id, bono_estado, fecha_prestacion, obra_social, lectura_id (conector "base") y fuente; `comprobar` con bono_estado_leido y lectura_id (facturado/refacturado \u2192 facturada; prefacturado \u2192 en prefactura; si no, sigue por presentar); `descartar` con motivo. En `circular_aranceles`: `extraer` con extraccion_a (lo que ley\xF3 el agente) y extraccion_b (la salida de leer-circular.mjs, tal cual) como [{codigo, nombre, valor_nuevo}], actual (la salida de leer-convenio.mjs: [{codigo, nombre, componentes:[{arancel, monto}], copago, tipo_copago}]), lectura_id (lectura del convenio, conector base o api), lectura_circular_id (lectura de la circular, conector archivo) y fuente; el plugin cruza las tres fuentes y decide qu\xE9 se propone, qu\xE9 se revisa y qu\xE9 es excepci\xF3n (el agente no decide eso); `proponer` sin datos; despu\xE9s de la carga, `verificar` con leidos (la salida de leer-convenio.mjs tras la carga) y lectura_id; `cancelar` con motivo. En `demanda_pendiente`: `contactar` (nivel ejecuta; datos: canal igual al de la regla y accion_id de la escritura registrada; el plugin controla regla activa, intentos, espera entre intentos y horario), `responder` (respuesta: acepta|rechaza|no_contesta), `comprobar` (lectura_id de la relectura del HIS, turno_id y turno_estado del turno encontrado), `cerrar` (motivo; solo con los intentos agotados o el plazo vencido), `descartar` (motivo). `credencial_profesional` (solo lee): `verificar` con profesional_id, matricula y tipo_matricula (nacional|provincial) si hay matr\xEDcula, resultado = el objeto que devuelve verificar-matriculas.mjs tal cual ({sin_matricula, encontrada, coincide_nombre, situacion, sancion, profesion, provincia, emisor}), lectura_id (conector "api", la consulta al registro) y fuente; el plugin decide vigente u observada y fija la observaci\xF3n (sin_matricula, no_figura, otra_persona, inhabilitada, sancion); `descartar` con motivo si el profesional ya no est\xE1 activo.',
       parametersSchema: {
         type: "object",
         properties: {

package/dist/worker.js

@@ -39932,7 +39932,7 @@ function startWorkerRpcHost(options) {
 
 // src/manifest.ts
 var PLUGIN_ID = "alephoo.autopilot-ops";
-var PLUGIN_VERSION = "0.1.20";
+var PLUGIN_VERSION = "0.1.22";
 var DB_NAMESPACE_SLUG = "autopilot_ops";
 var PAGE_ROUTE = "autopilot";
 var TOOL_NAMES = {
@@ -40045,7 +40045,7 @@ var manifest = {
     {
       name: TOOL_NAMES.abrirCaso,
       displayName: "Abrir caso",
-      description: 'Abre un caso nuevo en un workflow, en su estado inicial. Workflows: `demanda_pendiente` (referencia obligatoria `orden:<id>`, `solicitud:<id>` o `control:<persona_id>:<regla_id>`; datos: regla_id obligatorio y la regla tiene que estar activa, persona_id, tipo de origen, estudio o especialidad o prestacion, fecha_origen AAAA-MM-DD, dias; el plugin fija regla_version, canal, intentos, vence_el; nunca nombre, documento ni tel\xE9fono del paciente),`actualizacion_arancel`, `tarea_operativa`, `recupero_turno` (datos: fecha AAAA-MM-DD, hora HH:MM, profesional, especialidad del turno libre; referencia "AAAA-MM-DD HH:MM \xB7 Profesional"), `cuenta_completa` (una prestaci\xF3n pendiente de facturar con faltantes; referencia obligatoria "bono:<n\xFAmero>", datos: bono_id, bono_numero, obra_social, plan, prestacion, fecha_prestacion AAAA-MM-DD, monto_pesos, internacion_id opcional; en faltantes, `responsable` {tipo profesional, id, nombre} opcional para que el plugin avise a quien resuelve), `facturacion_pendiente` (una prestaci\xF3n sin facturar; misma referencia `bono:<n\xFAmero>` y mismos datos; el plugin calcula plazo_dias, vence_el y plazo_confirmado con los plazos por obra social de la instituci\xF3n), `credencial_profesional` (un profesional con agenda; referencia obligatoria `profesional:<id>`; datos: profesional_id, profesional (apellido y nombre, es personal de la instituci\xF3n), matricula_nacional, matricula_provincial, codigo_provincia, especialidades). `referencia` identifica el objeto real (convenio, cuenta, turno) y evita duplicados: si ya existe un caso abierto con la misma referencia, se devuelve ese. Pasar `idempotencyKey` para reintentos seguros.',
+      description: 'Abre un caso nuevo en un workflow, en su estado inicial. Workflows: `circular_aranceles` (una circular de aranceles entera; referencia obligatoria `circular:<obra social>:<hash corto del archivo>`; datos: obra_social, convenio (nombre en el HIS), archivo {nombre, hash, paginas}, vigencia_desde AAAA-MM-DD, porcentaje_declarado y filas_declaradas si la circular los dice), `demanda_pendiente` (referencia obligatoria `orden:<id>`, `solicitud:<id>` o `control:<persona_id>:<regla_id>`; datos: regla_id obligatorio y la regla tiene que estar activa, persona_id, tipo de origen, estudio o especialidad o prestacion, fecha_origen AAAA-MM-DD, dias; el plugin fija regla_version, canal, intentos, vence_el; nunca nombre, documento ni tel\xE9fono del paciente),`actualizacion_arancel`, `tarea_operativa`, `recupero_turno` (datos: fecha AAAA-MM-DD, hora HH:MM, profesional, especialidad del turno libre; referencia "AAAA-MM-DD HH:MM \xB7 Profesional"), `cuenta_completa` (una prestaci\xF3n pendiente de facturar con faltantes; referencia obligatoria "bono:<n\xFAmero>", datos: bono_id, bono_numero, obra_social, plan, prestacion, fecha_prestacion AAAA-MM-DD, monto_pesos, internacion_id opcional; en faltantes, `responsable` {tipo profesional, id, nombre} opcional para que el plugin avise a quien resuelve), `facturacion_pendiente` (una prestaci\xF3n sin facturar; misma referencia `bono:<n\xFAmero>` y mismos datos; el plugin calcula plazo_dias, vence_el y plazo_confirmado con los plazos por obra social de la instituci\xF3n), `credencial_profesional` (un profesional con agenda; referencia obligatoria `profesional:<id>`; datos: profesional_id, profesional (apellido y nombre, es personal de la instituci\xF3n), matricula_nacional, matricula_provincial, codigo_provincia, especialidades). `referencia` identifica el objeto real (convenio, cuenta, turno) y evita duplicados: si ya existe un caso abierto con la misma referencia, se devuelve ese. Pasar `idempotencyKey` para reintentos seguros.',
       parametersSchema: {
         type: "object",
         properties: {
@@ -40062,7 +40062,7 @@ var manifest = {
     {
       name: TOOL_NAMES.transicionar,
       displayName: "Transicionar caso",
-      description: 'Aplica una transici\xF3n del workflow al caso (p. ej. `proponer`, `aplicar`, `verificar`). El plugin valida contra la tabla de transiciones, la pol\xEDtica vigente (observa / propone / ejecuta / corte) y las reglas de negocio; si algo falla, el caso no cambia y se devuelve el motivo. Las transiciones humanas (aprobar, rechazar, corregir) no est\xE1n disponibles para agentes. Cuando una persona de la instituci\xF3n carga a mano lo aprobado, el caso queda en `aplicado`: el agente lo comprueba releyendo el sistema y llamando `verificar` con `datos.valor_leido`. En `recupero_turno`: `proponer` con solicitud_id, solicitud_estado, solicitud_especialidad, cola (la lista de espera pendiente de esa especialidad tal como se vio: [{solicitud_id, prioridad, alta}]; el plugin la ordena y exige justificaci\xF3n para no elegir la primera) y fuente; si la instituci\xF3n pide consulta previa (ops_leer_caso lo dice), `ofrecer` con canal y esperar `aceptar`/`no_acepta`; **antes de escribir en el sistema, `autorizar`** (sin esa autorizaci\xF3n no se escribe); despu\xE9s de escribir, `asignar` con accion_id; `verificar` con leido_fecha, leido_hora, leido_profesional y leido_solicitud_id; `sin_candidato` y `descartar` con motivo. En `cuenta_completa` el agente solo lee: `observar` con bono_id, bono_estado (no_confirmado, confirmado o prefacturado), faltantes [{regla, detalle, item?}] con reglas del cat\xE1logo (autorizacion_faltante, validacion_faltante, afiliado_faltante, orden_faltante, prestacion_sin_valor, epicrisis_faltante), lectura_id (la lectura registrada con ops_registrar_accion, conector "base") y fuente; `comprobar` con faltantes_leidos (lista vac\xEDa si ya est\xE1 completo), bono_estado_leido y lectura_id; `descartar` con motivo si el bono se elimin\xF3 o anul\xF3. En `facturacion_pendiente` (solo lee): `observar` con bono_id, bono_estado, fecha_prestacion, obra_social, lectura_id (conector "base") y fuente; `comprobar` con bono_estado_leido y lectura_id (facturado/refacturado \u2192 facturada; prefacturado \u2192 en prefactura; si no, sigue por presentar); `descartar` con motivo. En `demanda_pendiente`: `contactar` (nivel ejecuta; datos: canal igual al de la regla y accion_id de la escritura registrada; el plugin controla regla activa, intentos, espera entre intentos y horario), `responder` (respuesta: acepta|rechaza|no_contesta), `comprobar` (lectura_id de la relectura del HIS, turno_id y turno_estado del turno encontrado), `cerrar` (motivo; solo con los intentos agotados o el plazo vencido), `descartar` (motivo). `credencial_profesional` (solo lee): `verificar` con profesional_id, matricula y tipo_matricula (nacional|provincial) si hay matr\xEDcula, resultado = el objeto que devuelve verificar-matriculas.mjs tal cual ({sin_matricula, encontrada, coincide_nombre, situacion, sancion, profesion, provincia, emisor}), lectura_id (conector "api", la consulta al registro) y fuente; el plugin decide vigente u observada y fija la observaci\xF3n (sin_matricula, no_figura, otra_persona, inhabilitada, sancion); `descartar` con motivo si el profesional ya no est\xE1 activo.',
+      description: 'Aplica una transici\xF3n del workflow al caso (p. ej. `proponer`, `aplicar`, `verificar`). El plugin valida contra la tabla de transiciones, la pol\xEDtica vigente (observa / propone / ejecuta / corte) y las reglas de negocio; si algo falla, el caso no cambia y se devuelve el motivo. Las transiciones humanas (aprobar, rechazar, corregir) no est\xE1n disponibles para agentes. Cuando una persona de la instituci\xF3n carga a mano lo aprobado, el caso queda en `aplicado`: el agente lo comprueba releyendo el sistema y llamando `verificar` con `datos.valor_leido`. En `recupero_turno`: `proponer` con solicitud_id, solicitud_estado, solicitud_especialidad, cola (la lista de espera pendiente de esa especialidad tal como se vio: [{solicitud_id, prioridad, alta}]; el plugin la ordena y exige justificaci\xF3n para no elegir la primera) y fuente; si la instituci\xF3n pide consulta previa (ops_leer_caso lo dice), `ofrecer` con canal y esperar `aceptar`/`no_acepta`; **antes de escribir en el sistema, `autorizar`** (sin esa autorizaci\xF3n no se escribe); despu\xE9s de escribir, `asignar` con accion_id; `verificar` con leido_fecha, leido_hora, leido_profesional y leido_solicitud_id; `sin_candidato` y `descartar` con motivo. En `cuenta_completa` el agente solo lee: `observar` con bono_id, bono_estado (no_confirmado, confirmado o prefacturado), faltantes [{regla, detalle, item?}] con reglas del cat\xE1logo (autorizacion_faltante, validacion_faltante, afiliado_faltante, orden_faltante, prestacion_sin_valor, epicrisis_faltante), lectura_id (la lectura registrada con ops_registrar_accion, conector "base") y fuente; `comprobar` con faltantes_leidos (lista vac\xEDa si ya est\xE1 completo), bono_estado_leido y lectura_id; `descartar` con motivo si el bono se elimin\xF3 o anul\xF3. En `facturacion_pendiente` (solo lee): `observar` con bono_id, bono_estado, fecha_prestacion, obra_social, lectura_id (conector "base") y fuente; `comprobar` con bono_estado_leido y lectura_id (facturado/refacturado \u2192 facturada; prefacturado \u2192 en prefactura; si no, sigue por presentar); `descartar` con motivo. En `circular_aranceles`: `extraer` con extraccion_a (lo que ley\xF3 el agente) y extraccion_b (la salida de leer-circular.mjs, tal cual) como [{codigo, nombre, valor_nuevo}], actual (la salida de leer-convenio.mjs: [{codigo, nombre, componentes:[{arancel, monto}], copago, tipo_copago}]), lectura_id (lectura del convenio, conector base o api), lectura_circular_id (lectura de la circular, conector archivo) y fuente; el plugin cruza las tres fuentes y decide qu\xE9 se propone, qu\xE9 se revisa y qu\xE9 es excepci\xF3n (el agente no decide eso); `proponer` sin datos; despu\xE9s de la carga, `verificar` con leidos (la salida de leer-convenio.mjs tras la carga) y lectura_id; `cancelar` con motivo. En `demanda_pendiente`: `contactar` (nivel ejecuta; datos: canal igual al de la regla y accion_id de la escritura registrada; el plugin controla regla activa, intentos, espera entre intentos y horario), `responder` (respuesta: acepta|rechaza|no_contesta), `comprobar` (lectura_id de la relectura del HIS, turno_id y turno_estado del turno encontrado), `cerrar` (motivo; solo con los intentos agotados o el plazo vencido), `descartar` (motivo). `credencial_profesional` (solo lee): `verificar` con profesional_id, matricula y tipo_matricula (nacional|provincial) si hay matr\xEDcula, resultado = el objeto que devuelve verificar-matriculas.mjs tal cual ({sin_matricula, encontrada, coincide_nombre, situacion, sancion, profesion, provincia, emisor}), lectura_id (conector "api", la consulta al registro) y fuente; el plugin decide vigente u observada y fija la observaci\xF3n (sin_matricula, no_figura, otra_persona, inhabilitada, sancion); `descartar` con motivo si el profesional ya no est\xE1 activo.',
       parametersSchema: {
         type: "object",
         properties: {
@@ -40375,6 +40375,276 @@ var manifest_default = manifest;
 // src/ops.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
+// src/aranceles.ts
+import { createHash } from "node:crypto";
+var TOLERANCIA_EXTRACCIONES = 5e-3;
+var TOLERANCIA_FILAS = 0.1;
+var DESVIO_COHERENCIA = 15;
+var PROPORCION_INCOHERENTE = 0.1;
+var TOPE_VARIACION_POR_DEFECTO = 50;
+var LIMITES_TOPE = [10, 200];
+var VIGENCIA_DIAS_ATRAS = 60;
+var VIGENCIA_DIAS_ADELANTE = 120;
+var TOLERANCIA_RELECTURA = 0.01;
+var redondear = (n, dec = 2) => Math.round(n * 10 ** dec) / 10 ** dec;
+var pesos = (n) => `$ ${n.toLocaleString("es-AR", { maximumFractionDigits: 2 })}`;
+var porc = (n) => `${n.toLocaleString("es-AR", { maximumFractionDigits: 1 })} %`;
+function normalizarCodigo(v) {
+  const s = typeof v === "number" ? String(v) : typeof v === "string" ? v : "";
+  return s.toUpperCase().replace(/[^A-Z0-9]/g, "").replace(/^0+(?=.)/, "");
+}
+function leerMonto(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v !== "string") return null;
+  let s = v.replace(/[$\s]/g, "").replace(/ARS/i, "");
+  if (!s || !/^-?[\d.,]+$/.test(s)) return null;
+  const coma = s.lastIndexOf(",");
+  const punto = s.lastIndexOf(".");
+  if (coma > -1 && punto > -1) s = coma > punto ? s.replace(/\./g, "").replace(",", ".") : s.replace(/,/g, "");
+  else if (coma > -1) s = /,\d{3}$/.test(s) && s.split(",").length > 2 ? s.replace(/,/g, "") : s.replace(",", ".");
+  else if (punto > -1 && s.split(".").length > 2) s = s.replace(/\./g, "");
+  else if (punto > -1 && /\.\d{3}$/.test(s)) s = s.replace(".", "");
+  const n = Number(s);
+  return Number.isFinite(n) ? n : null;
+}
+function leerFilas(v, nombre) {
+  if (!Array.isArray(v)) return { error: `${nombre} tiene que ser una lista [{codigo, nombre, valor_nuevo}]` };
+  const filas = [];
+  const vistos = /* @__PURE__ */ new Set();
+  for (const [i, e] of v.entries()) {
+    if (!e || typeof e !== "object") return { error: `${nombre}[${i}] no es una fila` };
+    const r = e;
+    const codigo = normalizarCodigo(r.codigo);
+    if (!codigo) return { error: `${nombre}[${i}] no tiene c\xF3digo` };
+    if (vistos.has(codigo)) return { error: `${nombre} tiene el c\xF3digo ${codigo} repetido` };
+    vistos.add(codigo);
+    const valor = leerMonto(r.valor_nuevo);
+    if (valor === null || valor <= 0) return { error: `${nombre}[${i}] (c\xF3digo ${codigo}): valor_nuevo tiene que ser un n\xFAmero mayor a 0` };
+    filas.push({ codigo, codigo_original: String(r.codigo).trim(), nombre: typeof r.nombre === "string" && r.nombre.trim() ? r.nombre.trim().slice(0, 200) : null, valor_nuevo: redondear(valor) });
+  }
+  return { filas };
+}
+function leerActual(v) {
+  if (!Array.isArray(v)) return { error: "actual tiene que ser una lista [{codigo, nombre, componentes: [{arancel, monto}], copago, tipo_copago}]" };
+  const practicas = [];
+  const vistos = /* @__PURE__ */ new Set();
+  for (const [i, e] of v.entries()) {
+    if (!e || typeof e !== "object") return { error: `actual[${i}] no es una pr\xE1ctica` };
+    const r = e;
+    const codigo = normalizarCodigo(r.codigo);
+    if (!codigo) return { error: `actual[${i}] no tiene c\xF3digo` };
+    if (vistos.has(codigo)) continue;
+    vistos.add(codigo);
+    const comps = Array.isArray(r.componentes) ? r.componentes : [];
+    const componentes = [];
+    for (const c of comps) {
+      const cc = c;
+      const arancel = typeof cc.arancel === "string" ? cc.arancel.trim() : "";
+      const monto = leerMonto(cc.monto);
+      if (!arancel || monto === null || monto < 0) return { error: `actual[${i}] (c\xF3digo ${codigo}): cada componente necesita arancel y monto` };
+      componentes.push({ arancel, monto: redondear(monto) });
+    }
+    if (componentes.length === 0) return { error: `actual[${i}] (c\xF3digo ${codigo}): no tiene componentes de arancel` };
+    practicas.push({
+      codigo,
+      codigo_his: typeof r.codigo_his === "string" && r.codigo_his.trim() ? r.codigo_his.trim() : String(r.codigo).trim(),
+      nombre: typeof r.nombre === "string" && r.nombre.trim() ? r.nombre.trim() : codigo,
+      componentes,
+      copago: r.copago === null || r.copago === void 0 ? null : String(r.copago),
+      tipo_copago: r.tipo_copago === null || r.tipo_copago === void 0 ? null : String(r.tipo_copago)
+    });
+  }
+  return { practicas };
+}
+function repartir(componentes, nuevo) {
+  const total = componentes.reduce((a, c) => a + c.monto, 0);
+  if (componentes.length === 1) return [{ arancel: componentes[0].arancel, monto: redondear(nuevo) }];
+  if (total <= 0) return null;
+  const out = componentes.map((c) => ({ arancel: c.arancel, monto: redondear(c.monto / total * nuevo) }));
+  const resto = redondear(nuevo - out.reduce((a, c) => a + c.monto, 0));
+  if (resto !== 0) {
+    const mayor = out.reduce((m, c, i) => c.monto > out[m].monto ? i : m, 0);
+    out[mayor].monto = redondear(out[mayor].monto + resto);
+  }
+  return out;
+}
+function mediana(v) {
+  if (v.length === 0) return null;
+  const s = [...v].sort((a, b) => a - b);
+  const m = Math.floor(s.length / 2);
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+function sumarDias(fecha, dias) {
+  const d = /* @__PURE__ */ new Date(`${fecha}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + dias);
+  return d.toISOString().slice(0, 10);
+}
+function cruzarCircular(input2) {
+  const errores = [];
+  const a = leerFilas(input2.extraccionA, "extraccion_a");
+  const b = leerFilas(input2.extraccionB, "extraccion_b");
+  const act = leerActual(input2.actual);
+  if ("error" in a) errores.push(a.error);
+  if ("error" in b) errores.push(b.error);
+  if ("error" in act) errores.push(act.error);
+  const vigencia = typeof input2.vigenciaDesde === "string" && /^\d{4}-\d{2}-\d{2}$/.test(input2.vigenciaDesde) ? input2.vigenciaDesde : null;
+  if (!vigencia) errores.push("vigencia_desde: la circular tiene que decir desde cu\xE1ndo rige (AAAA-MM-DD)");
+  else if (vigencia < sumarDias(input2.hoy, -VIGENCIA_DIAS_ATRAS) || vigencia > sumarDias(input2.hoy, VIGENCIA_DIAS_ADELANTE)) {
+    errores.push(`vigencia_desde ${vigencia} fuera de rango: se aceptan circulares que rigen desde ${VIGENCIA_DIAS_ATRAS} d\xEDas atr\xE1s hasta ${VIGENCIA_DIAS_ADELANTE} d\xEDas adelante`);
+  }
+  if ("error" in a || "error" in b || "error" in act) return { ok: false, errores };
+  const filasA = a.filas;
+  const filasB = b.filas;
+  const nA = filasA.length;
+  const nB = filasB.length;
+  if (nA === 0 || nB === 0) errores.push("las dos extracciones tienen que traer al menos una fila");
+  else if (Math.abs(nA - nB) / Math.max(nA, nB) > TOLERANCIA_FILAS) {
+    errores.push(`las dos extracciones no coinciden en cantidad de filas (A ${nA}, B ${nB}): hay que volver a leer la circular`);
+  }
+  const declaradas = typeof input2.filasDeclaradas === "number" && input2.filasDeclaradas > 0 ? Math.round(input2.filasDeclaradas) : null;
+  if (declaradas !== null) {
+    for (const [n, cual] of [[nA, "A"], [nB, "B"]]) {
+      if (n > 0 && Math.abs(n - declaradas) / declaradas > TOLERANCIA_FILAS) errores.push(`la extracci\xF3n ${cual} tiene ${n} filas y la circular declara ${declaradas}`);
+    }
+  }
+  if (errores.length) return { ok: false, errores };
+  const tope = typeof input2.topeVariacion === "number" && input2.topeVariacion >= LIMITES_TOPE[0] && input2.topeVariacion <= LIMITES_TOPE[1] ? input2.topeVariacion : TOPE_VARIACION_POR_DEFECTO;
+  const porA = new Map(filasA.map((f) => [f.codigo, f]));
+  const porB = new Map(filasB.map((f) => [f.codigo, f]));
+  const porHis = new Map(act.practicas.map((p) => [p.codigo, p]));
+  const porBase = /* @__PURE__ */ new Map();
+  for (const p of act.practicas) {
+    const raiz = p.codigo.replace(/[A-Z]$/, "");
+    if (raiz !== p.codigo) porBase.set(raiz, [...porBase.get(raiz) ?? [], p]);
+  }
+  const usadas = /* @__PURE__ */ new Set();
+  const codigos = [.../* @__PURE__ */ new Set([...filasA.map((f) => f.codigo), ...filasB.map((f) => f.codigo)])];
+  const items = [];
+  for (const codigoCircular of codigos) {
+    const fa = porA.get(codigoCircular);
+    const fb = porB.get(codigoCircular);
+    let his = porHis.get(codigoCircular);
+    const variantes = his ? [] : porBase.get(codigoCircular) ?? [];
+    if (!his && variantes.length === 1) his = variantes[0];
+    const codigo = his?.codigo ?? codigoCircular;
+    const nombre = his?.nombre ?? fb?.nombre ?? fa?.nombre ?? codigo;
+    const valorActual = his ? redondear(his.componentes.reduce((s, c) => s + c.monto, 0)) : null;
+    const base = { codigo, codigo_his: his?.codigo_his ?? fb?.codigo_original ?? fa?.codigo_original ?? codigo, nombre, valor_a: fa?.valor_nuevo ?? null, valor_b: fb?.valor_nuevo ?? null, valor_actual: valorActual, valor_nuevo: null, variacion: null, estado: "revisar", motivo: null, componentes_nuevos: null };
+    if (variantes.length > 1) {
+      items.push({ ...base, motivo: `el convenio del HIS tiene ${variantes.length} variantes de este c\xF3digo (${variantes.map((v) => v.codigo_his).join(", ")}): no se carga hasta decidir a cu\xE1l corresponde` });
+      continue;
+    }
+    if (his && usadas.has(his.codigo)) {
+      items.push({ ...base, motivo: `otra fila de la circular ya corresponde a la pr\xE1ctica ${his.codigo_his} del HIS` });
+      continue;
+    }
+    if (his) usadas.add(his.codigo);
+    if (!fa || !fb) {
+      items.push({ ...base, motivo: fa ? "solo la ley\xF3 el agente: el programa no la encontr\xF3 en la circular" : "solo la ley\xF3 el programa: el agente no la inform\xF3" });
+      continue;
+    }
+    if (Math.abs(fa.valor_nuevo - fb.valor_nuevo) / Math.max(fa.valor_nuevo, fb.valor_nuevo) > TOLERANCIA_EXTRACCIONES) {
+      items.push({ ...base, motivo: `las dos lecturas no coinciden: el agente ley\xF3 ${pesos(fa.valor_nuevo)} y el programa ${pesos(fb.valor_nuevo)}` });
+      continue;
+    }
+    const nuevo = fb.valor_nuevo;
+    if (!his) {
+      items.push({ ...base, valor_nuevo: nuevo, estado: "sin_convenio", motivo: "la circular la trae y el convenio del HIS no la tiene: no se carga" });
+      continue;
+    }
+    const componentes = repartir(his.componentes, nuevo);
+    if (!componentes) {
+      items.push({ ...base, valor_nuevo: nuevo, motivo: "tiene varios componentes de arancel en $0: no se puede repartir el valor nuevo" });
+      continue;
+    }
+    const variacion = valorActual && valorActual > 0 ? redondear((nuevo - valorActual) / valorActual * 100, 1) : null;
+    items.push({ ...base, valor_nuevo: nuevo, variacion, estado: "propuesta", componentes_nuevos: componentes });
+  }
+  const conVariacion = items.filter((i) => i.estado === "propuesta" && i.variacion !== null);
+  const declarado = typeof input2.porcentajeDeclarado === "number" && Number.isFinite(input2.porcentajeDeclarado) ? input2.porcentajeDeclarado : null;
+  const referencia = declarado ?? mediana(conVariacion.map((i) => i.variacion));
+  let desviadas = 0;
+  for (const i of items) {
+    if (i.estado !== "propuesta") continue;
+    const motivos = [];
+    if (i.valor_actual === 0 || i.variacion === null) motivos.push("el HIS tiene hoy $0: no hay contra qu\xE9 comparar");
+    else {
+      if (i.variacion < 0) motivos.push(`baja el valor (${porc(i.variacion)})`);
+      if (i.variacion > tope) motivos.push(`sube ${porc(i.variacion)}, m\xE1s que el tope de ${porc(tope)}`);
+      if (referencia !== null && Math.abs(i.variacion - referencia) > DESVIO_COHERENCIA) {
+        desviadas += 1;
+        motivos.push(`se aparta ${redondear(Math.abs(i.variacion - referencia), 1).toLocaleString("es-AR")} puntos de la variaci\xF3n ${declarado !== null ? "que declara la circular" : "del resto"} (${porc(redondear(referencia, 1))})`);
+      }
+    }
+    if (motivos.length) {
+      i.estado = "excepcion";
+      i.motivo = motivos.join("; ");
+    }
+  }
+  const variaciones = items.filter((i) => i.variacion !== null && (i.estado === "propuesta" || i.estado === "excepcion")).map((i) => i.variacion);
+  const resumen = {
+    filas_a: nA,
+    filas_b: nB,
+    filas_declaradas: declaradas,
+    coinciden: items.filter((i) => i.valor_a !== null && i.valor_b !== null && (i.estado !== "revisar" || i.valor_nuevo !== null)).length,
+    propuestas: items.filter((i) => i.estado === "propuesta").length,
+    revisar: items.filter((i) => i.estado === "revisar").length,
+    sin_convenio: items.filter((i) => i.estado === "sin_convenio").length,
+    excepciones: items.filter((i) => i.estado === "excepcion").length,
+    bajas: items.filter((i) => i.variacion !== null && i.variacion < 0).length,
+    supera_tope: items.filter((i) => i.variacion !== null && i.variacion > tope).length,
+    referencia: declarado !== null ? "declarada" : referencia !== null ? "mediana" : null,
+    variacion_referencia: referencia === null ? null : redondear(referencia, 1),
+    variacion_min: variaciones.length ? Math.min(...variaciones) : null,
+    variacion_max: variaciones.length ? Math.max(...variaciones) : null,
+    coherencia_rota: conVariacion.length > 0 && desviadas / conVariacion.length > PROPORCION_INCOHERENTE,
+    tope_variacion: tope
+  };
+  return { ok: true, items, resumen };
+}
+function leerItems(v) {
+  return Array.isArray(v) ? v.filter((x) => x && typeof x === "object" && typeof x.codigo === "string") : [];
+}
+function itemsACargar(items, excluir) {
+  const fuera = new Set(Array.isArray(excluir) ? excluir.map(normalizarCodigo) : []);
+  return items.filter((i) => (i.estado === "propuesta" || i.estado === "excepcion") && i.componentes_nuevos && !fuera.has(i.codigo));
+}
+var csvCampo = (v) => /[;"\n\r]/.test(v) ? `"${v.replace(/"/g, '""')}"` : v;
+function archivoActualizacion(items, actual) {
+  const porHis = new Map(actual.map((p) => [p.codigo, p]));
+  const aranceles = [];
+  for (const i of items) for (const c of i.componentes_nuevos ?? []) if (!aranceles.includes(c.arancel)) aranceles.push(c.arancel);
+  const lineas = [["Prestacion", "Codigo", "Copago", "Tipo Copago", ...aranceles].map(csvCampo).join(";")];
+  for (const i of items) {
+    const his = porHis.get(i.codigo);
+    const montos = aranceles.map((a) => {
+      const c = (i.componentes_nuevos ?? []).find((x) => x.arancel === a);
+      return c ? c.monto.toFixed(2) : "";
+    });
+    lineas.push([his?.nombre ?? i.nombre, `	${his ? his.codigo_his : i.codigo}`, his?.copago ?? "", his?.tipo_copago ?? "", ...montos].map(csvCampo).join(";"));
+  }
+  const contenido = `\uFEFF${lineas.join("\r\n")}\r
+`;
+  return { contenido, hash: hashArchivo(contenido), filas: items.length, aranceles };
+}
+function hashArchivo(contenido) {
+  return createHash("sha256").update(contenido, "utf8").digest("hex");
+}
+function compararRelectura(aCargar, leidos) {
+  const lectura = leerActual(leidos);
+  if ("error" in lectura) return { error: `leidos: ${lectura.error}` };
+  const porHis = new Map(lectura.practicas.map((p) => [p.codigo, p]));
+  const diferencias = [];
+  for (const i of aCargar) {
+    const his = porHis.get(i.codigo);
+    for (const c of i.componentes_nuevos ?? []) {
+      const leido = his?.componentes.find((x) => x.arancel === c.arancel)?.monto ?? null;
+      if (leido === null || Math.abs(leido - c.monto) > TOLERANCIA_RELECTURA) diferencias.push({ codigo: i.codigo, nombre: i.nombre, arancel: c.arancel, aprobado: c.monto, leido });
+    }
+  }
+  return { diferencias, comprobadas: aCargar.length };
+}
+
 // src/workflows.ts
 var MODOS = ["corte", "observa", "propone", "ejecuta", "autonomo"];
 var MODO_POR_DEFECTO = "propone";
@@ -40988,7 +41258,7 @@ var cuentaCompleta = {
   ]
 };
 var PLAZO_PRESENTACION_POR_DEFECTO = 60;
-function sumarDias(fecha, dias) {
+function sumarDias2(fecha, dias) {
   const d = /* @__PURE__ */ new Date(`${fecha}T00:00:00Z`);
   d.setUTCDate(d.getUTCDate() + dias);
   return d.toISOString().slice(0, 10);
@@ -40997,7 +41267,7 @@ function calcularVencimiento(fechaPrestacion, obraSocial, contexto) {
   const nombre = normalizarNombre(obraSocial);
   const fijado = nombre ? Object.entries(contexto.plazosPresentacion ?? {}).find(([k]) => normalizarNombre(k) === nombre)?.[1] : void 0;
   const plazo = typeof fijado === "number" && Number.isInteger(fijado) && fijado > 0 && fijado <= 730 ? fijado : PLAZO_PRESENTACION_POR_DEFECTO;
-  return { plazo_dias: plazo, vence_el: sumarDias(fechaPrestacion, plazo), plazo_confirmado: typeof fijado === "number" };
+  return { plazo_dias: plazo, vence_el: sumarDias2(fechaPrestacion, plazo), plazo_confirmado: typeof fijado === "number" };
 }
 var facturacionPendiente = {
   clave: "facturacion_pendiente",
@@ -41317,6 +41587,156 @@ var demandaPendiente = {
     }
   ]
 };
+function resumenDe(caso) {
+  const r = caso.datos.resumen;
+  return r && typeof r === "object" ? r : null;
+}
+var circularAranceles = {
+  clave: "circular_aranceles",
+  nombre: "Circulares de aranceles",
+  puesto: "Convenios y facturaci\xF3n",
+  descripcion: "Lee la circular de aranceles de una obra social dos veces por caminos distintos, la cruza con el convenio del HIS y arma la actualizaci\xF3n completa; la direcci\xF3n la aprueba en un solo pedido, se carga con el archivo que genera el plugin y el puesto comprueba releyendo cada valor.",
+  inicial: "recibida",
+  estados: ["recibida", "extraida", "pendiente_aprobacion", "aprobada", "aplicada", "verificada", "con_diferencias", "rechazada", "cancelada"],
+  finalesOk: ["verificada"],
+  finalesNoOk: ["rechazada", "cancelada"],
+  minutosAbsorbidos: 180,
+  transiciones: [
+    {
+      via: "extraer",
+      de: ["recibida", "extraida"],
+      a: "extraida",
+      actor: ["agente", "humano"],
+      nivelRequerido: "observa",
+      descripcion: "Informar las dos lecturas de la circular (la del agente y la de leer-circular.mjs) y lo que tiene hoy el convenio en el HIS. El plugin las cruza y decide pr\xE1ctica por pr\xE1ctica.",
+      validar: (caso, datos, contexto) => {
+        const l = { ...caso.datos, ...datos };
+        const cruce = cruzarCircular({
+          extraccionA: datos.extraccion_a,
+          extraccionB: datos.extraccion_b,
+          actual: datos.actual,
+          filasDeclaradas: num(l.filas_declaradas),
+          porcentajeDeclarado: num(l.porcentaje_declarado),
+          vigenciaDesde: l.vigencia_desde,
+          hoy: contexto.hoy ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+          topeVariacion: contexto.topeVariacion ?? null
+        });
+        return [
+          texto(datos.lectura_id) ? ok("lectura_registrada") : falla("lectura_registrada", "extraer requiere lectura_id: la lectura del convenio en el HIS registrada con ops_registrar_accion"),
+          texto(datos.lectura_circular_id) ? ok("lectura_circular_registrada") : falla("lectura_circular_registrada", "extraer requiere lectura_circular_id: la lectura de la circular (conector archivo) registrada con ops_registrar_accion"),
+          texto(datos.fuente) ? ok("fuente_presente") : falla("fuente_presente", "fuente (la circular: nombre del archivo y de d\xF3nde vino) es obligatoria"),
+          cruce.ok ? ok("cruce_circular", `${cruce.resumen.propuestas} propuestas, ${cruce.resumen.excepciones} excepciones, ${cruce.resumen.revisar} a revisar, ${cruce.resumen.sin_convenio} sin convenio`) : falla("cruce_circular", cruce.errores.join(" \xB7 "))
+        ];
+      }
+    },
+    {
+      via: "proponer",
+      de: ["extraida"],
+      a: "pendiente_aprobacion",
+      actor: ["agente", "humano"],
+      nivelRequerido: "propone",
+      descripcion: "Pedir la aprobaci\xF3n de la circular con lo que calcul\xF3 el plugin.",
+      validar: (caso) => {
+        const r = resumenDe(caso);
+        return [r && r.propuestas + r.excepciones > 0 ? ok("hay_que_cargar", `${r.propuestas + r.excepciones} pr\xE1cticas`) : falla("hay_que_cargar", "no hay ninguna pr\xE1ctica para cargar: revisar la lectura o cancelar")];
+      },
+      autonomia: {
+        aSinExcepcion: "aprobada",
+        excepciones: (caso, _datos, contexto) => {
+          const r = resumenDe(caso);
+          const vigencia = texto(caso.datos.vigencia_desde);
+          return [
+            excepcion("practicas_con_excepcion", (r?.excepciones ?? 0) > 0, `${r?.excepciones ?? 0} pr\xE1cticas con baja, suba sobre el tope o desv\xEDo`),
+            excepcion("lecturas_que_no_coinciden", (r?.revisar ?? 0) > 0, `${r?.revisar ?? 0} pr\xE1cticas a revisar`),
+            excepcion("sin_convenio", (r?.sin_convenio ?? 0) > 0, `${r?.sin_convenio ?? 0} pr\xE1cticas que el convenio no tiene`),
+            excepcion("coherencia_rota", r?.coherencia_rota === true, r?.coherencia_rota ? "m\xE1s del 10 % de las pr\xE1cticas se aparta de la variaci\xF3n de la circular" : "coherente"),
+            excepcion("vigencia_pasada", vigencia !== null && contexto.hoy !== void 0 && vigencia < contexto.hoy, vigencia ? `rige desde ${vigencia}` : "sin vigencia")
+          ];
+        }
+      }
+    },
+    {
+      via: "aprobar",
+      de: ["pendiente_aprobacion"],
+      a: "aprobada",
+      actor: ["humano"],
+      descripcion: "Aprobaci\xF3n de la circular por la direcci\xF3n; puede excluir pr\xE1cticas (excluir: [c\xF3digos]).",
+      validar: (caso, datos) => {
+        const items = leerItems(caso.datos.items);
+        const excluir = datos.excluir === void 0 ? [] : datos.excluir;
+        if (!Array.isArray(excluir)) return [falla("excluir_valido", "excluir tiene que ser una lista de c\xF3digos")];
+        const codigos = new Set(items.map((i) => i.codigo));
+        const ajenos = excluir.map(normalizarCodigo).filter((c) => !codigos.has(c));
+        const quedan = itemsACargar(items, excluir).length;
+        return [
+          ajenos.length === 0 ? ok("excluir_valido") : falla("excluir_valido", `c\xF3digos que no est\xE1n en la circular: ${ajenos.join(", ")}`),
+          quedan > 0 ? ok("hay_que_cargar", `${quedan} pr\xE1cticas`) : falla("hay_que_cargar", "excluyendo esas no queda nada para cargar: rechazar la circular")
+        ];
+      }
+    },
+    {
+      via: "rechazar",
+      de: ["pendiente_aprobacion"],
+      a: "rechazada",
+      actor: ["humano"],
+      descripcion: "Rechazo con motivo.",
+      validar: (_caso, datos) => [texto(datos.motivo) ? ok("motivo_presente") : falla("motivo_presente", "el rechazo requiere motivo")]
+    },
+    {
+      via: "aplicar",
+      de: ["aprobada"],
+      a: "aplicada",
+      actor: ["agente", "humano"],
+      nivelRequerido: "ejecuta",
+      cargaManual: true,
+      descripcion: "Cargar en el HIS el archivo que gener\xF3 el plugin (Actualizaci\xF3n con archivo) y registrarlo, con el hash del archivo cargado.",
+      validar: (caso, datos) => {
+        const esperado = texto(caso.datos.archivo_csv?.hash);
+        const informado = texto(datos.archivo_hash);
+        return [
+          texto(datos.accion_id) ? ok("accion_registrada") : falla("accion_registrada", "aplicar requiere accion_id de la carga registrada"),
+          esperado && informado === esperado ? ok("archivo_aprobado") : falla("archivo_aprobado", esperado ? "el archivo cargado no es el que gener\xF3 el plugin para esta aprobaci\xF3n (archivo_hash distinto): descargarlo de nuevo y cargar ese" : "la circular no tiene archivo generado")
+        ];
+      }
+    },
+    {
+      via: "verificar",
+      de: ["aplicada"],
+      a: (caso, datos) => {
+        const r = compararRelectura(itemsACargar(leerItems(caso.datos.items), caso.datos.excluir), datos.leidos);
+        return "error" in r || r.diferencias.length > 0 ? "con_diferencias" : "verificada";
+      },
+      actor: ["agente", "humano", "sistema"],
+      nivelRequerido: "observa",
+      descripcion: "Releer el convenio en el HIS despu\xE9s de la carga e informar cada pr\xE1ctica con sus componentes (leidos). El plugin compara contra lo aprobado.",
+      validar: (_caso, datos) => {
+        const r = compararRelectura([], datos.leidos);
+        return [
+          texto(datos.lectura_id) ? ok("lectura_registrada") : falla("lectura_registrada", "verificar requiere lectura_id: la relectura del convenio registrada"),
+          "error" in r ? falla("leidos_validos", r.error) : ok("leidos_validos")
+        ];
+      }
+    },
+    {
+      via: "corregir",
+      de: ["con_diferencias"],
+      a: "aplicada",
+      actor: ["humano"],
+      cargaManual: true,
+      descripcion: "Corregir en el HIS las pr\xE1cticas que no coincidieron y volver a comprobar.",
+      validar: (_caso, datos) => [texto(datos.accion_id) ? ok("accion_registrada") : falla("accion_registrada", "corregir requiere accion_id de la correcci\xF3n registrada")]
+    },
+    {
+      via: "cancelar",
+      de: ["recibida", "extraida", "pendiente_aprobacion", "aprobada", "con_diferencias"],
+      a: "cancelada",
+      actor: ["humano", "agente"],
+      nivelRequerido: "observa",
+      descripcion: "Cancelar la circular (repetida, de otra regi\xF3n, ilegible).",
+      validar: (_caso, datos) => [texto(datos.motivo) ? ok("motivo_presente") : falla("motivo_presente", "la cancelaci\xF3n requiere motivo")]
+    }
+  ]
+};
 var WORKFLOWS_SOLO_LECTURA = /* @__PURE__ */ new Set([cuentaCompleta.clave, facturacionPendiente.clave, credencialProfesional.clave]);
 var WORKFLOWS = {
   [actualizacionArancel.clave]: actualizacionArancel,
@@ -41325,7 +41745,8 @@ var WORKFLOWS = {
   [cuentaCompleta.clave]: cuentaCompleta,
   [facturacionPendiente.clave]: facturacionPendiente,
   [credencialProfesional.clave]: credencialProfesional,
-  [demandaPendiente.clave]: demandaPendiente
+  [demandaPendiente.clave]: demandaPendiente,
+  [circularAranceles.clave]: circularAranceles
 };
 function getWorkflow(clave) {
   return WORKFLOWS[clave] ?? null;
@@ -41951,6 +42372,7 @@ async function listarPoliticas(ctx, companyId) {
 }
 function describirOpciones(antes, despues) {
   const partes = [];
+  if (antes.tope_variacion !== despues.tope_variacion && despues.tope_variacion !== void 0) partes.push(`tope de variaci\xF3n de las circulares: ${String(despues.tope_variacion)} %`);
   if (Boolean(antes.ofrecer_primero) !== Boolean(despues.ofrecer_primero)) partes.push(`consultar al paciente antes de asignar: ${despues.ofrecer_primero ? "s\xED" : "no"}`);
   const plazosAntes = JSON.stringify(leerPlazos(antes.plazos));
   const plazosDespues = leerPlazos(despues.plazos);
@@ -41960,6 +42382,10 @@ function describirOpciones(antes, despues) {
   }
   return partes.length ? partes.join(" \xB7 ") : null;
 }
+function leerTope(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : NaN;
+  return Number.isFinite(n) && n >= LIMITES_TOPE[0] && n <= LIMITES_TOPE[1] ? Math.round(n) : null;
+}
 function leerPlazos(v) {
   if (!v || typeof v !== "object" || Array.isArray(v)) return {};
   const out = {};
@@ -41976,6 +42402,11 @@ async function cambiarPolitica(ctx, input2) {
   const opcionesAntes = await obtenerOpciones(ctx, input2.companyId, input2.workflow);
   const opciones = { ...opcionesAntes, ...input2.opciones ?? {} };
   if (opciones.plazos !== void 0) opciones.plazos = leerPlazos(opciones.plazos);
+  if (opciones.tope_variacion !== void 0) {
+    const tope = leerTope(opciones.tope_variacion);
+    if (tope === null) throw new OpsError("validacion", `tope_variacion: tiene que ser un n\xFAmero entre ${LIMITES_TOPE[0]} y ${LIMITES_TOPE[1]}`);
+    opciones.tope_variacion = tope;
+  }
   const cambioOpciones = describirOpciones(opcionesAntes, opciones);
   const motivo = [input2.motivo ?? null, cambioOpciones].filter(Boolean).join(" \xB7 ") || null;
   const existe = await ctx.db.query(
@@ -42085,6 +42516,13 @@ async function abrirCaso(ctx, input2) {
     if (!referencia || !/^profesional:\S+$/.test(referencia)) throw new OpsError("referencia_requerida", "en credencial_profesional la referencia es obligatoria: profesional:<id del profesional>");
     if (prof && referencia !== `profesional:${prof}`) throw new OpsError("referencia_requerida", `la referencia ${referencia} no coincide con el profesional_id ${prof}`);
   }
+  if (wf.clave === "circular_aranceles") {
+    const d = input2.datos ?? {};
+    if (!referencia || !/^circular:\S+$/.test(referencia)) throw new OpsError("referencia_requerida", "en circular_aranceles la referencia es obligatoria: circular:<obra social>:<hash corto del archivo>");
+    const faltan = ["obra_social", "convenio", "vigencia_desde"].filter((k) => !str2(d[k]));
+    if (faltan.length) throw new OpsError("validacion", `circular_aranceles necesita ${faltan.join(", ")}`);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(String(d.vigencia_desde))) throw new OpsError("validacion", "vigencia_desde: AAAA-MM-DD");
+  }
   const extra = {};
   if (wf.clave === "demanda_pendiente") {
     if (!referencia || !/^(orden|solicitud|control):\S+$/.test(referencia)) {
@@ -42101,7 +42539,7 @@ async function abrirCaso(ctx, input2) {
     extra.tipo = regla.tipo;
     extra.canal = regla.contacto.canal;
     extra.intentos = 0;
-    extra.vence_el = sumarDias(hoy, regla.cierre.dias_para_cerrar);
+    extra.vence_el = sumarDias2(hoy, regla.cierre.dias_para_cerrar);
     extra.detectado_el = hoy;
   }
   if (referencia) {
@@ -42153,6 +42591,10 @@ async function contextoDe(ctx, companyId, caso, via, datos) {
     contexto.plazosPresentacion = leerPlazos((await obtenerOpciones(ctx, companyId, caso.workflow)).plazos);
     return contexto;
   }
+  if (caso.workflow === "circular_aranceles") {
+    contexto.topeVariacion = leerTope((await obtenerOpciones(ctx, companyId, caso.workflow)).tope_variacion);
+    return contexto;
+  }
   if (caso.workflow === "demanda_pendiente") {
     const reglaId = str2(caso.datos.regla_id);
     const regla = reglaId ? await leerRegla(ctx, companyId, reglaId) : null;
@@ -42223,7 +42665,7 @@ async function transicionar(ctx, input2) {
     );
     const lectura = rows[0];
     let vieja = false;
-    if (lectura && resultado.via === "comprobar") {
+    if (lectura && (resultado.via === "comprobar" || caso.workflow === "circular_aranceles" && resultado.via === "verificar")) {
       const ultima = await ctx.db.query(
         `SELECT max(created_at) AS ultima FROM ${t2(ctx, "transicion")} WHERE company_id = $1 AND caso_id = $2`,
         [input2.companyId, caso.id]
@@ -42236,6 +42678,48 @@ async function transicionar(ctx, input2) {
       throw new OpsError("validacion", `lectura_registrada: ${problema}`, { validaciones: [{ regla: "lectura_registrada", ok: false, detalle: problema }], estado: caso.estado });
     }
   }
+  const lecturaCircularId = str2(datos.lectura_circular_id);
+  if (caso.workflow === "circular_aranceles" && lecturaCircularId) {
+    const fila = (await ctx.db.query(`SELECT id, caso_id, tipo, conector, resultado FROM ${t2(ctx, "accion")} WHERE company_id = $1 AND id = $2 LIMIT 1`, [input2.companyId, lecturaCircularId]))[0];
+    const problema = !fila ? `lectura_circular_id ${lecturaCircularId} no existe en esta instituci\xF3n` : String(fila.caso_id) !== caso.id ? `la lectura ${lecturaCircularId} pertenece a otro caso` : String(fila.tipo) !== "lectura" || String(fila.conector) !== "archivo" ? "la lectura de la circular tiene que ser una lectura con conector archivo" : String(fila.resultado) !== "ok" ? `la lectura ${lecturaCircularId} termin\xF3 con resultado ${String(fila.resultado)}` : null;
+    if (problema) throw new OpsError("validacion", `lectura_circular_registrada: ${problema}`, { validaciones: [{ regla: "lectura_circular_registrada", ok: false, detalle: problema }], estado: caso.estado });
+  }
+  if (caso.workflow === "circular_aranceles") {
+    delete datos.items;
+    delete datos.resumen;
+    delete datos.archivo_csv;
+    delete datos.diferencias;
+    if (resultado.via === "extraer") {
+      const cruce = cruzarCircular({
+        extraccionA: datos.extraccion_a,
+        extraccionB: datos.extraccion_b,
+        actual: datos.actual,
+        filasDeclaradas: datos.filas_declaradas ?? caso.datos.filas_declaradas,
+        porcentajeDeclarado: datos.porcentaje_declarado ?? caso.datos.porcentaje_declarado,
+        vigenciaDesde: datos.vigencia_desde ?? caso.datos.vigencia_desde,
+        hoy: contexto.hoy ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+        topeVariacion: contexto.topeVariacion ?? null
+      });
+      if (cruce.ok) {
+        datos.items = cruce.items;
+        datos.resumen = cruce.resumen;
+        const act = leerActual(datos.actual);
+        datos.actual = "practicas" in act ? act.practicas : [];
+      }
+    }
+    if (resultado.via === "aprobar") datos.excluir = Array.isArray(datos.excluir) ? datos.excluir.map(normalizarCodigo) : [];
+    if (resultado.a === "aprobada") {
+      const aCargar = itemsACargar(leerItems(caso.datos.items), datos.excluir ?? caso.datos.excluir);
+      const actual = leerActual(caso.datos.actual);
+      const archivo = archivoActualizacion(aCargar, "practicas" in actual ? actual.practicas : []);
+      datos.archivo_csv = { contenido: archivo.contenido, hash: archivo.hash, filas: archivo.filas, aranceles: archivo.aranceles, nombre: `actualizacion-${String(caso.datos.convenio ?? "convenio").toLowerCase().replace(/[^a-z0-9]+/g, "-")}-${String(caso.datos.vigencia_desde ?? "")}.csv` };
+    }
+    if (resultado.via === "verificar") {
+      const r = compararRelectura(itemsACargar(leerItems(caso.datos.items), caso.datos.excluir), datos.leidos);
+      datos.diferencias = "error" in r ? [] : r.diferencias;
+      datos.verificada_el = contexto.hoy ?? null;
+    }
+  }
   if (caso.workflow === "cuenta_completa" && resultado.via === "observar") {
     datos.faltantes = leerFaltantes(datos.faltantes) ?? [];
     datos.faltantes_iniciales = datos.faltantes;
@@ -42265,7 +42749,7 @@ async function transicionar(ctx, input2) {
       datos.intentos = hechos;
       datos.ultimo_contacto = contexto.hoy ?? null;
       datos.canal = canalContacto(datos.canal);
-      datos.proximo_contacto = regla && hechos < regla.contacto.max_intentos && contexto.hoy ? sumarDias(contexto.hoy, regla.contacto.dias_entre_intentos) : null;
+      datos.proximo_contacto = regla && hechos < regla.contacto.max_intentos && contexto.hoy ? sumarDias2(contexto.hoy, regla.contacto.dias_entre_intentos) : null;
     }
     if (resultado.via === "responder") {
       datos.respuesta = respuestaContacto(datos.respuesta);
@@ -42411,7 +42895,8 @@ async function registrarCargaManual(ctx, input2) {
     throw new OpsError("validacion", "valor_cargado: debe ser un n\xFAmero", { validaciones: [{ regla: "valor_cargado_numerico", ok: false, detalle: "debe ser un n\xFAmero" }], estado: caso.estado });
   }
   const contextoPrevio = await contextoDe(ctx, input2.companyId, caso, def2.via, {});
-  const previa = evaluarTransicion({ caso, via: def2.via, actor: "humano", datos: { accion_id: "(por registrar)" }, modo: "ejecuta", contexto: contextoPrevio });
+  const archivoHash = str2(input2.archivoHash);
+  const previa = evaluarTransicion({ caso, via: def2.via, actor: "humano", datos: { accion_id: "(por registrar)", ...archivoHash ? { archivo_hash: archivoHash } : {} }, modo: "ejecuta", contexto: contextoPrevio });
   if (!previa.ok) throw new OpsError(previa.codigo, previa.motivo, { validaciones: previa.validaciones, estado: caso.estado });
   const persona = str2(input2.persona);
   const comentario = str2(input2.comentario);
@@ -42429,6 +42914,7 @@ async function registrarCargaManual(ctx, input2) {
       ...caso.datos.vigencia_desde !== void 0 ? { vigencia_desde: caso.datos.vigencia_desde } : {},
       ...caso.workflow === "cuenta_completa" ? { faltantes_que_completo: caso.datos.faltantes ?? [] } : {},
       ...caso.workflow === "facturacion_pendiente" ? { bono: caso.datos.bono_numero ?? caso.datos.bono_id, vence_el: caso.datos.vence_el } : {},
+      ...caso.workflow === "circular_aranceles" ? { archivo_hash: archivoHash, archivo: caso.datos.archivo_csv?.nombre ?? null, practicas: caso.datos.archivo_csv?.filas ?? null, convenio: caso.datos.convenio ?? null } : {},
       ...caso.workflow === "credencial_profesional" ? { profesional: caso.datos.profesional ?? caso.datos.profesional_id, observacion_que_corrigio: caso.datos.observacion ?? null } : {},
       ...comentario ? { nota: comentario } : {}
     },
@@ -42440,7 +42926,8 @@ async function registrarCargaManual(ctx, input2) {
     ...persona ? { cargado_por: persona } : {},
     ...valorCargado !== null ? { valor_cargado: valorCargado } : {},
     // Una lectura anterior (la que dio diferencias) ya no describe lo que hay en el sistema.
-    valor_leido: null
+    valor_leido: null,
+    ...archivoHash ? { archivo_hash: archivoHash } : {}
   };
   try {
     const r = await transicionar(ctx, { companyId: input2.companyId, casoId: caso.id, via: def2.via, datos, motivo: comentario, idempotencyKey: idem, actor: input2.actor });
@@ -42863,7 +43350,7 @@ function mapAviso(r) {
   };
 }
 async function listarAvisos(ctx, companyId, opciones = {}) {
-  const desde = opciones.desde ?? sumarDias(ahoraEnHospital().hoy, -DIAS_VENTANA);
+  const desde = opciones.desde ?? sumarDias2(ahoraEnHospital().hoy, -DIAS_VENTANA);
   const rows = await ctx.db.query(`SELECT ${COLS_AVISO} FROM ${t3(ctx, "aviso")} WHERE company_id = $1 AND dia >= $2 ORDER BY created_at ASC`, [companyId, desde]);
   return rows.map(mapAviso);
 }
@@ -42945,7 +43432,7 @@ async function generarAvisos(ctx, input2) {
       }
       const h = historial.get(`${caso.id}|${contacto.clave}`) ?? { veces: 0, ultimo: "" };
       if (h.veces >= MAX_AVISOS) continue;
-      if (h.veces > 0 && sumarDias(h.ultimo, DIAS_ENTRE_AVISOS) > hoy) continue;
+      if (h.veces > 0 && sumarDias2(h.ultimo, DIAS_ENTRE_AVISOS) > hoy) continue;
       if (yaHoy.has(contacto.clave)) continue;
       const g = porDestinatario.get(contacto.clave) ?? { contacto, pendientes: [] };
       g.pendientes.push({ casoId: caso.id, workflow: caso.workflow, que: p.que, intento: h.veces + 1, titulo: caso.titulo });
@@ -43576,7 +44063,7 @@ async function manejarApi(ctx, input2) {
     case "rechazar":
       return respuesta(200, await transicionar(ctx, { companyId, casoId: input2.params.casoId ?? "", via: "rechazar", motivo: str3(body.motivo), datos: conPersona(obj(body.datos)), actor }));
     case "marcar-cargado":
-      return respuesta(200, await registrarCargaManual(ctx, { companyId, casoId: input2.params.casoId ?? "", valorCargado: body.valorCargado, comentario: str3(body.comentario), persona: decididoPor, idempotencyKey: str3(body.idempotencyKey), actor }));
+      return respuesta(200, await registrarCargaManual(ctx, { companyId, casoId: input2.params.casoId ?? "", valorCargado: body.valorCargado, archivoHash: str3(body.archivoHash), comentario: str3(body.comentario), persona: decididoPor, idempotencyKey: str3(body.idempotencyKey), actor }));
     case "respuesta-paciente":
       return respuesta(200, await registrarRespuestaPaciente(ctx, { companyId, casoId: input2.params.casoId ?? "", acepto: body.acepto === true, comentario: str3(body.comentario), persona: decididoPor, idempotencyKey: str3(body.idempotencyKey), actor }));
     case "no-corresponde": {
@@ -43585,7 +44072,7 @@ async function manejarApi(ctx, input2) {
       return respuesta(200, await transicionar(ctx, { companyId, casoId: input2.params.casoId ?? "", via: "no_corresponde", motivo: motivoConPersona(str3(body.motivo)), datos: conPersona(obj(body.datos)), idempotencyKey: str3(body.idempotencyKey), actor }));
     }
     case "version":
-      return respuesta(200, { version: manifest_default.version, capacidades: ["carga-manual", "recupero-turnos", "ofrecer-primero", "cuenta-completa", "metricas-certificadas", "facturacion-pendiente", "credenciales", "demanda-pendiente", "reglas", "avisos"], workflows: listarWorkflows().map((w) => w.clave) });
+      return respuesta(200, { version: manifest_default.version, capacidades: ["carga-manual", "recupero-turnos", "ofrecer-primero", "cuenta-completa", "metricas-certificadas", "facturacion-pendiente", "credenciales", "demanda-pendiente", "reglas", "avisos", "circular-aranceles"], workflows: listarWorkflows().map((w) => w.clave) });
     case "politicas":
       return respuesta(200, { politicas: await listarPoliticas(ctx, companyId) });
     case "serie":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperclip-plugin-autopilot-ops",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "type": "module",
   "description": "Autopilot Care · operación autónoma gobernada para instituciones de salud: workflows determinísticos, validaciones, registro de negocio, políticas (observa/propone/ejecuta/corte) y tablero del director, como plugin de Paperclip.",
   "files": [