specrails-desktop 2.30.0 → 2.30.1

package/docs/internals/interactive-jobs.md

@@ -61,7 +61,7 @@ spawnInteractive = isInteractiveJobsEnabled()            // SPECRAILS_INTERACTIV
 | | `'finalize'` | `'auto'` |
 |---|---|---|
 | Who gets it | freestyle/Freestyle QueueManager jobs (claude) | every other interactive job + ALL loop ai-steps |
-| End of session | explicit human **Finalize** only (SIGTERM → 2s → SIGKILL) | **quiescence**: a turn `result` arrived, nothing queued, no write in flight |
+| End of session | explicit human **Finalize** only (SIGTERM → 2s → SIGKILL) | **quiescence**: a turn `result` arrived, nothing queued, no write in flight — torn down GRACEFULLY: stdin EOF (the CLI exits itself, flushing its session transcript so the next loop step can `--resume`), SIGTERM only after a grace window (`quiescentEofGraceMs`, default 5s) or when stdin is already gone |
 | Idle between turns | by design (awaiting the human) | only transiently (microtask window) |
 | Wedge detector | never armed | the queue's zombie-timeout budget, reset on any raw child output; silence for the whole budget → fold in-flight turn, settle `crashed` |
 | Composer action | **Finalize Job** | **Wrap up now** (QueueManager) / **Settle this step** (loop step) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specrails-desktop",
-  "version": "2.30.0",
+  "version": "2.30.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/server/dist/interactive-job-session.js

@@ -119,6 +119,10 @@ class InteractiveJobSession {
     _onSettle;
     _settleMode;
     _zombieTimeoutMs;
+    _quiescentEofGraceMs;
+    /** Armed by the quiescent graceful teardown: SIGTERM escalation if the child
+     *  ignores the stdin EOF. Cleared on close/settle/dispose. */
+    _eofTimer = null;
     _nextEventSeq;
     _persistTurnUsage;
     _persistTurnActivity;
@@ -194,6 +198,7 @@ class InteractiveJobSession {
         this._onSettle = deps.onSettle;
         this._settleMode = deps.settleMode ?? 'finalize';
         this._zombieTimeoutMs = deps.zombieTimeoutMs ?? 0;
+        this._quiescentEofGraceMs = deps.quiescentEofGraceMs ?? 5000;
         this._nextEventSeq = deps.nextEventSeq ?? null;
         this._persistTurnUsage = deps.persistTurnUsage ?? null;
         this._persistTurnActivity = deps.persistTurnActivity ?? null;
@@ -229,6 +234,7 @@ class InteractiveJobSession {
         child.on('close', (code) => {
             this._childClosed = true;
             this._clearKillTimer();
+            this._clearEofTimer();
             this._handleClose(code);
         });
         // A buffered write can fail asynchronously (typically EPIPE after the child
@@ -320,6 +326,39 @@ class InteractiveJobSession {
         this._clearZombieTimer();
         this._terminateChildTree('finalized');
     }
+    /** Quiescent auto-settle teardown, GRACEFUL: EOF the child's stdin so the
+     *  stream-json CLI exits by itself — it flushes its session transcript on the
+     *  way out, keeping the session `--resume`-able by the NEXT loop step. The
+     *  previous immediate SIGTERM raced that flush: the next step's resume found
+     *  no conversation, got an instant empty synthetic result, and settled
+     *  zero-work in 0.0s. SIGTERM remains as escalation after the grace window,
+     *  and as the direct fallback when stdin is already gone. */
+    _finalizeQuiescent() {
+        if (this._finalizing || this._settled)
+            return;
+        this._finalizing = true;
+        this._clearZombieTimer();
+        const child = this._child;
+        const stdin = child?.stdin;
+        if (!child || this._childClosed || !stdin || stdin.destroyed || this._stdinFailed) {
+            this._terminateChildTree('finalized');
+            return;
+        }
+        try {
+            stdin.end();
+        }
+        catch {
+            this._terminateChildTree('finalized');
+            return;
+        }
+        this._eofTimer = setTimeout(() => {
+            this._eofTimer = null;
+            if (this._childClosed || this._settled || this._disposed)
+                return;
+            this._terminateChildTree('finalized');
+        }, this._quiescentEofGraceMs);
+        this._eofTimer.unref?.();
+    }
     /** Programmatic teardown that SETTLES 'crashed' after folding any in-flight
      *  turn (loop step timeout / run cancel). Unlike dispose(), the onSettle
      *  callback fires — an owner AWAITING the settle (the loop engine) is
@@ -342,6 +381,7 @@ class InteractiveJobSession {
             return;
         this._disposed = true;
         this._clearZombieTimer();
+        this._clearEofTimer();
         this._closeReaders();
         this._terminateChildTree(null);
         this._child = null;
@@ -603,7 +643,7 @@ class InteractiveJobSession {
                     return;
                 if (this._streaming || this._pending.length > 0)
                     return;
-                this.finalize();
+                this._finalizeQuiescent();
             });
         }
     }
@@ -785,6 +825,7 @@ class InteractiveJobSession {
         this._streaming = false;
         this._awaitingResult = false;
         this._clearKillTimer();
+        this._clearEofTimer();
         this._clearZombieTimer();
         this._closeReaders();
         // The child is gone — any prompts still queued (turn died without a `result`,
@@ -888,6 +929,12 @@ class InteractiveJobSession {
             this._killTimer = null;
         }
     }
+    _clearEofTimer() {
+        if (this._eofTimer !== null) {
+            clearTimeout(this._eofTimer);
+            this._eofTimer = null;
+        }
+    }
     _closeReaders() {
         try {
             this._stdoutReader?.close();