@proagentstore/cli 0.4.99 → 0.4.101

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

@@ -21,6 +21,8 @@ export { defaultStatePath } from "./headless-state.js";
  * (refusing new records) would lose the turns that just happened rather than ancient ones.
  */
 const MAX_PENDING_USAGE = 200;
+/** How many consumed-input ids a session reports (#1019). Re-sent on every snapshot, so bounded; the oldest fall off. */
+export const MAX_CONSUMED_INPUTS = 50;
 /**
  * How many un-drained consequential acts a session holds (#294).
  *
@@ -92,6 +94,15 @@ export class HeadlessSession {
     stopped = false;
     /** How the last COMPLETED turn ended (#545). Null until one has. See {@link EngineTurnReport}. */
     turnReport = null;
+    /**
+     * Inputs written to the persistent process and not yet answered by a turn end, oldest first (#1019).
+     * `null` holds the place of an input sent without an id, so the ids after it stay aligned.
+     */
+    pendingInputs = [];
+    /** The id of the input the current one-shot turn was spawned for (#1019). */
+    turnInputId = null;
+    /** Ids of inputs a COMPLETED turn consumed, newest last and bounded (#1019). See {@link consumedInputs}. */
+    consumed = [];
     /**
      * The engine's own last output line of the turn in flight (#545).
      *
@@ -295,6 +306,27 @@ export class HeadlessSession {
     get lastTurn() {
         return this.turnReport;
     }
+    /**
+     * Ids of inputs a completed turn demonstrably consumed (#1019), newest last.
+     *
+     * The cloud used to mark an owner's message "processed" when ANY turn ended after it was sent —
+     * but a message queued behind a running turn arrives before that turn ends without being read
+     * by it. So consumption is correlated here, where the inputs are written: a one-shot turn
+     * consumed the input it was spawned for (unless we killed it); a persistent engine answers its
+     * inputs in order, so a turn end credits only the OLDEST outstanding one. If the engine folded
+     * two queued inputs into one turn, the second is credited one turn late — a delay, never a
+     * credit for something it had not read.
+     */
+    get consumedInputs() {
+        return this.consumed;
+    }
+    credit(id) {
+        if (!id)
+            return;
+        this.consumed.push(id);
+        if (this.consumed.length > MAX_CONSUMED_INPUTS)
+            this.consumed.shift();
+    }
     /** The engine process's pid while one is running — what per-session resource attribution reads (#924). */
     get pid() {
         return this.procAlive ? (this.proc?.pid ?? null) : null;
@@ -392,6 +424,8 @@ export class HeadlessSession {
         }
         if (this.procAlive)
             return;
+        // A new process has read none of what the old one was sent.
+        this.pendingInputs = [];
         const args = this.adapter.buildLaunchArgs(this.cmdArgs, this.claudeSessionId);
         const proc = spawn(this.cmdBin, args, {
             cwd: this.config.workDir,
@@ -493,8 +527,10 @@ export class HeadlessSession {
                 // disambiguation rides in the text instead (#505).
                 const msg = JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: withSeed }] } });
                 this.proc?.stdin?.write(`${msg}\n`);
+                this.pendingInputs.push(opts.inputId ?? null);
             }
             else {
+                this.turnInputId = opts.inputId ?? null;
                 // Raw CLI: spawn THIS turn. See `oneShot` — there is no persistent process to
                 // write to, because a non-interactive binary would never have read it.
                 this.runOneShot(withSeed);
@@ -527,6 +563,7 @@ export class HeadlessSession {
         this.sawStructuredEvent = false;
         this.structuredOutputRejected = false;
         const resumedCodexThreadId = this.codexResumeThreadId;
+        const inputId = this.turnInputId;
         const turnArgs = resumedCodexThreadId
             ? buildCodexResumeArgs(this.cmdArgs, resumedCodexThreadId, text)
             : this.adapter.buildTurnArgs(this.cmdArgs, text);
@@ -626,6 +663,9 @@ export class HeadlessSession {
             // A signal means WE ended it (the wedge ceiling, an interrupt), which is the `killed`
             // verdict: evidence about this platform's timers, not about the engine's health.
             this.turnReport = turnReportFromExit(code, signal, this.turnLastLine, Date.now(), this.turnTail);
+            // A turn we killed did not finish reading its input (#1019).
+            if (this.turnReport.verdict !== "killed")
+                this.credit(inputId);
             this.run = "idle";
             this.proc = null;
         });
@@ -800,6 +840,7 @@ export class HeadlessSession {
                     // own `is_error` — the same claim, in the words the engine states it in. Without
                     // this the field would exist for three engines and silently not for the flagship.
                     this.turnReport = turnReportFromResult(ev.isError, failure, Date.now(), this.turnTail);
+                    this.credit(this.pendingInputs.shift() ?? null);
                     // The same event that ends the turn also reports what the turn COST (#267). It was
                     // parsed and thrown away, which is why Engine spend was absent from the ledger.
                     // An errored turn still burned tokens, so this is recorded regardless of is_error.

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

@@ -240,6 +240,7 @@ export class CodingRuntime {
             // last turn end" is exactly the question asked about a session that just stopped, and
             // the omitted-when-null shape keeps "not measured" distinguishable from a verdict.
             ...(session.lastTurn ? { lastTurn: session.lastTurn } : {}),
+            ...(session.consumedInputs.length ? { consumedInputs: [...session.consumedInputs] } : {}),
             ...(opts.drainUsage ? { usage: session.takeUsage(), acts: session.takeActs() } : {}),
         };
     }
@@ -250,7 +251,11 @@ export class CodingRuntime {
             case "message":
                 // Narrowed rather than trusted: this runner is a published package any caller can
                 // POST to, and an unrecognised author must read as "unstated", not become a label.
-                session.input(action.text, { author: asTurnAuthor(action.author), replay: typeof action.replay === "string" ? action.replay : undefined });
+                session.input(action.text, {
+                    author: asTurnAuthor(action.author),
+                    replay: typeof action.replay === "string" ? action.replay : undefined,
+                    inputId: typeof action.inputId === "string" && action.inputId.length <= 128 ? action.inputId : undefined,
+                });
                 break;
             case "keys": {
                 // A snapshot is no longer the whole answer (#448). `key()` records the attempt and

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.99",
+  "version": "0.4.101",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",