@proagentstore/cli 0.4.25 → 0.4.26

package/dist/browser-runner/coding/headless.js

@@ -42,6 +42,8 @@ export class HeadlessSession {
     sawOutputSinceInput = false;
     /** Raw-mode: when the current turn started (absolute idle backstop). */
     turnStartedAt = 0;
+    /** Set by stop() — the only thing that ends a one-shot session (see `alive`). */
+    stopped = false;
     constructor(config) {
         this.config = config;
         this.sessionName = `pags-${config.clientType}-${config.id}`;
@@ -60,13 +62,36 @@ export class HeadlessSession {
         this.cmdArgs = bin ? args : fallback.args;
         this.binName = (this.cmdBin.split("/").pop() || this.cmdBin) || "cli";
     }
-    /** True while the agent process is running. NOTE: do NOT use `proc.killed` — Node sets
-     *  it true the instant a signal is DELIVERED, not when the process exits. interrupt()
-     *  SIGINTs to abort a turn while the process keeps running, so `killed` gave a false
-     *  "dead" → input() then spawned a SECOND process (orphaning the first). exitCode is
-     *  null while running and set on normal exit; signalCode is set when a signal actually
-     *  terminated it — together they're the real liveness signal. */
+    /**
+     * Can this session take a turn? — NOT "is a process executing right now".
+     *
+     * The distinction only appeared with one-shot engines. A persistent Claude session has a
+     * process alive between turns, so the two questions had the same answer and one getter served
+     * both. A one-shot engine has NO process between turns — that is its resting state — so the
+     * process-liveness answer is `false` for every question asked while the session sits idle,
+     * which is exactly when the Pilot asks.
+     *
+     * The cost of conflating them was total: `runCodingLoop` opens with
+     * `if (!snap.alive) return failed("coding session is not running")`, so every delegated goal
+     * on codex/grok/gemini/ollama died at iteration 0 having done nothing, reporting a dead
+     * session that was in fact healthy and answering interactive turns fine.
+     *
+     * So: a one-shot session is alive until `stop()`. Whether a turn is currently executing is
+     * `runState`, which is the question the loop actually has a use for.
+     *
+     * NOTE for the persistent path: do NOT use `proc.killed` — Node sets it true the instant a
+     * signal is DELIVERED, not when the process exits. interrupt() SIGINTs to abort a turn while
+     * the process keeps running, so `killed` gave a false "dead" → input() then spawned a SECOND
+     * process (orphaning the first). exitCode is null while running and set on normal exit;
+     * signalCode is set when a signal actually terminated it — together they're the real signal.
+     */
     get alive() {
+        if (this.oneShot)
+            return !this.stopped;
+        return this.procAlive;
+    }
+    /** Is a process running THIS instant? The persistent engine's liveness, and the spawn guard. */
+    get procAlive() {
         return this.proc !== null && this.proc.exitCode === null && this.proc.signalCode === null;
     }
     /** Idle = ready for the next instruction. */
@@ -125,13 +150,16 @@ export class HeadlessSession {
         return this.mode === "raw";
     }
     start() {
+        // Starting always un-stops: `stop()` is what ends a one-shot session, so a (re)start
+        // after one has to bring it back or the session is permanently unusable.
+        this.stopped = false;
         // A one-shot engine has nothing to start until there is a turn to run; starting it here
         // is what produced the instant "exited with code 1".
         if (this.oneShot) {
             this.run = "idle";
             return;
         }
-        if (this.alive)
+        if (this.procAlive)
             return;
         // stream-json: we own the structural flags + --resume; merge the user's extras
         // (e.g. --model) without letting them clobber or orphan-value our flags. raw:
@@ -262,7 +290,7 @@ export class HeadlessSession {
         this.run = "idle";
         this.lastOutputAt = Date.now();
     }
-    /** Tear the process down. */
+    /** Tear the process down. For a one-shot engine this is the ONLY thing that ends the session. */
     stop() {
         try {
             this.proc?.kill();
@@ -272,6 +300,7 @@ export class HeadlessSession {
         }
         this.proc = null;
         this.run = "idle";
+        this.stopped = true;
     }
     // ── internals ────────────────────────────────────────────────────────────
     onStdout(chunk) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.25",
+  "version": "0.4.26",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",