@proagentstore/cli 0.4.49 → 0.4.50

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

@@ -290,7 +290,16 @@ export function repoTree(workDir, relPath = ".", maxDepth = 3, maxEntries = 500)
                 try {
                     size = statSync(abs).size;
                 }
-                catch { }
+                catch {
+                    // Benign, and traced rather than assumed (#291). `size` stays `undefined`, which JSON
+                    // drops, so the entry reaches the model as `{path, type: "file"}` — the same listing a
+                    // successful stat produces, because `repo-local.ts`'s renderer prints `e.path` and has
+                    // never shown a size at all. The test is whether the fallback can be mistaken for a
+                    // real answer: `size: 0` would be a claim about an empty file; an absent field is not
+                    // a claim. The entry itself is still emitted because `readdir` saw it, and the one
+                    // case where that is already stale — deleted between the readdir and this stat —
+                    // degrades into an honest error from `repo_read_file`, not into a wrong listing.
+                }
                 entries.push({ path: rel, type: "file", size });
             }
         }

package/dist/browser-runner/coding/repo-write.js

@@ -119,10 +119,18 @@ export function switchRepoBranch(workDir, branch) {
     // CONFIRM, do not assume. The exit code says the command ran; only reading HEAD back says where
     // the checkout actually is, and that is the only thing the cloud is allowed to report as done.
     const after = currentBranch(workDir);
-    let dirtyAfter = false;
+    // And the same rule for the tree: `null` when git would not answer, never `false`. Nothing in
+    // the cloud reads this field today — `repo-policy-act.ts` acts on `refused`, `error` and its own
+    // independent read — so this is prophylactic rather than a live defect, and it is recorded that
+    // way. What makes it worth changing anyway is that the value is a CLAIM and the next reader
+    // inherits it: `dirty: false` off a failed `git status` says "clean" in the one field whose
+    // whole job is to say whether anything came across. Absent is degraded; manufactured is wrong.
+    let dirtyAfter;
     try {
         dirtyAfter = isDirty(workDir);
     }
-    catch { }
+    catch {
+        dirtyAfter = null;
+    }
     return { ok: after === to, changed: after === to, from, to, branch: after, dirty: dirtyAfter };
 }

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

@@ -187,6 +187,17 @@ export class CodingRuntime {
      * turn of a session very often runs after the final capture poll, and ending is where that
      * record would otherwise be lost — silently, and only for the turns at the end of every
      * session, which is a bias rather than noise.
+     *
+     * …and, since #554, WHO PAID for it. The spend was already returned here; the observation that
+     * makes it attributable was one field away on the session object in hand, so every closing turn
+     * of every session reached the ledger with `payer` NULL even when the credential was known. The
+     * bias is the same one the paragraph above describes, which is why the omission mattered: it
+     * did not lose a random sample of turns, it lost the last turn of every session.
+     *
+     * `null` is a REAL answer here, not a default. `end()` tolerates a `sessionId` it has never
+     * heard of, and the honest report for a session this runner does not have is that it cannot say
+     * what the engine authenticated with — not a guess derived from the preset (see
+     * `usage-payer.ts`, and the alternative #554 rejected).
      */
     end(sessionId) {
         const session = this.sessions.get(sessionId);
@@ -196,12 +207,16 @@ export class CodingRuntime {
         // happens after the final capture poll. Discarding the tail would systematically lose exactly
         // the acts this record exists for.
         const acts = session ? session.takeActs() : [];
+        // Read BEFORE `stop()`: `authResolved` is a live getter over the merged spawn env
+        // (`headless.ts`), so it must be taken while the session is still the object that spawned
+        // the process rather than after it has been torn down and dropped from the map.
+        const authResolved = session ? session.authResolved : null;
         if (session) {
             session.stop();
             this.sessions.delete(sessionId);
         }
         this.takeovers.delete(sessionId);
-        return { ok: true, usage, acts };
+        return { ok: true, usage, acts, authResolved };
     }
     list() {
         return [...this.sessions.entries()].map(([sessionId, s]) => ({

package/package.json

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