paperclip-plugin-autopilot-ops 0.1.30 → 0.1.31

package/dist/manifest.js

@@ -1,6 +1,6 @@
 // src/manifest.ts
 var PLUGIN_ID = "alephoo.autopilot-ops";
-var PLUGIN_VERSION = "0.1.30";
+var PLUGIN_VERSION = "0.1.31";
 var DB_NAMESPACE_SLUG = "autopilot_ops";
 var PAGE_ROUTE = "autopilot";
 var TOOL_NAMES = {
@@ -9,6 +9,10 @@ var TOOL_NAMES = {
   abrirCaso: "ops_abrir_caso",
   transicionar: "ops_transicionar",
   registrarAccion: "ops_registrar_accion",
+  reservarEscritura: "ops_reservar_escritura",
+  confirmarEscritura: "ops_confirmar_escritura",
+  cerrarEscritura: "ops_cerrar_escritura",
+  verificarEscritura: "ops_verificar_escritura",
   consultarIndicador: "ops_consultar_indicador",
   publicarTablero: "ops_publicar_tablero",
   listarTableros: "ops_listar_tableros",
@@ -161,6 +165,58 @@ var manifest = {
         required: ["casoId", "tipo", "conector", "objetivo", "resultado"]
       }
     },
+    {
+      name: TOOL_NAMES.reservarEscritura,
+      displayName: "Reservar una escritura en el HIS",
+      description: "Paso 1 de toda escritura en el HIS: antes de tocarlo, dec\xED qu\xE9 vas a escribir (clave de negocio \xFAnica, p. ej. turno:2026-10-20T10:00|prof:15|sol:8812), sobre qu\xE9 registro (p. ej. solicitud:8812) y qu\xE9 le\xEDste de ese registro reci\xE9n (leido). El plugin la rechaza si el freno est\xE1 puesto, fuera de horario, si se pas\xF3 el tope del d\xEDa, si esa escritura ya se hizo o qued\xF3 dudosa, o si otro trabajo escribe el mismo registro. Devuelve el id de la reserva (vence en 15 minutos).",
+      parametersSchema: {
+        type: "object",
+        properties: {
+          casoId: { type: "string" },
+          clave: { type: "string", description: "Identifica la escritura de negocio: la misma clave no se escribe dos veces." },
+          registro: { type: "string", description: "El registro del HIS que se toca (tipo:id)." },
+          conector: { type: "string", enum: ["api", "pantalla", "archivo"] },
+          objetivo: { type: "string", description: "Qu\xE9 pantalla, endpoint o archivo." },
+          leido: { type: "object", description: "Lo que le\xEDste del registro ahora (campos y valores); se compara justo antes de guardar." }
+        },
+        required: ["casoId", "clave", "registro", "conector", "objetivo", "leido"]
+      }
+    },
+    {
+      name: TOOL_NAMES.confirmarEscritura,
+      displayName: "Confirmar antes de guardar",
+      description: "Paso 2 (solo si la funci\xF3n lo exige, sobre sistemas que no validan por s\xED mismos): justo antes de guardar, volv\xE9 a leer el registro y mand\xE1 lo le\xEDdo con los mismos campos. Si cambi\xF3 desde la reserva (lo toc\xF3 una persona), la escritura se descarta: no guardes y volv\xE9 a proponer.",
+      parametersSchema: {
+        type: "object",
+        properties: { accionId: { type: "string" }, leido: { type: "object" } },
+        required: ["accionId", "leido"]
+      }
+    },
+    {
+      name: TOOL_NAMES.cerrarEscritura,
+      displayName: "Cerrar una escritura",
+      description: "Paso 3: c\xF3mo sali\xF3 la escritura. ok (qued\xF3 escrita; si la funci\xF3n exige confirmar, solo despu\xE9s de confirmarla), error (no se escribi\xF3 nada) o incierta (no sab\xE9s si qued\xF3 escrita: no reintentes; verificala con ops_verificar_escritura). Con 3 fallas seguidas la funci\xF3n se frena sola.",
+      parametersSchema: {
+        type: "object",
+        properties: {
+          accionId: { type: "string" },
+          resultado: { type: "string", enum: ["ok", "error", "incierta"] },
+          evidencia: { type: "object" },
+          detalle: { type: "string" }
+        },
+        required: ["accionId", "resultado"]
+      }
+    },
+    {
+      name: TOOL_NAMES.verificarEscritura,
+      displayName: "Verificar una escritura dudosa",
+      description: "Para una escritura que qued\xF3 incierta: rele\xE9 el HIS y dec\xED si qued\xF3 escrita (quedo true: se da por hecha y segu\xEDs), si no qued\xF3 (quedo false: se puede reintentar) o si no lo pod\xE9s saber (quedo null: despu\xE9s de 2 intentos o una hora pasa a una persona). Mand\xE1 en leido lo que rele\xEDste.",
+      parametersSchema: {
+        type: "object",
+        properties: { accionId: { type: "string" }, quedo: { type: ["boolean", "null"] }, leido: { type: "object" }, detalle: { type: "string" } },
+        required: ["accionId", "quedo", "leido"]
+      }
+    },
     {
       name: TOOL_NAMES.consultarIndicador,
       displayName: "Consultar indicador",

package/dist/ui/index.js

@@ -8,7 +8,7 @@ import {
 
 // src/manifest.ts
 var PLUGIN_ID = "alephoo.autopilot-ops";
-var PLUGIN_VERSION = "0.1.30";
+var PLUGIN_VERSION = "0.1.31";
 var DB_NAMESPACE_SLUG = "autopilot_ops";
 var PAGE_ROUTE = "autopilot";
 var TOOL_NAMES = {
@@ -17,6 +17,10 @@ var TOOL_NAMES = {
   abrirCaso: "ops_abrir_caso",
   transicionar: "ops_transicionar",
   registrarAccion: "ops_registrar_accion",
+  reservarEscritura: "ops_reservar_escritura",
+  confirmarEscritura: "ops_confirmar_escritura",
+  cerrarEscritura: "ops_cerrar_escritura",
+  verificarEscritura: "ops_verificar_escritura",
   consultarIndicador: "ops_consultar_indicador",
   publicarTablero: "ops_publicar_tablero",
   listarTableros: "ops_listar_tableros",
@@ -169,6 +173,58 @@ var manifest = {
         required: ["casoId", "tipo", "conector", "objetivo", "resultado"]
       }
     },
+    {
+      name: TOOL_NAMES.reservarEscritura,
+      displayName: "Reservar una escritura en el HIS",
+      description: "Paso 1 de toda escritura en el HIS: antes de tocarlo, dec\xED qu\xE9 vas a escribir (clave de negocio \xFAnica, p. ej. turno:2026-10-20T10:00|prof:15|sol:8812), sobre qu\xE9 registro (p. ej. solicitud:8812) y qu\xE9 le\xEDste de ese registro reci\xE9n (leido). El plugin la rechaza si el freno est\xE1 puesto, fuera de horario, si se pas\xF3 el tope del d\xEDa, si esa escritura ya se hizo o qued\xF3 dudosa, o si otro trabajo escribe el mismo registro. Devuelve el id de la reserva (vence en 15 minutos).",
+      parametersSchema: {
+        type: "object",
+        properties: {
+          casoId: { type: "string" },
+          clave: { type: "string", description: "Identifica la escritura de negocio: la misma clave no se escribe dos veces." },
+          registro: { type: "string", description: "El registro del HIS que se toca (tipo:id)." },
+          conector: { type: "string", enum: ["api", "pantalla", "archivo"] },
+          objetivo: { type: "string", description: "Qu\xE9 pantalla, endpoint o archivo." },
+          leido: { type: "object", description: "Lo que le\xEDste del registro ahora (campos y valores); se compara justo antes de guardar." }
+        },
+        required: ["casoId", "clave", "registro", "conector", "objetivo", "leido"]
+      }
+    },
+    {
+      name: TOOL_NAMES.confirmarEscritura,
+      displayName: "Confirmar antes de guardar",
+      description: "Paso 2 (solo si la funci\xF3n lo exige, sobre sistemas que no validan por s\xED mismos): justo antes de guardar, volv\xE9 a leer el registro y mand\xE1 lo le\xEDdo con los mismos campos. Si cambi\xF3 desde la reserva (lo toc\xF3 una persona), la escritura se descarta: no guardes y volv\xE9 a proponer.",
+      parametersSchema: {
+        type: "object",
+        properties: { accionId: { type: "string" }, leido: { type: "object" } },
+        required: ["accionId", "leido"]
+      }
+    },
+    {
+      name: TOOL_NAMES.cerrarEscritura,
+      displayName: "Cerrar una escritura",
+      description: "Paso 3: c\xF3mo sali\xF3 la escritura. ok (qued\xF3 escrita; si la funci\xF3n exige confirmar, solo despu\xE9s de confirmarla), error (no se escribi\xF3 nada) o incierta (no sab\xE9s si qued\xF3 escrita: no reintentes; verificala con ops_verificar_escritura). Con 3 fallas seguidas la funci\xF3n se frena sola.",
+      parametersSchema: {
+        type: "object",
+        properties: {
+          accionId: { type: "string" },
+          resultado: { type: "string", enum: ["ok", "error", "incierta"] },
+          evidencia: { type: "object" },
+          detalle: { type: "string" }
+        },
+        required: ["accionId", "resultado"]
+      }
+    },
+    {
+      name: TOOL_NAMES.verificarEscritura,
+      displayName: "Verificar una escritura dudosa",
+      description: "Para una escritura que qued\xF3 incierta: rele\xE9 el HIS y dec\xED si qued\xF3 escrita (quedo true: se da por hecha y segu\xEDs), si no qued\xF3 (quedo false: se puede reintentar) o si no lo pod\xE9s saber (quedo null: despu\xE9s de 2 intentos o una hora pasa a una persona). Mand\xE1 en leido lo que rele\xEDste.",
+      parametersSchema: {
+        type: "object",
+        properties: { accionId: { type: "string" }, quedo: { type: ["boolean", "null"] }, leido: { type: "object" }, detalle: { type: "string" } },
+        required: ["accionId", "quedo", "leido"]
+      }
+    },
     {
       name: TOOL_NAMES.consultarIndicador,
       displayName: "Consultar indicador",

package/dist/worker.js

@@ -39932,7 +39932,7 @@ function startWorkerRpcHost(options) {
 
 // src/manifest.ts
 var PLUGIN_ID = "alephoo.autopilot-ops";
-var PLUGIN_VERSION = "0.1.30";
+var PLUGIN_VERSION = "0.1.31";
 var DB_NAMESPACE_SLUG = "autopilot_ops";
 var PAGE_ROUTE = "autopilot";
 var TOOL_NAMES = {
@@ -39941,6 +39941,10 @@ var TOOL_NAMES = {
   abrirCaso: "ops_abrir_caso",
   transicionar: "ops_transicionar",
   registrarAccion: "ops_registrar_accion",
+  reservarEscritura: "ops_reservar_escritura",
+  confirmarEscritura: "ops_confirmar_escritura",
+  cerrarEscritura: "ops_cerrar_escritura",
+  verificarEscritura: "ops_verificar_escritura",
   consultarIndicador: "ops_consultar_indicador",
   publicarTablero: "ops_publicar_tablero",
   listarTableros: "ops_listar_tableros",
@@ -40093,6 +40097,58 @@ var manifest = {
         required: ["casoId", "tipo", "conector", "objetivo", "resultado"]
       }
     },
+    {
+      name: TOOL_NAMES.reservarEscritura,
+      displayName: "Reservar una escritura en el HIS",
+      description: "Paso 1 de toda escritura en el HIS: antes de tocarlo, dec\xED qu\xE9 vas a escribir (clave de negocio \xFAnica, p. ej. turno:2026-10-20T10:00|prof:15|sol:8812), sobre qu\xE9 registro (p. ej. solicitud:8812) y qu\xE9 le\xEDste de ese registro reci\xE9n (leido). El plugin la rechaza si el freno est\xE1 puesto, fuera de horario, si se pas\xF3 el tope del d\xEDa, si esa escritura ya se hizo o qued\xF3 dudosa, o si otro trabajo escribe el mismo registro. Devuelve el id de la reserva (vence en 15 minutos).",
+      parametersSchema: {
+        type: "object",
+        properties: {
+          casoId: { type: "string" },
+          clave: { type: "string", description: "Identifica la escritura de negocio: la misma clave no se escribe dos veces." },
+          registro: { type: "string", description: "El registro del HIS que se toca (tipo:id)." },
+          conector: { type: "string", enum: ["api", "pantalla", "archivo"] },
+          objetivo: { type: "string", description: "Qu\xE9 pantalla, endpoint o archivo." },
+          leido: { type: "object", description: "Lo que le\xEDste del registro ahora (campos y valores); se compara justo antes de guardar." }
+        },
+        required: ["casoId", "clave", "registro", "conector", "objetivo", "leido"]
+      }
+    },
+    {
+      name: TOOL_NAMES.confirmarEscritura,
+      displayName: "Confirmar antes de guardar",
+      description: "Paso 2 (solo si la funci\xF3n lo exige, sobre sistemas que no validan por s\xED mismos): justo antes de guardar, volv\xE9 a leer el registro y mand\xE1 lo le\xEDdo con los mismos campos. Si cambi\xF3 desde la reserva (lo toc\xF3 una persona), la escritura se descarta: no guardes y volv\xE9 a proponer.",
+      parametersSchema: {
+        type: "object",
+        properties: { accionId: { type: "string" }, leido: { type: "object" } },
+        required: ["accionId", "leido"]
+      }
+    },
+    {
+      name: TOOL_NAMES.cerrarEscritura,
+      displayName: "Cerrar una escritura",
+      description: "Paso 3: c\xF3mo sali\xF3 la escritura. ok (qued\xF3 escrita; si la funci\xF3n exige confirmar, solo despu\xE9s de confirmarla), error (no se escribi\xF3 nada) o incierta (no sab\xE9s si qued\xF3 escrita: no reintentes; verificala con ops_verificar_escritura). Con 3 fallas seguidas la funci\xF3n se frena sola.",
+      parametersSchema: {
+        type: "object",
+        properties: {
+          accionId: { type: "string" },
+          resultado: { type: "string", enum: ["ok", "error", "incierta"] },
+          evidencia: { type: "object" },
+          detalle: { type: "string" }
+        },
+        required: ["accionId", "resultado"]
+      }
+    },
+    {
+      name: TOOL_NAMES.verificarEscritura,
+      displayName: "Verificar una escritura dudosa",
+      description: "Para una escritura que qued\xF3 incierta: rele\xE9 el HIS y dec\xED si qued\xF3 escrita (quedo true: se da por hecha y segu\xEDs), si no qued\xF3 (quedo false: se puede reintentar) o si no lo pod\xE9s saber (quedo null: despu\xE9s de 2 intentos o una hora pasa a una persona). Mand\xE1 en leido lo que rele\xEDste.",
+      parametersSchema: {
+        type: "object",
+        properties: { accionId: { type: "string" }, quedo: { type: ["boolean", "null"] }, leido: { type: "object" }, detalle: { type: "string" } },
+        required: ["accionId", "quedo", "leido"]
+      }
+    },
     {
       name: TOOL_NAMES.consultarIndicador,
       displayName: "Consultar indicador",
@@ -40391,6 +40447,60 @@ var manifest_default = manifest;
 // src/ops.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
+// src/escrituras.ts
+var MINUTOS_RESERVA = 15;
+var FALLAS_PARA_FRENAR = 3;
+var INTENTOS_VERIFICACION = 2;
+var MINUTOS_DUDOSA_PARA_PERSONA = 60;
+function dudosaParaPersona(intentosSinSaber, minutosDudosa) {
+  return intentosSinSaber >= INTENTOS_VERIFICACION || minutosDudosa >= MINUTOS_DUDOSA_PARA_PERSONA;
+}
+var RESULTADOS_CIERRE = ["ok", "error", "incierta"];
+var HORA = /^([01]\d|2[0-3]):[0-5]\d$/;
+function leerVentana(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return null;
+  const x = v;
+  const desde = String(x.desde ?? "").trim();
+  const hasta = String(x.hasta ?? "").trim();
+  if (!HORA.test(desde) || !HORA.test(hasta) || desde >= hasta) return null;
+  const dias = Array.isArray(x.dias) ? [...new Set(x.dias.map(Number).filter((d) => Number.isInteger(d) && d >= 1 && d <= 7))].sort() : null;
+  return { desde, hasta, dias: dias && dias.length ? dias : null };
+}
+function leerTopeDiario(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : NaN;
+  return Number.isInteger(n) && n >= 1 && n <= 1e4 ? n : null;
+}
+function evaluarReserva(h) {
+  if (h.freno) return { ok: false, codigo: "freno", motivo: `el freno de la instituci\xF3n est\xE1 puesto (${h.freno}): ning\xFAn puesto escribe en el HIS` };
+  if (h.ventana) {
+    if (h.ventana.dias && !h.ventana.dias.includes(h.diaSemana)) return { ok: false, codigo: "fuera_de_horario", motivo: "hoy no es un d\xEDa en que la funci\xF3n pueda escribir en el HIS" };
+    if (h.hora < h.ventana.desde || h.hora >= h.ventana.hasta) return { ok: false, codigo: "fuera_de_horario", motivo: `la funci\xF3n escribe en el HIS de ${h.ventana.desde} a ${h.ventana.hasta}` };
+  }
+  if (h.tope !== null && h.escriturasHoy >= h.tope) return { ok: false, codigo: "tope_diario", motivo: `se lleg\xF3 al tope de ${h.tope} escrituras por d\xEDa de la funci\xF3n` };
+  const m = h.mismaClave;
+  if (m) {
+    if (m.resultado === "ok") return { ok: false, codigo: "ya_escrita", motivo: "esa escritura ya se hizo: no se repite", accionId: m.id };
+    if (m.resultado === "pendiente" && !m.vencida) return { ok: false, codigo: "en_curso", motivo: "esa escritura ya est\xE1 en curso", accionId: m.id };
+    if (m.resultado === "incierta" || m.resultado === "pendiente" && m.vencida) {
+      return { ok: false, codigo: "incierta", motivo: "una escritura anterior con esa clave qued\xF3 dudosa: verificala releyendo el HIS (ops_verificar_escritura) antes de reintentar", accionId: m.id };
+    }
+  }
+  if (h.ocupado) return { ok: false, codigo: "registro_ocupado", motivo: "otro trabajo est\xE1 escribiendo ese mismo registro; esperar a que termine", accionId: h.ocupado.id };
+  return { ok: true };
+}
+var normal = (v) => v === null || v === void 0 ? "" : typeof v === "object" ? JSON.stringify(v) : String(v).trim().toLowerCase();
+function compararLecturas(antes, ahora) {
+  return Object.keys(antes).filter((k) => normal(antes[k]) !== normal(ahora[k])).sort();
+}
+function debeFrenar(resultados, fallas = FALLAS_PARA_FRENAR) {
+  if (resultados.length < fallas) return false;
+  return resultados.slice(0, fallas).every((r) => r === "error" || r === "incierta");
+}
+function diaDeLaSemana(fecha5) {
+  const d = (/* @__PURE__ */ new Date(`${fecha5}T12:00:00Z`)).getUTCDay();
+  return d === 0 ? 7 : d;
+}
+
 // src/demanda.ts
 var txt = (v) => typeof v === "string" && v.trim() ? v.trim() : typeof v === "number" ? String(v) : null;
 var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : typeof v === "string" && /^-?\d+(\.\d+)?$/.test(v.trim()) ? Number(v) : null;
@@ -44272,6 +44382,9 @@ 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 HIS`);
   }
+  if (input2.tipo === "escritura" && input2.actor.tipo === "agente") {
+    throw new OpsError("usar_reserva", "un puesto escribe en el HIS en tres pasos: ops_reservar_escritura, ops_confirmar_escritura (releyendo justo antes de guardar) y ops_cerrar_escritura");
+  }
   const id3 = randomUUID2();
   const evidencia = { ...input2.evidencia ?? {} };
   delete evidencia.fuera_de_flujo;
@@ -44300,6 +44413,217 @@ async function registrarAccion(ctx, input2) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+var FRENO_INSTITUCION = "*";
+async function leerFreno(ctx, companyId) {
+  const rows = await ctx.db.query(
+    `SELECT modo, motivo FROM ${t2(ctx, "politica")} WHERE company_id = $1 AND workflow = $2 LIMIT 1`,
+    [companyId, FRENO_INSTITUCION]
+  );
+  return rows[0] && String(rows[0].modo) === "corte" ? str2(rows[0].motivo) ?? "freno puesto" : null;
+}
+async function guardarModo(ctx, companyId, workflow, modo, motivo, actor, anterior) {
+  const existe = await ctx.db.query(`SELECT id FROM ${t2(ctx, "politica")} WHERE company_id = $1 AND workflow = $2 LIMIT 1`, [companyId, workflow]);
+  if (existe.length > 0) {
+    await ctx.db.execute(
+      `UPDATE ${t2(ctx, "politica")} SET modo = $3, motivo = $4, actor_tipo = $5, actor_id = $6, updated_at = now() WHERE company_id = $1 AND workflow = $2`,
+      [companyId, workflow, modo, motivo, actor.tipo, actor.id]
+    );
+  } else {
+    await ctx.db.execute(
+      `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(), companyId, workflow, modo, motivo, actor.tipo, actor.id, "{}"]
+    );
+  }
+  await ctx.db.execute(
+    `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(), companyId, workflow, anterior, modo, motivo, actor.tipo, actor.id]
+  );
+}
+async function frenarFuncion(ctx, companyId, workflow) {
+  const anterior = await obtenerModo(ctx, companyId, workflow);
+  if (anterior === "corte") return;
+  const motivo = `Freno autom\xE1tico: ${FALLAS_PARA_FRENAR} escrituras seguidas en el HIS fallaron o quedaron sin confirmar. Revisar y volver a habilitar.`;
+  await guardarModo(ctx, companyId, workflow, "corte", motivo, { tipo: "sistema", id: null }, anterior);
+  await ctx.activity.log({ companyId, message: `Autopilot Care: ${workflow} frenada autom\xE1ticamente (${FALLAS_PARA_FRENAR} escrituras fallidas seguidas)`, metadata: { workflow, freno: "automatico" } });
+}
+async function marcarDudosa(ctx, companyId, accion, detalle) {
+  await ctx.db.execute(
+    `UPDATE ${t2(ctx, "accion")} SET resultado = 'incierta', detalle = $3, cerrada_at = now() WHERE company_id = $1 AND id = $2`,
+    [companyId, String(accion.id), detalle]
+  );
+  await ctx.db.execute(
+    `UPDATE ${t2(ctx, "caso")} SET datos = datos || $3::jsonb, updated_at = now() WHERE company_id = $1 AND id = $2`,
+    [companyId, String(accion.caso_id), JSON.stringify({ escritura_incierta: { accion_id: String(accion.id), objetivo: str2(accion.objetivo), detalle, desde: (/* @__PURE__ */ new Date()).toISOString(), intentos_verificacion: 0, para_persona: false } })]
+  );
+  await ctx.activity.log({ companyId, message: `Autopilot Care: escritura dudosa en el HIS (${str2(accion.objetivo) ?? "sin objetivo"}): ${detalle}`, metadata: { accionId: String(accion.id), casoId: String(accion.caso_id) } });
+}
+async function verificarEscritura(ctx, input2) {
+  const fila = await leerAccionEscritura(ctx, input2.companyId, input2.accionId);
+  if (String(fila.resultado) !== "incierta") throw new OpsError("no_dudosa", `la escritura ${input2.accionId} no est\xE1 dudosa (${String(fila.resultado)})`);
+  const leido = input2.leido && typeof input2.leido === "object" && !Array.isArray(input2.leido) ? input2.leido : {};
+  if (Object.keys(leido).length === 0) throw new OpsError("validacion", "leido: lo que se reley\xF3 del HIS para verificar (al menos un campo)");
+  const evidencia = jsonb2(fila.evidencia);
+  const caso = await leerCaso(ctx, input2.companyId, String(fila.caso_id));
+  const dudosa = caso?.datos.escritura_incierta && typeof caso.datos.escritura_incierta === "object" ? caso.datos.escritura_incierta : {};
+  if (input2.quedo === true || input2.quedo === false) {
+    const resultado = input2.quedo ? "ok" : "error";
+    const nueva = { ...evidencia, verificada_despues: leido };
+    await ctx.db.execute(
+      `UPDATE ${t2(ctx, "accion")} SET resultado = $3, evidencia = $4::jsonb, detalle = $5, cerrada_at = now() WHERE company_id = $1 AND id = $2`,
+      [input2.companyId, input2.accionId, resultado, JSON.stringify(nueva), str2(input2.detalle) ?? (input2.quedo ? "verificada releyendo el HIS: qued\xF3 escrita" : "verificada releyendo el HIS: no se escribi\xF3")]
+    );
+    await ctx.db.execute(
+      `UPDATE ${t2(ctx, "caso")} SET datos = datos - 'escritura_incierta', updated_at = now() WHERE company_id = $1 AND id = $2`,
+      [input2.companyId, String(fila.caso_id)]
+    );
+    return { accion: aAccion(fila, { resultado, evidencia: nueva }), paraPersona: false };
+  }
+  const intentos = Number(dudosa.intentos_verificacion ?? 0) + 1;
+  const desde = Date.parse(String(dudosa.desde ?? "")) || Date.now();
+  const paraPersona = dudosaParaPersona(intentos, (Date.now() - desde) / 6e4);
+  await ctx.db.execute(
+    `UPDATE ${t2(ctx, "caso")} SET datos = datos || $3::jsonb, updated_at = now() WHERE company_id = $1 AND id = $2`,
+    [input2.companyId, String(fila.caso_id), JSON.stringify({ escritura_incierta: { ...dudosa, intentos_verificacion: intentos, ultimo_intento: (/* @__PURE__ */ new Date()).toISOString(), ultima_lectura: leido, para_persona: paraPersona } })]
+  );
+  if (paraPersona) await ctx.activity.log({ companyId: input2.companyId, message: `Autopilot Care: escritura dudosa que el puesto no pudo verificar, para una persona (${str2(fila.objetivo) ?? "sin objetivo"})`, metadata: { accionId: input2.accionId, casoId: String(fila.caso_id) } });
+  return { accion: aAccion(fila), paraPersona };
+}
+async function leerAccionEscritura(ctx, companyId, accionId) {
+  const rows = await ctx.db.query(
+    `SELECT id, caso_id, tipo, conector, objetivo, resultado, evidencia, vence_en, confirmada_at, clave, registro, actor_tipo, actor_id, created_at FROM ${t2(ctx, "accion")} WHERE company_id = $1 AND id = $2 LIMIT 1`,
+    [companyId, accionId]
+  );
+  const fila = rows[0];
+  if (!fila || String(fila.tipo) !== "escritura" || !str2(fila.clave)) throw new OpsError("reserva_inexistente", `no existe la reserva de escritura ${accionId} en esta instituci\xF3n`);
+  return fila;
+}
+function aAccion(fila, extra = {}) {
+  return {
+    id: String(fila.id),
+    casoId: String(fila.caso_id),
+    tipo: String(fila.tipo),
+    conector: String(fila.conector),
+    objetivo: String(fila.objetivo),
+    resultado: String(fila.resultado),
+    evidencia: jsonb2(fila.evidencia),
+    detalle: fila.detalle ?? null,
+    actorTipo: String(fila.actor_tipo),
+    actorId: fila.actor_id ?? null,
+    createdAt: iso2(fila.created_at),
+    ...extra
+  };
+}
+async function reservarEscritura(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 (input2.actor.tipo !== "agente") throw new OpsError("actor_no_permitido", "las reservas de escritura son de los puestos; lo que carga una persona se registra como carga manual");
+  if (WORKFLOWS_SOLO_LECTURA.has(caso.workflow)) throw new OpsError("politica", `en ${caso.workflow} el puesto solo lee: no escribe en el HIS; eso lo hace el equipo`);
+  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 escribir en el HIS`);
+  const clave = str2(input2.clave);
+  const registro = str2(input2.registro);
+  const objetivo = str2(input2.objetivo);
+  if (!clave || !registro) throw new OpsError("validacion", "clave (qu\xE9 escritura de negocio es) y registro (qu\xE9 registro del HIS toca) son obligatorios");
+  if (!objetivo) throw new OpsError("objetivo_requerido", "objetivo es obligatorio (qu\xE9 pantalla, endpoint o archivo se toca)");
+  if (!CONECTORES.includes(input2.conector)) throw new OpsError("conector_invalido", `conector debe ser: ${CONECTORES.join(", ")}`);
+  const leido = input2.leido && typeof input2.leido === "object" && !Array.isArray(input2.leido) ? input2.leido : {};
+  if (Object.keys(leido).length === 0) throw new OpsError("validacion", "leido: lo que se ley\xF3 del registro antes de escribir (al menos un campo); se compara justo antes de guardar");
+  const opciones = await obtenerOpciones(ctx, input2.companyId, caso.workflow);
+  const { hoy, hora, inicioDelDia } = ahoraEnHospital();
+  const cuenta = await ctx.db.query(
+    `SELECT count(*) AS cantidad FROM ${t2(ctx, "accion")} a JOIN ${t2(ctx, "caso")} c ON c.company_id = a.company_id AND c.id = a.caso_id WHERE a.company_id = $1 AND c.workflow = $2 AND a.tipo = 'escritura' AND a.actor_tipo = 'agente' AND a.clave IS NOT NULL AND a.resultado IN ('ok', 'pendiente', 'incierta') AND a.created_at >= $3`,
+    [input2.companyId, caso.workflow, inicioDelDia.toISOString()]
+  );
+  const previas = await ctx.db.query(
+    `SELECT id, caso_id, objetivo, resultado, vence_en FROM ${t2(ctx, "accion")} WHERE company_id = $1 AND clave = $2 AND tipo = 'escritura' ORDER BY created_at DESC LIMIT 1`,
+    [input2.companyId, clave]
+  );
+  const ocupadas = await ctx.db.query(
+    `SELECT id, caso_id FROM ${t2(ctx, "accion")} WHERE company_id = $1 AND registro = $2 AND tipo = 'escritura' AND resultado = 'pendiente' AND vence_en > now() AND caso_id <> $3 LIMIT 1`,
+    [input2.companyId, registro, caso.id]
+  );
+  const previa = previas[0];
+  const vencida = Boolean(previa && String(previa.resultado) === "pendiente" && previa.vence_en && Date.parse(iso2(previa.vence_en)) < Date.now());
+  if (previa && vencida) await marcarDudosa(ctx, input2.companyId, previa, "la reserva venci\xF3 sin cerrarse: no se sabe si se escribi\xF3");
+  const r = evaluarReserva({
+    freno: await leerFreno(ctx, input2.companyId),
+    ventana: leerVentana(opciones.ventana_escritura),
+    hora,
+    diaSemana: diaDeLaSemana(hoy),
+    tope: leerTopeDiario(opciones.tope_escrituras_dia),
+    escriturasHoy: Number(cuenta[0]?.cantidad ?? 0),
+    mismaClave: previa ? { id: String(previa.id), resultado: vencida ? "incierta" : String(previa.resultado), vencida } : null,
+    ocupado: ocupadas[0] ? { id: String(ocupadas[0].id), casoId: String(ocupadas[0].caso_id) } : null
+  });
+  if (!r.ok) throw new OpsError(r.codigo, r.motivo, r.accionId ? { accionId: r.accionId } : void 0);
+  const id3 = randomUUID2();
+  const evidencia = { leido };
+  if (caso.workflow === "recupero_turno" && caso.estado !== "asignando") evidencia.fuera_de_flujo = true;
+  const venceEn = new Date(Date.now() + MINUTOS_RESERVA * 6e4).toISOString();
+  await ctx.db.execute(
+    `INSERT INTO ${t2(ctx, "accion")} (id, company_id, caso_id, tipo, conector, objetivo, resultado, evidencia, detalle, actor_tipo, actor_id, run_id, clave, registro, vence_en) VALUES ($1, $2, $3, 'escritura', $4, $5, 'pendiente', $6::jsonb, $7, $8, $9, $10, $11, $12, $13)`,
+    [id3, input2.companyId, caso.id, input2.conector, objetivo, JSON.stringify(evidencia), null, input2.actor.tipo, input2.actor.id, input2.actor.runId ?? null, clave, registro, venceEn]
+  );
+  await ctx.db.execute(`UPDATE ${t2(ctx, "caso")} SET updated_at = now() WHERE company_id = $1 AND id = $2`, [input2.companyId, caso.id]);
+  return { id: id3, casoId: caso.id, tipo: "escritura", conector: input2.conector, objetivo, resultado: "pendiente", evidencia, detalle: null, actorTipo: input2.actor.tipo, actorId: input2.actor.id, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function confirmarEscritura(ctx, input2) {
+  const fila = await leerAccionEscritura(ctx, input2.companyId, input2.accionId);
+  if (String(fila.resultado) !== "pendiente") throw new OpsError("reserva_cerrada", `la reserva ${input2.accionId} ya est\xE1 cerrada (${String(fila.resultado)})`);
+  if (fila.vence_en && Date.parse(iso2(fila.vence_en)) < Date.now()) {
+    await marcarDudosa(ctx, input2.companyId, fila, "la reserva venci\xF3 antes de confirmarse");
+    throw new OpsError("reserva_vencida", "la reserva venci\xF3: una persona tiene que mirar el HIS antes de reintentar");
+  }
+  const evidencia = jsonb2(fila.evidencia);
+  const leidoAntes = evidencia.leido && typeof evidencia.leido === "object" ? evidencia.leido : {};
+  const leido = input2.leido && typeof input2.leido === "object" && !Array.isArray(input2.leido) ? input2.leido : {};
+  const cambios = compararLecturas(leidoAntes, leido);
+  const nueva = { ...evidencia, leido_al_confirmar: leido };
+  if (cambios.length > 0) {
+    await ctx.db.execute(
+      `UPDATE ${t2(ctx, "accion")} SET resultado = 'descartada', evidencia = $3::jsonb, detalle = $4, cerrada_at = now() WHERE company_id = $1 AND id = $2`,
+      [input2.companyId, input2.accionId, JSON.stringify(nueva), `el registro cambi\xF3 desde que se ley\xF3 (${cambios.join(", ")}): no se escribi\xF3`]
+    );
+    throw new OpsError("registro_cambiado", `el registro cambi\xF3 desde que se ley\xF3 (${cambios.join(", ")}): no se escribe; volver a proponer con la lectura nueva`, { diferencias: cambios });
+  }
+  await ctx.db.execute(
+    `UPDATE ${t2(ctx, "accion")} SET confirmada_at = now(), evidencia = $3::jsonb WHERE company_id = $1 AND id = $2`,
+    [input2.companyId, input2.accionId, JSON.stringify(nueva)]
+  );
+  return aAccion(fila, { evidencia: nueva });
+}
+async function cerrarEscritura(ctx, input2) {
+  if (!RESULTADOS_CIERRE.includes(input2.resultado)) throw new OpsError("resultado_invalido", `resultado debe ser: ${RESULTADOS_CIERRE.join(", ")}`);
+  const fila = await leerAccionEscritura(ctx, input2.companyId, input2.accionId);
+  if (String(fila.resultado) !== "pendiente") throw new OpsError("reserva_cerrada", `la reserva ${input2.accionId} ya est\xE1 cerrada (${String(fila.resultado)})`);
+  const casoDeLaEscritura = await leerCaso(ctx, input2.companyId, String(fila.caso_id));
+  const exigeRelectura = Boolean(casoDeLaEscritura && getWorkflow(casoDeLaEscritura.workflow)?.releerAntesDeEscribir);
+  if (input2.resultado === "ok" && exigeRelectura && !fila.confirmada_at) throw new OpsError("sin_confirmar", "en esta funci\xF3n no se puede dar por hecha una escritura que no se confirm\xF3 releyendo el registro justo antes de guardar");
+  const evidencia = { ...jsonb2(fila.evidencia), ...input2.evidencia ?? {} };
+  const detalle = str2(input2.detalle);
+  if (input2.resultado === "incierta") {
+    await ctx.db.execute(`UPDATE ${t2(ctx, "accion")} SET evidencia = $3::jsonb WHERE company_id = $1 AND id = $2`, [input2.companyId, input2.accionId, JSON.stringify(evidencia)]);
+    await marcarDudosa(ctx, input2.companyId, fila, detalle ?? "el puesto no pudo comprobar si la escritura qued\xF3 hecha");
+  } else {
+    await ctx.db.execute(
+      `UPDATE ${t2(ctx, "accion")} SET resultado = $3, evidencia = $4::jsonb, detalle = $5, cerrada_at = now() WHERE company_id = $1 AND id = $2`,
+      [input2.companyId, input2.accionId, input2.resultado, JSON.stringify(evidencia), detalle]
+    );
+  }
+  const caso = await leerCaso(ctx, input2.companyId, String(fila.caso_id));
+  let frenada = false;
+  if (caso && input2.resultado !== "ok") {
+    const ultimas = await ctx.db.query(
+      `SELECT a.resultado FROM ${t2(ctx, "accion")} a JOIN ${t2(ctx, "caso")} c ON c.company_id = a.company_id AND c.id = a.caso_id WHERE a.company_id = $1 AND c.workflow = $2 AND a.tipo = 'escritura' AND a.actor_tipo = 'agente' AND a.cerrada_at IS NOT NULL AND a.resultado IN ('ok', 'error', 'incierta') ORDER BY a.cerrada_at DESC LIMIT ${FALLAS_PARA_FRENAR}`,
+      [input2.companyId, caso.workflow]
+    );
+    if (debeFrenar(ultimas.map((u) => String(u.resultado)))) {
+      await frenarFuncion(ctx, input2.companyId, caso.workflow);
+      frenada = true;
+    }
+  }
+  return { accion: aAccion(fila, { resultado: input2.resultado, evidencia, detalle }), frenada };
+}
 function numero(v) {
   if (typeof v === "number" && Number.isFinite(v)) return v;
   if (typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v))) return Number(v);
@@ -45441,6 +45765,28 @@ Transiciones registradas: ${detalle.transiciones.length}; acciones registradas:
     });
     return { content: `Acci\xF3n registrada ${accion.id} (${accion.tipo} \xB7 ${accion.conector} \xB7 ${accion.resultado})`, data: { accion } };
   }));
+  ctx.tools.register(TOOL_NAMES.reservarEscritura, toolSchema(TOOL_NAMES.reservarEscritura), async (params, runCtx) => conErrores(async () => {
+    const p = obj(params);
+    const accion = await reservarEscritura(ctx, { companyId: runCtx.companyId, casoId: str3(p.casoId) ?? "", clave: str3(p.clave) ?? "", registro: str3(p.registro) ?? "", conector: str3(p.conector) ?? "", objetivo: str3(p.objetivo) ?? "", leido: obj(p.leido), actor: actorAgente(runCtx) });
+    return { content: `Escritura reservada ${accion.id}: rele\xE9 el registro justo antes de guardar y confirmala con ops_confirmar_escritura.`, data: { accion } };
+  }));
+  ctx.tools.register(TOOL_NAMES.confirmarEscritura, toolSchema(TOOL_NAMES.confirmarEscritura), async (params, runCtx) => conErrores(async () => {
+    const p = obj(params);
+    const accion = await confirmarEscritura(ctx, { companyId: runCtx.companyId, accionId: str3(p.accionId) ?? "", leido: obj(p.leido), actor: actorAgente(runCtx) });
+    return { content: `Confirmada ${accion.id}: el registro no cambi\xF3. Guard\xE1 en el HIS y cerr\xE1 con ops_cerrar_escritura.`, data: { accion } };
+  }));
+  ctx.tools.register(TOOL_NAMES.cerrarEscritura, toolSchema(TOOL_NAMES.cerrarEscritura), async (params, runCtx) => conErrores(async () => {
+    const p = obj(params);
+    const r = await cerrarEscritura(ctx, { companyId: runCtx.companyId, accionId: str3(p.accionId) ?? "", resultado: str3(p.resultado) ?? "", evidencia: obj(p.evidencia), detalle: str3(p.detalle), actor: actorAgente(runCtx) });
+    return { content: `Escritura ${r.accion.id} cerrada: ${r.accion.resultado}${r.frenada ? " \xB7 la funci\xF3n qued\xF3 frenada por fallas seguidas" : ""}`, data: r };
+  }));
+  ctx.tools.register(TOOL_NAMES.verificarEscritura, toolSchema(TOOL_NAMES.verificarEscritura), async (params, runCtx) => conErrores(async () => {
+    const p = obj(params);
+    const quedo = p.quedo === true ? true : p.quedo === false ? false : null;
+    const r = await verificarEscritura(ctx, { companyId: runCtx.companyId, accionId: str3(p.accionId) ?? "", quedo, leido: obj(p.leido), detalle: str3(p.detalle), actor: actorAgente(runCtx) });
+    const texto7 = quedo === true ? "qued\xF3 escrita: se da por hecha" : quedo === false ? "no se escribi\xF3: se puede reintentar" : r.paraPersona ? "no se pudo saber: pasa a una persona" : "no se pudo saber: volv\xE9 a verificar m\xE1s tarde";
+    return { content: `Escritura ${r.accion.id}: ${texto7}`, data: r };
+  }));
   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) });

package/migrations/007_escrituras_seguras.sql

@@ -0,0 +1,16 @@
+-- Escrituras seguras sobre el HIS (src/escrituras.ts): una escritura de un puesto se reserva con una clave de negocio
+-- y el registro que toca, se confirma releyendo justo antes de guardar y se cierra con su resultado.
+-- clave: la misma escritura no se repite. registro: dos trabajos no escriben a la vez el mismo registro.
+-- vence_en: una reserva sin cerrar a tiempo se considera dudosa.
+
+ALTER TABLE plugin_autopilot_ops_1a68482ede.accion ADD COLUMN clave text;
+ALTER TABLE plugin_autopilot_ops_1a68482ede.accion ADD COLUMN registro text;
+ALTER TABLE plugin_autopilot_ops_1a68482ede.accion ADD COLUMN vence_en timestamptz;
+ALTER TABLE plugin_autopilot_ops_1a68482ede.accion ADD COLUMN confirmada_at timestamptz;
+ALTER TABLE plugin_autopilot_ops_1a68482ede.accion ADD COLUMN cerrada_at timestamptz;
+
+CREATE INDEX accion_clave_idx
+  ON plugin_autopilot_ops_1a68482ede.accion (company_id, clave);
+
+CREATE INDEX accion_registro_idx
+  ON plugin_autopilot_ops_1a68482ede.accion (company_id, registro);

package/package.json

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