@nac3/forge-cli 1.17.0 → 1.18.0

package/dist/chat/server.js

@@ -55,7 +55,7 @@ import { relayPoll } from '../relay/relay_client.js';
 import { startCommandConsumer } from '../relay/command_consumer.js';
 import { getSessionStore, DEFAULT_SESSION_ID } from './session_store.js';
 import { getSessionProject, setSessionProject } from './session_projects.js';
-import { beginTurn, endTurn, interruptActiveTurn, isTurnActive, activeTurnId } from './turn_control.js';
+import { beginTurn, endTurn, interruptActiveTurn, interruptAllTurns, isTurnActive, activeTurnId, activeTurns, } from './turn_control.js';
 import { openSteering, closeSteering, drainSteers, formatSteer, queueSteer, pendingSteers, } from './turn_steering.js';
 import { manifest as nac3Manifest } from '../nac3/internal_manifest.js';
 import { buildManifestForPrompt } from '../nac3/manifest_lazy.js';
@@ -334,9 +334,11 @@ export async function startChatServer(opts) {
              * claude_cli_timeout_ms <ms>` or the panel. */
             try {
                 const { readLimitsConfig } = await import('../core/limits_config.js');
-                cliOpts['timeoutMs'] = (await readLimitsConfig()).claude_cli_timeout_ms;
+                const _lim = await readLimitsConfig();
+                cliOpts['timeoutMs'] = _lim.claude_cli_timeout_ms;
+                cliOpts['silenceMs'] = _lim.claude_cli_silence_ms;
             }
-            catch { /* fall back to the ClaudeCliClient default (30 min) */ }
+            catch { /* fall back to the ClaudeCliClient defaults (30 min / 15 min) */ }
             /* Wire the panel MCP bridge: the subprocess gets the forge_panel
              * MCP server so it can create pizarron tabs. */
             cliOpts['panelBridge'] = { port: opts.port, token: panelPushToken };
@@ -1394,6 +1396,36 @@ function stopRelayHeartbeat() {
         _relayHeartbeat = null;
     }
 }
+/**
+ * El turno que esta corriendo pero que el anuncio del relay no cubre.
+ *
+ * `setInFlightTurn` se saltea A PROPOSITO los turnos de origen mobile y
+ * bridge: el telefono ya pinta su propia burbuja y anunciarlos de vuelta la
+ * duplicaba. El efecto secundario se vio el 14-oct-2026: un turno pedido
+ * DESDE el telefono es invisible para el panel del escritorio. Pablo mando
+ * "Adelante", el subproceso corrio veinte minutos escribiendo en el arbol, y
+ * la ventana del panel contestaba `in_flight: null` todo el tiempo.
+ *
+ * El registro de turnos vivos (turn_control) si los tiene a todos, sin
+ * importar de donde vinieron. Cuando el anuncio no tiene nada, se cae ahi y
+ * se reporta el MAS VIEJO: entre varios, el que lleva mas rato sin que nadie
+ * lo vea es el que hay que mostrar.
+ */
+function turnoVivoSinAnunciar() {
+    try {
+        const t = activeTurns()[0];
+        if (!t)
+            return null;
+        return {
+            id: t.id,
+            user: t.user ?? '',
+            started_at: new Date(t.startedAt).toISOString(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 function startRelayHeartbeat() {
     stopRelayHeartbeat();
     _relayHeartbeat = setInterval(() => {
@@ -1588,10 +1620,24 @@ async function route(req, res, ctx) {
      * abort the active turn's signal so the caller unwinds (claude.ts
      * breaks at the next round boundary; claude_cli kills `claude -p`).
      * Idempotent: returns active:false when nothing is running. */
+    /* `?all=1` corta TODOS los turnos vivos, no solo el ultimo. Es la salida
+     * para el turno que se perdio de vista: el 14-oct un turno del telefono
+     * quedo corriendo 20 minutos detras de otro mas nuevo, y "Detener" no lo
+     * alcanzaba porque apuntaba al de arriba. `live` viaja siempre para que
+     * quien llama pueda DECIR cuantos hay en vez de adivinar. */
     if (req.method === 'POST' && url.pathname === '/api/chat/interrupt') {
+        const vivos = activeTurns();
         const wasActive = isTurnActive();
-        const r = interruptActiveTurn();
-        sendJson(res, 200, { ok: true, active: wasActive, interrupted: r.ok, turn_id: r.id });
+        const todos = url.searchParams.get('all') === '1';
+        const r = todos ? interruptAllTurns() : interruptActiveTurn();
+        sendJson(res, 200, {
+            ok: true,
+            active: wasActive,
+            interrupted: r.ok,
+            turn_id: 'id' in r ? r.id : undefined,
+            turn_ids: 'ids' in r ? r.ids : undefined,
+            live: vivos.length,
+        });
         return;
     }
     /* Steering mid-turn (2026-09-29) -- el usuario escribio con un turno en
@@ -2234,7 +2280,7 @@ async function route(req, res, ctx) {
             const { redactDeep } = await import('../vault/redactor.js');
             sendJson(res, 200, construirRestore({
                 messages: store.messages(),
-                inFlight: inFlightTurn(),
+                inFlight: inFlightTurn() ?? turnoVivoSinAnunciar(),
                 projectRoot: ctx.projectRoot,
                 sessionStartedAt: store.startedAt(),
                 redactar: (s) => String(redactDeep(s)),
@@ -5707,6 +5753,33 @@ async function handleChat(req, res, ctx) {
         const pilotState = await readPilotState(ctx.projectRoot);
         const lastUserMsg = normalized.filter((m) => m.role === 'user').slice(-1)[0];
         const lastUserText = typeof lastUserMsg?.content === 'string' ? lastUserMsg.content : '';
+        /* El pedido entra al transcript AHORA, no al final del turno (Pablo,
+         * 14-oct-2026).
+         *
+         * Antes el mensaje del usuario se grababa recien despues de tener la
+         * respuesta, junto con ella. Un turno que no llegaba a contestar no
+         * dejaba NADA: ni el pedido. El 14-oct un "Adelante" del telefono corrio
+         * veinte minutos y despues se perdio sin rastro -- `turn_routing.jsonl`
+         * tenia seis turnos ese dia y el transcript cinco mensajes de usuario, y
+         * el que faltaba era justo el que habia fallado. Para saber que existio
+         * hubo que cruzar tres logs.
+         *
+         * Un pedido sin respuesta es un transcript honesto: dice que se pidio y
+         * que no se contesto. Perderlo es mentir por omision. El append de abajo
+         * (el del cierre del turno) sigue estando y queda como no-op por su
+         * propia guarda de duplicado; es la red para cualquier camino que no
+         * pase por aca. */
+        {
+            const _nuevo = normalized[normalized.length - 1];
+            if (_nuevo && _nuevo.role === 'user') {
+                const _previos = sessionStore.messages();
+                const _cola = _previos[_previos.length - 1];
+                if (!_cola || _cola.role !== 'user' || _cola.content !== _nuevo.content) {
+                    sessionStore.append(_nuevo);
+                    void sessionStore.flush();
+                }
+            }
+        }
         /* Immediate cross-device ack (PND -- "duda si esta trabajando"). The
          * RECEIVING device must see the incoming message + a working state the
          * instant the turn STARTS, not when it finishes. Shared id correlates
@@ -6106,11 +6179,14 @@ async function handleChat(req, res, ctx) {
         /* Register THIS turn as the active one right before the model
          * call. beginTurn returns the AbortSignal the callers honor
          * (claude.ts at round boundary, claude_cli kills the subprocess).
-         * A concurrent turn (desktop + mobile own-session) replaces the
-         * registry entry; interrupt then targets the latest -- acceptable
-         * until the queue (task #28) serializes turns. */
+         * Un turno concurrente (desktop + sesion propia del movil) ya NO pisa
+         * al anterior en el registro: los dos quedan vivos y `interrupt` apunta
+         * al mas reciente, pero el viejo sigue alcanzable (interruptAllTurns).
+         * Pisarlo era lo que dejaba subprocesos huerfanos el 14-oct-2026. */
         turnId = sessionId + ':' + String(Date.now());
-        const turnSignal = beginTurn(turnId);
+        /* El texto viaja al registro para que un turno que se pierda de vista se
+         * pueda MOSTRAR y no solo contar (ver turnoVivoSinAnunciar). */
+        const turnSignal = beginTurn(turnId, undefined, lastUserText);
         /* Steering mid-turn: desde aca el panel puede depositar correcciones
          * que el turno retira en su proxima frontera de ronda. */
         openSteering(turnId);
@@ -6223,6 +6299,11 @@ async function handleChat(req, res, ctx) {
              * seguia avisando 5000000. Sale del mismo `_limits` que ya se lee cada
              * turno para max_tokens_per_turn. Los clientes HTTP lo ignoran. */
             timeoutMs: _limits.claude_cli_timeout_ms,
+            /* Tope de SILENCIO, tambien por turno. El de reloj esta puesto alto a
+             * proposito (turnos autonomos de horas); este es el que corta al hijo
+             * que se quedo mudo sin dejar cuatro horas de proceso colgado en el
+             * arbol del proyecto (Pablo, 14-oct-2026). */
+            silenceMs: _limits.claude_cli_silence_ms,
             /* Plan/CLI uses Claude Code's native tools (FORGE_TOOL_SPECS = just
              * nac3_invoke via the MCP bridge); the HTTP path (BYOK/Console + managed)
              * gets direct native file tools + nac3_invoke so the model is fluent with
@@ -6564,10 +6645,10 @@ async function handleChat(req, res, ctx) {
             }
             catch { /* best-effort */ }
         }
-        // Append the latest user message + the assistant's reply to
-        // the persistent transcript. Older messages may already be
-        // present from previous turns; we only need to capture the
-        // *new* turn so the on-disk file matches conversation order.
+        // El mensaje del usuario YA se grabo al entrar el turno (ver el bloque
+        // "El pedido entra al transcript AHORA" mas arriba), asi que este append
+        // normalmente no hace nada: queda como red para cualquier camino que no
+        // haya pasado por alla. Lo que si se graba aca es la respuesta.
         const lastUser = normalized[normalized.length - 1];
         if (lastUser && lastUser.role === 'user') {
             // Only append if this user message isn't already the last