gh-glance 0.13.0 → 0.13.2

package/CHANGELOG.md

@@ -7,6 +7,42 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.2] - 2026-09-07
+
+### Fixed
+
+- **"Upgrade waiting for legacy quota reset" could never clear.** A pane holding
+  a pre-0.12.0 ledger with unsettled GraphQL charges waited on a deadline that
+  did not exist, so the message stayed for as long as that file was present --
+  weeks, in one case, long after the quota windows it was waiting for had ended.
+  Migrating such a ledger deliberately drops its budgets, because their numbers
+  came from `/rate_limit` and were never spendable capacity; the reset times
+  recorded alongside them are still facts about when those windows closed, and
+  are now read as the deadline they always were. Reading a reset is not the same
+  as spending against it. Affected panes clear themselves on the next launch.
+
+## [0.13.1] - 2026-09-07
+
+### Fixed
+
+- **Upgrading from 0.12.0 no longer leaves every pane unable to coordinate.**
+  0.13.0 moved the coordination protocol from version 3 to 5 but could migrate
+  only version 1, and unlike earlier protocol changes it kept the state file in
+  the same place. A pane upgrading therefore read its own file, could neither
+  validate nor migrate it, and reported unusable coordination state on every
+  launch from then on -- the read happens before any write, so nothing ever
+  replaced the file. Versions 2, 3 and 4 now upgrade in place, keeping the
+  unsettled charges and observed budgets they hold. A file from a *newer*
+  protocol is still refused, which is the recoverable direction: the newer build
+  is still there to rewrite it.
+
+- **Diagnostics and manual actions no longer pace as though they spent their
+  worst case.** Work is admitted against the most it could cost, and the
+  difference is returned once the real cost is known. That return was wired
+  into only one of the two settlement paths, so every `--doctor` probe and
+  manual operation kept paying for capacity it had not used, delaying later
+  requests for no reason.
+
 ## [0.13.0] - 2026-09-06
 
 ### Changed
@@ -904,7 +940,9 @@ engineering, security, QA and UX. What follows is what changed as a result.
 - The `main` field from `package.json`. It advertised the file as importable,
   but importing it took over the terminal or exited the host process.
 
-[Unreleased]: https://github.com/juan294/gh-glance/compare/v0.13.0...HEAD
+[Unreleased]: https://github.com/juan294/gh-glance/compare/v0.13.2...HEAD
+[0.13.2]: https://github.com/juan294/gh-glance/compare/v0.13.1...v0.13.2
+[0.13.1]: https://github.com/juan294/gh-glance/compare/v0.13.0...v0.13.1
 [0.13.0]: https://github.com/juan294/gh-glance/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/juan294/gh-glance/compare/v0.11.2...v0.12.0
 [0.11.2]: https://github.com/juan294/gh-glance/compare/v0.11.1...v0.11.2

package/index.mjs

@@ -2528,7 +2528,19 @@ function inspectLegacyMigration(root, state, now) {
       const uncertain = Object.values(legacy.reservations).some((reservation) =>
         ["started", "completed"].includes(reservation.status) && reservationCost(reservation, resource, legacy.leases, now) > 0);
       if (uncertain) {
-        const reset = budget?.resetMs;
+        // The deadline may only be read from the migrated view for resources the
+        // migration kept. A v1 file's budgets are dropped on purpose -- they came
+        // from /rate_limit and are not spendable capacity -- but the reset they
+        // record is still a fact about when that window ended, and using it as a
+        // deadline is not the same as admitting work against it. Core already had
+        // a reconstruction above; GraphQL never did, so a v1 file holding any
+        // uncertain GraphQL charge asked a dropped budget for its reset, found
+        // none, and reported legacy-unresolved -- which has no deadline and so
+        // never cleared. The file it came from had a perfectly good reset in it
+        // the whole time.
+        const reset = Number.isFinite(budget?.resetMs)
+          ? budget.resetMs
+          : Number(raw?.budgets?.[resource]?.resetMs);
         if (!Number.isFinite(reset)) return { ok: false, reason: "legacy-unresolved" };
         holdUntil = Math.max(holdUntil, reset + BUDGET_RESET_GRACE_MS);
       }
@@ -3510,7 +3522,36 @@ function serializeGovernorState(state) {
   return `${JSON.stringify(state)}\n`;
 }
 
+// Failing closed on a version this build does not write is right in one
+// direction only. An *older* binary meeting a newer file must refuse it, because
+// it cannot know what the new fields mean. A *newer* binary meeting an older
+// file at its own canonical path has to migrate it: the read happens before any
+// write, so refusing leaves the file in place and the pane never recovers. It is
+// not a transient failure, it is a permanent one, and every later launch repeats
+// it.
+//
+// That asymmetry was missed when the observer split moved the protocol from 3 to
+// 5. Versions 1 and 2 escaped it only because the file moved path at the same
+// time, so a new build simply found nothing and started clean; 3 onwards share a
+// path with 5 and collided.
 function migrateGovernorState(raw, nowMs) {
+  if (!isRecord(raw) || !Number.isSafeInteger(raw.version) || raw.version < 1) return null;
+  if (raw.version >= GOVERNOR_STATE_VERSION) return null;
+  if (raw.version === 1) return migrateV1GovernorState(raw, nowMs);
+  // Everything from 2 onwards is this build's shape or one adaptation away from
+  // it, and what it holds is worth keeping: the uncertain reservations are debts
+  // that must not be forgiven by an upgrade, and the budgets were written by the
+  // same observers this build trusts.
+  const shaped = raw.version >= GOVERNOR_OBSERVER_SPLIT_VERSION
+    ? structuredClone(raw)
+    : adaptPreSplitGovernorShape(raw);
+  if (!shaped) return null;
+  if (!isRecord(shaped.fairness)) shaped.fairness = { manualStreak: 0 };
+  shaped.version = GOVERNOR_STATE_VERSION;
+  return normalizeGovernorState(shaped, nowMs);
+}
+
+function migrateV1GovernorState(raw, nowMs) {
   if (!exactKeys(raw, [
     "version", "epochs", "budgets", "probeClaim", "probeOutcome", "leases",  // v1 shape
     "intents", "reservations", "manualProbe",
@@ -4478,6 +4519,15 @@ function completeReservation(scope, reservationId, completion, nowMs) {
     reservation.outcome = completion.outcome;
     reservation.actualCosts = { ...measured };
     reservation.accountedCosts = { core: 0, graphql: 0 };
+    // The same rule as the observing settlement path: this one narrows the
+    // charge in exactly the same way, so it releases the pacing in exactly the
+    // same way. Wiring it into only one of the two settlement paths left every
+    // doctor probe and manual operation paying for capacity it did not use.
+    if (completion.outcome === "measured-success") {
+      for (const resource of RATE_RESOURCES) {
+        returnPacingCredit(state, resource, reservation.costs[resource] - measured[resource], at);
+      }
+    }
     return { value: { status: "completed", actualCosts: reservation.actualCosts } };
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gh-glance",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "A live-refreshing GitHub dashboard for your terminal: Actions, Issues, Pull Requests, and Security alerts in one narrow pane",
   "type": "module",
   "bin": {