@proagentstore/cli 0.4.100 → 0.4.102

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

@@ -1730,11 +1730,18 @@ function mayAutomaticallyRestart(input) {
 }
 
 // src/commands/runner/auto-update-controller.ts
+var MAX_OBSERVATIONS = 5;
+var IDLE_RETRY_MS = 15e3;
+function blockerClassFor(waitingFor) {
+  if (waitingFor.includes("runner-work-observation-unavailable")) return "observation_failure";
+  return waitingFor.length ? "active_sessions" : "unknown";
+}
 var AutomaticUpdateController = class {
   constructor(deps) {
     this.deps = deps;
     this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
     this.clearTimer = deps.clearTimer ?? ((timer) => clearTimeout(timer));
+    this.now = deps.now ?? Date.now;
   }
   deps;
   timer = null;
@@ -1742,8 +1749,18 @@ var AutomaticUpdateController = class {
   waiting = false;
   installing = false;
   failures = 0;
+  checkAt = null;
+  decisionAt = null;
+  nextRetryDueAt = null;
+  blockerClass = null;
+  observations = [];
+  now;
   setTimer;
   clearTimer;
+  /** The controller's own record, safe to report: times, a normalized class, and observation outcomes. */
+  diagnostics() {
+    return { checkAt: this.checkAt, decisionAt: this.decisionAt, nextRetryDueAt: this.nextRetryDueAt, blockerClass: this.blockerClass, observations: [...this.observations] };
+  }
   /** Called only for a true policy transition. `keep` deliberately leaves a due heartbeat timer alone. */
   onPolicy(action) {
     if (action === "cancel") return this.cancel();
@@ -1756,10 +1773,10 @@ var AutomaticUpdateController = class {
     this.checking = true;
     try {
       if (!await this.deps.refreshPolicy() || !this.enabled()) {
-        this.deps.status("offline", { reason: "The owner policy could not be refreshed; automatic update is deferred." });
+        this.offline();
         return;
       }
-      await this.decide(false);
+      await this.decide();
     } catch (error) {
       this.fail(error);
     } finally {
@@ -1779,23 +1796,40 @@ var AutomaticUpdateController = class {
     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;
+      this.nextRetryDueAt = null;
       void this.runNow();
     }, delay);
     this.timer.unref?.();
+    this.nextRetryDueAt = this.now() + delay;
   }
   cancel() {
     if (this.timer) this.clearTimer(this.timer);
     this.timer = null;
+    this.nextRetryDueAt = null;
+  }
+  /**
+   * The owner policy could not be re-read, so nothing installs (fail closed) — but the controller keeps
+   * a timer (#1020). It used to report `offline` and stop, leaving an enabled runner with no callback
+   * until the next policy transition. `schedule` itself refuses once the policy is disabled.
+   */
+  offline() {
+    this.failures++;
+    this.deps.status("offline", { reason: "The owner policy could not be refreshed; automatic update is deferred." });
+    this.schedule();
   }
   fail(error) {
     this.failures++;
     this.deps.status("failure", { reason: error instanceof Error ? error.message : String(error) });
     this.schedule();
   }
-  async decide(deferred) {
+  async decide() {
     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;
     const plan = this.deps.plan(facts);
+    this.decisionAt = this.now();
+    this.blockerClass = plan.action === "wait" ? blockerClassFor(plan.waitingFor) : null;
     if (plan.action === "up-to-date") {
       this.failures = 0;
       this.deps.status("verified-success", { latestVersion: facts.latest ?? void 0, reason: void 0 });
@@ -1814,28 +1848,34 @@ var AutomaticUpdateController = class {
     }
     this.deps.status("running", { latestVersion: plan.latest, reason: void 0 });
     const restarted = await this.install(plan, true);
-    if (restarted) this.deps.status("restarting", { latestVersion: plan.latest, reason: void 0 });
-    else if (!deferred) this.defer(plan.latest);
+    if (restarted) {
+      this.deps.status("restarting", { latestVersion: plan.latest, reason: void 0 });
+      return;
+    }
+    this.blockerClass = "idle_wait";
+    this.defer(plan.latest);
   }
   defer(latest) {
     if (this.waiting) return;
     this.waiting = true;
     this.timer = this.setTimer(() => {
       this.timer = null;
+      this.nextRetryDueAt = null;
       void (async () => {
         this.waiting = false;
         try {
           if (!await this.deps.refreshPolicy() || !this.enabled()) {
-            this.deps.status("offline", { reason: "The owner policy could not be refreshed; automatic update is deferred." });
+            this.offline();
             return;
           }
-          await this.decide(true);
+          await this.decide();
         } catch (error) {
           this.fail(error);
         }
       })();
-    }, 15e3);
+    }, IDLE_RETRY_MS);
     this.timer.unref?.();
+    this.nextRetryDueAt = this.now() + IDLE_RETRY_MS;
     this.deps.status("waiting-for-idle", latest ? { latestVersion: latest } : void 0);
   }
   async install(plan, automatic) {
@@ -1914,6 +1954,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   let autoUpdatePolicyAuthoritative = false;
   let refreshingAutomaticPolicy = false;
   let scheduleAutomaticUpdate = () => void 0;
+  let autoUpdateDiagnostics = () => ({});
   const saveAutoUpdateStatus = (status, extra = {}) => {
     autoUpdatePolicy = {
       ...autoUpdatePolicy,
@@ -1959,7 +2000,8 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
         autoUpdateStatus: {
           status: autoUpdateStatusWire(autoUpdatePolicy.status),
           latestVersion: autoUpdatePolicy.latestVersion,
-          error: autoUpdatePolicy.reason
+          error: autoUpdatePolicy.reason,
+          ...autoUpdateDiagnostics()
         }
       });
       acceptAutoUpdatePolicy(result);
@@ -2006,7 +2048,14 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       requestRunner("GET", "/health", { url: localUrl, token: runnerToken, instanceId: instanceIds[0] })
     ]);
     const busy = sessionsResult.status === "fulfilled" && healthResult.status === "fulfilled" ? observedRunnerWork({ sessions: sessionsResult.value.sessions, work: healthResult.value.work }) : ["runner-work-observation-unavailable"];
+    const sampledAt = Date.now();
+    const observations = [
+      // An answer is a success only when it has the shape the guard reads; malformed is a failed look.
+      { source: "sessions", success: sessionsResult.status === "fulfilled" && Array.isArray(sessionsResult.value.sessions), sampledAt },
+      { source: "health", success: healthResult.status === "fulfilled" && !!healthResult.value.work && typeof healthResult.value.work === "object", sampledAt }
+    ];
     return {
+      observations,
       current: CLI_VERSION,
       latest: await latestPublishedVersion(),
       fromSource: runsFromSource(),
@@ -2196,6 +2245,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     },
     status: saveAutoUpdateStatus
   });
+  autoUpdateDiagnostics = () => automaticUpdateController.diagnostics();
   scheduleAutomaticUpdate = (initial = false, cancel = false) => automaticUpdateController.onPolicy(cancel ? "cancel" : initial ? "start" : "keep");
   if (autoUpdatePolicyAuthoritative && autoUpdatePolicy.autoUpdate) scheduleAutomaticUpdate(true);
   const answerUpdate = async (body) => {
@@ -2331,7 +2381,8 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
             autoUpdateStatus: {
               status: autoUpdateStatusWire(autoUpdatePolicy.status),
               latestVersion: autoUpdatePolicy.latestVersion,
-              error: autoUpdatePolicy.reason
+              error: autoUpdatePolicy.reason,
+              ...autoUpdateDiagnostics()
             }
           });
           acceptAutoUpdatePolicy(response);

package/package.json

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