@proagentstore/cli 0.4.98 → 0.4.100

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/browser-runner/local-apply/reconciliation-runtime.js

@@ -15,9 +15,14 @@ export class LocalApplyReconciliationRuntime {
     deps;
     sessions = new Map();
     now;
+    schedule;
     constructor(deps) {
         this.deps = deps;
         this.now = deps.now ?? (() => Date.now());
+        this.schedule = deps.schedule ?? ((task, delayMs) => {
+            const timer = setTimeout(task, delayMs);
+            return () => clearTimeout(timer);
+        });
     }
     async start(raw) {
         const envelope = parseEnvelope(raw);
@@ -30,6 +35,9 @@ export class LocalApplyReconciliationRuntime {
         const browser = await this.deps.browserFor(envelope.browserProfile, join(this.deps.dataDir, "reconciliation", envelope.reconciliationId));
         const session = { envelope, browser, state: "running", expiresAt: this.now() + TTL_MS };
         this.sessions.set(envelope.reconciliationId, session);
+        // The deadline belongs to the Runner, not to Console polling.  It is installed before
+        // navigation so an abandoned client cannot retain an owned browser/liveWork indefinitely.
+        session.cancelDeadline = this.schedule(() => { void this.expire(session); }, TTL_MS);
         try {
             const page = this.page(session);
             if (!page)
@@ -49,8 +57,10 @@ export class LocalApplyReconciliationRuntime {
             return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
         if (!this.page(session))
             return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
-        if (session.handoff?.state === "ready" && (session.handoff.expiresAt <= this.now() || !this.deps.takeover || await this.deps.takeover.state(session.handoff.id) !== "ready"))
+        if (session.handoff?.state === "ready" && (session.handoff.expiresAt <= this.now() || !this.deps.takeover || await this.deps.takeover.state(session.handoff.id) !== "ready")) {
             await this.closeHandoff(session, session.handoff.expiresAt <= this.now() ? "expired" : "page_lost");
+            return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+        }
         return this.view(session);
     }
     async handoff(raw) {
@@ -80,6 +90,7 @@ export class LocalApplyReconciliationRuntime {
         }
         catch {
             await this.closeHandoff(session, "page_lost");
+            await this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
             throw new RunnerInputError("The reconciliation page is no longer available", 409);
         }
     }
@@ -98,6 +109,7 @@ export class LocalApplyReconciliationRuntime {
         }
         catch {
             await this.closeHandoff(session, "page_lost");
+            await this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
             throw new RunnerInputError("The reconciliation page is no longer available", 409);
         }
     }
@@ -106,12 +118,14 @@ export class LocalApplyReconciliationRuntime {
         return this.inspect(session);
     }
     async end(raw) {
-        const session = this.require(raw);
+        const request = this.handoffRequest(raw);
+        const session = this.require(request);
+        this.assertHandoffBinding(session, request);
+        if (session.handoff?.id !== request.handoffId)
+            throw new RunnerInputError("The reconciliation handoff is closed", 409);
         if (session.handoff?.state === "ready")
             await this.closeHandoff(session, "unavailable");
-        session.state = "running";
-        session.pauseReason = undefined;
-        return this.view(session);
+        return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
     }
     liveWork() { return [...this.sessions.values()].filter((s) => s.state !== "ended").map((s) => `reconciliation:${s.envelope.reconciliationId}`); }
     closeAll() { for (const session of this.sessions.values())
@@ -141,16 +155,29 @@ export class LocalApplyReconciliationRuntime {
         // prose, receipt-like URLs, unauthenticated pages and absent receipts prove nothing.
         return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
     }
+    async expire(session) {
+        if (session.state !== "ended" && session.expiresAt <= this.now())
+            await this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+    }
     async finish(session, result) {
+        if (session.finishing)
+            return session.finishing;
         if (session.state === "ended")
             return this.view(session);
-        if (session.handoff?.state === "ready")
-            await this.closeHandoff(session, "unavailable");
+        // Set terminal state synchronously, before any async teardown.  Concurrent End/timeout/page
+        // loss callers then converge on the same result and liveWork stops advertising ownership.
         session.state = "ended";
         session.pauseReason = undefined;
         session.result = result;
-        await session.browser.stop().catch(() => undefined);
-        return this.view(session);
+        session.cancelDeadline?.();
+        session.cancelDeadline = undefined;
+        session.finishing = (async () => {
+            if (session.handoff?.state === "ready")
+                await this.closeHandoff(session, "unavailable");
+            await session.browser.stop().catch(() => undefined);
+            return this.view(session);
+        })();
+        return session.finishing;
     }
     async closeHandoff(session, reason) {
         if (!session.handoff || session.handoff.state === "closed")
@@ -159,7 +186,10 @@ export class LocalApplyReconciliationRuntime {
         session.handoff.reason = reason;
         await this.deps.takeover?.end(session.handoff.id).catch(() => undefined);
     }
-    closedHandoff(session, id, reason) { session.handoff = { id, expiresAt: this.now(), state: "closed", reason }; return this.view(session); }
+    async closedHandoff(session, id, reason) {
+        session.handoff = { id, expiresAt: this.now(), state: "closed", reason };
+        return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+    }
     page(session) { const page = session.browser.handoffPage?.(); return page && !page.isClosed() ? page : null; }
     permitted(session, raw) { try {
         const host = new URL(raw).hostname.toLowerCase();
@@ -191,6 +221,7 @@ export class LocalApplyReconciliationRuntime {
     async liveHandoff(raw) { const request = this.handoffRequest(raw); const session = this.require(request); this.assertHandoffBinding(session, request); if ((session.state !== "paused" && session.state !== "running") || session.handoff?.id !== request.handoffId || session.handoff.state !== "ready")
         throw new RunnerInputError("The reconciliation handoff is closed", 409); if (session.handoff.expiresAt <= this.now()) {
         await this.closeHandoff(session, "expired");
+        await this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
         throw new RunnerInputError("The reconciliation handoff is closed", 409);
     } return session; }
     view(session) { const e = session.envelope; return { reconciliationId: e.reconciliationId, runId: e.runId, applicationId: e.applicationId, browserProfile: e.browserProfile, context: "separate_read_only_context", state: session.state, ...(session.pauseReason ? { pauseReason: session.pauseReason } : {}), ...(session.result ? { result: session.result } : {}) }; }

package/package.json

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