paperclip-plugin-autopilot-ops 0.1.13 → 0.1.14

package/dist/worker.js

@@ -844,14 +844,14 @@ function promiseAllObject(promisesObj) {
 }
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str3 = "";
+  let str4 = "";
   for (let i = 0; i < length; i++) {
-    str3 += chars[Math.floor(Math.random() * chars.length)];
+    str4 += chars[Math.floor(Math.random() * chars.length)];
   }
-  return str3;
+  return str4;
 }
-function esc(str3) {
-  return JSON.stringify(str3);
+function esc(str4) {
+  return JSON.stringify(str4);
 }
 function slugify(input2) {
   return input2.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -913,8 +913,8 @@ function numKeys(data) {
   return keyCount;
 }
 var getParsedType = (data) => {
-  const t3 = typeof data;
-  switch (t3) {
+  const t4 = typeof data;
+  switch (t4) {
     case "undefined":
       return "undefined";
     case "string":
@@ -953,7 +953,7 @@ var getParsedType = (data) => {
       }
       return "object";
     default:
-      throw new Error(`Unknown data type: ${t3}`);
+      throw new Error(`Unknown data type: ${t4}`);
   }
 };
 var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
@@ -965,8 +965,8 @@ var primitiveTypes = /* @__PURE__ */ new Set([
   "symbol",
   "undefined"
 ]);
-function escapeRegex(str3) {
-  return str3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str4) {
+  return str4.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function clone(inst, def2, params) {
   const cl = new inst._zod.constr(def2 ?? inst._zod.def);
@@ -1232,13 +1232,13 @@ function getSizableOrigin(input2) {
   return "unknown";
 }
 var highSurrogate = /[\uD800-\uDBFF]/;
-function codePointLength(str3) {
-  const units = str3.length;
-  if (!highSurrogate.test(str3))
+function codePointLength(str4) {
+  const units = str4.length;
+  if (!highSurrogate.test(str4))
     return units;
   let count = units;
   for (let i = 0; i < units - 1; i++) {
-    if ((str3.charCodeAt(i) & 64512) === 55296 && (str3.charCodeAt(i + 1) & 64512) === 56320) {
+    if ((str4.charCodeAt(i) & 64512) === 55296 && (str4.charCodeAt(i + 1) & 64512) === 56320) {
       count--;
       i++;
     }
@@ -1253,8 +1253,8 @@ function getLengthableOrigin(input2) {
   return "unknown";
 }
 function parsedType(data) {
-  const t3 = typeof data;
-  switch (t3) {
+  const t4 = typeof data;
+  switch (t4) {
     case "number": {
       return Number.isNaN(data) ? "nan" : "number";
     }
@@ -1271,7 +1271,7 @@ function parsedType(data) {
       }
     }
   }
-  return t3;
+  return t4;
 }
 function issue(...args) {
   const [iss, input2, inst] = args;
@@ -3495,7 +3495,7 @@ function handleCatchall(proms, input2, payload, ctx, def2, inst, abortEarly) {
   const unrecognized = [];
   const keySet = def2.keySet;
   const _catchall = def2.catchall._zod;
-  const t3 = _catchall.def.type;
+  const t4 = _catchall.def.type;
   const optin = _catchall.optin;
   const optout = _catchall.optout;
   let seen = 0;
@@ -3508,11 +3508,11 @@ function handleCatchall(proms, input2, payload, ctx, def2, inst, abortEarly) {
     if (keySet.has(key))
       continue;
     if (key === "__proto__") {
-      if (t3 === "never")
+      if (t4 === "never")
         unrecognized.push(key);
       continue;
     }
-    if (t3 === "never") {
+    if (t4 === "never") {
       unrecognized.push(key);
       continue;
     }
@@ -7748,16 +7748,16 @@ var error20 = () => {
     number: { unit: "", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }
     // no unit
   };
-  const typeEntry = (t3) => t3 ? TypeNames[t3] : void 0;
-  const typeLabel = (t3) => {
-    const e = typeEntry(t3);
+  const typeEntry = (t4) => t4 ? TypeNames[t4] : void 0;
+  const typeLabel = (t4) => {
+    const e = typeEntry(t4);
     if (e)
       return e.label;
-    return t3 ?? TypeNames.unknown.label;
+    return t4 ?? TypeNames.unknown.label;
   };
-  const withDefinite = (t3) => `\u05D4${typeLabel(t3)}`;
-  const verbFor = (t3) => {
-    const e = typeEntry(t3);
+  const withDefinite = (t4) => `\u05D4${typeLabel(t4)}`;
+  const verbFor = (t4) => {
+    const e = typeEntry(t4);
     const gender = e?.gender ?? "m";
     return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA";
   };
@@ -16638,7 +16638,7 @@ function stringifyKeyNames(bySchema, json2, visited) {
       json2 = { ...json2, [keyword]: mapped };
   }
   const types = Array.isArray(json2.type) ? json2.type : [json2.type];
-  const numericType = !types.includes("string") && types.some((t3) => t3 === "number" || t3 === "integer");
+  const numericType = !types.includes("string") && types.some((t4) => t4 === "number" || t4 === "integer");
   const values = json2.enum ?? (json2.const !== void 0 ? [json2.const] : void 0);
   if (!numericType && !values?.some((v) => typeof v === "number"))
     return json2;
@@ -19141,8 +19141,8 @@ function convertBaseSchema(schema, ctx) {
   }
   const type = schema.type;
   if (Array.isArray(type)) {
-    const typeSchemas = type.map((t3) => {
-      const typeSchema = { ...schema, type: t3 };
+    const typeSchemas = type.map((t4) => {
+      const typeSchema = { ...schema, type: t4 };
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
@@ -31178,7 +31178,7 @@ var pluginManifestV1Schema = external_exports.object({
     }
   }
   if (manifest2.tools) {
-    const toolNames = manifest2.tools.map((t3) => t3.name);
+    const toolNames = manifest2.tools.map((t4) => t4.name);
     const duplicates = toolNames.filter((name, i) => toolNames.indexOf(name) !== i);
     if (duplicates.length > 0) {
       ctx.addIssue({
@@ -39932,7 +39932,7 @@ function startWorkerRpcHost(options) {
 
 // src/manifest.ts
 var PLUGIN_ID = "alephoo.autopilot-ops";
-var PLUGIN_VERSION = "0.1.13";
+var PLUGIN_VERSION = "0.1.14";
 var DB_NAMESPACE_SLUG = "autopilot_ops";
 var PAGE_ROUTE = "autopilot";
 var TOOL_NAMES = {
@@ -39943,7 +39943,9 @@ var TOOL_NAMES = {
   registrarAccion: "ops_registrar_accion",
   consultarIndicador: "ops_consultar_indicador",
   publicarTablero: "ops_publicar_tablero",
-  listarTableros: "ops_listar_tableros"
+  listarTableros: "ops_listar_tableros",
+  listarReglas: "ops_listar_reglas",
+  informarPruebaRegla: "ops_informar_prueba_regla"
 };
 var DATA_KEYS = {
   tablero: "tablero",
@@ -40003,6 +40005,33 @@ var manifest = {
         }
       }
     },
+    {
+      name: TOOL_NAMES.listarReglas,
+      displayName: "Listar reglas",
+      description: "Lista las reglas que el hospital arm\xF3 para un puesto (demanda_pendiente): tipo, par\xE1metros, contacto (canal, intentos, horario), cierre, estado y versi\xF3n. Filtro opcional: estado (activa). Solo lectura: las reglas las crea y activa el hospital desde el portal.",
+      parametersSchema: {
+        type: "object",
+        properties: {
+          workflow: { type: "string" },
+          estado: { type: "string", enum: ["borrador", "activa", "pausada"] }
+        }
+      }
+    },
+    {
+      name: TOOL_NAMES.informarPruebaRegla,
+      displayName: "Informar prueba de regla",
+      description: "Informa el resultado de probar una regla sobre los datos reales: a cu\xE1ntos pacientes alcanza hoy (alcanza) y hasta 10 referencias de muestra (orden:<id>, solicitud:<id>, control:<persona>:<regla>; nunca datos personales). Sin esta prueba de la versi\xF3n vigente, el hospital no puede activar la regla.",
+      parametersSchema: {
+        type: "object",
+        properties: {
+          reglaId: { type: "string" },
+          alcanza: { type: "number" },
+          muestra: { type: "array", items: { type: "string" } },
+          consulta: { type: "string", description: "La consulta que se corri\xF3 (opcional, para auditor\xEDa)." }
+        },
+        required: ["reglaId", "alcanza"]
+      }
+    },
     {
       name: TOOL_NAMES.leerCaso,
       displayName: "Leer caso",
@@ -40016,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: `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), `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 del hospital), 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: `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), `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 del hospital), 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: {
@@ -40033,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 del hospital 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 `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 del hospital 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 de Alephoo, 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: {
@@ -40232,6 +40261,54 @@ var manifest = {
       auth: "board",
       capability: "api.routes.register",
       companyResolution: { from: "query", key: "companyId" }
+    },
+    {
+      routeKey: "reglas",
+      method: "GET",
+      path: "/reglas",
+      auth: "board",
+      capability: "api.routes.register",
+      companyResolution: { from: "query", key: "companyId" }
+    },
+    {
+      routeKey: "crear-regla",
+      method: "POST",
+      path: "/reglas",
+      auth: "board",
+      capability: "api.routes.register",
+      companyResolution: { from: "body", key: "companyId" }
+    },
+    {
+      routeKey: "editar-regla",
+      method: "POST",
+      path: "/reglas/:reglaId",
+      auth: "board",
+      capability: "api.routes.register",
+      companyResolution: { from: "body", key: "companyId" }
+    },
+    {
+      routeKey: "estado-regla",
+      method: "POST",
+      path: "/reglas/:reglaId/estado",
+      auth: "board",
+      capability: "api.routes.register",
+      companyResolution: { from: "body", key: "companyId" }
+    },
+    {
+      routeKey: "probar-regla",
+      method: "POST",
+      path: "/reglas/:reglaId/probar",
+      auth: "board",
+      capability: "api.routes.register",
+      companyResolution: { from: "body", key: "companyId" }
+    },
+    {
+      routeKey: "contacto",
+      method: "POST",
+      path: "/casos/:casoId/contacto",
+      auth: "board",
+      capability: "api.routes.register",
+      companyResolution: { from: "body", key: "companyId" }
     }
   ],
   ui: {
@@ -40256,7 +40333,7 @@ var manifest = {
 var manifest_default = manifest;
 
 // src/ops.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/workflows.ts
 var MODOS = ["corte", "observa", "propone", "ejecuta", "autonomo"];
@@ -40459,8 +40536,8 @@ function fechaAISO(v) {
   if (fechaISO(s.slice(0, 10))) return s.slice(0, 10);
   const m = /^(\d{1,2})\/(\d{1,2})\/(\d{4})/.exec(s);
   if (!m) return null;
-  const iso3 = `${m[3]}-${m[2].padStart(2, "0")}-${m[1].padStart(2, "0")}`;
-  return fechaISO(iso3) ? iso3 : null;
+  const iso4 = `${m[3]}-${m[2].padStart(2, "0")}-${m[1].padStart(2, "0")}`;
+  return fechaISO(iso4) ? iso4 : null;
 }
 function leerCola(v) {
   if (!Array.isArray(v) || v.length === 0) return null;
@@ -41043,6 +41120,151 @@ var credencialProfesional = {
     }
   ]
 };
+var TIPOS_REGLA_DEMANDA = ["orden_sin_turno", "solicitud_pendiente", "control_periodico"];
+var CANALES_CONTACTO = ["whatsapp", "sms", "mail", "llamada"];
+var RESPUESTAS_CONTACTO = ["acepta", "rechaza", "no_contesta"];
+var TURNO_ATENDIDO = ["M", "R", "V"];
+function diasEntre(desde, hasta) {
+  const a = fechaAISO(desde);
+  const b = fechaAISO(hasta);
+  if (!a || !b) return null;
+  return Math.round((Date.parse(`${b}T00:00:00Z`) - Date.parse(`${a}T00:00:00Z`)) / 864e5);
+}
+function horaDentro(hora, desde, hasta) {
+  const h = horaHM(hora);
+  const d = horaHM(desde);
+  const t4 = horaHM(hasta);
+  if (!h || !d || !t4) return false;
+  return h >= d && h <= t4;
+}
+function codigoContacto(v) {
+  const s = texto(v);
+  return s ? s.toLowerCase().replace(/\s+/g, "_") : null;
+}
+function respuestaContacto(v) {
+  const s = codigoContacto(v);
+  return s && RESPUESTAS_CONTACTO.includes(s) ? s : null;
+}
+function canalContacto(v) {
+  const s = codigoContacto(v);
+  return s && CANALES_CONTACTO.includes(s) ? s : null;
+}
+var demandaPendiente = {
+  clave: "demanda_pendiente",
+  nombre: "Demanda pendiente",
+  puesto: "Pacientes y agenda",
+  descripcion: "Mueve la demanda que el hospital ya gener\xF3 y no se ejecut\xF3: \xF3rdenes de estudio sin turno, solicitudes de turno pendientes y controles peri\xF3dicos vencidos. Las reglas las arma el hospital en el portal; el plugin las aplica en cada contacto; el caso se cierra cuando el turno queda agendado.",
+  inicial: "detectado",
+  estados: [
+    "detectado",
+    "contactado",
+    "aceptado",
+    "turno_agendado",
+    "realizado",
+    "no_quiere",
+    "cerrado_sin_turno",
+    "no_corresponde",
+    "descartado"
+  ],
+  finalesOk: ["turno_agendado", "realizado"],
+  finalesNoOk: ["no_quiere", "cerrado_sin_turno", "no_corresponde", "descartado"],
+  minutosAbsorbidos: 12,
+  transiciones: [
+    {
+      via: "contactar",
+      de: ["detectado", "contactado"],
+      a: "contactado",
+      actor: ["agente", "humano"],
+      nivelRequerido: "ejecuta",
+      descripcion: "Contactar al paciente por el canal de la regla (el agente por el CRM de Alephoo; una persona del equipo, por donde lo hizo). Exige la escritura registrada (accion_id).",
+      validar: (_caso, datos, contexto) => {
+        const out = [];
+        const regla = contexto.regla ?? null;
+        const agente = contexto.actor === "agente";
+        out.push(regla && regla.estado === "activa" ? ok("regla_activa") : falla("regla_activa", regla ? `la regla est\xE1 ${regla.estado}: no se contacta hasta que se active` : "la regla que abri\xF3 el caso ya no existe"));
+        const canal = canalContacto(datos.canal);
+        out.push(canal ? ok("canal_informado") : falla("canal_informado", `canal es obligatorio: ${CANALES_CONTACTO.join(", ")}`));
+        if (agente && regla && canal) {
+          out.push(canal === regla.contacto.canal ? ok("canal_de_la_regla") : falla("canal_de_la_regla", `la regla contacta por ${regla.contacto.canal}, no por ${canal}`));
+        }
+        if (regla) {
+          const hechos = contexto.intentosContacto ?? 0;
+          out.push(hechos < regla.contacto.max_intentos ? ok("intentos_disponibles", `${hechos} de ${regla.contacto.max_intentos}`) : falla("intentos_disponibles", `ya se hicieron ${hechos} contactos (tope ${regla.contacto.max_intentos}): cerrar sin turno`));
+          if (agente) {
+            const desdeUltimo = contexto.ultimoContacto ? diasEntre(contexto.ultimoContacto, contexto.hoy) : null;
+            out.push(desdeUltimo === null || desdeUltimo >= regla.contacto.dias_entre_intentos ? ok("espera_entre_intentos") : falla("espera_entre_intentos", `el \xFAltimo contacto fue hace ${desdeUltimo} d\xEDas y la regla pide esperar ${regla.contacto.dias_entre_intentos}`));
+            out.push(horaDentro(contexto.horaActual, regla.contacto.hora_desde, regla.contacto.hora_hasta) ? ok("horario_permitido") : falla("horario_permitido", `son las ${contexto.horaActual ?? "?"} y la regla contacta de ${regla.contacto.hora_desde} a ${regla.contacto.hora_hasta}`));
+          }
+        }
+        out.push(texto(datos.accion_id) ? ok("accion_registrada") : falla("accion_registrada", "contactar requiere accion_id: la escritura (mensaje enviado o llamada hecha) registrada antes"));
+        return out;
+      }
+    },
+    {
+      via: "responder",
+      de: ["contactado"],
+      a: (_caso, datos) => {
+        const r = respuestaContacto(datos.respuesta);
+        return r === "acepta" ? "aceptado" : r === "rechaza" ? "no_quiere" : "contactado";
+      },
+      actor: ["agente", "humano"],
+      nivelRequerido: "observa",
+      descripcion: "Registrar la respuesta del paciente: acepta (va a sacar turno), rechaza o no_contesta (queda para el pr\xF3ximo intento).",
+      validar: (_caso, datos) => [
+        respuestaContacto(datos.respuesta) ? ok("respuesta_valida") : falla("respuesta_valida", `respuesta debe ser ${RESPUESTAS_CONTACTO.join(", ")}`)
+      ]
+    },
+    {
+      via: "comprobar",
+      de: ["detectado", "contactado", "aceptado"],
+      a: (_caso, datos) => TURNO_ATENDIDO.includes(String(datos.turno_estado ?? "").toUpperCase()) ? "realizado" : "turno_agendado",
+      actor: ["agente", "humano"],
+      nivelRequerido: "observa",
+      descripcion: "Releer Alephoo y encontrar el turno de esa orden, solicitud o control: con el turno, el caso se cierra como movido.",
+      validar: (_caso, datos) => [
+        texto(datos.lectura_id) ? ok("lectura_registrada") : falla("lectura_registrada", "comprobar requiere lectura_id: la relectura de Alephoo registrada antes"),
+        refExterna(datos.turno_id) ? ok("turno_presente") : falla("turno_presente", "comprobar requiere turno_id: el turno encontrado en Alephoo; sin turno no hay nada que comprobar")
+      ]
+    },
+    {
+      via: "cerrar",
+      de: ["detectado", "contactado"],
+      a: "cerrado_sin_turno",
+      actor: ["agente", "humano"],
+      nivelRequerido: "observa",
+      descripcion: "Cerrar sin turno: solo cuando se agotaron los intentos o venci\xF3 el plazo de la regla.",
+      validar: (_caso, datos, contexto) => {
+        const out = [texto(datos.motivo) ? ok("motivo_presente") : falla("motivo_presente", "cerrar requiere motivo")];
+        const regla = contexto.regla ?? null;
+        if (regla) {
+          const hechos = contexto.intentosContacto ?? 0;
+          const dias = contexto.diasAbierto ?? 0;
+          const agotados = hechos >= regla.contacto.max_intentos;
+          const vencido = dias >= regla.cierre.dias_para_cerrar;
+          out.push(agotados || vencido ? ok("cierre_habilitado", agotados ? `${hechos} contactos hechos` : `${dias} d\xEDas abierto`) : falla("cierre_habilitado", `van ${hechos} de ${regla.contacto.max_intentos} contactos y ${dias} de ${regla.cierre.dias_para_cerrar} d\xEDas: todav\xEDa no se cierra`));
+        }
+        return out;
+      }
+    },
+    {
+      via: "descartar",
+      de: ["detectado", "contactado", "aceptado"],
+      a: "descartado",
+      actor: ["agente", "humano"],
+      nivelRequerido: "observa",
+      descripcion: "Descartar con motivo: el dato era err\xF3neo, el paciente ya lo hizo afuera, falleci\xF3 o pidi\xF3 no ser contactado.",
+      validar: (_caso, datos) => [texto(datos.motivo) ? ok("motivo_presente") : falla("motivo_presente", "descartar requiere motivo")]
+    },
+    {
+      via: "no_corresponde",
+      de: ["detectado", "contactado", "aceptado"],
+      a: "no_corresponde",
+      actor: ["humano"],
+      descripcion: "Una persona del hospital decide que este caso no corresponde a la regla.",
+      validar: (_caso, datos) => [texto(datos.motivo) ? ok("motivo_presente") : falla("motivo_presente", "no_corresponde requiere motivo")]
+    }
+  ]
+};
 var WORKFLOWS_SOLO_LECTURA = /* @__PURE__ */ new Set([cuentaCompleta.clave, facturacionPendiente.clave, credencialProfesional.clave]);
 var WORKFLOWS = {
   [actualizacionArancel.clave]: actualizacionArancel,
@@ -41050,7 +41272,8 @@ var WORKFLOWS = {
   [recuperoTurno.clave]: recuperoTurno,
   [cuentaCompleta.clave]: cuentaCompleta,
   [facturacionPendiente.clave]: facturacionPendiente,
-  [credencialProfesional.clave]: credencialProfesional
+  [credencialProfesional.clave]: credencialProfesional,
+  [demandaPendiente.clave]: demandaPendiente
 };
 function getWorkflow(clave) {
   return WORKFLOWS[clave] ?? null;
@@ -41072,9 +41295,9 @@ function evaluarTransicion(input2) {
   if (!wf) {
     return { ok: false, codigo: "workflow_desconocido", motivo: `workflow desconocido: ${caso.workflow}`, validaciones: [] };
   }
-  const def2 = wf.transiciones.find((t3) => t3.via === via);
+  const def2 = wf.transiciones.find((t4) => t4.via === via);
   if (!def2) {
-    const disponibles = wf.transiciones.filter((t3) => t3.de.includes(caso.estado)).map((t3) => t3.via);
+    const disponibles = wf.transiciones.filter((t4) => t4.de.includes(caso.estado)).map((t4) => t4.via);
     return { ok: false, codigo: "via_desconocida", motivo: `la transici\xF3n "${via}" no existe en ${wf.clave}; desde "${caso.estado}" se puede: ${disponibles.join(", ") || "ninguna"}`, validaciones: [] };
   }
   if (!def2.de.includes(caso.estado)) {
@@ -41117,15 +41340,333 @@ function evaluarTransicion(input2) {
 function transicionesDisponibles(caso, actor) {
   const wf = getWorkflow(caso.workflow);
   if (!wf) return [];
-  return wf.transiciones.filter((t3) => t3.de.includes(caso.estado) && (!actor || t3.actor.includes(actor)));
+  return wf.transiciones.filter((t4) => t4.de.includes(caso.estado) && (!actor || t4.actor.includes(actor)));
 }
 function transicionCargaManual(caso) {
-  return transicionesDisponibles(caso, "humano").find((t3) => t3.cargaManual) ?? null;
+  return transicionesDisponibles(caso, "humano").find((t4) => t4.cargaManual) ?? null;
 }
 function esModo(v) {
   return typeof v === "string" && MODOS.includes(v);
 }
 
+// src/reglas.ts
+import { randomUUID } from "node:crypto";
+var ESTADOS_REGLA = ["borrador", "activa", "pausada"];
+var LIMITES_REGLA = {
+  dias_desde: [1, 365, 30],
+  cada_meses: [1, 60, 12],
+  max_intentos: [1, 5, 2],
+  dias_entre_intentos: [1, 30, 7],
+  dias_para_cerrar: [7, 180, 45],
+  edad: [0, 120, 0]
+};
+var SIN_QUE = ["turno", "informe"];
+function t(ctx, table) {
+  return `${ctx.db.namespace}.${table}`;
+}
+function str(v) {
+  return typeof v === "string" && v.trim().length > 0 ? v.trim().replace(/\s+/g, " ") : null;
+}
+function iso(v) {
+  if (v instanceof Date) return v.toISOString();
+  if (typeof v === "string") return v;
+  return "";
+}
+function jsonb(v) {
+  if (v && typeof v === "object" && !Array.isArray(v)) return v;
+  if (typeof v === "string") {
+    try {
+      const parsed = JSON.parse(v);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function jsonArr(v) {
+  if (Array.isArray(v)) return v;
+  if (typeof v === "string") {
+    try {
+      const parsed = JSON.parse(v);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function entero(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : NaN;
+  return Number.isInteger(n) ? n : null;
+}
+function numeroEn(problemas, campo, v, nombre = campo) {
+  const [min, max, def2] = LIMITES_REGLA[campo];
+  if (v === void 0 || v === null || v === "") return def2;
+  const n = entero(v);
+  if (n === null || n < min || n > max) {
+    problemas.push(`${nombre}: debe ser un entero entre ${min} y ${max}`);
+    return def2;
+  }
+  return n;
+}
+function textoCorto(problemas, campo, v, max, obligatorio) {
+  if (v === void 0 || v === null || v === "") {
+    if (obligatorio) problemas.push(`${campo}: es obligatorio`);
+    return null;
+  }
+  const s = typeof v === "string" ? v.trim().replace(/\s+/g, " ") : "";
+  if (!s) {
+    problemas.push(`${campo}: debe ser un texto`);
+    return null;
+  }
+  if (s.length > max) {
+    problemas.push(`${campo}: como m\xE1ximo ${max} caracteres`);
+    return s.slice(0, max);
+  }
+  return s;
+}
+function poblacion(problemas, p) {
+  const out = {};
+  if (p.edad_desde !== void 0 && p.edad_desde !== null && p.edad_desde !== "") out.edad_desde = numeroEn(problemas, "edad", p.edad_desde, "edad_desde");
+  if (p.edad_hasta !== void 0 && p.edad_hasta !== null && p.edad_hasta !== "") out.edad_hasta = numeroEn(problemas, "edad", p.edad_hasta, "edad_hasta");
+  if (typeof out.edad_desde === "number" && typeof out.edad_hasta === "number" && out.edad_desde > out.edad_hasta) problemas.push("edad_desde: no puede ser mayor que edad_hasta");
+  if (p.sexo !== void 0 && p.sexo !== null && p.sexo !== "") {
+    const s = String(p.sexo).trim().toUpperCase();
+    if (s === "F" || s === "M") out.sexo = s;
+    else problemas.push("sexo: debe ser F o M");
+  }
+  if (p.obras_sociales !== void 0 && p.obras_sociales !== null) {
+    const lista = Array.isArray(p.obras_sociales) ? p.obras_sociales.map((x) => str(x)).filter((x) => x !== null) : [];
+    if (!Array.isArray(p.obras_sociales)) problemas.push("obras_sociales: debe ser una lista de nombres");
+    else if (lista.length > 20) problemas.push("obras_sociales: como m\xE1ximo 20");
+    else if (lista.length > 0) out.obras_sociales = lista.map((x) => x.slice(0, 80));
+  }
+  return out;
+}
+function validarRegla(input2) {
+  const problemas = [];
+  const nombre = textoCorto(problemas, "nombre", input2.nombre, 80, true) ?? "";
+  if (nombre && nombre.length < 3) problemas.push("nombre: al menos 3 caracteres");
+  const tipoCrudo = str(input2.tipo);
+  const tipo = tipoCrudo && TIPOS_REGLA_DEMANDA.includes(tipoCrudo) ? tipoCrudo : null;
+  if (!tipo) problemas.push(`tipo: debe ser ${TIPOS_REGLA_DEMANDA.join(", ")}`);
+  const p = jsonb(input2.parametros);
+  const parametros = poblacion(problemas, p);
+  if (tipo === "orden_sin_turno") {
+    const estudio = textoCorto(problemas, "estudio", p.estudio, 80, false);
+    if (estudio) parametros.estudio = estudio;
+    parametros.dias_desde = numeroEn(problemas, "dias_desde", p.dias_desde);
+    const sin = Array.isArray(p.sin) ? p.sin.map((x) => String(x).trim().toLowerCase()) : [...SIN_QUE];
+    if (sin.length === 0 || sin.some((x) => !SIN_QUE.includes(x))) problemas.push(`sin: lista con ${SIN_QUE.join(" y/o ")}`);
+    parametros.sin = [...new Set(sin)].filter((x) => SIN_QUE.includes(x));
+  } else if (tipo === "solicitud_pendiente") {
+    const especialidad = textoCorto(problemas, "especialidad", p.especialidad, 80, false);
+    if (especialidad) parametros.especialidad = especialidad;
+    const prioridad = textoCorto(problemas, "prioridad", p.prioridad, 40, false);
+    if (prioridad) parametros.prioridad = prioridad;
+    parametros.dias_desde = numeroEn(problemas, "dias_desde", p.dias_desde);
+  } else if (tipo === "control_periodico") {
+    const diagnostico = textoCorto(problemas, "diagnostico", p.diagnostico, 10, true);
+    if (diagnostico) {
+      if (!/^[A-Za-z][0-9]{2}(\.[0-9A-Za-z]{1,2})?$/.test(diagnostico) && !/^[A-Za-z][0-9]{1,2}$/.test(diagnostico)) problemas.push("diagnostico: un c\xF3digo CIE-10 o su prefijo (p. ej. E11 o I10)");
+      else parametros.diagnostico = diagnostico.toUpperCase();
+    }
+    const prestacion = textoCorto(problemas, "prestacion", p.prestacion, 80, true);
+    if (prestacion) parametros.prestacion = prestacion;
+    parametros.cada_meses = numeroEn(problemas, "cada_meses", p.cada_meses);
+  }
+  const c = jsonb(input2.contacto);
+  const canalCrudo = str(c.canal)?.toLowerCase() ?? null;
+  const canal = canalCrudo && CANALES_CONTACTO.includes(canalCrudo) ? canalCrudo : null;
+  if (!canal) problemas.push(`contacto.canal: debe ser ${CANALES_CONTACTO.join(", ")}`);
+  const plantilla = textoCorto(problemas, "contacto.plantilla", c.plantilla, 600, true) ?? "";
+  if (plantilla && plantilla.length < 10) problemas.push("contacto.plantilla: al menos 10 caracteres");
+  const maxIntentos = numeroEn(problemas, "max_intentos", c.max_intentos, "contacto.max_intentos");
+  const diasEntreIntentos = numeroEn(problemas, "dias_entre_intentos", c.dias_entre_intentos, "contacto.dias_entre_intentos");
+  const horaDesde = c.hora_desde === void 0 || c.hora_desde === null || c.hora_desde === "" ? "09:00" : horaHM(c.hora_desde);
+  const horaHasta = c.hora_hasta === void 0 || c.hora_hasta === null || c.hora_hasta === "" ? "19:00" : horaHM(c.hora_hasta);
+  if (!horaDesde) problemas.push("contacto.hora_desde: hora HH:MM");
+  if (!horaHasta) problemas.push("contacto.hora_hasta: hora HH:MM");
+  if (horaDesde && horaHasta && horaDesde >= horaHasta) problemas.push("contacto.hora_desde: tiene que ser anterior a hora_hasta");
+  const ci = jsonb(input2.cierre);
+  const diasParaCerrar = numeroEn(problemas, "dias_para_cerrar", ci.dias_para_cerrar, "cierre.dias_para_cerrar");
+  if (problemas.length > 0) throw new OpsError("validacion", problemas.join("; "), { problemas });
+  return {
+    nombre,
+    tipo,
+    parametros,
+    contacto: { canal, plantilla, max_intentos: maxIntentos, dias_entre_intentos: diasEntreIntentos, hora_desde: horaDesde, hora_hasta: horaHasta },
+    cierre: { dias_para_cerrar: diasParaCerrar }
+  };
+}
+function reglaParaContexto(r) {
+  return {
+    id: r.id,
+    estado: r.estado,
+    version: r.version,
+    contacto: { canal: r.contacto.canal, max_intentos: r.contacto.max_intentos, dias_entre_intentos: r.contacto.dias_entre_intentos, hora_desde: r.contacto.hora_desde, hora_hasta: r.contacto.hora_hasta },
+    cierre: { dias_para_cerrar: r.cierre.dias_para_cerrar }
+  };
+}
+var COLS = "id, company_id, workflow, nombre, tipo, parametros, contacto, cierre, estado, version, historial, ultima_prueba, actor_tipo, actor_id, created_at, updated_at";
+function mapRegla(r) {
+  const contacto = jsonb(r.contacto);
+  const cierre = jsonb(r.cierre);
+  const prueba = r.ultima_prueba ? jsonb(r.ultima_prueba) : null;
+  return {
+    id: String(r.id),
+    companyId: String(r.company_id),
+    workflow: String(r.workflow),
+    nombre: String(r.nombre),
+    tipo: String(r.tipo),
+    parametros: jsonb(r.parametros),
+    contacto: {
+      canal: String(contacto.canal ?? "whatsapp"),
+      plantilla: String(contacto.plantilla ?? ""),
+      max_intentos: Number(contacto.max_intentos ?? LIMITES_REGLA.max_intentos[2]),
+      dias_entre_intentos: Number(contacto.dias_entre_intentos ?? LIMITES_REGLA.dias_entre_intentos[2]),
+      hora_desde: String(contacto.hora_desde ?? "09:00"),
+      hora_hasta: String(contacto.hora_hasta ?? "19:00")
+    },
+    cierre: { dias_para_cerrar: Number(cierre.dias_para_cerrar ?? LIMITES_REGLA.dias_para_cerrar[2]) },
+    estado: ESTADOS_REGLA.includes(String(r.estado)) ? String(r.estado) : "borrador",
+    version: Number(r.version ?? 1),
+    historial: jsonArr(r.historial).map((h) => {
+      const x = jsonb(h);
+      return { version: Number(x.version ?? 0), fecha: String(x.fecha ?? ""), actorTipo: String(x.actorTipo ?? ""), actorId: x.actorId ?? null, cambio: String(x.cambio ?? "") };
+    }),
+    ultimaPrueba: prueba && (prueba.estado === "pedida" || prueba.estado === "lista") ? {
+      estado: prueba.estado,
+      version: Number(prueba.version ?? 0),
+      fecha: String(prueba.fecha ?? ""),
+      ...prueba.alcanza !== void 0 ? { alcanza: Number(prueba.alcanza) } : {},
+      ...Array.isArray(prueba.muestra) ? { muestra: prueba.muestra.map((m) => String(m)) } : {},
+      ...prueba.consulta !== void 0 ? { consulta: prueba.consulta ?? null } : {},
+      ...prueba.por !== void 0 ? { por: prueba.por ?? null } : {}
+    } : null,
+    actorTipo: String(r.actor_tipo),
+    actorId: r.actor_id ?? null,
+    createdAt: iso(r.created_at),
+    updatedAt: iso(r.updated_at)
+  };
+}
+async function listarReglas(ctx, companyId, filtro = {}) {
+  const params = [companyId];
+  let where = "company_id = $1";
+  if (filtro.workflow) {
+    params.push(filtro.workflow);
+    where += ` AND workflow = $${params.length}`;
+  }
+  if (filtro.estado) {
+    params.push(filtro.estado);
+    where += ` AND estado = $${params.length}`;
+  }
+  const rows = await ctx.db.query(`SELECT ${COLS} FROM ${t(ctx, "regla")} WHERE ${where} ORDER BY created_at ASC`, params);
+  return rows.map(mapRegla);
+}
+async function leerRegla(ctx, companyId, id) {
+  const rows = await ctx.db.query(`SELECT ${COLS} FROM ${t(ctx, "regla")} WHERE company_id = $1 AND id = $2 LIMIT 1`, [companyId, id]);
+  return rows[0] ? mapRegla(rows[0]) : null;
+}
+async function requerirRegla(ctx, companyId, id) {
+  const r = await leerRegla(ctx, companyId, id);
+  if (!r) throw new OpsError("regla_inexistente", `no existe la regla ${id} en esta instituci\xF3n`);
+  return r;
+}
+function cambio(version2, actor, texto3) {
+  return { version: version2, fecha: (/* @__PURE__ */ new Date()).toISOString(), actorTipo: actor.tipo, actorId: actor.id, cambio: texto3 };
+}
+function soloPersonas(actor, que) {
+  if (actor.tipo !== "humano") throw new OpsError("actor_no_permitido", `${que} lo hace una persona del hospital desde el portal; el agente solo lee las reglas e informa la prueba`);
+}
+async function crearRegla(ctx, input2) {
+  soloPersonas(input2.actor, "crear una regla");
+  if (input2.workflow !== "demanda_pendiente") throw new OpsError("workflow_sin_reglas", `el puesto ${input2.workflow} no tiene reglas configurables`);
+  const v = validarRegla(input2);
+  const id = randomUUID();
+  const historial = [cambio(1, input2.actor, "creada")];
+  await ctx.db.execute(
+    `INSERT INTO ${t(ctx, "regla")} (id, company_id, workflow, nombre, tipo, parametros, contacto, cierre, estado, version, historial, actor_tipo, actor_id) VALUES ($1, $2, $3, $4, $5, $6::jsonb, $7::jsonb, $8::jsonb, $9, $10, $11::jsonb, $12, $13)`,
+    [id, input2.companyId, input2.workflow, v.nombre, v.tipo, JSON.stringify(v.parametros), JSON.stringify(v.contacto), JSON.stringify(v.cierre), "borrador", 1, JSON.stringify(historial), input2.actor.tipo, input2.actor.id]
+  );
+  await ctx.activity.log({ companyId: input2.companyId, message: `Autopilot Care: regla \xAB${v.nombre}\xBB creada (${v.tipo}, borrador)`, metadata: { reglaId: id, workflow: input2.workflow } });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return { id, companyId: input2.companyId, workflow: input2.workflow, ...v, estado: "borrador", version: 1, historial, ultimaPrueba: null, actorTipo: input2.actor.tipo, actorId: input2.actor.id, createdAt: now, updatedAt: now };
+}
+async function editarRegla(ctx, input2) {
+  soloPersonas(input2.actor, "editar una regla");
+  const actual = await requerirRegla(ctx, input2.companyId, input2.id);
+  const v = validarRegla({
+    nombre: input2.nombre ?? actual.nombre,
+    tipo: input2.tipo ?? actual.tipo,
+    parametros: input2.parametros ?? actual.parametros,
+    contacto: input2.contacto ?? actual.contacto,
+    cierre: input2.cierre ?? actual.cierre
+  });
+  const version2 = actual.version + 1;
+  const estado = actual.estado === "activa" ? "pausada" : actual.estado;
+  const detalle = `editada${input2.motivo ? `: ${str(input2.motivo)}` : ""}${actual.estado === "activa" ? " \xB7 pausada hasta probar y activar la versi\xF3n nueva" : ""}`;
+  const historial = [...actual.historial, cambio(version2, input2.actor, detalle)];
+  await ctx.db.execute(
+    `UPDATE ${t(ctx, "regla")} SET nombre = $3, tipo = $4, parametros = $5::jsonb, contacto = $6::jsonb, cierre = $7::jsonb, estado = $8, version = $9, historial = $10::jsonb, actor_tipo = $11, actor_id = $12, updated_at = now() WHERE company_id = $1 AND id = $2`,
+    [input2.companyId, input2.id, v.nombre, v.tipo, JSON.stringify(v.parametros), JSON.stringify(v.contacto), JSON.stringify(v.cierre), estado, version2, JSON.stringify(historial), input2.actor.tipo, input2.actor.id]
+  );
+  await ctx.activity.log({ companyId: input2.companyId, message: `Autopilot Care: regla \xAB${v.nombre}\xBB editada (versi\xF3n ${version2}, ${estado})`, metadata: { reglaId: input2.id } });
+  return { ...actual, ...v, estado, version: version2, historial, actorTipo: input2.actor.tipo, actorId: input2.actor.id, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function cambiarEstadoRegla(ctx, input2) {
+  soloPersonas(input2.actor, "activar o pausar una regla");
+  const actual = await requerirRegla(ctx, input2.companyId, input2.id);
+  const estado = str(input2.estado);
+  if (estado !== "activa" && estado !== "pausada") throw new OpsError("estado_invalido", "estado debe ser activa o pausada");
+  if (estado === actual.estado) return actual;
+  if (estado === "activa") {
+    const prueba = actual.ultimaPrueba;
+    if (!prueba || prueba.estado !== "lista" || prueba.version !== actual.version) {
+      throw new OpsError("prueba_requerida", `la versi\xF3n ${actual.version} de \xAB${actual.nombre}\xBB no se prob\xF3 todav\xEDa: pedir la prueba y activar cuando llegue el resultado`);
+    }
+  }
+  if (estado === "pausada" && actual.estado !== "activa") throw new OpsError("estado_invalido", `una regla en ${actual.estado} no se pausa`);
+  const historial = [...actual.historial, cambio(actual.version, input2.actor, `${estado}${input2.motivo ? `: ${str(input2.motivo)}` : ""}`)];
+  await ctx.db.execute(
+    `UPDATE ${t(ctx, "regla")} SET estado = $3, historial = $4::jsonb, actor_tipo = $5, actor_id = $6, updated_at = now() WHERE company_id = $1 AND id = $2`,
+    [input2.companyId, input2.id, estado, JSON.stringify(historial), input2.actor.tipo, input2.actor.id]
+  );
+  await ctx.activity.log({ companyId: input2.companyId, message: `Autopilot Care: regla \xAB${actual.nombre}\xBB ${estado} (versi\xF3n ${actual.version})`, metadata: { reglaId: input2.id } });
+  return { ...actual, estado, historial, actorTipo: input2.actor.tipo, actorId: input2.actor.id, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function pedirPruebaRegla(ctx, input2) {
+  soloPersonas(input2.actor, "pedir la prueba de una regla");
+  const actual = await requerirRegla(ctx, input2.companyId, input2.id);
+  const prueba = { estado: "pedida", version: actual.version, fecha: (/* @__PURE__ */ new Date()).toISOString() };
+  await ctx.db.execute(`UPDATE ${t(ctx, "regla")} SET ultima_prueba = $3::jsonb, updated_at = now() WHERE company_id = $1 AND id = $2`, [input2.companyId, input2.id, JSON.stringify(prueba)]);
+  return { ...actual, ultimaPrueba: prueba, updatedAt: prueba.fecha };
+}
+var REF_MUESTRA = /^(orden|solicitud|control):[A-Za-z0-9:_-]{1,80}$/;
+async function informarPruebaRegla(ctx, input2) {
+  const actual = await requerirRegla(ctx, input2.companyId, input2.id);
+  const alcanza = entero(input2.alcanza);
+  if (alcanza === null || alcanza < 0) throw new OpsError("validacion", "alcanza: entero mayor o igual a 0 (pacientes que la regla alcanza hoy)");
+  const crudos = Array.isArray(input2.muestra) ? input2.muestra : [];
+  if (crudos.length > 10) throw new OpsError("validacion", "muestra: como m\xE1ximo 10 referencias");
+  const muestra = crudos.map((m) => String(m).trim());
+  const mala = muestra.find((m) => !REF_MUESTRA.test(m));
+  if (mala) throw new OpsError("validacion", `muestra: solo referencias orden:<id>, solicitud:<id> o control:<persona>:<regla>; \xAB${mala.slice(0, 40)}\xBB no lo es (sin datos personales)`);
+  const prueba = {
+    estado: "lista",
+    version: actual.version,
+    fecha: (/* @__PURE__ */ new Date()).toISOString(),
+    alcanza,
+    muestra,
+    consulta: str(input2.consulta)?.slice(0, 4e3) ?? null,
+    por: input2.actor.id
+  };
+  await ctx.db.execute(`UPDATE ${t(ctx, "regla")} SET ultima_prueba = $3::jsonb, updated_at = now() WHERE company_id = $1 AND id = $2`, [input2.companyId, input2.id, JSON.stringify(prueba)]);
+  await ctx.activity.log({ companyId: input2.companyId, message: `Autopilot Care: prueba de la regla \xAB${actual.nombre}\xBB (versi\xF3n ${actual.version}): alcanza a ${alcanza}`, metadata: { reglaId: input2.id, alcanza } });
+  return { ...actual, ultimaPrueba: prueba, updatedAt: prueba.fecha };
+}
+
 // src/ops.ts
 var OpsError = class extends Error {
   constructor(codigo, motivo, detalle) {
@@ -41140,18 +41681,18 @@ var OpsError = class extends Error {
   /** Mensaje sin el prefijo de código. */
   motivo;
 };
-function t(ctx, table) {
+function t2(ctx, table) {
   return `${ctx.db.namespace}.${table}`;
 }
-function str(v) {
+function str2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v.trim() : null;
 }
-function iso(v) {
+function iso2(v) {
   if (v instanceof Date) return v.toISOString();
   if (typeof v === "string") return v;
   return "";
 }
-function jsonb(v) {
+function jsonb2(v) {
   if (v && typeof v === "object" && !Array.isArray(v)) return v;
   if (typeof v === "string") {
     try {
@@ -41163,7 +41704,7 @@ function jsonb(v) {
   }
   return {};
 }
-function jsonArr(v) {
+function jsonArr2(v) {
   if (Array.isArray(v)) return v;
   if (typeof v === "string") {
     try {
@@ -41183,15 +41724,15 @@ function mapCaso(r) {
     estado: String(r.estado),
     referencia: r.referencia ?? null,
     titulo: String(r.titulo),
-    datos: jsonb(r.datos),
+    datos: jsonb2(r.datos),
     abiertoPorTipo: String(r.abierto_por_tipo),
     abiertoPorId: r.abierto_por_id ?? null,
     agenteId: r.agente_id ?? null,
     issueId: r.issue_id ?? null,
     minutosAbsorbidos: Number(r.minutos_absorbidos ?? 0),
-    createdAt: iso(r.created_at),
-    updatedAt: iso(r.updated_at),
-    cerradoAt: r.cerrado_at ? iso(r.cerrado_at) : null
+    createdAt: iso2(r.created_at),
+    updatedAt: iso2(r.updated_at),
+    cerradoAt: r.cerrado_at ? iso2(r.cerrado_at) : null
   };
 }
 function mapTransicion(r) {
@@ -41204,9 +41745,9 @@ function mapTransicion(r) {
     actorTipo: String(r.actor_tipo),
     actorId: r.actor_id ?? null,
     motivo: r.motivo ?? null,
-    datos: jsonb(r.datos),
-    validaciones: jsonArr(r.validaciones),
-    createdAt: iso(r.created_at)
+    datos: jsonb2(r.datos),
+    validaciones: jsonArr2(r.validaciones),
+    createdAt: iso2(r.created_at)
   };
 }
 function mapAccion(r) {
@@ -41217,17 +41758,17 @@ function mapAccion(r) {
     conector: String(r.conector),
     objetivo: String(r.objetivo),
     resultado: String(r.resultado),
-    evidencia: jsonb(r.evidencia),
+    evidencia: jsonb2(r.evidencia),
     detalle: r.detalle ?? null,
     actorTipo: String(r.actor_tipo),
     actorId: r.actor_id ?? null,
-    createdAt: iso(r.created_at)
+    createdAt: iso2(r.created_at)
   };
 }
 var CASO_COLS = "id, company_id, workflow, estado, referencia, titulo, datos, abierto_por_tipo, abierto_por_id, agente_id, issue_id, minutos_absorbidos, created_at, updated_at, cerrado_at";
 async function obtenerModo(ctx, companyId, workflow) {
   const rows = await ctx.db.query(
-    `SELECT modo FROM ${t(ctx, "politica")} WHERE company_id = $1 AND workflow = $2 LIMIT 1`,
+    `SELECT modo FROM ${t2(ctx, "politica")} WHERE company_id = $1 AND workflow = $2 LIMIT 1`,
     [companyId, workflow]
   );
   const modo = rows[0]?.modo;
@@ -41235,14 +41776,14 @@ async function obtenerModo(ctx, companyId, workflow) {
 }
 async function obtenerOpciones(ctx, companyId, workflow) {
   const rows = await ctx.db.query(
-    `SELECT opciones FROM ${t(ctx, "politica")} WHERE company_id = $1 AND workflow = $2 LIMIT 1`,
+    `SELECT opciones FROM ${t2(ctx, "politica")} WHERE company_id = $1 AND workflow = $2 LIMIT 1`,
     [companyId, workflow]
   );
-  return jsonb(rows[0]?.opciones);
+  return jsonb2(rows[0]?.opciones);
 }
 async function listarPoliticas(ctx, companyId) {
   const rows = await ctx.db.query(
-    `SELECT workflow, modo, motivo, opciones, updated_at FROM ${t(ctx, "politica")} WHERE company_id = $1`,
+    `SELECT workflow, modo, motivo, opciones, updated_at FROM ${t2(ctx, "politica")} WHERE company_id = $1`,
     [companyId]
   );
   const porWorkflow = new Map(rows.map((r) => [String(r.workflow), r]));
@@ -41254,9 +41795,9 @@ async function listarPoliticas(ctx, companyId) {
       puesto: wf.puesto,
       modo: r ? String(r.modo) : MODO_POR_DEFECTO,
       motivo: r ? r.motivo ?? null : null,
-      actualizadaEn: r ? iso(r.updated_at) : null,
+      actualizadaEn: r ? iso2(r.updated_at) : null,
       porDefecto: !r,
-      opciones: r ? jsonb(r.opciones) : {}
+      opciones: r ? jsonb2(r.opciones) : {}
     };
   });
 }
@@ -41290,23 +41831,23 @@ async function cambiarPolitica(ctx, input2) {
   const cambioOpciones = describirOpciones(opcionesAntes, opciones);
   const motivo = [input2.motivo ?? null, cambioOpciones].filter(Boolean).join(" \xB7 ") || null;
   const existe = await ctx.db.query(
-    `SELECT id FROM ${t(ctx, "politica")} WHERE company_id = $1 AND workflow = $2 LIMIT 1`,
+    `SELECT id FROM ${t2(ctx, "politica")} WHERE company_id = $1 AND workflow = $2 LIMIT 1`,
     [input2.companyId, input2.workflow]
   );
   if (existe.length > 0) {
     await ctx.db.execute(
-      `UPDATE ${t(ctx, "politica")} SET modo = $3, motivo = $4, actor_tipo = $5, actor_id = $6, opciones = $7::jsonb, updated_at = now() WHERE company_id = $1 AND workflow = $2`,
+      `UPDATE ${t2(ctx, "politica")} SET modo = $3, motivo = $4, actor_tipo = $5, actor_id = $6, opciones = $7::jsonb, updated_at = now() WHERE company_id = $1 AND workflow = $2`,
       [input2.companyId, input2.workflow, input2.modo, motivo, input2.actor.tipo, input2.actor.id, JSON.stringify(opciones)]
     );
   } else {
     await ctx.db.execute(
-      `INSERT INTO ${t(ctx, "politica")} (id, company_id, workflow, modo, motivo, actor_tipo, actor_id, opciones) VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb)`,
-      [randomUUID(), input2.companyId, input2.workflow, input2.modo, motivo, input2.actor.tipo, input2.actor.id, JSON.stringify(opciones)]
+      `INSERT INTO ${t2(ctx, "politica")} (id, company_id, workflow, modo, motivo, actor_tipo, actor_id, opciones) VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb)`,
+      [randomUUID2(), input2.companyId, input2.workflow, input2.modo, motivo, input2.actor.tipo, input2.actor.id, JSON.stringify(opciones)]
     );
   }
   await ctx.db.execute(
-    `INSERT INTO ${t(ctx, "politica_historial")} (id, company_id, workflow, modo_anterior, modo_nuevo, motivo, actor_tipo, actor_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
-    [randomUUID(), input2.companyId, input2.workflow, anterior, input2.modo, motivo, input2.actor.tipo, input2.actor.id]
+    `INSERT INTO ${t2(ctx, "politica_historial")} (id, company_id, workflow, modo_anterior, modo_nuevo, motivo, actor_tipo, actor_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+    [randomUUID2(), input2.companyId, input2.workflow, anterior, input2.modo, motivo, input2.actor.tipo, input2.actor.id]
   );
   await ctx.activity.log({
     companyId: input2.companyId,
@@ -41318,7 +41859,7 @@ async function cambiarPolitica(ctx, input2) {
 }
 async function leerCaso(ctx, companyId, casoId) {
   const rows = await ctx.db.query(
-    `SELECT ${CASO_COLS} FROM ${t(ctx, "caso")} WHERE company_id = $1 AND id = $2 LIMIT 1`,
+    `SELECT ${CASO_COLS} FROM ${t2(ctx, "caso")} WHERE company_id = $1 AND id = $2 LIMIT 1`,
     [companyId, casoId]
   );
   return rows[0] ? mapCaso(rows[0]) : null;
@@ -41328,11 +41869,11 @@ async function leerCasoCompleto(ctx, companyId, casoId) {
   if (!caso) return null;
   const [transiciones, acciones] = await Promise.all([
     ctx.db.query(
-      `SELECT id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, motivo, datos, validaciones, created_at FROM ${t(ctx, "transicion")} WHERE company_id = $1 AND caso_id = $2 ORDER BY created_at ASC`,
+      `SELECT id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, motivo, datos, validaciones, created_at FROM ${t2(ctx, "transicion")} WHERE company_id = $1 AND caso_id = $2 ORDER BY created_at ASC`,
       [companyId, casoId]
     ),
     ctx.db.query(
-      `SELECT id, caso_id, tipo, conector, objetivo, resultado, evidencia, detalle, actor_tipo, actor_id, created_at FROM ${t(ctx, "accion")} WHERE company_id = $1 AND caso_id = $2 ORDER BY created_at ASC`,
+      `SELECT id, caso_id, tipo, conector, objetivo, resultado, evidencia, detalle, actor_tipo, actor_id, created_at FROM ${t2(ctx, "accion")} WHERE company_id = $1 AND caso_id = $2 ORDER BY created_at ASC`,
       [companyId, casoId]
     )
   ]);
@@ -41363,7 +41904,7 @@ async function listarCasos(ctx, input2) {
   const limit = Math.min(Math.max(Number(input2.limit ?? 50) || 50, 1), 100);
   params.push(limit);
   const rows = await ctx.db.query(
-    `SELECT ${CASO_COLS} FROM ${t(ctx, "caso")} WHERE ${where.join(" AND ")} ORDER BY updated_at DESC LIMIT $${params.length}`,
+    `SELECT ${CASO_COLS} FROM ${t2(ctx, "caso")} WHERE ${where.join(" AND ")} ORDER BY updated_at DESC LIMIT $${params.length}`,
     params
   );
   return rows.map(mapCaso);
@@ -41371,21 +41912,21 @@ async function listarCasos(ctx, input2) {
 async function abrirCaso(ctx, input2) {
   const wf = getWorkflow(input2.workflow);
   if (!wf) throw new OpsError("workflow_desconocido", `workflow desconocido: ${input2.workflow}. Disponibles: ${listarWorkflows().map((w) => w.clave).join(", ")}`);
-  const titulo = str(input2.titulo);
+  const titulo = str2(input2.titulo);
   if (!titulo) throw new OpsError("titulo_requerido", "titulo es obligatorio");
   if (input2.actor.tipo === "agente") {
     const modo = await obtenerModo(ctx, input2.companyId, input2.workflow);
     if (modo === "corte") throw new OpsError("politica", `el workflow ${input2.workflow} est\xE1 cortado para agentes en esta instituci\xF3n`);
   }
-  const idem = str(input2.idempotencyKey);
+  const idem = str2(input2.idempotencyKey);
   if (idem) {
     const prev = await ctx.db.query(
-      `SELECT ${CASO_COLS} FROM ${t(ctx, "caso")} WHERE company_id = $1 AND idempotency_key = $2 LIMIT 1`,
+      `SELECT ${CASO_COLS} FROM ${t2(ctx, "caso")} WHERE company_id = $1 AND idempotency_key = $2 LIMIT 1`,
       [input2.companyId, idem]
     );
     if (prev[0]) return { caso: mapCaso(prev[0]), creado: false };
   }
-  const referencia = str(input2.referencia);
+  const referencia = str2(input2.referencia);
   if (wf.clave === "cuenta_completa" || wf.clave === "facturacion_pendiente") {
     const bono = refExterna(input2.datos?.bono_id);
     if (!referencia || !/^bono:\S+$/.test(referencia)) throw new OpsError("referencia_requerida", `en ${wf.clave} la referencia es obligatoria: bono:<n\xFAmero de bono>`);
@@ -41396,17 +41937,36 @@ 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}`);
   }
+  const extra = {};
+  if (wf.clave === "demanda_pendiente") {
+    if (!referencia || !/^(orden|solicitud|control):\S+$/.test(referencia)) {
+      throw new OpsError("referencia_requerida", "en demanda_pendiente la referencia es obligatoria: orden:<id>, solicitud:<id> o control:<persona_id>:<regla_id>");
+    }
+    const reglaId = str2(input2.datos?.regla_id);
+    if (!reglaId) throw new OpsError("regla_requerida", "en demanda_pendiente datos.regla_id es obligatorio: la regla activa que detect\xF3 el caso");
+    const regla = await leerRegla(ctx, input2.companyId, reglaId);
+    if (!regla || regla.workflow !== wf.clave) throw new OpsError("regla_inexistente", `no existe la regla ${reglaId} en esta instituci\xF3n`);
+    if (regla.estado !== "activa") throw new OpsError("regla_inactiva", `la regla \xAB${regla.nombre}\xBB est\xE1 ${regla.estado}: no abre casos hasta que se active`);
+    const { hoy } = ahoraEnHospital();
+    extra.regla_nombre = regla.nombre;
+    extra.regla_version = regla.version;
+    extra.tipo = regla.tipo;
+    extra.canal = regla.contacto.canal;
+    extra.intentos = 0;
+    extra.vence_el = sumarDias(hoy, regla.cierre.dias_para_cerrar);
+    extra.detectado_el = hoy;
+  }
   if (referencia) {
     const abiertos = await ctx.db.query(
-      `SELECT ${CASO_COLS} FROM ${t(ctx, "caso")} WHERE company_id = $1 AND workflow = $2 AND referencia = $3 AND cerrado_at IS NULL ORDER BY created_at DESC LIMIT 1`,
+      `SELECT ${CASO_COLS} FROM ${t2(ctx, "caso")} WHERE company_id = $1 AND workflow = $2 AND referencia = $3 AND cerrado_at IS NULL ORDER BY created_at DESC LIMIT 1`,
       [input2.companyId, input2.workflow, referencia]
     );
     if (abiertos[0]) return { caso: mapCaso(abiertos[0]), creado: false };
   }
-  const id = randomUUID();
-  const datos = input2.datos ?? {};
+  const id = randomUUID2();
+  const datos = { ...input2.datos ?? {}, ...extra };
   await ctx.db.execute(
-    `INSERT INTO ${t(ctx, "caso")} (id, company_id, workflow, estado, referencia, titulo, datos, abierto_por_tipo, abierto_por_id, agente_id, issue_id, idempotency_key) VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8, $9, $10, $11, $12)`,
+    `INSERT INTO ${t2(ctx, "caso")} (id, company_id, workflow, estado, referencia, titulo, datos, abierto_por_tipo, abierto_por_id, agente_id, issue_id, idempotency_key) VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8, $9, $10, $11, $12)`,
     [id, input2.companyId, wf.clave, wf.inicial, referencia, titulo, JSON.stringify(datos), input2.actor.tipo, input2.actor.id, input2.agenteId ?? null, input2.issueId ?? null, idem]
   );
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -41445,11 +42005,24 @@ async function contextoDe(ctx, companyId, caso, via, datos) {
     contexto.plazosPresentacion = leerPlazos((await obtenerOpciones(ctx, companyId, caso.workflow)).plazos);
     return contexto;
   }
+  if (caso.workflow === "demanda_pendiente") {
+    const reglaId = str2(caso.datos.regla_id);
+    const regla = reglaId ? await leerRegla(ctx, companyId, reglaId) : null;
+    contexto.regla = regla ? reglaParaContexto(regla) : null;
+    const contactos = (await ctx.db.query(
+      `SELECT caso_id, via, created_at FROM ${t2(ctx, "transicion")} WHERE company_id = $1 AND caso_id = $2 AND via = $3 ORDER BY created_at DESC LIMIT 50`,
+      [companyId, caso.id, "contactar"]
+    )).filter((r) => String(r.caso_id) === caso.id && String(r.via) === "contactar");
+    contexto.intentosContacto = contactos.length;
+    contexto.ultimoContacto = contactos[0]?.created_at ? ahoraEnHospital(new Date(iso2(contactos[0].created_at))).hoy : null;
+    contexto.diasAbierto = caso.createdAt ? Math.max(0, diasEntre(ahoraEnHospital(new Date(caso.createdAt)).hoy, hoy) ?? 0) : 0;
+    return contexto;
+  }
   if (caso.workflow !== "recupero_turno") return contexto;
   contexto.ofrecerPrimero = (await obtenerOpciones(ctx, companyId, caso.workflow)).ofrecer_primero === true;
   if (via !== "proponer") return contexto;
   const otros = await ctx.db.query(
-    `SELECT id, datos->>'solicitud_id' AS solicitud_id FROM ${t(ctx, "caso")} WHERE company_id = $1 AND workflow = $2 AND id <> $3 AND datos->>'solicitud_id' IS NOT NULL AND estado NOT IN ($4, $5, $6) LIMIT 1000`,
+    `SELECT id, datos->>'solicitud_id' AS solicitud_id FROM ${t2(ctx, "caso")} WHERE company_id = $1 AND workflow = $2 AND id <> $3 AND datos->>'solicitud_id' IS NOT NULL AND estado NOT IN ($4, $5, $6) LIMIT 1000`,
     [companyId, "recupero_turno", caso.id, "sin_candidato", "rechazado", "cancelado"]
   );
   contexto.solicitudesEnCurso = [...new Set(otros.map((r) => String(r.solicitud_id)))];
@@ -41457,7 +42030,7 @@ async function contextoDe(ctx, companyId, caso, via, datos) {
   const mismo = solicitud ? otros.find((r) => String(r.solicitud_id) === solicitud) : void 0;
   contexto.solicitudEnOtroCaso = mismo ? String(mismo.id) : null;
   const asignados = await ctx.db.query(
-    `SELECT count(*)::int AS cantidad FROM ${t(ctx, "transicion")} WHERE company_id = $1 AND via = $2 AND created_at >= $3`,
+    `SELECT count(*)::int AS cantidad FROM ${t2(ctx, "transicion")} WHERE company_id = $1 AND via = $2 AND created_at >= $3`,
     [companyId, "asignar", inicioDelDia.toISOString()]
   );
   contexto.asignacionesHoy = Number(asignados[0]?.cantidad ?? 0);
@@ -41466,10 +42039,10 @@ async function contextoDe(ctx, companyId, caso, via, datos) {
 async function transicionar(ctx, input2) {
   const caso = await leerCaso(ctx, input2.companyId, input2.casoId);
   if (!caso) throw new OpsError("caso_inexistente", `no existe el caso ${input2.casoId} en esta instituci\xF3n`);
-  const idem = str(input2.idempotencyKey);
+  const idem = str2(input2.idempotencyKey);
   if (idem) {
     const prev = await ctx.db.query(
-      `SELECT id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, motivo, datos, validaciones, created_at FROM ${t(ctx, "transicion")} WHERE company_id = $1 AND idempotency_key = $2 LIMIT 1`,
+      `SELECT id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, motivo, datos, validaciones, created_at FROM ${t2(ctx, "transicion")} WHERE company_id = $1 AND idempotency_key = $2 LIMIT 1`,
       [input2.companyId, idem]
     );
     if (prev[0]) return { caso, transicion: mapTransicion(prev[0]), repetida: true };
@@ -41482,10 +42055,10 @@ async function transicionar(ctx, input2) {
   if (!resultado.ok) {
     throw new OpsError(resultado.codigo, resultado.motivo, { validaciones: resultado.validaciones, estado: caso.estado });
   }
-  const accionId = str(datos.accion_id);
+  const accionId = str2(datos.accion_id);
   if (accionId) {
     const rows = await ctx.db.query(
-      `SELECT id, caso_id, tipo, resultado FROM ${t(ctx, "accion")} WHERE company_id = $1 AND id = $2 LIMIT 1`,
+      `SELECT id, caso_id, tipo, resultado FROM ${t2(ctx, "accion")} WHERE company_id = $1 AND id = $2 LIMIT 1`,
       [input2.companyId, accionId]
     );
     const accion = rows[0];
@@ -41494,21 +42067,21 @@ async function transicionar(ctx, input2) {
       throw new OpsError("validacion", `accion_registrada: ${problema}`, { validaciones: [{ regla: "accion_registrada", ok: false, detalle: problema }], estado: caso.estado });
     }
   }
-  const lecturaId = str(datos.lectura_id);
+  const lecturaId = str2(datos.lectura_id);
   if (lecturaId) {
     const rows = await ctx.db.query(
-      `SELECT id, caso_id, tipo, resultado, created_at FROM ${t(ctx, "accion")} WHERE company_id = $1 AND id = $2 LIMIT 1`,
+      `SELECT id, caso_id, tipo, resultado, created_at FROM ${t2(ctx, "accion")} WHERE company_id = $1 AND id = $2 LIMIT 1`,
       [input2.companyId, lecturaId]
     );
     const lectura = rows[0];
     let vieja = false;
     if (lectura && resultado.via === "comprobar") {
       const ultima = await ctx.db.query(
-        `SELECT max(created_at) AS ultima FROM ${t(ctx, "transicion")} WHERE company_id = $1 AND caso_id = $2`,
+        `SELECT max(created_at) AS ultima FROM ${t2(ctx, "transicion")} WHERE company_id = $1 AND caso_id = $2`,
         [input2.companyId, caso.id]
       );
-      const desde = ultima[0]?.ultima ? Date.parse(iso(ultima[0].ultima)) : NaN;
-      vieja = Number.isFinite(desde) && Date.parse(iso(lectura.created_at)) <= desde;
+      const desde = ultima[0]?.ultima ? Date.parse(iso2(ultima[0].ultima)) : NaN;
+      vieja = Number.isFinite(desde) && Date.parse(iso2(lectura.created_at)) <= desde;
     }
     const problema = !lectura ? `lectura_id ${lecturaId} no existe en esta instituci\xF3n` : String(lectura.caso_id) !== caso.id ? `la lectura ${lecturaId} pertenece a otro caso` : !["lectura", "verificacion"].includes(String(lectura.tipo)) ? `la acci\xF3n ${lecturaId} es de tipo ${String(lectura.tipo)}; hace falta una lectura o verificaci\xF3n` : String(lectura.resultado) !== "ok" ? `la lectura ${lecturaId} termin\xF3 con resultado ${String(lectura.resultado)}` : vieja ? `la lectura ${lecturaId} es anterior al \xFAltimo cambio del caso: volver a leer el bono y registrar esa lectura` : null;
     if (problema) {
@@ -41535,6 +42108,23 @@ async function transicionar(ctx, input2) {
     const fecha = String(datos.fecha_prestacion ?? caso.datos.fecha_prestacion ?? "");
     Object.assign(datos, calcularVencimiento(fecha, datos.obra_social ?? caso.datos.obra_social, contexto));
   }
+  if (caso.workflow === "demanda_pendiente") {
+    delete datos.intentos;
+    delete datos.proximo_contacto;
+    if (resultado.via === "contactar") {
+      const hechos = (contexto.intentosContacto ?? 0) + 1;
+      const regla = contexto.regla ?? null;
+      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;
+    }
+    if (resultado.via === "responder") {
+      datos.respuesta = respuestaContacto(datos.respuesta);
+      datos.respondio_el = contexto.hoy ?? null;
+    }
+    if (resultado.via === "comprobar") datos.turno_encontrado_el = contexto.hoy ?? null;
+  }
   if (caso.workflow === "recupero_turno" && resultado.via === "no_acepta") {
     const previas = Array.isArray(caso.datos.declinaron) ? caso.datos.declinaron.map((v) => refExterna(v)).filter((v) => v !== null) : [];
     const esta = refExterna(caso.datos.solicitud_id);
@@ -41551,18 +42141,18 @@ async function transicionar(ctx, input2) {
     datos.largo_cola = total;
     const cola = leerCola(datos.cola);
     const elegida = cola?.find((e) => e.solicitud_id === refExterna(datos.solicitud_id));
-    if (elegida?.prioridad && !str(datos.solicitud_prioridad)) datos.solicitud_prioridad = elegida.prioridad;
+    if (elegida?.prioridad && !str2(datos.solicitud_prioridad)) datos.solicitud_prioridad = elegida.prioridad;
     if (cola) datos.cola = ordenarCola(cola).map((e) => enCurso.has(e.solicitud_id) && e.solicitud_id !== elegida?.solicitud_id ? { ...e, en_otro_recupero: true } : e);
   }
-  const transicionId = randomUUID();
+  const transicionId = randomUUID2();
   await ctx.db.execute(
-    `INSERT INTO ${t(ctx, "transicion")} (id, company_id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, run_id, motivo, datos, validaciones, idempotency_key) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11::jsonb, $12::jsonb, $13)`,
+    `INSERT INTO ${t2(ctx, "transicion")} (id, company_id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, run_id, motivo, datos, validaciones, idempotency_key) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11::jsonb, $12::jsonb, $13)`,
     [transicionId, input2.companyId, caso.id, resultado.de, resultado.a, resultado.via, input2.actor.tipo, input2.actor.id, input2.actor.runId ?? null, resultado.autoaprobado ? input2.motivo ?? "Aprobado autom\xE1ticamente: pol\xEDtica aut\xF3noma, sin excepciones" : input2.motivo ?? null, JSON.stringify(resultado.autoaprobado ? { ...datos, autoaprobado: true } : datos), JSON.stringify(resultado.validaciones), idem]
   );
   const nuevosDatos = { ...caso.datos, ...datos };
   delete nuevosDatos.motivo;
   await ctx.db.execute(
-    `UPDATE ${t(ctx, "caso")} SET estado = $3, datos = $4::jsonb, minutos_absorbidos = minutos_absorbidos + $5::int, cerrado_at = CASE WHEN $6::boolean THEN now() ELSE NULL END, updated_at = now() WHERE company_id = $1 AND id = $2`,
+    `UPDATE ${t2(ctx, "caso")} SET estado = $3, datos = $4::jsonb, minutos_absorbidos = minutos_absorbidos + $5::int, cerrado_at = CASE WHEN $6::boolean THEN now() ELSE NULL END, updated_at = now() WHERE company_id = $1 AND id = $2`,
     [input2.companyId, caso.id, resultado.a, JSON.stringify(nuevosDatos), resultado.minutosAbsorbidos, resultado.esFinal]
   );
   await ctx.activity.log({
@@ -41598,7 +42188,7 @@ async function registrarAccion(ctx, input2) {
   if (!TIPOS_ACCION.includes(input2.tipo)) throw new OpsError("tipo_invalido", `tipo debe ser: ${TIPOS_ACCION.join(", ")}`);
   if (!CONECTORES.includes(input2.conector)) throw new OpsError("conector_invalido", `conector debe ser: ${CONECTORES.join(", ")}`);
   if (!RESULTADOS_ACCION.includes(input2.resultado)) throw new OpsError("resultado_invalido", `resultado debe ser: ${RESULTADOS_ACCION.join(", ")}`);
-  const objetivo = str(input2.objetivo);
+  const objetivo = str2(input2.objetivo);
   if (!objetivo) throw new OpsError("objetivo_requerido", "objetivo es obligatorio (qu\xE9 pantalla, endpoint o archivo se toc\xF3)");
   if (WORKFLOWS_SOLO_LECTURA.has(caso.workflow) && input2.tipo === "escritura" && input2.actor.tipo === "agente") {
     throw new OpsError("politica", `en ${caso.workflow} el puesto solo lee: no registra escrituras sobre el sistema del hospital; eso lo hace el equipo`);
@@ -41607,18 +42197,18 @@ async function registrarAccion(ctx, input2) {
     const modo = await obtenerModo(ctx, input2.companyId, caso.workflow);
     if (!modoHabilita(modo, "ejecuta")) throw new OpsError("politica", `la pol\xEDtica vigente de ${caso.workflow} es "${modo}": un agente no puede registrar escrituras sobre el sistema del hospital`);
   }
-  const id = randomUUID();
+  const id = randomUUID2();
   const evidencia = { ...input2.evidencia ?? {} };
   delete evidencia.fuera_de_flujo;
   if (caso.workflow === "recupero_turno" && input2.tipo === "escritura" && input2.actor.tipo === "agente" && caso.estado !== "asignando") {
     evidencia.fuera_de_flujo = true;
   }
   await ctx.db.execute(
-    `INSERT INTO ${t(ctx, "accion")} (id, company_id, caso_id, tipo, conector, objetivo, resultado, evidencia, detalle, actor_tipo, actor_id, run_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9, $10, $11, $12)`,
+    `INSERT INTO ${t2(ctx, "accion")} (id, company_id, caso_id, tipo, conector, objetivo, resultado, evidencia, detalle, actor_tipo, actor_id, run_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9, $10, $11, $12)`,
     [id, input2.companyId, caso.id, input2.tipo, input2.conector, objetivo, input2.resultado, JSON.stringify(evidencia), input2.detalle ?? null, input2.actor.tipo, input2.actor.id, input2.actor.runId ?? null]
   );
   await ctx.db.execute(
-    `UPDATE ${t(ctx, "caso")} SET updated_at = now() WHERE company_id = $1 AND id = $2`,
+    `UPDATE ${t2(ctx, "caso")} SET updated_at = now() WHERE company_id = $1 AND id = $2`,
     [input2.companyId, caso.id]
   );
   return {
@@ -41642,10 +42232,10 @@ function numero(v) {
 }
 function motivoSinCarga(caso) {
   const wf = getWorkflow(caso.workflow);
-  if (!wf || !wf.transiciones.some((t3) => t3.cargaManual)) return `el workflow ${caso.workflow} no tiene carga manual en el sistema de gesti\xF3n`;
+  if (!wf || !wf.transiciones.some((t4) => t4.cargaManual)) return `el workflow ${caso.workflow} no tiene carga manual en el sistema de gesti\xF3n`;
   if (wf.finalesOk.includes(caso.estado)) return "ya est\xE1 cargado y comprobado";
   if (wf.finalesNoOk.includes(caso.estado)) return `est\xE1 ${caso.estado}: no se carga`;
-  if (wf.transiciones.some((t3) => t3.cargaManual && t3.a === caso.estado)) return "ya figura como cargado; falta la comprobaci\xF3n del puesto";
+  if (wf.transiciones.some((t4) => t4.cargaManual && t4.a === caso.estado)) return "ya figura como cargado; falta la comprobaci\xF3n del puesto";
   return "todav\xEDa no est\xE1 aprobado: no hay nada para cargar";
 }
 async function registrarCargaManual(ctx, input2) {
@@ -41654,10 +42244,10 @@ async function registrarCargaManual(ctx, input2) {
   }
   const caso = await leerCaso(ctx, input2.companyId, input2.casoId);
   if (!caso) throw new OpsError("caso_inexistente", `no existe el caso ${input2.casoId} en esta instituci\xF3n`);
-  const idem = str(input2.idempotencyKey);
+  const idem = str2(input2.idempotencyKey);
   if (idem) {
     const prev = await ctx.db.query(
-      `SELECT id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, motivo, datos, validaciones, created_at FROM ${t(ctx, "transicion")} WHERE company_id = $1 AND idempotency_key = $2 LIMIT 1`,
+      `SELECT id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, motivo, datos, validaciones, created_at FROM ${t2(ctx, "transicion")} WHERE company_id = $1 AND idempotency_key = $2 LIMIT 1`,
       [input2.companyId, idem]
     );
     if (prev[0]) {
@@ -41675,8 +42265,8 @@ async function registrarCargaManual(ctx, input2) {
   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 });
   if (!previa.ok) throw new OpsError(previa.codigo, previa.motivo, { validaciones: previa.validaciones, estado: caso.estado });
-  const persona = str(input2.persona);
-  const comentario = str(input2.comentario);
+  const persona = str2(input2.persona);
+  const comentario = str2(input2.comentario);
   const accion = await registrarAccion(ctx, {
     companyId: input2.companyId,
     casoId: caso.id,
@@ -41710,7 +42300,7 @@ async function registrarCargaManual(ctx, input2) {
   } catch (err) {
     if (idem) {
       const prev = await ctx.db.query(
-        `SELECT id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, motivo, datos, validaciones, created_at FROM ${t(ctx, "transicion")} WHERE company_id = $1 AND idempotency_key = $2 LIMIT 1`,
+        `SELECT id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, motivo, datos, validaciones, created_at FROM ${t2(ctx, "transicion")} WHERE company_id = $1 AND idempotency_key = $2 LIMIT 1`,
         [input2.companyId, idem]
       );
       if (prev[0]) {
@@ -41726,11 +42316,75 @@ async function registrarRespuestaPaciente(ctx, input2) {
   const caso = await leerCaso(ctx, input2.companyId, input2.casoId);
   if (!caso) throw new OpsError("caso_inexistente", `no existe el caso ${input2.casoId} en esta instituci\xF3n`);
   if (caso.workflow !== "recupero_turno") throw new OpsError("estado_invalido", "solo las citas ofrecidas al paciente llevan respuesta");
-  const persona = str(input2.persona);
-  const comentario = str(input2.comentario);
+  const persona = str2(input2.persona);
+  const comentario = str2(input2.comentario);
   const datos = input2.acepto ? { respuesta: comentario ?? "Acept\xF3 la cita", ...persona ? { registrado_por: persona } : {} } : { motivo: comentario ?? "No acept\xF3 la cita", ...persona ? { registrado_por: persona } : {} };
   return transicionar(ctx, { companyId: input2.companyId, casoId: caso.id, via: input2.acepto ? "aceptar" : "no_acepta", datos, motivo: comentario, idempotencyKey: input2.idempotencyKey, actor: input2.actor });
 }
+async function registrarContacto(ctx, input2) {
+  if (input2.actor.tipo !== "humano") throw new OpsError("actor_no_permitido", "el contacto manual lo declara una persona del hospital; un agente registra la escritura y usa ops_transicionar con contactar");
+  const caso = await leerCaso(ctx, input2.companyId, input2.casoId);
+  if (!caso) throw new OpsError("caso_inexistente", `no existe el caso ${input2.casoId} en esta instituci\xF3n`);
+  if (caso.workflow !== "demanda_pendiente") throw new OpsError("estado_invalido", "solo los casos de demanda pendiente llevan contacto");
+  const idem = str2(input2.idempotencyKey);
+  if (idem) {
+    const prev = await ctx.db.query(
+      `SELECT id, caso_id, de_estado, a_estado, via, actor_tipo, actor_id, motivo, datos, validaciones, created_at FROM ${t2(ctx, "transicion")} WHERE company_id = $1 AND idempotency_key = $2 LIMIT 1`,
+      [input2.companyId, idem]
+    );
+    if (prev[0]) return { caso, transicion: mapTransicion(prev[0]), accion: null, respondio: null, repetida: true };
+  }
+  const canal = canalContacto(input2.canal);
+  const respuesta2 = input2.respuesta === void 0 || input2.respuesta === null || input2.respuesta === "" ? null : respuestaContacto(input2.respuesta);
+  if (input2.respuesta !== void 0 && input2.respuesta !== null && input2.respuesta !== "" && !respuesta2) {
+    throw new OpsError("validacion", "respuesta_valida: respuesta debe ser acepta, rechaza o no_contesta", { estado: caso.estado });
+  }
+  const contextoPrevio = await contextoDe(ctx, input2.companyId, caso, "contactar", {});
+  const previa = evaluarTransicion({ caso, via: "contactar", actor: "humano", datos: { accion_id: "(por registrar)", canal }, modo: "ejecuta", contexto: contextoPrevio });
+  if (!previa.ok) throw new OpsError(previa.codigo, previa.motivo, { validaciones: previa.validaciones, estado: caso.estado });
+  if (respuesta2) {
+    const despues = evaluarTransicion({ caso: { ...caso, estado: "contactado" }, via: "responder", actor: "humano", datos: { respuesta: respuesta2 }, modo: "ejecuta", contexto: contextoPrevio });
+    if (!despues.ok) throw new OpsError(despues.codigo, despues.motivo, { validaciones: despues.validaciones, estado: caso.estado });
+  }
+  const persona = str2(input2.persona);
+  const comentario = str2(input2.comentario);
+  const accion = await registrarAccion(ctx, {
+    companyId: input2.companyId,
+    casoId: caso.id,
+    tipo: "escritura",
+    conector: "manual",
+    objetivo: `Paciente \xB7 ${caso.titulo}${caso.referencia ? ` (ref ${caso.referencia})` : ""}`,
+    resultado: "ok",
+    evidencia: { canal, ...persona ? { contactado_por: persona } : {}, ...respuesta2 ? { respuesta: respuesta2 } : {}, ...comentario ? { nota: comentario } : {} },
+    detalle: comentario,
+    actor: input2.actor
+  });
+  const r = await transicionar(ctx, {
+    companyId: input2.companyId,
+    casoId: caso.id,
+    via: "contactar",
+    datos: { accion_id: accion.id, canal, ...persona ? { contactado_por: persona } : {} },
+    motivo: comentario,
+    idempotencyKey: idem,
+    actor: input2.actor
+  });
+  let respondio = null;
+  let final = r.caso;
+  if (respuesta2) {
+    const r2 = await transicionar(ctx, {
+      companyId: input2.companyId,
+      casoId: caso.id,
+      via: "responder",
+      datos: { respuesta: respuesta2, ...persona ? { registrado_por: persona } : {} },
+      motivo: comentario,
+      idempotencyKey: idem ? `${idem}:respuesta` : null,
+      actor: input2.actor
+    });
+    respondio = r2.transicion;
+    final = r2.caso;
+  }
+  return { caso: final, transicion: r.transicion, accion, respondio, repetida: false };
+}
 function finalesOk() {
   return [...new Set(listarWorkflows().flatMap((w) => w.finalesOk))];
 }
@@ -41741,20 +42395,20 @@ async function tablero(ctx, companyId, diasInput) {
   const dias = Math.min(Math.max(Number(diasInput ?? 30) || 30, 1), 365);
   const p1 = [companyId];
   const porEstadoRows = await ctx.db.query(
-    `SELECT workflow, estado, count(*)::int AS cantidad FROM ${t(ctx, "caso")} WHERE company_id = $1 GROUP BY workflow, estado ORDER BY workflow, estado`,
+    `SELECT workflow, estado, count(*)::int AS cantidad FROM ${t2(ctx, "caso")} WHERE company_id = $1 GROUP BY workflow, estado ORDER BY workflow, estado`,
     p1
   );
   const p2 = [companyId, dias];
   const cerradosRows = await ctx.db.query(
-    `SELECT workflow, estado, count(*)::int AS cantidad, coalesce(sum(minutos_absorbidos), 0)::int AS minutos FROM ${t(ctx, "caso")} WHERE company_id = $1 AND cerrado_at IS NOT NULL AND cerrado_at >= now() - ($2::int * interval '1 day') GROUP BY workflow, estado`,
+    `SELECT workflow, estado, count(*)::int AS cantidad, coalesce(sum(minutos_absorbidos), 0)::int AS minutos FROM ${t2(ctx, "caso")} WHERE company_id = $1 AND cerrado_at IS NOT NULL AND cerrado_at >= now() - ($2::int * interval '1 day') GROUP BY workflow, estado`,
     p2
   );
   const totalRows = await ctx.db.query(
-    `SELECT coalesce(sum(minutos_absorbidos), 0)::int AS minutos FROM ${t(ctx, "caso")} WHERE company_id = $1`,
+    `SELECT coalesce(sum(minutos_absorbidos), 0)::int AS minutos FROM ${t2(ctx, "caso")} WHERE company_id = $1`,
     p1
   );
   const accionesRows = await ctx.db.query(
-    `SELECT tipo, count(*)::int AS cantidad FROM ${t(ctx, "accion")} WHERE company_id = $1 AND created_at >= now() - ($2::int * interval '1 day') GROUP BY tipo`,
+    `SELECT tipo, count(*)::int AS cantidad FROM ${t2(ctx, "accion")} WHERE company_id = $1 AND created_at >= now() - ($2::int * interval '1 day') GROUP BY tipo`,
     p2
   );
   const [pendientes, recientes, politicas] = await Promise.all([
@@ -41826,15 +42480,15 @@ async function serie(ctx, companyId, diasInput) {
   const p = [companyId, dias];
   const [abiertos, cerrados, acciones] = await Promise.all([
     ctx.db.query(
-      `SELECT to_char(created_at, 'YYYY-MM-DD') AS dia, count(*)::int AS cantidad FROM ${t(ctx, "caso")} WHERE company_id = $1 AND created_at >= now() - ($2::int * interval '1 day') GROUP BY 1 ORDER BY 1`,
+      `SELECT to_char(created_at, 'YYYY-MM-DD') AS dia, count(*)::int AS cantidad FROM ${t2(ctx, "caso")} WHERE company_id = $1 AND created_at >= now() - ($2::int * interval '1 day') GROUP BY 1 ORDER BY 1`,
       p
     ),
     ctx.db.query(
-      `SELECT to_char(cerrado_at, 'YYYY-MM-DD') AS dia, estado, count(*)::int AS cantidad, coalesce(sum(minutos_absorbidos), 0)::int AS minutos FROM ${t(ctx, "caso")} WHERE company_id = $1 AND cerrado_at IS NOT NULL AND cerrado_at >= now() - ($2::int * interval '1 day') GROUP BY 1, 2 ORDER BY 1`,
+      `SELECT to_char(cerrado_at, 'YYYY-MM-DD') AS dia, estado, count(*)::int AS cantidad, coalesce(sum(minutos_absorbidos), 0)::int AS minutos FROM ${t2(ctx, "caso")} WHERE company_id = $1 AND cerrado_at IS NOT NULL AND cerrado_at >= now() - ($2::int * interval '1 day') GROUP BY 1, 2 ORDER BY 1`,
       p
     ),
     ctx.db.query(
-      `SELECT to_char(created_at, 'YYYY-MM-DD') AS dia, count(*)::int AS cantidad FROM ${t(ctx, "accion")} WHERE company_id = $1 AND created_at >= now() - ($2::int * interval '1 day') GROUP BY 1 ORDER BY 1`,
+      `SELECT to_char(created_at, 'YYYY-MM-DD') AS dia, count(*)::int AS cantidad FROM ${t2(ctx, "accion")} WHERE company_id = $1 AND created_at >= now() - ($2::int * interval '1 day') GROUP BY 1 ORDER BY 1`,
       p
     )
   ]);
@@ -41868,7 +42522,7 @@ async function serie(ctx, companyId, diasInput) {
 async function historialPoliticas(ctx, companyId, limitInput) {
   const limit = Math.min(Math.max(Number(limitInput ?? 50) || 50, 1), 200);
   const rows = await ctx.db.query(
-    `SELECT id, workflow, modo_anterior, modo_nuevo, motivo, actor_tipo, actor_id, created_at FROM ${t(ctx, "politica_historial")} WHERE company_id = $1 ORDER BY created_at DESC LIMIT $2`,
+    `SELECT id, workflow, modo_anterior, modo_nuevo, motivo, actor_tipo, actor_id, created_at FROM ${t2(ctx, "politica_historial")} WHERE company_id = $1 ORDER BY created_at DESC LIMIT $2`,
     [companyId, limit]
   );
   return rows.map((r) => ({
@@ -41879,7 +42533,7 @@ async function historialPoliticas(ctx, companyId, limitInput) {
     motivo: r.motivo ?? null,
     actorTipo: String(r.actor_tipo),
     actorId: r.actor_id ?? null,
-    createdAt: iso(r.created_at)
+    createdAt: iso2(r.created_at)
   }));
 }
 async function indicador(ctx, input2) {
@@ -41931,14 +42585,14 @@ function metricaPorId(id) {
 }
 
 // src/tableros.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 var TIPOS = ["indicador", "barras", "linea", "tabla", "texto"];
 var TONOS = ["neutro", "ambar", "senal", "corte"];
 var MAX_WIDGETS = 24;
-function t2(ctx, table) {
+function t3(ctx, table) {
   return `${ctx.db.namespace}.${table}`;
 }
-function iso2(v) {
+function iso3(v) {
   if (v instanceof Date) return v.toISOString();
   if (typeof v === "string") return v;
   return "";
@@ -42150,18 +42804,18 @@ function mapTablero(r) {
     publicadoPorTipo: String(r.publicado_por_tipo),
     publicadoPorId: r.publicado_por_id ?? null,
     versiones: Number(r.versiones ?? 1),
-    createdAt: iso2(r.created_at),
-    updatedAt: iso2(r.updated_at)
+    createdAt: iso3(r.created_at),
+    updatedAt: iso3(r.updated_at)
   };
 }
-var COLS = "id, company_id, clave, titulo, descripcion, pedido, periodo, fuentes, widgets, agente_id, issue_id, publicado_por_tipo, publicado_por_id, versiones, created_at, updated_at";
+var COLS2 = "id, company_id, clave, titulo, descripcion, pedido, periodo, fuentes, widgets, agente_id, issue_id, publicado_por_tipo, publicado_por_id, versiones, created_at, updated_at";
 var CLAVE_RE = /^[a-z0-9][a-z0-9-]{1,60}$/;
 async function listarTableros(ctx, companyId) {
-  const rows = await ctx.db.query(`SELECT ${COLS} FROM ${t2(ctx, "tablero")} WHERE company_id = $1 ORDER BY updated_at DESC`, [companyId]);
+  const rows = await ctx.db.query(`SELECT ${COLS2} FROM ${t3(ctx, "tablero")} WHERE company_id = $1 ORDER BY updated_at DESC`, [companyId]);
   return rows.map(mapTablero);
 }
 async function leerTablero(ctx, companyId, clave) {
-  const rows = await ctx.db.query(`SELECT ${COLS} FROM ${t2(ctx, "tablero")} WHERE company_id = $1 AND clave = $2 LIMIT 1`, [companyId, clave]);
+  const rows = await ctx.db.query(`SELECT ${COLS2} FROM ${t3(ctx, "tablero")} WHERE company_id = $1 AND clave = $2 LIMIT 1`, [companyId, clave]);
   return rows[0] ? mapTablero(rows[0]) : null;
 }
 async function publicarTablero(ctx, input2) {
@@ -42176,7 +42830,7 @@ async function publicarTablero(ctx, input2) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (previo) {
     await ctx.db.execute(
-      `UPDATE ${t2(ctx, "tablero")} SET titulo = $3, descripcion = $4, pedido = COALESCE($5, pedido), periodo = $6, fuentes = $7::jsonb, widgets = $8::jsonb, agente_id = COALESCE($9, agente_id), issue_id = COALESCE($10, issue_id), publicado_por_tipo = $11, publicado_por_id = $12, versiones = versiones + 1, updated_at = now() WHERE company_id = $1 AND clave = $2`,
+      `UPDATE ${t3(ctx, "tablero")} SET titulo = $3, descripcion = $4, pedido = COALESCE($5, pedido), periodo = $6, fuentes = $7::jsonb, widgets = $8::jsonb, agente_id = COALESCE($9, agente_id), issue_id = COALESCE($10, issue_id), publicado_por_tipo = $11, publicado_por_id = $12, versiones = versiones + 1, updated_at = now() WHERE company_id = $1 AND clave = $2`,
       [input2.companyId, clave, titulo, limpio(input2.descripcion, 600), limpio(input2.pedido, 1e3), limpio(input2.periodo, 80), JSON.stringify(fuentes), JSON.stringify(widgets), input2.agenteId ?? null, input2.issueId ?? null, input2.actor.tipo, input2.actor.id]
     );
     await ctx.activity.log({ companyId: input2.companyId, message: `Autopilot Care: tablero \xAB${titulo}\xBB actualizado (${clave}, versi\xF3n ${previo.versiones + 1})`, metadata: { clave, widgets: widgets.length, agentId: input2.agenteId ?? null, issueId: input2.issueId ?? null } });
@@ -42185,9 +42839,9 @@ async function publicarTablero(ctx, input2) {
       tablero: { ...previo, titulo, descripcion: limpio(input2.descripcion, 600), pedido: limpio(input2.pedido, 1e3) ?? previo.pedido, periodo: limpio(input2.periodo, 80), fuentes, widgets, agenteId: input2.agenteId ?? previo.agenteId, issueId: input2.issueId ?? previo.issueId, publicadoPorTipo: input2.actor.tipo, publicadoPorId: input2.actor.id, versiones: previo.versiones + 1, updatedAt: now }
     };
   }
-  const id = randomUUID2();
+  const id = randomUUID3();
   await ctx.db.execute(
-    `INSERT INTO ${t2(ctx, "tablero")} (id, company_id, clave, titulo, descripcion, pedido, periodo, fuentes, widgets, agente_id, issue_id, publicado_por_tipo, publicado_por_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9::jsonb, $10, $11, $12, $13)`,
+    `INSERT INTO ${t3(ctx, "tablero")} (id, company_id, clave, titulo, descripcion, pedido, periodo, fuentes, widgets, agente_id, issue_id, publicado_por_tipo, publicado_por_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9::jsonb, $10, $11, $12, $13)`,
     [id, input2.companyId, clave, titulo, limpio(input2.descripcion, 600), limpio(input2.pedido, 1e3), limpio(input2.periodo, 80), JSON.stringify(fuentes), JSON.stringify(widgets), input2.agenteId ?? null, input2.issueId ?? null, input2.actor.tipo, input2.actor.id]
   );
   await ctx.activity.log({ companyId: input2.companyId, message: `Autopilot Care: tablero \xAB${titulo}\xBB publicado (${clave})`, metadata: { clave, widgets: widgets.length, agentId: input2.agenteId ?? null, issueId: input2.issueId ?? null } });
@@ -42198,14 +42852,14 @@ async function publicarTablero(ctx, input2) {
 }
 
 // src/worker.ts
-function str2(v) {
+function str3(v) {
   return typeof v === "string" && v.trim().length > 0 ? v.trim() : null;
 }
 function obj(v) {
   return v && typeof v === "object" && !Array.isArray(v) ? v : {};
 }
 function uuidOrNull(v) {
-  const s = str2(v);
+  const s = str3(v);
   return s && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s) ? s : null;
 }
 function numOrNull(v) {
@@ -42213,12 +42867,12 @@ function numOrNull(v) {
   return Number.isFinite(n) ? n : null;
 }
 function companyFrom(params, fallback) {
-  const companyId = str2(params.companyId) ?? str2(fallback);
+  const companyId = str3(params.companyId) ?? str3(fallback);
   if (!companyId) throw new OpsError("company_requerida", "companyId es obligatorio");
   return companyId;
 }
 function toolSchema(name) {
-  const decl = manifest_default.tools?.find((t3) => t3.name === name);
+  const decl = manifest_default.tools?.find((t4) => t4.name === name);
   return {
     displayName: decl?.displayName ?? name,
     description: decl?.description ?? "",
@@ -42241,7 +42895,7 @@ async function conErrores(fn) {
 function registrarHerramientas(ctx) {
   ctx.tools.register(TOOL_NAMES.listarCasos, toolSchema(TOOL_NAMES.listarCasos), async (params, runCtx) => conErrores(async () => {
     const p = obj(params);
-    const casos = await listarCasos(ctx, { companyId: runCtx.companyId, workflow: str2(p.workflow), estado: str2(p.estado), limit: numOrNull(p.limit) });
+    const casos = await listarCasos(ctx, { companyId: runCtx.companyId, workflow: str3(p.workflow), estado: str3(p.estado), limit: numOrNull(p.limit) });
     return {
       content: casos.length ? casos.map(resumenCaso).join("\n") : "No hay casos que coincidan.",
       data: { casos }
@@ -42249,7 +42903,7 @@ function registrarHerramientas(ctx) {
   }));
   ctx.tools.register(TOOL_NAMES.leerCaso, toolSchema(TOOL_NAMES.leerCaso), async (params, runCtx) => conErrores(async () => {
     const p = obj(params);
-    const casoId = str2(p.casoId);
+    const casoId = str3(p.casoId);
     if (!casoId) throw new OpsError("caso_requerido", "casoId es obligatorio");
     const detalle = await leerCasoCompleto(ctx, runCtx.companyId, casoId);
     if (!detalle) throw new OpsError("caso_inexistente", `no existe el caso ${casoId} en esta instituci\xF3n`);
@@ -42268,11 +42922,11 @@ Transiciones registradas: ${detalle.transiciones.length}; acciones registradas:
     const p = obj(params);
     const { caso, creado } = await abrirCaso(ctx, {
       companyId: runCtx.companyId,
-      workflow: str2(p.workflow) ?? "",
-      titulo: str2(p.titulo) ?? "",
-      referencia: str2(p.referencia),
+      workflow: str3(p.workflow) ?? "",
+      titulo: str3(p.titulo) ?? "",
+      referencia: str3(p.referencia),
       datos: obj(p.datos),
-      idempotencyKey: str2(p.idempotencyKey),
+      idempotencyKey: str3(p.idempotencyKey),
       actor: actorAgente(runCtx),
       agenteId: runCtx.agentId,
       issueId: uuidOrNull(p.issueId)
@@ -42284,16 +42938,16 @@ Transiciones registradas: ${detalle.transiciones.length}; acciones registradas:
   }));
   ctx.tools.register(TOOL_NAMES.transicionar, toolSchema(TOOL_NAMES.transicionar), async (params, runCtx) => conErrores(async () => {
     const p = obj(params);
-    const casoId = str2(p.casoId);
-    const via = str2(p.via);
+    const casoId = str3(p.casoId);
+    const via = str3(p.via);
     if (!casoId || !via) throw new OpsError("parametros", "casoId y via son obligatorios");
     const r = await transicionar(ctx, {
       companyId: runCtx.companyId,
       casoId,
       via,
       datos: obj(p.datos),
-      motivo: str2(p.motivo),
-      idempotencyKey: str2(p.idempotencyKey),
+      motivo: str3(p.motivo),
+      idempotencyKey: str3(p.idempotencyKey),
       actor: actorAgente(runCtx)
     });
     return {
@@ -42305,32 +42959,45 @@ Transiciones registradas: ${detalle.transiciones.length}; acciones registradas:
     const p = obj(params);
     const accion = await registrarAccion(ctx, {
       companyId: runCtx.companyId,
-      casoId: str2(p.casoId) ?? "",
-      tipo: str2(p.tipo) ?? "",
-      conector: str2(p.conector) ?? "",
-      objetivo: str2(p.objetivo) ?? "",
-      resultado: str2(p.resultado) ?? "",
+      casoId: str3(p.casoId) ?? "",
+      tipo: str3(p.tipo) ?? "",
+      conector: str3(p.conector) ?? "",
+      objetivo: str3(p.objetivo) ?? "",
+      resultado: str3(p.resultado) ?? "",
       evidencia: obj(p.evidencia),
-      detalle: str2(p.detalle),
+      detalle: str3(p.detalle),
       actor: actorAgente(runCtx)
     });
     return { content: `Acci\xF3n registrada ${accion.id} (${accion.tipo} \xB7 ${accion.conector} \xB7 ${accion.resultado})`, data: { accion } };
   }));
+  ctx.tools.register(TOOL_NAMES.listarReglas, toolSchema(TOOL_NAMES.listarReglas), async (params, runCtx) => conErrores(async () => {
+    const p = obj(params);
+    const reglas = await listarReglas(ctx, runCtx.companyId, { workflow: str3(p.workflow) ?? "demanda_pendiente", estado: str3(p.estado) });
+    const resumen = reglas.map((r) => `${r.id} \xB7 ${r.nombre} \xB7 ${r.tipo} \xB7 ${r.estado} \xB7 v${r.version}${r.ultimaPrueba?.estado === "pedida" && r.ultimaPrueba.version === r.version ? " \xB7 PRUEBA PEDIDA" : ""}`);
+    return { content: resumen.length ? resumen.join("\n") : "No hay reglas.", data: { reglas } };
+  }));
+  ctx.tools.register(TOOL_NAMES.informarPruebaRegla, toolSchema(TOOL_NAMES.informarPruebaRegla), async (params, runCtx) => conErrores(async () => {
+    const p = obj(params);
+    const reglaId = str3(p.reglaId);
+    if (!reglaId) throw new OpsError("regla_requerida", "reglaId es obligatorio");
+    const regla = await informarPruebaRegla(ctx, { companyId: runCtx.companyId, id: reglaId, alcanza: p.alcanza, muestra: p.muestra, consulta: str3(p.consulta), actor: actorAgente(runCtx) });
+    return { content: `Prueba informada: la regla \xAB${regla.nombre}\xBB (versi\xF3n ${regla.version}) alcanza hoy a ${regla.ultimaPrueba?.alcanza ?? 0}`, data: { regla } };
+  }));
   ctx.tools.register(TOOL_NAMES.consultarIndicador, toolSchema(TOOL_NAMES.consultarIndicador), async (params, runCtx) => conErrores(async () => {
     const p = obj(params);
-    const nombre = str2(p.indicador) ?? "resumen";
-    const data = await indicador(ctx, { companyId: runCtx.companyId, indicador: nombre, workflow: str2(p.workflow), dias: numOrNull(p.dias) });
+    const nombre = str3(p.indicador) ?? "resumen";
+    const data = await indicador(ctx, { companyId: runCtx.companyId, indicador: nombre, workflow: str3(p.workflow), dias: numOrNull(p.dias) });
     return { content: JSON.stringify(data, null, 2), data };
   }));
   ctx.tools.register(TOOL_NAMES.publicarTablero, toolSchema(TOOL_NAMES.publicarTablero), async (params, runCtx) => conErrores(async () => {
     const p = obj(params);
     const r = await publicarTablero(ctx, {
       companyId: runCtx.companyId,
-      clave: str2(p.clave) ?? "",
-      titulo: str2(p.titulo) ?? "",
-      descripcion: str2(p.descripcion),
-      pedido: str2(p.pedido),
-      periodo: str2(p.periodo),
+      clave: str3(p.clave) ?? "",
+      titulo: str3(p.titulo) ?? "",
+      descripcion: str3(p.descripcion),
+      pedido: str3(p.pedido),
+      periodo: str3(p.periodo),
       fuentes: p.fuentes,
       widgets: p.widgets,
       actor: actorAgente(runCtx),
@@ -42366,12 +43033,12 @@ function registrarDatosYAcciones(ctx) {
     finalesOk: w.finalesOk,
     finalesNoOk: w.finalesNoOk,
     minutosAbsorbidos: w.minutosAbsorbidos,
-    transiciones: w.transiciones.map((t3) => ({ via: t3.via, de: t3.de, a: typeof t3.a === "string" ? t3.a : "(seg\xFAn datos)", actor: t3.actor, nivelRequerido: t3.nivelRequerido ?? null, descripcion: t3.descripcion }))
+    transiciones: w.transiciones.map((t4) => ({ via: t4.via, de: t4.de, a: typeof t4.a === "string" ? t4.a : "(seg\xFAn datos)", actor: t4.actor, nivelRequerido: t4.nivelRequerido ?? null, descripcion: t4.descripcion }))
   })));
   ctx.data.register(DATA_KEYS.tablero, async (params) => tablero(ctx, companyFrom(params), numOrNull(params.dias)));
-  ctx.data.register(DATA_KEYS.casos, async (params) => listarCasos(ctx, { companyId: companyFrom(params), workflow: str2(params.workflow), estado: str2(params.estado), limit: numOrNull(params.limit) }));
+  ctx.data.register(DATA_KEYS.casos, async (params) => listarCasos(ctx, { companyId: companyFrom(params), workflow: str3(params.workflow), estado: str3(params.estado), limit: numOrNull(params.limit) }));
   ctx.data.register(DATA_KEYS.caso, async (params) => {
-    const casoId = str2(params.casoId);
+    const casoId = str3(params.casoId);
     if (!casoId) throw new OpsError("caso_requerido", "casoId es obligatorio");
     return leerCasoCompleto(ctx, companyFrom(params), casoId);
   });
@@ -42379,40 +43046,40 @@ function registrarDatosYAcciones(ctx) {
   ctx.data.register(DATA_KEYS.serie, async (params) => serie(ctx, companyFrom(params), numOrNull(params.dias)));
   ctx.data.register(DATA_KEYS.historialPoliticas, async (params) => historialPoliticas(ctx, companyFrom(params), numOrNull(params.limit)));
   ctx.actions.register(ACTION_KEYS.aprobar, async (params, context) => {
-    const casoId = str2(params.casoId);
+    const casoId = str3(params.casoId);
     if (!casoId) throw new OpsError("caso_requerido", "casoId es obligatorio");
-    return transicionar(ctx, { companyId: companyFrom(params, context.companyId), casoId, via: "aprobar", motivo: str2(params.motivo), datos: obj(params.datos), actor: actorHumano(context) });
+    return transicionar(ctx, { companyId: companyFrom(params, context.companyId), casoId, via: "aprobar", motivo: str3(params.motivo), datos: obj(params.datos), actor: actorHumano(context) });
   });
   ctx.actions.register(ACTION_KEYS.rechazar, async (params, context) => {
-    const casoId = str2(params.casoId);
+    const casoId = str3(params.casoId);
     if (!casoId) throw new OpsError("caso_requerido", "casoId es obligatorio");
-    return transicionar(ctx, { companyId: companyFrom(params, context.companyId), casoId, via: "rechazar", motivo: str2(params.motivo), datos: obj(params.datos), actor: actorHumano(context) });
+    return transicionar(ctx, { companyId: companyFrom(params, context.companyId), casoId, via: "rechazar", motivo: str3(params.motivo), datos: obj(params.datos), actor: actorHumano(context) });
   });
   ctx.actions.register(ACTION_KEYS.marcarCargado, async (params, context) => {
-    const casoId = str2(params.casoId);
+    const casoId = str3(params.casoId);
     if (!casoId) throw new OpsError("caso_requerido", "casoId es obligatorio");
     return registrarCargaManual(ctx, {
       companyId: companyFrom(params, context.companyId),
       casoId,
       valorCargado: params.valorCargado,
-      comentario: str2(params.comentario),
-      persona: str2(params.cargadoPor),
+      comentario: str3(params.comentario),
+      persona: str3(params.cargadoPor),
       actor: actorHumano(context)
     });
   });
   ctx.actions.register(ACTION_KEYS.cambiarPolitica, async (params, context) => {
-    const workflow = str2(params.workflow);
+    const workflow = str3(params.workflow);
     const modo = params.modo;
     if (!workflow) throw new OpsError("workflow_requerido", "workflow es obligatorio");
     if (!esModo(modo)) throw new OpsError("modo_invalido", "modo debe ser corte, observa, propone, ejecuta o autonomo");
-    return cambiarPolitica(ctx, { companyId: companyFrom(params, context.companyId), workflow, modo, motivo: str2(params.motivo), actor: actorHumano(context) });
+    return cambiarPolitica(ctx, { companyId: companyFrom(params, context.companyId), workflow, modo, motivo: str3(params.motivo), actor: actorHumano(context) });
   });
   ctx.actions.register(ACTION_KEYS.abrirCaso, async (params, context) => {
     return abrirCaso(ctx, {
       companyId: companyFrom(params, context.companyId),
-      workflow: str2(params.workflow) ?? "",
-      titulo: str2(params.titulo) ?? "",
-      referencia: str2(params.referencia),
+      workflow: str3(params.workflow) ?? "",
+      titulo: str3(params.titulo) ?? "",
+      referencia: str3(params.referencia),
       datos: obj(params.datos),
       actor: actorHumano(context)
     });
@@ -42425,10 +43092,10 @@ async function manejarApi(ctx, input2) {
   const companyId = input2.companyId;
   const body = obj(input2.body);
   const q = input2.query;
-  const qs = (k) => Array.isArray(q[k]) ? str2(q[k][0]) : str2(q[k]);
+  const qs = (k) => Array.isArray(q[k]) ? str3(q[k][0]) : str3(q[k]);
   const actor = input2.actor.actorType === "agent" ? { tipo: "agente", id: input2.actor.agentId ?? input2.actor.actorId, runId: input2.actor.runId ?? null } : { tipo: "humano", id: input2.actor.userId ?? input2.actor.actorId };
   const quien = obj(body.decididoPor);
-  const decididoPor = str2(quien.nombre) ? `${str2(quien.nombre)}${str2(quien.email) ? ` (${str2(quien.email)})` : ""}` : null;
+  const decididoPor = str3(quien.nombre) ? `${str3(quien.nombre)}${str3(quien.email) ? ` (${str3(quien.email)})` : ""}` : null;
   const conPersona = (datos) => decididoPor ? { ...datos, decidido_por: decididoPor } : datos;
   const motivoConPersona = (motivo) => decididoPor ? `${motivo ? `${motivo} \xB7 ` : ""}decidido por ${decididoPor}` : motivo ?? null;
   switch (input2.routeKey) {
@@ -42441,20 +43108,20 @@ async function manejarApi(ctx, input2) {
       return detalle ? respuesta(200, detalle) : respuesta(404, { error: "caso_inexistente" });
     }
     case "aprobar":
-      return respuesta(200, await transicionar(ctx, { companyId, casoId: input2.params.casoId ?? "", via: "aprobar", motivo: str2(body.motivo), datos: conPersona(obj(body.datos)), actor }));
+      return respuesta(200, await transicionar(ctx, { companyId, casoId: input2.params.casoId ?? "", via: "aprobar", motivo: str3(body.motivo), datos: conPersona(obj(body.datos)), actor }));
     case "rechazar":
-      return respuesta(200, await transicionar(ctx, { companyId, casoId: input2.params.casoId ?? "", via: "rechazar", motivo: str2(body.motivo), datos: conPersona(obj(body.datos)), actor }));
+      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: str2(body.comentario), persona: decididoPor, idempotencyKey: str2(body.idempotencyKey), actor }));
+      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 }));
     case "respuesta-paciente":
-      return respuesta(200, await registrarRespuestaPaciente(ctx, { companyId, casoId: input2.params.casoId ?? "", acepto: body.acepto === true, comentario: str2(body.comentario), persona: decididoPor, idempotencyKey: str2(body.idempotencyKey), actor }));
+      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": {
       if (actor.tipo !== "humano") return respuesta(403, { error: "actor_no_permitido", motivo: "no_corresponde lo decide una persona del hospital" });
-      if (!str2(body.motivo)) return respuesta(422, { error: "validacion", motivo: "motivo_presente: no_corresponde requiere motivo" });
-      return respuesta(200, await transicionar(ctx, { companyId, casoId: input2.params.casoId ?? "", via: "no_corresponde", motivo: motivoConPersona(str2(body.motivo)), datos: conPersona(obj(body.datos)), idempotencyKey: str2(body.idempotencyKey), actor }));
+      if (!str3(body.motivo)) return respuesta(422, { error: "validacion", motivo: "motivo_presente: no_corresponde requiere motivo" });
+      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"], 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"], workflows: listarWorkflows().map((w) => w.clave) });
     case "politicas":
       return respuesta(200, { politicas: await listarPoliticas(ctx, companyId) });
     case "serie":
@@ -42469,12 +43136,33 @@ async function manejarApi(ctx, input2) {
       const tb = await leerTablero(ctx, companyId, (input2.params.clave ?? "").toLowerCase());
       return tb ? respuesta(200, tb) : respuesta(404, { error: "tablero_inexistente" });
     }
+    case "reglas":
+      return respuesta(200, { reglas: await listarReglas(ctx, companyId, { workflow: qs("workflow") ?? "demanda_pendiente", estado: qs("estado") }) });
+    case "crear-regla": {
+      if (actor.tipo !== "humano") return respuesta(403, { error: "actor_no_permitido", motivo: "las reglas las crea una persona del hospital" });
+      const workflow = str3(body.workflow) ?? "demanda_pendiente";
+      return respuesta(200, { regla: await crearRegla(ctx, { companyId, workflow, nombre: body.nombre, tipo: body.tipo, parametros: body.parametros, contacto: body.contacto, cierre: body.cierre, actor: { tipo: "humano", id: decididoPor ?? actor.id } }) });
+    }
+    case "editar-regla": {
+      if (actor.tipo !== "humano") return respuesta(403, { error: "actor_no_permitido", motivo: "las reglas las edita una persona del hospital" });
+      return respuesta(200, { regla: await editarRegla(ctx, { companyId, id: input2.params.reglaId ?? "", nombre: body.nombre, tipo: body.tipo, parametros: body.parametros, contacto: body.contacto, cierre: body.cierre, motivo: str3(body.motivo), actor: { tipo: "humano", id: decididoPor ?? actor.id } }) });
+    }
+    case "estado-regla": {
+      if (actor.tipo !== "humano") return respuesta(403, { error: "actor_no_permitido", motivo: "activar o pausar una regla lo hace una persona del hospital" });
+      return respuesta(200, { regla: await cambiarEstadoRegla(ctx, { companyId, id: input2.params.reglaId ?? "", estado: body.estado, motivo: str3(body.motivo), actor: { tipo: "humano", id: decididoPor ?? actor.id } }) });
+    }
+    case "probar-regla": {
+      if (actor.tipo !== "humano") return respuesta(403, { error: "actor_no_permitido", motivo: "la prueba la pide una persona del hospital; el agente la informa con ops_informar_prueba_regla" });
+      return respuesta(200, { regla: await pedirPruebaRegla(ctx, { companyId, id: input2.params.reglaId ?? "", actor: { tipo: "humano", id: decididoPor ?? actor.id } }) });
+    }
+    case "contacto":
+      return respuesta(200, await registrarContacto(ctx, { companyId, casoId: input2.params.casoId ?? "", canal: body.canal, respuesta: body.respuesta, comentario: str3(body.comentario), persona: decididoPor, idempotencyKey: str3(body.idempotencyKey), actor }));
     case "cambiar-politica": {
-      const workflow = str2(body.workflow);
+      const workflow = str3(body.workflow);
       if (!workflow) return respuesta(400, { error: "workflow_requerido" });
       if (!esModo(body.modo)) return respuesta(400, { error: "modo_invalido", detalle: "modo debe ser corte, observa, propone, ejecuta o autonomo" });
       const opciones = body.opciones && typeof body.opciones === "object" && !Array.isArray(body.opciones) ? body.opciones : null;
-      return respuesta(200, await cambiarPolitica(ctx, { companyId, workflow, modo: body.modo, motivo: motivoConPersona(str2(body.motivo)), opciones, actor }));
+      return respuesta(200, await cambiarPolitica(ctx, { companyId, workflow, modo: body.modo, motivo: motivoConPersona(str3(body.motivo)), opciones, actor }));
     }
     default:
       return respuesta(404, { error: "ruta_desconocida", routeKey: input2.routeKey });