@nac3/forge-cli 1.23.3 → 1.23.5

package/dist/nac3/verb_budget.js

@@ -0,0 +1,142 @@
+/**
+ * Cuanto puede durar la invocacion de un verbo, y quien lo decide.
+ *
+ * EL DEFECTO (PND-235). Los dos servers MCP reenvian cada invocacion al
+ * servidor de chat por loopback y esperan la respuesta. Con `fetch` esa espera
+ * heredaba el techo de undici -- 305.677 ms MEDIDOS en Node 22.16 -- y moria
+ * ahi. El techo no era una decision de nadie: era el default de una libreria
+ * aplicado a un canal para el que no estaba pensado. Y era un techo SECRETO:
+ * `yujin.evidence.run` declara en su schema que acepta hasta 30 minutos, el
+ * servidor los honra, y la invocacion se caia a los cinco. El verbo que
+ * acredita una bateria de siete minutos era justo el que no podia dejar
+ * recibo.
+ *
+ * LA REGLA. El presupuesto del transporte sale de lo que el VERBO declara, no
+ * de lo que la libreria trae puesto. Nadie impone por debajo un techo mas bajo
+ * que el que el verbo promete.
+ *
+ * PERO EL PRESUPUESTO NO ES INFINITO, Y EL LIMITE NO ES ARBITRARIO. En modo
+ * Plan el verbo corre adentro de un turno de `claude -p`, y ese turno tiene su
+ * propia vigilia de SILENCIO (limits.claude_cli_silence_ms, 15 min por
+ * default): mientras una tool call esta pendiente el subproceso no emite un
+ * solo evento, asi que una invocacion que bloquea mas que esa ventana no falla
+ * sola -- se lleva el TURNO ENTERO por colgado. Por eso lo que un verbo puede
+ * BLOQUEAR tiene que quedar por debajo de esa ventana, con margen.
+ *
+ * Y de ahi sale la otra mitad del arreglo: un verbo que legitimamente dura mas
+ * que la ventana de bloqueo no se recorta en silencio, se corre EN SEGUNDO
+ * PLANO y devuelve un handle (ver chat/tools/evidence.ts). El techo deja de ser
+ * secreto: o entra en la ventana, o el verbo te dice que lo lanzo aparte.
+ *
+ * ASCII puro.
+ */
+import { manifest } from './internal_manifest.js';
+/**
+ * Lo maximo que una invocacion puede BLOQUEAR el turno.
+ *
+ * Diez minutos. El numero sale de la vigilia de silencio del subproceso
+ * (claude_cli_silence_ms, 15 min por default): bloquear mas que eso no da un
+ * error del verbo, mata el turno. Diez mas el margen de abajo deja cuatro
+ * minutos de aire. La simetria con ese limite esta cuidada por un test: si
+ * alguien baja la vigilia, el test lo avisa antes de que se vuelva un turno
+ * muerto en produccion.
+ */
+export const VERB_BLOCKING_MAX_MS = 10 * 60_000;
+/**
+ * Margen del despachador por encima del tope del propio verbo.
+ *
+ * El verbo mide SU trabajo; el presupuesto del transporte tiene que cubrir
+ * ademas lo que pasa alrededor (resolver el schema, la cola del panel, armar y
+ * serializar la respuesta). Sin margen, el transporte se cae un instante antes
+ * de que la respuesta salga -- el peor de los dos mundos: el trabajo hecho y
+ * el resultado perdido.
+ */
+export const VERB_BUDGET_OVERHEAD_MS = 60_000;
+/** Piso: ni la invocacion mas trivial se corta antes de esto. */
+export const VERB_BUDGET_MIN_MS = 30_000;
+/**
+ * El presupuesto de un verbo que NO declara cuanto puede durar.
+ *
+ * Cinco minutos, y si -- es casi el mismo numero que heredaba de undici. Eso
+ * es deliberado: para un verbo que no declara nada (leer un archivo, un git
+ * status, el grafo) cinco minutos nunca fue el problema. El problema era
+ * aplicarle ese mismo techo al verbo que declara TREINTA minutos y despues
+ * tratar el corte como un fracaso del trabajo.
+ *
+ * Elegirlo igual tiene una segunda virtud: el radio de este cambio queda
+ * acotado a los verbos que SI declaran un tope. Para todos los demas el
+ * comportamiento es el de antes, y un servidor colgado se reporta en cinco
+ * minutos y no en once -- que, con la vigilia de silencio en quince, es la
+ * diferencia entre un error legible y un turno muerto sin explicacion.
+ */
+export const VERB_BUDGET_DEFAULT_MS = 5 * 60_000;
+/** El techo absoluto que puede salir de esta funcion. */
+export const VERB_BUDGET_MAX_MS = VERB_BLOCKING_MAX_MS + VERB_BUDGET_OVERHEAD_MS;
+/**
+ * El tope que el VERBO declara para si mismo, leido de su schema.
+ *
+ * `undefined` cuando el verbo no acepta timeout_ms: no es un verbo pensado
+ * para durar, y su presupuesto sale del default.
+ */
+export function verbTimeoutCeilingMs(verb) {
+    const props = verb?.schema?.properties;
+    const t = props?.['timeout_ms'];
+    if (!t)
+        return undefined;
+    const max = typeof t.maximum === 'number' && Number.isFinite(t.maximum) && t.maximum > 0
+        ? t.maximum : undefined;
+    /* Declara timeout_ms pero sin maximo en el schema: se le cree que puede
+     * durar, y el techo lo pone la ventana de bloqueo. */
+    return max ?? VERB_BLOCKING_MAX_MS;
+}
+function positivo(v) {
+    const n = typeof v === 'number' ? v : typeof v === 'string' ? Number(v) : NaN;
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+/**
+ * El presupuesto de transporte para UNA invocacion.
+ *
+ * Orden de preferencia: lo que el llamador pidio en los args, si no el tope
+ * que el verbo declara, si no el default. Siempre con el margen del
+ * despachador encima y acotado por la ventana de bloqueo.
+ */
+export function invokeBudgetMs(verbId, args = {}, verbs = manifest().verbs) {
+    const verb = verbs.find((v) => v.id === verbId);
+    const ceiling = verbTimeoutCeilingMs(verb);
+    /* El verbo no declara cuanto puede durar: techo plano, sin margen que
+     * cubrir, y el de siempre. */
+    if (ceiling === undefined)
+        return VERB_BUDGET_DEFAULT_MS;
+    /* El tope del verbo manda sobre lo que pida el llamador: el servidor lo va a
+     * recortar igual, asi que esperar mas seria esperar de gusto. */
+    const propio = Math.min(positivo(args['timeout_ms']) ?? ceiling, ceiling);
+    const conMargen = Math.min(propio, VERB_BLOCKING_MAX_MS) + VERB_BUDGET_OVERHEAD_MS;
+    return Math.min(Math.max(conMargen, VERB_BUDGET_MIN_MS), VERB_BUDGET_MAX_MS);
+}
+/**
+ * Este trabajo entra en la ventana de bloqueo, o hay que lanzarlo aparte.
+ *
+ * El llamador que SI conoce la ventana real (el servidor, que lee limits.json)
+ * puede pasarla; sin eso se usa el default, que es el caso del subproceso.
+ */
+export function fitsInBlockingWindow(timeoutMs, windowMs = VERB_BLOCKING_MAX_MS) {
+    return timeoutMs <= windowMs;
+}
+/** Margen que se le deja a la vigilia de silencio: el turno tiene que poder
+ *  recibir el resultado y contarlo antes de que el vigilante lo mate. */
+export const BLOCKING_WINDOW_MARGIN_MS = 2 * 60_000;
+/**
+ * La ventana de bloqueo REAL, para quien puede leer la configuracion viva.
+ *
+ * El default es una cota superior pensada para la vigilia de silencio por
+ * default (15 min). Si el dueno la baja, la ventana baja con ella: si no,
+ * un verbo que "entra" por el default se llevaria el turno puesto. Y nunca
+ * baja de un minuto, porque una ventana de cero mandaria al fondo hasta la
+ * corrida mas corta.
+ */
+export function blockingWindowMs(silenceMs) {
+    if (!Number.isFinite(silenceMs) || silenceMs <= 0)
+        return VERB_BLOCKING_MAX_MS;
+    return Math.max(60_000, Math.min(VERB_BLOCKING_MAX_MS, silenceMs - BLOCKING_WINDOW_MARGIN_MS));
+}
+//# sourceMappingURL=verb_budget.js.map

package/dist/nac3/verb_budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verb_budget.js","sourceRoot":"","sources":["../../src/nac3/verb_budget.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,QAAQ,EAAiB,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,GAAG,MAAM,CAAC;AAEhD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC;AAE9C,iEAAiE;AACjE,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC;AAEzC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,GAAG,MAAM,CAAC;AAEjD,yDAAyD;AACzD,MAAM,CAAC,MAAM,kBAAkB,GAAG,oBAAoB,GAAG,uBAAuB,CAAC;AAEjF;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAA0B;IAC7D,MAAM,KAAK,GAAI,IAAI,EAAE,MAA6E,EAAE,UAAU,CAAC;IAC/G,MAAM,CAAC,GAAG,KAAK,EAAE,CAAC,YAAY,CAAC,CAAC;IAChC,IAAI,CAAC,CAAC;QAAE,OAAO,SAAS,CAAC;IACzB,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,GAAG,CAAC;QACtF,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1B;0DACsD;IACtD,OAAO,GAAG,IAAI,oBAAoB,CAAC;AACrC,CAAC;AAED,SAAS,QAAQ,CAAC,CAAU;IAC1B,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAC9E,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACrD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAc,EACd,OAAgC,EAAE,EAClC,QAA6B,QAAQ,EAAE,CAAC,KAAK;IAE7C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC;IAChD,MAAM,OAAO,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAC3C;kCAC8B;IAC9B,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,sBAAsB,CAAC;IACzD;qEACiE;IACjE,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI,OAAO,EAAE,OAAO,CAAC,CAAC;IAC1E,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAAG,uBAAuB,CAAC;IACnF,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,kBAAkB,CAAC,EAAE,kBAAkB,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,SAAiB,EAAE,QAAQ,GAAG,oBAAoB;IACrF,OAAO,SAAS,IAAI,QAAQ,CAAC;AAC/B,CAAC;AAED;yEACyE;AACzE,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,GAAG,MAAM,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,SAA6B;IAC5D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAmB,CAAC,IAAK,SAAoB,IAAI,CAAC;QAAE,OAAO,oBAAoB,CAAC;IACrG,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,oBAAoB,EAAG,SAAoB,GAAG,yBAAyB,CAAC,CAAC,CAAC;AAC7G,CAAC"}

package/dist/relay/in_flight_turn.d.ts

@@ -24,6 +24,32 @@
  * refresco a mano -- cae sobre un latido reciente y reconstruye que esta
  * corriendo, incluso si el telefono no estaba conectado cuando arranco.
  *
+ * POR QUE ES UN REGISTRO Y NO UNA VARIABLE (PND-237, 30-oct-2026).
+ *
+ * Esto era UN solo slot (`let current`), y un panel corre turnos SOLAPADOS: el
+ * dueno manda un pedido mientras el anterior sigue, o entra uno por el puente.
+ * Con un solo slot el segundo pisaba al primero, y `clearInFlightTurn(id)` --
+ * que NO limpia si el id no coincide, y eso esta bien, porque un cierre tardio
+ * no tiene que borrar el anuncio del que recien arranco -- dejaba al pisado
+ * SIN NINGUN camino de salida. Peor: `touchInFlightTurn()` refrescaba lo que
+ * hubiera en el slot sin mirar el id, asi que el latido de cualquier turno
+ * POSTERIOR mantenia vivo al huerfano y el tope de silencio no vencia nunca.
+ *
+ * Medido en produccion (D1, 30-oct-2026 13:25 UTC): el panel de adip-kikan
+ * venia anunciando `dt-mvuyvonj` -- arrancado 12:47:13 -- durante 152 latidos
+ * y 38 minutos, mientras el MISMO panel ya habia publicado los remote_turn
+ * completos de dos turnos que arrancaron a su lado (12:46:39 y 12:47:40: los
+ * tres se solapan en 61 segundos). El telefono mostraba la burbuja "trabajando"
+ * con el texto viejo, y como su guarda es por id, el turno REAL no recibia
+ * burbuja: el dueno veia una sesion trabajando sin su pedido a la vista.
+ *
+ * Las dos reglas que lo cierran, y que son el contrato de este modulo:
+ *  - un turno es una ENTRADA propia, identificada por su id. Nadie pisa a
+ *    nadie, y cada uno sale por su propio cierre o por su propio silencio.
+ *  - la SENAL DE VIDA esta ligada al id que la produce (touchInFlightTurn(id)).
+ *    Un latido solo puede hablar por SU turno. Eso es lo que le devuelve el
+ *    poder al tope de silencio: un huerfano deja de ser tocado y vence.
+ *
  * ASCII puro.
  */
 export interface InFlightTurn {
@@ -60,30 +86,45 @@ export declare const PULSO_DE_PROGRESO_MS: number;
  *
  * Diez pulsos de margen: tolera que se pierdan nueve latidos seguidos antes de
  * dar por muerto un turno que esta vivo.
+ *
+ * PND-237: esta garantia solo existe de verdad desde que la senal de vida va
+ * por id. Mientras `touch()` refrescaba el slot entero, el latido de un turno
+ * nuevo reseteaba el reloj del huerfano y este tope era letra muerta.
  */
 export declare const SILENCIO_MAX_MS: number;
 export declare function setInFlightTurn(t: InFlightTurn, now?: number): void;
 /**
- * Senal de vida del turno en curso. La llama el latido de actividad del
- * servidor, que corre solo mientras hay turno.
+ * Senal de vida de UN turno. La llama el latido de actividad de ese turno,
+ * que corre solo mientras el turno vive.
  *
- * No crea nada: si no hay turno registrado, no hace nada. Asi un latido
- * rezagado no puede resucitar un turno ya cerrado.
+ * No crea nada: si ese id no esta registrado, no hace nada. Asi un latido
+ * rezagado no puede resucitar un turno ya cerrado -- y, desde PND-237, no
+ * puede tampoco mantener vivo el anuncio de OTRO turno, que era el agujero
+ * por el que un huerfano se anunciaba para siempre.
  */
-export declare function touchInFlightTurn(now?: number): void;
+export declare function touchInFlightTurn(id: string, now?: number): void;
 /**
- * Limpia el turno en vuelo. Con `id`, SOLO si coincide: dos turnos encadenados
- * pueden cerrar fuera de orden, y un cierre tardio del viejo no tiene que
- * borrar el anuncio del que recien arranco.
+ * Limpia el turno en vuelo. Con `id`, SOLO ese: dos turnos encadenados pueden
+ * cerrar fuera de orden, y un cierre tardio del viejo no tiene que borrar el
+ * anuncio del que recien arranco. Sin `id`, TODOS (apagado del servidor).
  */
 export declare function clearInFlightTurn(id?: string): void;
 /**
- * El turno en vuelo, o null si no hay o si se quedo CALLADO.
+ * El turno que se ANUNCIA, o null si no hay ninguno vivo.
+ *
+ * El latido de presencia lleva UN turno (contrato del relay), asi que entre
+ * varios solapados hay que elegir, y se elige el que arranco ULTIMO: es el
+ * pedido que el dueno acaba de hacer y que esta esperando ver. Era justo el
+ * que se perdia -- con el slot unico, el que quedaba anunciado podia ser
+ * cualquiera, y si era un huerfano la guarda por id del telefono dejaba al
+ * pedido nuevo sin burbuja (PND-237, sintoma 6).
  *
- * La edad del turno no entra en la decision: un turno de tres horas que sigue
- * latiendo es un turno vivo y se anuncia. Lo que lo saca es el silencio.
+ * La edad del turno no entra en la decision de VIDA: un turno de tres horas
+ * que sigue latiendo es un turno vivo. Lo que lo saca es el silencio.
  */
 export declare function inFlightTurn(now?: number): InFlightTurn | null;
+/** Cuantos turnos vivos declara este panel (diagnostico / tests). */
+export declare function inFlightCount(now?: number): number;
 /** Solo para tests. */
 export declare function _resetInFlightTurn(): void;
 //# sourceMappingURL=in_flight_turn.d.ts.map

package/dist/relay/in_flight_turn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in_flight_turn.d.ts","sourceRoot":"","sources":["../../src/relay/in_flight_turn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,QAAY,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,QAA4B,CAAC;AASzD,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,EAAE,GAAG,GAAE,MAAmB,GAAG,IAAI,CAQ/E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAmB,GAAG,IAAI,CAGhE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAInD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAmB,GAAG,YAAY,GAAG,IAAI,CAU1E;AAED,uBAAuB;AACvB,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}
+{"version":3,"file":"in_flight_turn.d.ts","sourceRoot":"","sources":["../../src/relay/in_flight_turn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,QAAY,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,QAA4B,CAAC;AAUzD,wBAAgB,eAAe,CAAC,CAAC,EAAE,YAAY,EAAE,GAAG,GAAE,MAAmB,GAAG,IAAI,CAS/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,IAAI,CAK5E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnD;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAmB,GAAG,YAAY,GAAG,IAAI,CAiB1E;AAED,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAmB,GAAG,MAAM,CAG9D;AAED,uBAAuB;AACvB,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/dist/relay/in_flight_turn.js

@@ -24,6 +24,32 @@
  * refresco a mano -- cae sobre un latido reciente y reconstruye que esta
  * corriendo, incluso si el telefono no estaba conectado cuando arranco.
  *
+ * POR QUE ES UN REGISTRO Y NO UNA VARIABLE (PND-237, 30-oct-2026).
+ *
+ * Esto era UN solo slot (`let current`), y un panel corre turnos SOLAPADOS: el
+ * dueno manda un pedido mientras el anterior sigue, o entra uno por el puente.
+ * Con un solo slot el segundo pisaba al primero, y `clearInFlightTurn(id)` --
+ * que NO limpia si el id no coincide, y eso esta bien, porque un cierre tardio
+ * no tiene que borrar el anuncio del que recien arranco -- dejaba al pisado
+ * SIN NINGUN camino de salida. Peor: `touchInFlightTurn()` refrescaba lo que
+ * hubiera en el slot sin mirar el id, asi que el latido de cualquier turno
+ * POSTERIOR mantenia vivo al huerfano y el tope de silencio no vencia nunca.
+ *
+ * Medido en produccion (D1, 30-oct-2026 13:25 UTC): el panel de adip-kikan
+ * venia anunciando `dt-mvuyvonj` -- arrancado 12:47:13 -- durante 152 latidos
+ * y 38 minutos, mientras el MISMO panel ya habia publicado los remote_turn
+ * completos de dos turnos que arrancaron a su lado (12:46:39 y 12:47:40: los
+ * tres se solapan en 61 segundos). El telefono mostraba la burbuja "trabajando"
+ * con el texto viejo, y como su guarda es por id, el turno REAL no recibia
+ * burbuja: el dueno veia una sesion trabajando sin su pedido a la vista.
+ *
+ * Las dos reglas que lo cierran, y que son el contrato de este modulo:
+ *  - un turno es una ENTRADA propia, identificada por su id. Nadie pisa a
+ *    nadie, y cada uno sale por su propio cierre o por su propio silencio.
+ *  - la SENAL DE VIDA esta ligada al id que la produce (touchInFlightTurn(id)).
+ *    Un latido solo puede hablar por SU turno. Eso es lo que le devuelve el
+ *    poder al tope de silencio: un huerfano deja de ser tocado y vence.
+ *
  * ASCII puro.
  */
 /**
@@ -54,63 +80,105 @@ export const PULSO_DE_PROGRESO_MS = 60 * 1000;
  *
  * Diez pulsos de margen: tolera que se pierdan nueve latidos seguidos antes de
  * dar por muerto un turno que esta vivo.
+ *
+ * PND-237: esta garantia solo existe de verdad desde que la senal de vida va
+ * por id. Mientras `touch()` refrescaba el slot entero, el latido de un turno
+ * nuevo reseteaba el reloj del huerfano y este tope era letra muerta.
  */
 export const SILENCIO_MAX_MS = PULSO_DE_PROGRESO_MS * 10;
-let current = null;
+/** Los turnos vivos de ESTE panel, por id. Varios a la vez es lo normal. */
+const vivos = new Map();
 export function setInFlightTurn(t, now = Date.now()) {
     if (!t || !t.id)
         return;
-    current = {
-        id: String(t.id),
+    const id = String(t.id);
+    vivos.set(id, {
+        id,
         user: String(t.user || ''),
         started_at: String(t.started_at || new Date(now).toISOString()),
         visto: now,
-    };
+    });
 }
 /**
- * Senal de vida del turno en curso. La llama el latido de actividad del
- * servidor, que corre solo mientras hay turno.
+ * Senal de vida de UN turno. La llama el latido de actividad de ese turno,
+ * que corre solo mientras el turno vive.
  *
- * No crea nada: si no hay turno registrado, no hace nada. Asi un latido
- * rezagado no puede resucitar un turno ya cerrado.
+ * No crea nada: si ese id no esta registrado, no hace nada. Asi un latido
+ * rezagado no puede resucitar un turno ya cerrado -- y, desde PND-237, no
+ * puede tampoco mantener vivo el anuncio de OTRO turno, que era el agujero
+ * por el que un huerfano se anunciaba para siempre.
  */
-export function touchInFlightTurn(now = Date.now()) {
-    if (!current)
+export function touchInFlightTurn(id, now = Date.now()) {
+    if (!id)
+        return;
+    const r = vivos.get(String(id));
+    if (!r)
         return;
-    current.visto = now;
+    r.visto = now;
 }
 /**
- * Limpia el turno en vuelo. Con `id`, SOLO si coincide: dos turnos encadenados
- * pueden cerrar fuera de orden, y un cierre tardio del viejo no tiene que
- * borrar el anuncio del que recien arranco.
+ * Limpia el turno en vuelo. Con `id`, SOLO ese: dos turnos encadenados pueden
+ * cerrar fuera de orden, y un cierre tardio del viejo no tiene que borrar el
+ * anuncio del que recien arranco. Sin `id`, TODOS (apagado del servidor).
  */
 export function clearInFlightTurn(id) {
-    if (!current)
+    if (!id) {
+        vivos.clear();
         return;
-    if (id && current.id !== id)
-        return;
-    current = null;
+    }
+    vivos.delete(String(id));
+}
+/** Poda las entradas que se quedaron CALLADAS. */
+function podar(now) {
+    for (const [id, r] of vivos) {
+        /* Un reloj que salta hacia atras da silencio negativo: no vence. Preferible
+         * anunciar un turno de mas que descartar uno vivo por un salto de NTP. */
+        if (now - r.visto > SILENCIO_MAX_MS)
+            vivos.delete(id);
+    }
 }
 /**
- * El turno en vuelo, o null si no hay o si se quedo CALLADO.
+ * El turno que se ANUNCIA, o null si no hay ninguno vivo.
  *
- * La edad del turno no entra en la decision: un turno de tres horas que sigue
- * latiendo es un turno vivo y se anuncia. Lo que lo saca es el silencio.
+ * El latido de presencia lleva UN turno (contrato del relay), asi que entre
+ * varios solapados hay que elegir, y se elige el que arranco ULTIMO: es el
+ * pedido que el dueno acaba de hacer y que esta esperando ver. Era justo el
+ * que se perdia -- con el slot unico, el que quedaba anunciado podia ser
+ * cualquiera, y si era un huerfano la guarda por id del telefono dejaba al
+ * pedido nuevo sin burbuja (PND-237, sintoma 6).
+ *
+ * La edad del turno no entra en la decision de VIDA: un turno de tres horas
+ * que sigue latiendo es un turno vivo. Lo que lo saca es el silencio.
  */
 export function inFlightTurn(now = Date.now()) {
-    if (!current)
-        return null;
-    /* Un reloj que salta hacia atras da silencio negativo: no vence. Preferible
-     * anunciar un turno de mas que descartar uno vivo por un salto de NTP. */
-    if (now - current.visto > SILENCIO_MAX_MS) {
-        current = null;
-        return null;
+    podar(now);
+    let elegido = null;
+    let mejor = -Infinity;
+    for (const r of vivos.values()) {
+        /* Un started_at ilegible NO puede ganar la eleccion. Date.parse devuelve
+         * NaN y toda comparacion con NaN es false, asi que comparando en crudo el
+         * primero de la iteracion se quedaba con el anuncio para siempre -- el
+         * mismo sintoma que estamos arreglando, por otra puerta. Vale -Infinity:
+         * se anuncia solo si es el unico que hay. */
+        const t = Date.parse(r.started_at);
+        const orden = Number.isFinite(t) ? t : -Infinity;
+        if (!elegido || orden > mejor) {
+            elegido = r;
+            mejor = orden;
+        }
     }
-    const { id, user, started_at } = current;
+    if (!elegido)
+        return null;
+    const { id, user, started_at } = elegido;
     return { id, user, started_at };
 }
+/** Cuantos turnos vivos declara este panel (diagnostico / tests). */
+export function inFlightCount(now = Date.now()) {
+    podar(now);
+    return vivos.size;
+}
 /** Solo para tests. */
 export function _resetInFlightTurn() {
-    current = null;
+    vivos.clear();
 }
 //# sourceMappingURL=in_flight_turn.js.map

package/dist/relay/in_flight_turn.js.map

@@ -1 +1 @@
-{"version":3,"file":"in_flight_turn.js","sourceRoot":"","sources":["../../src/relay/in_flight_turn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AASH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,GAAG,IAAI,CAAC;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,oBAAoB,GAAG,EAAE,CAAC;AAOzD,IAAI,OAAO,GAAoB,IAAI,CAAC;AAEpC,MAAM,UAAU,eAAe,CAAC,CAAe,EAAE,MAAc,IAAI,CAAC,GAAG,EAAE;IACvE,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;QAAE,OAAO;IACxB,OAAO,GAAG;QACR,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC;QAC1B,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,UAAU,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;QAC/D,KAAK,EAAE,GAAG;KACX,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc,IAAI,CAAC,GAAG,EAAE;IACxD,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,OAAO,CAAC,KAAK,GAAG,GAAG,CAAC;AACtB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAAW;IAC3C,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,IAAI,EAAE,IAAI,OAAO,CAAC,EAAE,KAAK,EAAE;QAAE,OAAO;IACpC,OAAO,GAAG,IAAI,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,MAAc,IAAI,CAAC,GAAG,EAAE;IACnD,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1B;8EAC0E;IAC1E,IAAI,GAAG,GAAG,OAAO,CAAC,KAAK,GAAG,eAAe,EAAE,CAAC;QAC1C,OAAO,GAAG,IAAI,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IACzC,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAClC,CAAC;AAED,uBAAuB;AACvB,MAAM,UAAU,kBAAkB;IAChC,OAAO,GAAG,IAAI,CAAC;AACjB,CAAC"}
+{"version":3,"file":"in_flight_turn.js","sourceRoot":"","sources":["../../src/relay/in_flight_turn.ts"],"names":[],"mappings":"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"}

package/dist/relay/loopback_turn.d.ts

@@ -9,47 +9,21 @@
  * sin una segunda implementacion que se desincronice.
  *
  * EL DEFECTO QUE ESTE MODULO CIERRA (PND-234. Pablo, 29-oct-2026, desde el
- * telefono: "No pude completar tu pedido: fetch failed").
+ * telefono: "No pude completar tu pedido: fetch failed"). La respuesta de
+ * /api/chat es un JSON que recien se arma cuando el turno entero termino, asi
+ * que con `fetch` el POST moria a los cinco minutos y el usuario recibia un
+ * fracaso por un trabajo que el escritorio estaba terminando bien.
  *
- * La respuesta de /api/chat es un JSON, no un stream, asi que sus CABECERAS
- * recien salen cuando el turno entero termino. Con `fetch` sin opciones ese
- * POST hereda el headersTimeout de undici, que es un limite pensado para una
- * llamada corta, y pasado ese punto muere el fetch -- no el turno. El
- * escritorio seguia trabajando y terminaba el trabajo, pero el telefono ya
- * habia recibido "fetch failed" y el usuario quedaba creyendo que no se hizo
- * nada.
- *
- * El limite esta MEDIDO, no estimado: contra un servidor que acepta la
- * conexion y nunca responde, el fetch global de Node 22.16 murio a los
- * 305.677 ms con name=TypeError, message="fetch failed" y
- * cause.code=UND_ERR_HEADERS_TIMEOUT. El turno del reporte habia durado 22
- * minutos (turn_routing.jsonl 13:36:33Z; los archivos que escribio tienen
- * mtime hasta 10:58 local). O sea: cinco minutos de techo para turnos que
- * duran veinte. El defecto es determinista y crece con la utilidad del
- * pedido -- cuanto mas trabajo pide el usuario desde el telefono, mas seguro
- * es que no vea el resultado.
- *
- * POR QUE node:http Y NO fetch. Es la unica forma de mandar los tiempos sin
- * depender de undici: Node lo trae adentro pero no lo expone como paquete, y
- * construir un Agent con otro headersTimeout exigiria declarar una
- * dependencia nueva para algo que el stdlib ya hace. La conexion es loopback
- * y en claro, asi que no se pierde nada por bajar de capa.
- *
- * EL PRESUPUESTO NO DESAPARECE, cambia de escala. Sin ningun limite, un
- * servidor de chat colgado dejaria al consumidor esperando para siempre -- y
- * como atiende un pedido a la vez, ningun pedido POSTERIOR del telefono se
- * correria nunca. Lo que no se usa es `req.setTimeout`, que mide INACTIVIDAD
- * del socket: un turno que piensa diez minutos no manda un byte, y ese
- * temporizador lo mataria sin motivo, que es la forma exacta del bug que esto
- * cierra. Lo que se mide es el tiempo TOTAL, con un techo mas alto que
- * cualquier turno legitimo.
- *
- * Y al vencerse, el usuario recibe algo accionable y VERDADERO: que el
- * escritorio puede seguir trabajando y donde ver el resultado. El mensaje
- * anterior ("no pude completar tu pedido") era falso en el caso mas comun.
+ * EL TRANSPORTE YA NO VIVE ACA (PND-235). El mismo techo aparecio identico en
+ * el canal de los verbos MCP, asi que el POST con presupuesto se mudo a
+ * core/loopback_post.ts y lo comparten los dos caminos. Lo que queda aca es lo
+ * que SI es del telefono: el techo de una hora y como se le cuenta el corte al
+ * usuario. El detalle de por que node:http y no fetch esta en ese modulo.
  *
  * ASCII puro.
  */
+import { type LoopbackResponse } from '../core/loopback_post.js';
+export type { LoopbackResponse };
 /**
  * Techo de tiempo total para un turno pedido desde el telefono.
  *
@@ -63,15 +37,14 @@
 export declare const MOBILE_TURN_BUDGET_MS: number;
 /** El techo efectivo, con el override de operacion. */
 export declare function mobileTurnBudgetMs(env?: NodeJS.ProcessEnv): number;
-export interface LoopbackResponse {
-    status: number;
-    body: string;
-}
 /**
  * POST al /api/chat local, esperando lo que tarde el turno.
  *
  * Devuelve el status y el cuerpo crudo; parsear es del llamador, que es el
- * que conoce la forma de la respuesta.
+ * que conoce la forma de la respuesta. Al cortarse, el usuario recibe algo
+ * accionable y VERDADERO: que el escritorio puede seguir trabajando y donde
+ * ver el resultado. El mensaje anterior ("no pude completar tu pedido") era
+ * falso en el caso mas comun.
  */
 export declare function postChatTurn(args: {
     port: number;

package/dist/relay/loopback_turn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loopback_turn.d.ts","sourceRoot":"","sources":["../../src/relay/loopback_turn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAQH;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,QAAc,CAAC;AAEjD,uDAAuD;AACvD,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAU/E;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6E5B"}
+{"version":3,"file":"loopback_turn.d.ts","sourceRoot":"","sources":["../../src/relay/loopback_turn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,OAAO,EAAiC,KAAK,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEhG,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,QAAc,CAAC;AAEjD,uDAAuD;AACvD,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAU/E;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwB5B"}