@proagentstore/cli 0.4.101 → 0.4.103

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

@@ -424,8 +424,9 @@ export class HeadlessSession {
         }
         if (this.procAlive)
             return;
-        // A new process has read none of what the old one was sent.
+        // A new process has read none of what the old one was sent, and owns none of its half-read line.
         this.pendingInputs = [];
+        this.buf = "";
         const args = this.adapter.buildLaunchArgs(this.cmdArgs, this.claudeSessionId);
         const proc = spawn(this.cmdBin, args, {
             cwd: this.config.workDir,
@@ -446,8 +447,17 @@ export class HeadlessSession {
         });
         // Swallow EPIPE when writing to a process that just exited (one-shot turn).
         proc.stdin?.on("error", () => { });
-        proc.stdout?.on("data", (d) => this.onStdout(d.toString("utf8")));
+        // FENCED to this process (#1019). A stopped process can outlive its replacement — it may ignore the
+        // signal, or flush buffered output on its way out — and its late `result` would otherwise be read as
+        // the NEW process's turn end: crediting the new turn's input as consumed, filing its report and
+        // marking it idle while it is still working.
+        proc.stdout?.on("data", (d) => {
+            if (this.proc === proc)
+                this.onStdout(d.toString("utf8"));
+        });
         proc.stderr?.on("data", (d) => {
+            if (this.proc !== proc)
+                return;
             this.lastOutputAt = Date.now();
             this.sawOutputSinceInput = true;
             const text = d.toString("utf8").trim();
@@ -591,6 +601,7 @@ export class HeadlessSession {
             }
         }
         this.proc = proc;
+        this.buf = ""; // the replaced turn's half-written line is not this turn's (#1019)
         // 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) => {
@@ -604,8 +615,15 @@ export class HeadlessSession {
             // real reason instead of retrying a binary that does not exist.
             this.spawnFailed = true;
         });
-        proc.stdout?.on("data", (d) => this.onStdout(d.toString()));
-        proc.stderr?.on("data", (d) => this.onStdout(d.toString()));
+        // Fenced like the persistent process (#1019): a turn this one replaced must not speak for it.
+        proc.stdout?.on("data", (d) => {
+            if (this.proc === proc)
+                this.onStdout(d.toString());
+        });
+        proc.stderr?.on("data", (d) => {
+            if (this.proc === proc)
+                this.onStdout(d.toString());
+        });
         // The enforced ceiling (#391). `unref` so a pending timer can never keep the runner's
         // event loop alive past its own shutdown.
         const maxTurnMs = this.config.maxTurnMs ?? MAX_ONE_SHOT_TURN_MS;

package/dist/index.js

@@ -1766,10 +1766,12 @@ var AutomaticUpdateController = class {
     if (action === "cancel") return this.cancel();
     if (action === "start") this.schedule(true);
   }
-  /** Testable immediate entry point; production reaches it through the scheduled timer. */
+  /**
+   * Testable immediate entry point; production reaches it through the scheduled timer. Authority is
+   * NOT required to get here: a failed refresh clears it, and the retry is what re-establishes it.
+   */
   async runNow() {
-    const current = this.deps.policy();
-    if (this.checking || this.waiting || !current.authoritative || !current.value.autoUpdate) return;
+    if (this.checking || this.waiting || !this.retryable()) return;
     this.checking = true;
     try {
       if (!await this.deps.refreshPolicy() || !this.enabled()) {
@@ -1787,12 +1789,22 @@ var AutomaticUpdateController = class {
   async installManually(plan) {
     return this.install(plan, false);
   }
+  /** May observe work, install or restart: only a freshly confirmed owner ON. */
   enabled() {
     const { value, authoritative } = this.deps.policy();
     return authoritative && value.autoUpdate;
   }
+  /**
+   * May keep a timer to re-read the policy: anything but an explicit OFF (#1020). The relay clears
+   * authority before every refresh, so a failed one left `enabled()` false and `schedule` refused —
+   * no timer, until a heartbeat happened to restore authority. The retry only refreshes; every
+   * install still passes `enabled()` and the relay's final admission.
+   */
+  retryable() {
+    return this.deps.policy().value.autoUpdate;
+  }
   schedule(initial = false) {
-    if (!this.enabled() || this.timer || this.waiting) return;
+    if (!this.retryable() || this.timer || this.waiting) return;
     const delay = initial ? Math.round(5e3 + (this.deps.random ?? Math.random)() * 25e3) : nextAutoUpdateDelayMs(this.failures, this.deps.random);
     this.timer = this.setTimer(() => {
       this.timer = null;
@@ -1813,6 +1825,7 @@ var AutomaticUpdateController = class {
    * until the next policy transition. `schedule` itself refuses once the policy is disabled.
    */
   offline() {
+    if (!this.retryable()) return;
     this.failures++;
     this.deps.status("offline", { reason: "The owner policy could not be refreshed; automatic update is deferred." });
     this.schedule();
@@ -1826,7 +1839,7 @@ var AutomaticUpdateController = class {
     const facts = await this.deps.facts();
     this.checkAt = this.now();
     if (facts.observations?.length) this.observations = [...this.observations, ...facts.observations].slice(-MAX_OBSERVATIONS);
-    if (!this.enabled()) return;
+    if (!this.enabled()) return this.offline();
     const plan = this.deps.plan(facts);
     this.decisionAt = this.now();
     this.blockerClass = plan.action === "wait" ? blockerClassFor(plan.waitingFor) : null;
@@ -1858,6 +1871,7 @@ var AutomaticUpdateController = class {
   defer(latest) {
     if (this.waiting) return;
     this.waiting = true;
+    if (this.timer) this.clearTimer(this.timer);
     this.timer = this.setTimer(() => {
       this.timer = null;
       this.nextRetryDueAt = null;

package/package.json

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