@proagentstore/cli 0.4.25 → 0.4.27

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:
@@ -227,10 +255,24 @@ export class HeadlessSession {
             env: mergeEnv(process.env, this.config.env),
             stdio: ["ignore", "pipe", "pipe"],
         });
+        // A turn already running is aborted before its replacement starts. `input()` never killed
+        // the previous process, and the raw idle heuristic declares idle after a >1.5s output
+        // pause — so a long build could be judged idle, the brain sends turn 2, and TWO engine
+        // processes edit the same repo at once.
+        if (this.procAlive) {
+            try {
+                this.proc?.kill();
+            }
+            catch {
+                /* already gone */
+            }
+        }
         this.proc = proc;
         // Without an 'error' listener a spawn failure (binary not on PATH) is an uncaught
         // exception that takes the whole runner down, not just this session.
         proc.on("error", (err) => {
+            if (this.proc !== proc)
+                return; // stale: a newer turn owns the session now
             this.push(`[${this.config.clientType}] failed to start: ${err.message}`);
             this.run = "idle";
             this.proc = null;
@@ -243,13 +285,29 @@ export class HeadlessSession {
             // looked like an idle session for a whole afternoon.
             if (code)
                 this.push(`[${this.config.clientType} exited with code ${code}]`);
+            // STALENESS GUARD, matching the persistent path's. Without it, an older turn's
+            // `close` clobbered the newer one: `run = "idle"` while process B was still working
+            // (so the brain acted on a half-done turn and could double-send), and `proc = null`
+            // so stop()/interrupt()/end() could no longer kill B — ending the session left a
+            // codex process still editing the repo, invisible to `alive`, diagnostics and
+            // kill-tmux.
+            if (this.proc !== proc)
+                return;
             this.run = "idle";
             this.proc = null;
         });
     }
-    /** No TTY in headless mode; control is via messages. Kept for interface parity. */
-    key(_keys) {
-        /* intentionally a no-op — there are no raw keystrokes without a terminal */
+    /**
+     * No TTY in headless mode; control is via messages. Kept for interface parity — the human
+     * takeover path can still route a keypress here.
+     *
+     * RECORDED rather than silently dropped. As a pure no-op it was indistinguishable from
+     * success: `act` returned an ordinary snapshot with an unchanged pane, so the caller could not
+     * tell "sent, nothing happened" from "never sent". The transcript is what the brain and the
+     * console both read, so the truth belongs there.
+     */
+    key(keys) {
+        this.push(`[ignored keypress ${keys.slice(0, 40)} — this session has no terminal attached]`);
     }
     /** Abort the current turn (SIGINT, like Ctrl-C). The process stays usable. */
     interrupt() {
@@ -262,7 +320,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 +330,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.27",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",