gh-glance 0.18.0 → 0.19.0

package/index.mjs

@@ -567,10 +567,12 @@ function unavailableRemedy(accounts, targetHost) {
   return candidate.length <= MAX_ERR_LENGTH ? candidate : VERDICT_REMEDY.unavailable;
 }
 
+const BUDGET_PAUSE_ERROR = /^API budget paused(?:\s|\()/i;
+
 function formatTabError(error, failureContext = null) {
   if (error == null) return null;
   if (error.kind === "text") return error.text;
-  if (/^API budget paused(?:\s|\()/i.test(error.raw ?? "")) {
+  if (BUDGET_PAUSE_ERROR.test(error.raw ?? "")) {
     return "GitHub checks are paused until the shared API budget allows them";
   }
   if (error.verdict === "other") return error.raw;
@@ -761,6 +763,9 @@ async function runGh(args, { signal, operation, input = null, execute = null,
   let control = null;
   const identityCoordinator = bound?.identityCoordinator ?? runtimeIdentityCoordinator;
   const requestNow = typeof bound?.now === "function" ? bound.now : Date.now;
+  if (identityCoordinator && bound && operation === "budget-core-observer") {
+    retryTransportAfterReset(identityCoordinator, bound, requestNow);
+  }
   const permit = identityCoordinator && !local
     ? await acquireIdentityHttpPermit(identityCoordinator, { signal, now: requestNow,
         operationDeadline: CONTROL_OPERATIONS.includes(operation) ? undefined : bound?.receiptCapability?.deadline,
@@ -2555,13 +2560,14 @@ async function fetchGraphqlList(kind, mapRow, {
   const incomplete = merged.incomplete || truncatedWalk;
   // Serialized rows are the payload identity the unchanged-frame suppression
   // and the cache both compare on, so it must cover exactly what is rendered --
-  // including the markers that say the list is not all of it.
-  const raw = JSON.stringify({
-    v: GRAPHQL_QUERY_VERSION,
-    totalCount,
-    incomplete,
-    hasNextPage: merged.hasNextPage,
+  // including the markers that say the list is not all of it. It is the shared
+  // representation a stored snapshot rebuilds, so a collector producer that
+  // compares against its normalized previous snapshot can see "unchanged".
+  // `truncated` is what pollResultTransition derives from the limit below.
+  const raw = acquisitionContentRaw(kind, {
     rows: merged.rows,
+    truncated: incomplete || merged.rows.length >= LIST_LIMIT,
+    hasNextPage: merged.hasNextPage,
   });
   return {
     raw: raw === previousRaw ? previousRaw : raw,
@@ -4187,6 +4193,19 @@ function classifyThrottle({ status = null, headers = null, graphqlErrors = null,
   return { kind: "none" };
 }
 
+// A "rate limit" message does not say which limit. Secondary limits are already
+// held by the shared transport cooldown; publishing one as a resource block until
+// the sampled primary reset would hold every pane for the rest of the window.
+// Only evidence classified as secondary is excluded. Stderr alone ("API rate
+// limit exceeded" with no headers) classifies as none and stays primary.
+function secondaryThrottleEvidence(error) {
+  if (error?.coordinationReason === "throttle-paused") return true;
+  const response = nativeCiThrottleEvidence.get(error) ?? error?.apiResponse ??
+    parseGhApiResponse(error?.stdout ?? "");
+  return classifyThrottle({ status: response.status, headers: response.headers, stderr: errText(error) })
+    .kind === "secondary";
+}
+
 function transportCooldownDeadline({ retryAfter, status, secondary, at, attempts = 0 }) {
   const supplied = typeof retryAfter === "string" && /^\d+(?:\.\d+)?$/.test(retryAfter)
     ? at + Number(retryAfter) * 1000
@@ -4271,17 +4290,40 @@ function releaseIdentityHttpPermit(coordinator, permit, error = null, now = Date
   return result;
 }
 
-// The explicit retry a paused transport waits for. Clears the ladder and the
-// deadline together: a person choosing to retry is choosing to spend the next
-// request finding out, which is exactly the recovery election the pause defers.
-function retryThrottledTransport(root, host, { now = Date.now } = {}) {
+// The explicit retry, or the reset-triggered recovery, a paused transport waits
+// for. Clears the ladder and the pause but never the deadline: a server-supplied
+// Retry-After is honoured exactly (ADR 0003), so the next request still waits it
+// out. The registry lock is the election: only the first caller resumes a given
+// pause. A reset recovers only a pause whose last throttle predates that reset,
+// so one primary window elects at most one recovery.
+function retryThrottledTransport(root, host, { now = Date.now, resetAt = null } = {}) {
+  const at = now();
   return withIdentityRegistry(root, (state) => {
     const transport = state.hosts[host];
     if (!transport?.throttle?.paused) return { ok: true, value: { resumed: false } };
+    if (resetAt !== null &&
+        !(Number.isFinite(resetAt) && at >= resetAt && transport.throttle.lastAt < resetAt)) {
+      return { ok: true, value: { resumed: false } };
+    }
     transport.throttle = emptyTransportThrottle();
-    transport.cooldownUntil = Math.min(transport.cooldownUntil, now());
-    return { ok: true, value: { resumed: true } };
-  }, { now: now() });
+    return { ok: true, value: { resumed: true, cooldownUntil: transport.cooldownUntil } };
+  }, { now: at });
+}
+
+function retryPausedTransport(coordinator, options = {}) {
+  const host = coordinator?.current?.()?.host;
+  if (typeof coordinator?.root !== "string" || !host) return { ok: true, value: { resumed: false } };
+  return retryThrottledTransport(coordinator.root, host, options);
+}
+
+// Only the pane holding the core observer claim runs budget-core-observer, so the
+// claim elects the one request that finds out whether the limit has lifted.
+function retryTransportAfterReset(coordinator, scope, now = Date.now) {
+  const at = now();
+  const snapshot = inspectGovernor({ ...scope, identityProvider: null }, at);
+  const resetAt = snapshot.ok ? snapshot.value.budgets.core?.resetMs : null;
+  if (!Number.isFinite(resetAt) || at < resetAt) return { ok: true, value: { resumed: false } };
+  return retryPausedTransport(coordinator, { now: () => at, resetAt });
 }
 
 function identityCoordinationMessage(reason) {
@@ -5363,7 +5405,7 @@ function readGovernorState(path, nowMs, { persistMigration = true } = {}) {
     if (Buffer.byteLength(raw) > GOVERNOR_MAX_LEDGER_BYTES) return { ok: false, reason: "capacity" };
     const parsed = JSON.parse(raw);
     const normalized = normalizeGovernorState(parsed, nowMs);
-    if (normalized) return { ok: true, value: normalized };
+    if (normalized) return { ok: true, value: normalized, bytes: raw };
     if (Number.isSafeInteger(parsed?.version) && parsed.version > GOVERNOR_STATE_VERSION) {
       return { ok: false, reason: "version-mismatch" };
     }
@@ -5785,6 +5827,13 @@ function mutateGovernor(scope, nowMs, mutate) {
     if (!governorAccountingSafe(state, at)) return returnAfterMigration(ACCOUNTING_OVERFLOW);
     const normalized = normalizeGovernorState(state, at);
     if (!normalized) return returnAfterMigration({ ok: false, reason: "corrupt" });
+    // A wait or decision read that changed nothing must not bump the revision
+    // and replace the file: compare the would-be bytes, as the identity
+    // registry does. Migrations and explicit rejected writes always commit.
+    if (migration === null && value?.ok !== false && typeof loaded.bytes === "string" &&
+        serializeGovernorState(normalized) === loaded.bytes) {
+      return { ok: true, value: value?.value };
+    }
     const written = commitGovernorMigration(scope.path, normalized, loaded.migration);
     if (!written.ok) return written;
     return value?.ok === false ? { ok: false, reason: value.reason } : { ok: true, value: value?.value };
@@ -6512,9 +6561,11 @@ function startReservation(scope, reservationId, nowMs) {
       return { ok: false, reason: "stale", write: Boolean(reservation) };
     }
     if (reservation.notBefore > at) return { value: { status: "waiting", notBefore: reservation.notBefore } };
-    // Any live observer claim defers a start: the claim owns the shared HTTP
-    // permit for its window, so starting here would contend for it.
+    // A live observer claim defers only work that charges its resource. The
+    // other resource's observer says nothing about this counter, and the shared
+    // HTTP pool, start gap and host cooldown still bound the two together.
     const liveClaim = RATE_RESOURCES
+      .filter((resource) => reservation.costs[resource] > 0)
       .map((resource) => state.probeClaims[resource])
       .filter((claim) => claim && claim.leaseUntil > at)
       .sort((left, right) => right.leaseUntil - left.leaseUntil)[0];
@@ -7240,9 +7291,15 @@ function mergeAlertRows(groups) {
 // mid-session is picked up within the hour.
 const alertBackoff = new Map();
 
-function backoffStorageKey(key) {
-  const access = requestIdentityStorage.getStore()?.accessKey ?? runtimeIdentityCoordinator?.current()?.accessKey;
-  return access ? `${access}\0${key}` : key;
+// A capability verdict is a statement about one repository on one host, so the
+// bound host and repository are part of the key: one collector credential can
+// serve several repositories, and one repository's 403 must not replay for
+// (or be cleared by) another.
+function backoffStorageKey(key, accessKey = null) {
+  const access = accessKey ?? requestIdentityStorage.getStore()?.accessKey ??
+    runtimeIdentityCoordinator?.current()?.accessKey;
+  const scoped = `${effectiveRuntimeHost() ?? ""}\0${effectiveRuntimeRepository()?.toLowerCase() ?? ""}\0${key}`;
+  return access ? `${access}\0${scoped}` : scoped;
 }
 
 function backoffActive(key, now) {
@@ -7428,6 +7485,7 @@ async function fetchAlertSource(source, signal, now, {
       rest200,
       rest304,
       verdict,
+      secondaryThrottle: verdict === "rate-limited" && secondaryThrottleEvidence(err),
       allNotModified: false,
       stagedEntities: new Map(),
       observations,
@@ -7499,7 +7557,15 @@ async function fetchSecurity(signal, {
     requestMetrics,
     graphqlSpent: 0,
     measuredSuccess: parts.every((part) => part.verdict === "ok"),
-    rateLimited: parts.some((part) => part.verdict === "rate-limited"),
+    // Whether this batch observed the source at all: some source made a real
+    // request and GitHub answered it (200/304, or a current capability refusal).
+    // A batch in which every source replayed its backoff made no request, so it
+    // must not advance freshness or complete webhook work (plan D6, ADR 0005).
+    // With no sources (an App granted no Security permission) there is nothing
+    // to observe, and the configuration answer keeps its existing behavior.
+    sourceObserved: parts.length === 0 || parts.some((part) => part.httpRequests > 0 &&
+      (part.verdict === "ok" || part.verdict === "unavailable")),
+    rateLimited: parts.some((part) => part.verdict === "rate-limited" && !part.secondaryThrottle),
     stagedEntities,
     observations: parts.flatMap((part) => part.observations ?? []),
     capabilities,
@@ -7774,7 +7840,16 @@ function createCollectorSourceAgeTracker({ now = Date.now, monotonicNow = () =>
     lowerBound += Math.max(0, now() - checkpoint.clientCheckpointAt);
   }
   let measuredAt = monotonicNow();
-  const current = () => lowerBound + Math.max(0, monotonicNow() - measuredAt);
+  // The monotonic clock does not advance across a suspend, so positive wall
+  // elapsed time also bounds the age. A forward wall step can only overstate
+  // staleness; the high-water mark keeps a backward step from shrinking it.
+  let wallMeasuredAt = now();
+  let reported = lowerBound;
+  const current = () => {
+    reported = Math.max(reported, lowerBound +
+      Math.max(0, monotonicNow() - measuredAt, now() - wallMeasuredAt));
+    return reported;
+  };
   return {
     observe({ lastSuccessAt, serverNow }) {
       if (!Number.isFinite(lastSuccessAt) || !Number.isFinite(serverNow)) return current();
@@ -7784,6 +7859,8 @@ function createCollectorSourceAgeTracker({ now = Date.now, monotonicNow = () =>
       else lowerBound = Math.max(elapsed, candidate);
       sourceAt = sourceAt === null ? lastSuccessAt : Math.max(sourceAt, lastSuccessAt);
       measuredAt = monotonicNow();
+      wallMeasuredAt = now();
+      reported = lowerBound;
       return lowerBound;
     },
     current,
@@ -10045,7 +10122,11 @@ async function createCollectorService({ config, pathOptions = {}, runtime, platf
 }
 
 function collectorPublicationFromResult(resource, result, previous, demand, completedAt, state = {}) {
-  const transition = pollResultTransition({
+  // A Security batch that only replayed capability backoff made no request. It
+  // republishes the previous observation unchanged, with its success time, so
+  // neither freshness nor webhook completion can advance on it.
+  const observed = result.sourceObserved !== false;
+  const transition = !observed ? { kind: "unchanged", completedAt } : pollResultTransition({
     key: resource,
     previousRaw: previous?.raw ?? null,
     raw: result.raw,
@@ -10074,7 +10155,8 @@ function collectorPublicationFromResult(resource, result, previous, demand, comp
     },
     raw: transition.kind === "changed" ? transition.nextRaw : previous.raw,
     entities,
-    lastSuccessAt: completedAt,
+    lastSuccessAt: observed ? completedAt : previous.lastSuccessAt,
+    sourceObserved: observed,
     lastChangedAt,
     nextDueAt: completedAt + pollPolicyInterval({
       tab: resource,
@@ -10181,11 +10263,13 @@ function createCollectorAcquisitionRuntime({
       providerContexts.set(target.provider, context);
     }
     let identity;
+    let credentialEnvironment = null;
+    let capabilities = null;
     if (context.definition.type === "github-app") {
       const resolved = await context.coordinator.resolve({ signal });
       identity = resolved.identity;
-      context.credentialEnvironment = resolved.environment;
-      context.capabilities = resolved.capabilities;
+      credentialEnvironment = resolved.environment;
+      capabilities = resolved.capabilities;
       if (context.identity?.accessKey !== identity.accessKey) {
         const persisted = persistGitHubAppIdentity(context.coordinator.root, identity, now());
         if (!persisted.ok) throw new Error("collector provider unavailable");
@@ -10194,13 +10278,10 @@ function createCollectorAcquisitionRuntime({
       const resolved = await context.coordinator.refresh();
       if (!resolved.ok) throw new Error("collector provider unavailable");
       identity = resolved.value;
-      context.credentialEnvironment = null;
-      context.capabilities = null;
       context.readBudgets = readBudgets;
     }
     if (identity.host !== target.host) throw new Error("collector provider unavailable");
-    context.identity = identity;
-    context.scope = {
+    const scope = Object.freeze({
       ...createQuotaScope(identity, {
         root: context.coordinator.root,
         now,
@@ -10210,9 +10291,28 @@ function createCollectorAcquisitionRuntime({
       repository: target.repo,
       providerType: context.definition.type,
       ...(executeGh ? { executeGh } : {}),
-      ...(context.credentialEnvironment ? { credentialEnvironment: context.credentialEnvironment } : {}),
-    };
-    return context;
+      ...(credentialEnvironment ? { credentialEnvironment } : {}),
+    });
+    // The provider context keeps only provider-wide state (coordinator,
+    // lease, budget reader, latest access identity). Its scope is used to
+    // release the provider lease on close, never to bind a request.
+    context.identity = identity;
+    context.credentialEnvironment = credentialEnvironment;
+    context.capabilities = capabilities;
+    context.scope = { ...scope };
+    // Each target operation gets its own immutable binding, captured once, so
+    // another target's resolution cannot redirect it after an await.
+    return Object.freeze({
+      coordinator: context.coordinator,
+      definition: context.definition,
+      leaseId: context.leaseId,
+      readBudgets: context.readBudgets,
+      onObserverPublished: context.onObserverPublished,
+      identity,
+      scope,
+      credentialEnvironment,
+      capabilities,
+    });
   }
 
   async function defaultProduce({ target, resource, demand, snapshot, claim, markStarted, provider, signal, force }) {
@@ -10444,9 +10544,17 @@ function createCollectorAcquisitionRuntime({
     item.invalidations.clear();
   }
 
+  // Identifies one delivered generation for one engine subscription and
+  // binding. A rebind or a new subscription (a new connection) changes it.
+  function collectorDeliveryKey(subscriptionId, bindingRevision, snapshot) {
+    return Number.isSafeInteger(snapshot?.generation)
+      ? `${subscriptionId}\0${bindingRevision}\0${snapshot.generation}` : null;
+  }
+
   function deliverCollectorSnapshot(item, snapshot, bindingRevision, { publication = false } = {}) {
     if (bindingRevision !== item.bindingRevision) return false;
     item.nextDueAt = snapshot.nextDueAt;
+    item.lastDeliveryKey = collectorDeliveryKey(item.id, bindingRevision, snapshot);
     if (Number.isSafeInteger(snapshot.generation)) item.lastDeliveredGeneration = snapshot.generation;
     if (Number.isFinite(snapshot.lastSuccessAt)) item.lastDeliveredSuccessAt = snapshot.lastSuccessAt;
     if (publication && item.requestedAt !== null && snapshot.lastSuccessAt >= item.requestedAt) {
@@ -10454,13 +10562,21 @@ function createCollectorAcquisitionRuntime({
     }
     item.onSnapshot(snapshot);
     if (!publication || !Number.isSafeInteger(snapshot.generation)) return true;
+    let awaitingObservation = false;
     for (const waiter of item.invalidations) {
       if (bindingRevision !== waiter.bindingRevision || waiter.requiredGeneration === null ||
           snapshot.generation < waiter.requiredGeneration) continue;
+      // A newer generation that republished an older observation (a Security
+      // capability-backoff replay) is not API validation of the webhook. Leave
+      // the waiter for the next real observation on the ordinary cadence.
+      if (Number.isFinite(waiter.invalidatedAt) && !(snapshot.lastSuccessAt >= waiter.invalidatedAt)) {
+        awaitingObservation = true;
+        continue;
+      }
       item.invalidations.delete(waiter);
       waiter.resolve(snapshot);
     }
-    if (item.invalidations.size > 0 && !closed && !item.closed && demandEnabled(item.demand)) {
+    if (item.invalidations.size > 0 && !awaitingObservation && !closed && !item.closed && demandEnabled(item.demand)) {
       queueMicrotask(() => startPoll(item, { manual: true }));
     }
     return true;
@@ -10531,11 +10647,15 @@ function createCollectorAcquisitionRuntime({
         retryIn = 1;
         return;
       }
-      item.provider = refreshedProvider;
+      const provider = refreshedProvider;
+      item.provider = provider;
       const ownership = await engine.refresh(subscriptionId, { force: manual });
       if (!ownership.ok) { item.onHold?.("disconnected"); retryIn = 1_000; return; }
       if (ownership.value.role !== "producer") {
-        if (ownership.value.snapshot) {
+        // A follower wake re-reads the shared record; re-send only a
+        // generation this subscription has not already delivered.
+        if (ownership.value.snapshot && item.lastDeliveryKey !==
+            collectorDeliveryKey(subscriptionId, bindingRevision, ownership.value.snapshot)) {
           deliverCollectorSnapshot(item, ownership.value.snapshot, bindingRevision);
         }
         if (ownership.value.reason !== "fresh") {
@@ -10566,7 +10686,7 @@ function createCollectorAcquisitionRuntime({
             active: ownership.value.demand?.active || item.requestedAt !== null },
           snapshot: ownership.value.snapshot,
           claim: { ...claim, state: item },
-          provider: item.provider,
+          provider,
           signal: item.controller.signal,
           force,
           markStarted: async (receipt) => {
@@ -10576,11 +10696,11 @@ function createCollectorAcquisitionRuntime({
             return started;
           },
         }));
-        const produced = item.provider?.scope
-          ? await requestIdentityStorage.run(item.provider.scope, produceBound)
+        const produced = provider?.scope
+          ? await requestIdentityStorage.run(provider.scope, produceBound)
           : await produceBound();
-        if (item.provider?.definition?.type === "github-app" &&
-            item.provider.coordinator.current()?.accessKey !== claim.accessKey) {
+        if (provider?.definition?.type === "github-app" &&
+            provider.coordinator.current()?.accessKey !== claim.accessKey) {
           engine.refresh(subscriptionId, { claim, failure: {
             hold: "disconnected",
             requestMetrics: produced.requestMetrics ?? {},
@@ -10610,13 +10730,16 @@ function createCollectorAcquisitionRuntime({
         const published = await engine.refresh(subscriptionId, { claim, publish: produced });
         if (!published.ok) { item.onHold?.("disconnected"); retryIn = 1_000; }
         else {
-          item.provider?.coordinator?.markAuthorized?.();
+          provider?.coordinator?.markAuthorized?.();
+          // A replay answers the request as far as backoff allows without
+          // advancing the success time that would otherwise clear it.
+          if (produced.sourceObserved === false) item.requestedAt = null;
           retryIn = Math.max(1, published.value.snapshot.nextDueAt - now());
         }
       } catch (error) {
-        if (item.provider?.definition?.type === "github-app" && error?.apiResponse?.status === 401 &&
+        if (provider?.definition?.type === "github-app" && error?.apiResponse?.status === 401 &&
             !error.appCredentialInvalidated) {
-          item.provider.coordinator.invalidate("unauthorized");
+          provider.coordinator.invalidate("unauthorized");
         }
         const hold = error?.notStarted ? "shared-wait" : acquisitionFailureHold(error);
         if (claim && error?.notStarted) engine.refresh(subscriptionId, { cancel: claim });
@@ -10625,7 +10748,7 @@ function createCollectorAcquisitionRuntime({
           requestMetrics: error?.requestMetrics ?? {},
         } });
         else engine.setHold(subscriptionId, hold, { resource: item.resource, accessKey: item.identity.accessKey });
-        item.onHold?.(item.provider?.definition?.type === "github-app" &&
+        item.onHold?.(provider?.definition?.type === "github-app" &&
           (error?.apiResponse?.status === 401 || error?.message === "GitHub App token unavailable" ||
             classify(error) === "auth-problem")
           ? "app-auth" : hold);
@@ -10713,7 +10836,7 @@ function createCollectorAcquisitionRuntime({
       const item = { target, resource, demand: normalizedDemand, onSnapshot, onHold, id: null, identity: null,
         provider: null, polling: false, pollPhase: null, pollPromise: null, controller: null,
         initializePromise: null, closed: false, timer: null, queuedRefresh: null, requestedAt: null,
-        bindingRevision: 0, invalidations: new Set(), lastDeliveredGeneration: null,
+        bindingRevision: 0, invalidations: new Set(), lastDeliveredGeneration: null, lastDeliveryKey: null,
         lastDeliveredSuccessAt: null, promotionGeneration: null, promotionAt: null };
       items.add(item);
       void startInitialize(item);
@@ -10748,7 +10871,10 @@ function createCollectorAcquisitionRuntime({
           }
           return updated;
         },
-        refresh(force = false) { return startPoll(item, { manual: true, force: force === true }); },
+        refresh(force = false) {
+          retryPausedTransport(item.provider?.scope?.identityCoordinator);
+          return startPoll(item, { manual: true, force: force === true });
+        },
         inspect() {
           if (!item.id) return { source: "local collector", status: "initializing", resource: item.resource };
           const inspected = engine.inspect(item.id);
@@ -10825,6 +10951,7 @@ function createCollectorAcquisitionRuntime({
         }
         item.invalidations.add({
           requiredGeneration,
+          invalidatedAt: now(),
           bindingRevision: item.bindingRevision,
           accessRemoved: normalized.accessRemoved,
           accessOnly: normalized.accessRemoved && !demandEnabled(item.demand),
@@ -10863,7 +10990,9 @@ function createCollectorAcquisitionRuntime({
       for (const entry of targetInitializations.values()) entry.controller.abort();
       await Promise.allSettled([...items].flatMap((item) =>
         [item.initializePromise, item.pollPromise].filter(Boolean)));
-      for (const item of items) if (item.id) engine.unsubscribe(item.id);
+      // Per-target operation contexts are frozen; drop them so a retained
+      // handle does not keep the credential environment reachable.
+      for (const item of items) { if (item.id) engine.unsubscribe(item.id); item.provider = null; }
       items.clear();
       engine.close();
       for (const context of providerContexts.values()) {
@@ -11001,7 +11130,13 @@ function createCollectorProtocolClient({ createTransport, onReady = () => {},
     resourceForId: (id) => subscriptions.get(id)?.resource ?? null,
     onSnapshot(snapshot, frame) {
       const item = subscriptions.get(frame.id);
-      if (!item || frame.serverEpoch !== serverEpoch || snapshot.generation <= item.generation) return;
+      if (!item || frame.serverEpoch !== serverEpoch || snapshot.generation < item.generation) return;
+      // A same-epoch reconnect keeps the generation fence, and the server
+      // replays its cached generation for the new subscription. The first
+      // equal-generation snapshot on a connection acknowledges that
+      // connection; later repeats on it are not new deliveries.
+      if (snapshot.generation === item.generation && item.connectionAcknowledged) return;
+      item.connectionAcknowledged = true;
       item.generation = snapshot.generation;
       item.controlGeneration = Math.max(item.controlGeneration, snapshot.generation);
       const sourceAgeMs = item.sourceAge.observe({
@@ -11036,6 +11171,7 @@ function createCollectorProtocolClient({ createTransport, onReady = () => {},
         item.generation = -1;
         item.controlGeneration = -1;
       }
+      item.connectionAcknowledged = false;
       write({ type: "subscribe", id: item.id, host: item.host, repo: item.repo,
         resource: item.resource, demand: item.demand });
       flushRefresh(item);
@@ -11129,7 +11265,7 @@ function createCollectorProtocolClient({ createTransport, onReady = () => {},
         return { ok: false, reason: "invalid" };
       }
       const item = { ...subscription,
-        onSnapshot, onHold, onError, onDiagnostic, generation: -1, controlGeneration: -1, pendingRefresh: null,
+        onSnapshot, onHold, onError, onDiagnostic, generation: -1, controlGeneration: -1, connectionAcknowledged: false, pendingRefresh: null,
         sourceAge: createCollectorSourceAgeTracker({ now, monotonicNow, checkpoint: sourceCheckpoint }) };
       subscriptions.set(id, item);
       if (welcomed) write({ type: "subscribe", id: item.id, host: item.host, repo: item.repo,
@@ -12226,6 +12362,7 @@ const { version } = JSON.parse(readFileSync(new URL("./package.json", import.met
 // this file already applies to argv vectors and to classify().
 const KEY_TABLE = [
   ["1 2 3 4", "Actions / Issues / Pull requests / Security"],
+  ["5", "Notifications: status history; Up / Down scroll, r checks GitHub status, Esc returns"],
   ["Left / Right", "Previous / next tab"],
   ["Tab / Shift+Tab", "Next / previous tab"],
   ["Up / Down, j / k", "Move the cursor between rows"],
@@ -12255,6 +12392,7 @@ const HELP_PRIORITY = [
   "Enter",
   "Up / Down, j / k",
   "1 2 3 4",
+  "5",
   "w",
   "?",
   "Left / Right",
@@ -12390,6 +12528,9 @@ Environment:
                             Minimum active-tab poll interval, ${MIN_REFRESH_SECONDS}-${MAX_REFRESH_SECONDS};
                             safe shared grants may run later
                             (--refresh takes precedence)
+  GH_GLANCE_GITHUB_STATUS=off
+                            Turn off the githubstatus.com check in
+                            Notifications (an http(s) URL replaces the endpoint)
   GH_GLANCE_ICONS=unicode   Unicode status glyphs and text row substitutes
   GH_GLANCE_ICONS=ascii     ASCII-only status and row icons
   GH_GLANCE_NO_ANIMATION=1  Stop motion; semantic status words remain
@@ -13833,8 +13974,10 @@ function authCacheIdentity({
 }
 
 // Explicit targets are stable across working directories. In inferred mode the
-// directory is the only repository identity available without making another
-// GitHub call -- exactly the call that cannot succeed when this cache is needed.
+// directory and the remote slug, both resolved offline without the GitHub call
+// that cannot succeed when this cache is needed, form the identity: a changed
+// remote or a reused checkout path must not restore another repository's rows.
+// A null slug (no remote, or remotes that disagree) is its own key.
 // JSON encoding avoids delimiter ambiguity in host, repo, and path strings.
 function dashboardCacheTarget({
   repo = null,
@@ -13842,11 +13985,13 @@ function dashboardCacheTarget({
   host = null,
   cwd = process.cwd(),
   account = authCacheIdentity(),
+  remoteUrls = [],
 } = {}) {
   const target = repo || ghRepo;
   return target
     ? JSON.stringify({ kind: "repo", host: String(host ?? ""), repo: String(target), account })
-    : JSON.stringify({ kind: "cwd", host: String(host ?? ""), cwd: String(cwd), account });
+    : JSON.stringify({ kind: "cwd", host: String(host ?? ""), cwd: String(cwd),
+      remote: resolveEffectiveRepository({ remoteUrls }), account });
 }
 
 function sshCollectorCacheIdentity(alias) {
@@ -13932,6 +14077,33 @@ function normalizeCachedItem(tabKey, item) {
   return null;
 }
 
+// The one "unchanged" identity for an acquired result. Fetchers emit it, the
+// shared store rebuilds it from a validated snapshot, and adoption carries it,
+// so a producer comparing against a stored snapshot sees the same string it
+// would have produced itself. It covers what the tab renders: the rows through
+// the stored-snapshot validator, the markers that say the list is incomplete
+// and, for Security, the coverage notes. Timestamps are excluded on purpose.
+function acquisitionContentRaw(resource, { rows, truncated = false, hasNextPage = false, notes = [], blind = false }) {
+  return JSON.stringify({
+    v: GRAPHQL_QUERY_VERSION,
+    resource,
+    truncated: truncated === true,
+    hasNextPage: hasNextPage === true,
+    notes: resource === "security" ? notes : [],
+    blind: resource === "security" && blind === true,
+    rows: rows.map((row) => normalizeCachedItem(resource, row)),
+  });
+}
+
+// A pane's unchanged sentinel must describe the rows it displays. Adopting a
+// peer's different content without moving it let an A, B, A sequence compare
+// the third result against A and republish B as "unchanged". A snapshot that
+// does not carry the shared representation clears it, which costs one parse.
+function adoptedAcquisitionRaw(currentRaw, snapshot, sameContent) {
+  if (sameContent) return currentRaw;
+  return typeof snapshot?.raw === "string" ? snapshot.raw : null;
+}
+
 function normalizeDashboardCacheEntry(entry) {
   if (!isRecord(entry) || !isRecord(entry.tabs)) return null;
   const tabs = {};
@@ -14558,6 +14730,7 @@ function normalizeAcquisitionSnapshot(raw, query, generation, producerEpoch) {
   const content = JSON.stringify(rows);
   const contentDigest = createHash("sha256").update(content).digest("hex");
   if (raw.raw === undefined && raw.contentDigest !== contentDigest) return null;
+  const securityNotes = raw.securityNotes.filter((note) => typeof note === "string").map(safe);
   return {
     schema: 1,
     producerEpoch,
@@ -14565,7 +14738,8 @@ function normalizeAcquisitionSnapshot(raw, query, generation, producerEpoch) {
     generation,
     rows,
     pageInfo,
-    raw: content,
+    raw: acquisitionContentRaw(query.resource, { rows, truncated: raw.meta.truncated,
+      hasNextPage: pageInfo?.hasNextPage, notes: securityNotes, blind: raw.securityBlind }),
     contentDigest,
     entities,
     lastSuccessAt: raw.lastSuccessAt,
@@ -14574,7 +14748,7 @@ function normalizeAcquisitionSnapshot(raw, query, generation, producerEpoch) {
     hold: null,
     capabilities,
     meta: { at: raw.meta.at, truncated: raw.meta.truncated },
-    securityNotes: raw.securityNotes.filter((note) => typeof note === "string").map(safe),
+    securityNotes,
     securityBlind: raw.securityBlind,
   };
 }
@@ -16465,10 +16639,14 @@ function cleanupQueueForResource(queue, resource) {
   return count;
 }
 
+function recoveryResourceLabel(resource) {
+  return resource === "graphql" ? "GraphQL" : resource === "core" ? "Core" : "GitHub";
+}
+
 function presentRecovery(cause, { nowMs = Date.now(), cols = 80, hasSnapshot } = {}) {
   if (!cause) return [];
   const width = Math.max(1, Number.isSafeInteger(cols) ? cols - 1 : 79);
-  const resource = cause.resource === "graphql" ? "GraphQL" : cause.resource === "core" ? "Core" : "GitHub";
+  const resource = recoveryResourceLabel(cause.resource);
   const age = hasSnapshot === false ? "Not checked yet"
     : Number.isFinite(cause.sourceAt) && cause.sourceAt <= nowMs
       ? `cached ${formatDuration(nowMs - cause.sourceAt)}`
@@ -16650,6 +16828,7 @@ function contextHelpPages({ view, target, tab, remoteSetup = false }, keys = key
     issues: "Issues shows open issues in the selected repository.",
     prs: "Pull requests shows open requests to merge changes into the selected repository.",
     security: "Security shows alerts returned by the checked sources; unavailable sources can hide alerts.",
+    notifications: "Notifications lists status events for this pane: waits, refreshes, failures and cleared causes.",
   };
   const title = remoteSetup ? "No GitHub remote found" : view.title;
   const action = remoteSetup ? "Close help with ?, then Enter to start gh repo create; or restart with gh-glance --repo owner/name."
@@ -16812,6 +16991,587 @@ function safeRecordRecoveryTransition(scope, event, write = recordRecoveryTransi
   try { return write(scope, event); } catch { return { ok: false, reason: "unavailable" }; }
 }
 
+// ---------- Notifications ----------
+
+// Only causes the user must act on, or that waiting cannot fix, earn rows above
+// a table. Everything else -- automatic retries, refreshes, cleared causes --
+// goes to the Notifications view, so an ordinary wait no longer pushes the
+// table down. Every RECOVERY_COPY key is listed explicitly: the unknown-code
+// fallback below would otherwise hide a new code nobody classified, and
+// test/notifications.test.mjs compares the two key sets.
+const NOTICE_ACTION_CODES = Object.freeze([
+  "unwritable", "corrupt", "capacity", "accounting-overflow", "reservations-invalid",
+  "external-factor-invalid", "pacing-invalid", "budget-resource", "legacy-unresolved",
+  "legacy-corrupt", "restart-required", "throttle-paused", "credential-unavailable",
+  "identity-unavailable", "disconnected", "app-auth", "auth-problem", "unavailable",
+  "backup-conflict", "version-mismatch", "unsafe-permissions", "disk-full",
+]);
+// `coordination` is the fallback copy for unmapped reasons (an external quota
+// drain among them), and `unknown-scope` is the startup login check; the real
+// storage and login failures have their own action codes above.
+const NOTICE_WAIT_CODES = Object.freeze([
+  "busy", "stale", "identity-busy", "transport-busy", "debt-journal-full", "migration-hold",
+  "identity-backoff", "identity-capacity", "budget-unknown", "budget-stale", "budget-future",
+  "probe-failed", "block-unpublished", "budget-reset", "reset", "priority", "rate-limit",
+  "rate-limited", "local-reserve", "reserve", "blocked", "secondary", "secondary-rate-limit",
+  "abuse-limit", "network-outage", "security-incomplete", "receipt-retry", "interrupted-request",
+  "request-queue", "acquisition-busy", "clock-recovery", "source-incomplete", "unknown-scope",
+  "coordination",
+]);
+const NOTICE_LEVELS = Object.freeze(Object.fromEntries([
+  ...NOTICE_ACTION_CODES.map((code) => [code, "action"]),
+  ...NOTICE_WAIT_CODES.map((code) => [code, "wait"]),
+]));
+const VERDICT_NOTICE_LEVELS = Object.freeze({
+  "auth-problem": "action", unavailable: "action", "no-remote": "action", "rate-limited": "wait",
+});
+const NOTIFICATION_LOG_MAX = 500;
+// Tabs whose requests draw on each rate resource; a cause on that resource
+// holds them up. The cost table is fixed, so this is computed once.
+const NOTICE_RESOURCE_TABS = Object.freeze(Object.fromEntries(RATE_RESOURCES.map((resource) =>
+  [resource, TAB_KEYS.filter((key) => tabRequestCost(key)?.[resource] > 0)])));
+const EARLIER_SESSION_SOURCE = "Earlier session";
+
+// When a governor hold says it will try again.
+function decisionRetryAt(decision) {
+  return decision?.retryAt ?? decision?.resetMs ?? decision?.notBefore ?? null;
+}
+
+function noticeLevel({ code = null, verdict = null } = {}) {
+  if (code != null) return Object.hasOwn(NOTICE_LEVELS, code) ? NOTICE_LEVELS[code] : "wait";
+  // Any other verdict is a failed refresh whose raw text is the best report.
+  if (verdict != null) return Object.hasOwn(VERDICT_NOTICE_LEVELS, verdict) ? VERDICT_NOTICE_LEVELS[verdict] : "problem";
+  return "info";
+}
+
+function fetchErrorLevel(error) {
+  if (!error) return null;
+  if (error.kind !== "fetch") return "problem";
+  // A shared-budget pause reaches the tab as an unclassified fetch error.
+  if (BUDGET_PAUSE_ERROR.test(error.raw ?? "")) return "wait";
+  return noticeLevel({ verdict: error.verdict });
+}
+
+// One bounded, in-memory history per pane. Entries hold sanitized display text
+// only. A repeat of the latest entry with the same key coalesces into a count
+// (an informational repeat only if no non-info entry from the same source, or
+// one affecting the same tab, came after it); an ended entry never reopens, so a recurring condition reads
+// as a new episode. An entry the bound already dropped cannot be ended, so its
+// "Cleared" line is silently skipped. Earlier-session history is context, not
+// news, so it never raises the badge.
+function createNotificationLog({ max = NOTIFICATION_LOG_MAX, now = Date.now } = {}) {
+  const entries = []; // oldest first
+  let nextId = 1;
+  let seenId = 0;
+  let truncated = false;
+  let cachedSummary = null;
+  let cachedList = null;
+  const changed = () => {
+    cachedSummary = null;
+    cachedList = null;
+  };
+  const timeOr = (value) => Number.isFinite(value) ? value : now();
+  function record({ key, level = "info", source = "", code = null, text = "", action = null,
+    at, lastAt, tabs = [] }) {
+    const firstAt = timeOr(at);
+    const latest = Number.isFinite(lastAt) ? Math.max(lastAt, firstAt) : firstAt;
+    const cleanSource = safe(source);
+    const cleanText = safe(text);
+    let index = -1;
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+      const entry = entries[i];
+      if (entry.key === key) {
+        if (entry.endedAt === null) index = i;
+        break;
+      }
+      // Only informational repeats (refreshes) are split by a later problem; a
+      // still-open condition recorded again is the same condition, updated.
+      if (level === "info" && entry.level !== "info" && (entry.source === cleanSource ||
+        entry.tabs.some((tab) => tabs.includes(tab)))) break;
+    }
+    if (index >= 0) {
+      const [entry] = entries.splice(index, 1);
+      // A refresh repeats; a changed open condition is the same occurrence.
+      if (level === "info") entry.count += 1;
+      entry.lastAt = Math.max(entry.lastAt, latest);
+      entry.text = cleanText;
+      entries.push(entry);
+    } else {
+      entries.push({ id: nextId, key, level, source: cleanSource, code,
+        text: cleanText, action: action == null ? null : safe(action),
+        firstAt, lastAt: latest, count: 1, endedAt: null, tabs: [...tabs] });
+      nextId += 1;
+      if (entries.length > max) {
+        entries.shift();
+        truncated = true;
+      }
+    }
+    changed();
+  }
+  function end(key, at) {
+    const entry = entries.findLast((candidate) => candidate.key === key);
+    if (!entry || entry.endedAt !== null) return false;
+    entry.endedAt = timeOr(at);
+    changed();
+    if (entry.level !== "info") {
+      record({ key: `${key}:cleared`, level: "info", source: entry.source,
+        text: `Cleared: ${entry.text}`, at: entry.endedAt, tabs: entry.tabs });
+    }
+    return true;
+  }
+  function summary() {
+    if (cachedSummary) return cachedSummary;
+    let unread = 0;
+    let red = false;
+    let yellow = false;
+    for (const entry of entries) {
+      if (entry.level === "info" || entry.source === EARLIER_SESSION_SOURCE || entry.id <= seenId) continue;
+      unread += 1;
+      if (entry.level === "wait") yellow = true;
+      else red = true;
+    }
+    cachedSummary = { unread, tone: red ? "red" : yellow ? "yellow" : "none", truncated, size: entries.length };
+    return cachedSummary;
+  }
+  return {
+    record,
+    end,
+    summary,
+    // Newest first. Shared between calls until the log changes; callers read only.
+    list: () => {
+      cachedList ??= entries.map((entry) => Object.freeze({ ...entry, tabs: Object.freeze([...entry.tabs]) })).reverse();
+      return cachedList;
+    },
+    markSeen: () => {
+      if (seenId === nextId - 1) return;
+      seenId = nextId - 1;
+      changed();
+    },
+    size: () => entries.length,
+  };
+}
+
+// Conditions present in one render's snapshot. The same cause reported by a
+// rate resource and by several tabs is one condition; the resource names it
+// when it has one, because that is where it lives.
+function notificationConditions(snapshot) {
+  const conditions = new Map();
+  // `tabs` names the sections a cause holds up, so a refresh of one of them
+  // after the cause never merges with a refresh from before it.
+  const cause = (reason, source, tabs, detail = null) => {
+    // Same normalization as recoveryCause: unknown reasons use the fallback copy.
+    const code = Object.hasOwn(RECOVERY_COPY, reason) ? reason : "coordination";
+    const [summary, action] = RECOVERY_COPY[code];
+    const key = `cause:${code}`;
+    const existing = conditions.get(key);
+    if (existing) {
+      for (const tab of tabs) if (!existing.tabs.includes(tab)) existing.tabs.push(tab);
+      return;
+    }
+    conditions.set(key, { key, level: noticeLevel({ code }), source, code,
+      text: detail?.summary ?? summary, action: detail?.action ?? action, tabs: [...tabs] });
+  };
+  for (const resource of RATE_RESOURCES) {
+    const recovery = snapshot?.recovery?.[resource];
+    if (recovery?.code) {
+      cause(recovery.code, recoveryResourceLabel(resource), NOTICE_RESOURCE_TABS[resource], recovery);
+    }
+  }
+  for (const tab of TABS) {
+    const state = snapshot?.tabs?.[tab.key];
+    if (!state) continue;
+    if (state.error) {
+      // A budget pause and a real failure share the `other` verdict; the level
+      // keeps them distinct so one never hides the other.
+      const level = fetchErrorLevel(state.error);
+      const key = `fetch:${tab.key}:${level}:${state.error.kind === "fetch" ? state.error.verdict : "text"}`;
+      conditions.set(key, { key, level, source: tab.label, code: null,
+        text: formatTabError(state.error, snapshot.failureContext ?? null) ?? "", action: null, tabs: [tab.key] });
+    }
+    if (state.failure) cause(state.failure, tab.label, [tab.key]);
+    if (state.paused) cause(state.paused, tab.label, [tab.key]);
+  }
+  for (const note of snapshot?.securityNotes ?? []) {
+    const text = safe(note);
+    const key = `security:${text}`;
+    conditions.set(key, { key, level: /not enabled/i.test(text) ? "info" : "wait",
+      source: "Security", code: null, text, action: null, tabs: ["security"] });
+  }
+  if (snapshot?.disconnected) {
+    cause(typeof snapshot.disconnected === "string" ? snapshot.disconnected : "disconnected",
+      "Connection", TAB_KEYS);
+  }
+  return conditions;
+}
+
+// Diff two render snapshots into log events. A condition must persist for the
+// same debounce the inline notice used, so startup and lock-contention blips
+// never become history; `pending` is when the earliest unconfirmed condition
+// becomes due, for the caller to re-check without waiting for another render.
+function diffNotificationSnapshots(previous, current, nowMs) {
+  const prior = previous?.conditions ?? new Map();
+  const conditions = new Map();
+  const begin = [];
+  const end = [];
+  let pending = null;
+  for (const [key, condition] of notificationConditions(current)) {
+    const before = prior.get(key);
+    const since = before?.since ?? nowMs;
+    const begun = Boolean(before?.begun) || nowMs - since >= COORDINATION_NOTICE_AFTER_MS;
+    if (begun && !before?.begun) begin.push({ ...condition, at: since });
+    if (!begun) {
+      const due = since + COORDINATION_NOTICE_AFTER_MS;
+      pending = pending === null ? due : Math.min(pending, due);
+    }
+    conditions.set(key, { since, begun });
+  }
+  for (const [key, before] of prior) if (before.begun && !conditions.has(key)) end.push(key);
+  const lastOk = {};
+  for (const tab of TABS) {
+    const before = previous?.lastOk?.[tab.key];
+    const value = current?.tabs?.[tab.key]?.lastOk;
+    if (!Number.isFinite(value)) {
+      if (Number.isFinite(before)) lastOk[tab.key] = before;
+      continue;
+    }
+    lastOk[tab.key] = value;
+    if (Number.isFinite(before) && value > before) {
+      begin.push({ key: `refreshed:${tab.key}`, level: "info", source: tab.label, code: null,
+        text: `Refreshed ${tab.label}`, action: null, at: value, tabs: [tab.key] });
+    }
+  }
+  return { state: { conditions, lastOk }, begin, end, pending };
+}
+
+// Read-only: earlier recovery transitions become dimmed context in a new pane.
+function seedNotificationsFromJournal(log, scope, read = readRecoveryTransitions) {
+  let journal;
+  try { journal = read(scope); } catch { journal = { status: "unavailable", entries: [] }; }
+  if (journal.status === "missing") return;
+  if (journal.status !== "healthy") {
+    log.record({ key: "journal:unavailable", level: "info", source: EARLIER_SESSION_SOURCE,
+      text: "Earlier recovery history unavailable; run gh-glance --doctor" });
+    return;
+  }
+  const open = {};
+  for (const entry of journal.entries) {
+    const key = `journal:${entry.resource}:${entry.code}`;
+    // The same cause re-journaled for a new origin or tab is one episode here.
+    if (open[entry.resource] === key) continue;
+    if (open[entry.resource]) {
+      log.end(open[entry.resource], entry.at);
+      open[entry.resource] = null;
+    }
+    if (entry.code === "clear") continue;
+    log.record({ key, level: noticeLevel({ code: entry.code }), source: EARLIER_SESSION_SOURCE,
+      code: entry.code, text: `${recoveryResourceLabel(entry.resource)}: ${entry.summary}`,
+      action: entry.action, at: entry.firstAt, lastAt: entry.at });
+    open[entry.resource] = key;
+  }
+}
+
+// The rows a visible table gives up: an action cause's recovery lines (after
+// the usual debounce) or an action fetch verdict's one-line remedy. Waits,
+// failed refreshes and history go to the Notifications view instead.
+function criticalInlineLines({ cause = null, showCause = false, tabError = null, displayError = "",
+  capacity = 0, nowMs = Date.now(), cols = 80, hasSnapshot } = {}) {
+  let lines = [];
+  let source = null;
+  if (showCause && cause && noticeLevel({ code: cause.code }) === "action") {
+    lines = presentRecovery(cause, { nowMs, cols, hasSnapshot });
+    source = "cause";
+  } else if (tabError && displayError && fetchErrorLevel(tabError) === "action") {
+    lines = [displayError];
+    source = "error";
+  }
+  if (capacity < 1 || lines.length === 0) return { lines: [], source: null };
+  // On a one-row pane the remedy outranks the summary.
+  return { lines: capacity === 1 && lines.length > 1 ? [lines[1]] : lines.slice(0, capacity), source };
+}
+
+// `today` is a toDateString() value, or a time on that day.
+function notificationTime(at, today) {
+  const date = new Date(at);
+  const pad = (value) => String(value).padStart(2, "0");
+  const day = date.toDateString() === (typeof today === "string" ? today : new Date(today).toDateString()) ? ""
+    : `${pad(date.getMonth() + 1)}-${pad(date.getDate())} `;
+  return `${day}${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+// The Notifications body: a GitHub status row, then events newest first. Open
+// waits show their live retry time (`liveRetry`, keyed by cause code) because
+// the time a condition began says nothing about when it will clear. Ended,
+// informational and earlier-session entries are dimmed.
+function notificationViewLines({ entries, statusLine, nowMs = Date.now(), capacity, offset = 0,
+  liveRetry = {}, profile = ICON_PROFILE === "ascii" ? "ascii" : "unicode" }) {
+  const glyphs = REFRESH_STATUS_GLYPHS[profile] ?? REFRESH_STATUS_GLYPHS.unicode;
+  const glyph = { action: glyphs.failed, problem: glyphs.failed, wait: glyphs.paused, info: glyphs.watching };
+  const today = new Date(nowMs).toDateString();
+  const rows = Math.max(1, capacity);
+  const listRows = Math.max(0, rows - 1);
+  const maxOffset = Math.max(0, entries.length - listRows);
+  const start = Math.min(Math.max(0, offset), maxOffset);
+  const lines = [{ text: statusLine, level: "status", dim: false }];
+  if (entries.length === 0) lines.push({ text: "No events yet", level: "info", dim: true });
+  for (const entry of entries.slice(start, start + listRows)) {
+    const open = entry.endedAt === null;
+    const retryAt = open && entry.code ? liveRetry[entry.code] : null;
+    const retry = Number.isFinite(retryAt) ? `; next ${statusInterval(retryAt, nowMs)}` : "";
+    const action = entry.level === "action" && entry.action ? `; ${entry.action}` : "";
+    const count = entry.count > 1 ? ` x${entry.count}` : "";
+    lines.push({
+      text: `${notificationTime(entry.lastAt, today)} ${glyph[entry.level] ?? glyph.info} ${entry.source}: ${entry.text}${action}${retry}${count}`,
+      level: entry.level,
+      dim: !open || entry.level === "info" || entry.source === EARLIER_SESSION_SOURCE,
+    });
+  }
+  return { lines: lines.slice(0, rows), offset: start, maxOffset, pageRows: Math.max(1, listRows) };
+}
+
+// ---------- GitHub platform status ----------
+
+// githubstatus.com is a separate public host: checking it spends no GitHub API
+// quota and never goes through `gh` or the governor. It describes github.com
+// only, so other hosts are not checked. All remote text is display text and
+// passes safe() before it reaches the log or the screen.
+const GITHUB_STATUS_URL = "https://www.githubstatus.com/api/v2/summary.json";
+const GITHUB_STATUS_MAX_BYTES = 256 * 1024;
+const GITHUB_STATUS_TIMEOUT_MS = 10_000;
+const GITHUB_STATUS_INTERVAL_MS = 10 * 60_000;
+const GITHUB_STATUS_BACKOFF_MS = 15 * 60_000;
+const GITHUB_STATUS_MIN_GAP_MS = 60_000;
+const GITHUB_STATUS_COMPONENTS = Object.freeze(["API Requests", "Actions", "Issues", "Pull Requests",
+  "Git Operations", "Webhooks"]);
+const GITHUB_STATUS_ENV = "GH_GLANCE_GITHUB_STATUS";
+// Words in an untagged incident's name that point at a surface this dashboard
+// shows. A generic "GitHub services" disruption may touch any of them.
+const GITHUB_STATUS_RELEVANT_NAME = /\b(?:actions?|runners?|issues?|pull requests?|prs?|requests?|webhooks?|git|api|repos?|repositor(?:y|ies)|dependabot|code scanning|secret scanning|security|github services)\b/i;
+
+function githubStatusConfig(env = process.env, host = null) {
+  const raw = env[GITHUB_STATUS_ENV];
+  const value = typeof raw === "string" ? raw.trim() : "";
+  if (/^(?:off|0)$/i.test(value)) {
+    return { enabled: false, url: null, reason: `GitHub status checks off (${GITHUB_STATUS_ENV})` };
+  }
+  let url = GITHUB_STATUS_URL;
+  if (value) {
+    let parsed = null;
+    try { parsed = new URL(value); } catch { /* reported below */ }
+    if (!parsed || !["http:", "https:"].includes(parsed.protocol)) {
+      return { enabled: false, url: null, reason: `${GITHUB_STATUS_ENV} value not recognised; GitHub status checks off` };
+    }
+    url = parsed.href;
+  }
+  const selected = normalizeHost(host);
+  if (selected && selected !== "github.com") {
+    return { enabled: false, url: null, reason: `GitHub status not checked for ${safe(selected)}` };
+  }
+  return { enabled: true, url, reason: null };
+}
+
+async function readBoundedText(response, limit) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > limit) throw new Error("oversize");
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > limit) {
+      await reader.cancel().catch(() => {});
+      throw new Error("oversize");
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+function parseGitHubStatus(body) {
+  if (!isRecord(body) || !Array.isArray(body.components) ||
+      (body.incidents !== undefined && !Array.isArray(body.incidents))) return null;
+  const text = (value, fallback = "") => typeof value === "string" && value.trim() ? safe(value) : fallback;
+  const components = body.components
+    .filter((component) => isRecord(component) && GITHUB_STATUS_COMPONENTS.includes(component.name))
+    .map((component) => {
+      const status = text(component.status, "unknown");
+      return { name: component.name, status, label: GITHUB_COMPONENT_STATUS[status] ?? status };
+    });
+  // An incident tagged with components, none of them tracked, is about a
+  // product this dashboard does not show and is dropped. About a third of
+  // GitHub's incidents carry no tag (often the first post); those are kept, and
+  // count as relevant only when the name names something this dashboard shows.
+  const incidents = [];
+  for (const [index, incident] of (body.incidents ?? []).entries()) {
+    if (!isRecord(incident)) continue;
+    const tagged = Array.isArray(incident.components) && incident.components.length > 0;
+    const tracked = tagged && incident.components.some((component) =>
+      GITHUB_STATUS_COMPONENTS.includes(component?.name));
+    if (tagged && !tracked) continue;
+    const name = text(incident.name, "Unnamed incident");
+    incidents.push({
+      id: text(incident.id, `incident-${index}`),
+      name,
+      status: text(incident.status, "unknown"),
+      impact: text(incident.impact, "unknown"),
+      updatedAt: text(incident.updated_at, null),
+      relevant: tracked || GITHUB_STATUS_RELEVANT_NAME.test(name),
+    });
+  }
+  return { components, incidents };
+}
+
+async function fetchGitHubStatus({ url, etag = null, signal = null, fetchImpl = globalThis.fetch,
+  timeoutMs = GITHUB_STATUS_TIMEOUT_MS } = {}) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  try {
+    const response = await fetchImpl(url, { signal: combined, redirect: "follow",
+      headers: { accept: "application/json", ...(etag ? { "if-none-match": etag } : {}) } });
+    if (response.status === 304) return { status: "not-modified" };
+    if (!response.ok) return { status: "unavailable", reason: `HTTP ${response.status}` };
+    const summary = parseGitHubStatus(JSON.parse(await readBoundedText(response, GITHUB_STATUS_MAX_BYTES)));
+    if (!summary) return { status: "unavailable", reason: "unexpected response" };
+    const tag = response.headers.get("etag");
+    return { status: "ok", summary, etag: typeof tag === "string" && tag.length <= 256 ? tag : null };
+  } catch (error) {
+    return { status: "unavailable", reason: error?.name === "TimeoutError" ? "timeout" : "unreachable" };
+  }
+}
+
+const GITHUB_COMPONENT_STATUS = Object.freeze({ degraded_performance: "degraded performance",
+  partial_outage: "partial outage", major_outage: "major outage", under_maintenance: "under maintenance" });
+
+// `state` is a monitor's current(): the last good summary, kept separately from
+// whether the latest check reached the page.
+function githubStatusLine(state, nowMs = Date.now()) {
+  if (!state?.enabled) return state?.reason ?? "GitHub status checks off";
+  if (state.unavailable) {
+    return Number.isFinite(state.nextAt)
+      ? `GitHub status unavailable; next check ${notificationTime(state.nextAt, nowMs)}`
+      : "GitHub status unavailable";
+  }
+  if (!state.summary) return "GitHub status: not checked yet";
+  const { components } = state.summary;
+  const incidents = state.summary.incidents.filter((incident) => incident.relevant !== false);
+  const others = state.summary.incidents.length - incidents.length;
+  if (incidents.length > 0) {
+    const more = incidents.length > 1 ? ` (+${incidents.length - 1} more)` : "";
+    return `GitHub incident: ${incidents[0].name}${more}`;
+  }
+  const degraded = components.filter((component) => component.status !== "operational");
+  if (degraded.length > 0) {
+    return `GitHub: ${degraded.map((component) => `${component.name} ${component.label}`).join(", ")}`;
+  }
+  if (others > 0) {
+    return `GitHub status: no incident affecting this dashboard (${others} ${others === 1 ? "other" : "others"})`;
+  }
+  return "GitHub status: All systems operational";
+}
+
+// Polls the status page on a slow cadence and turns changes into log entries:
+// an incident or a degraded tracked component is a problem, its end is a
+// "Cleared" line, and an unreachable status page is one info entry per
+// episode. `checkNow` (view open, r, a failing tab) runs at most once a minute.
+function createGitHubStatusMonitor({ config, log, fetchImpl = globalThis.fetch, now = Date.now,
+  setTimer = setTimeout, clearTimer = clearTimeout, onChange = () => {} }) {
+  let summary = null;
+  let etag = null;
+  let lastAttemptAt = -Infinity;
+  let nextAt = null;
+  let timer = null;
+  let stopped = !config?.enabled;
+  let inFlight = null;
+  let controller = null;
+  let unavailable = false;
+  let open = new Map(); // log key -> { text, level } of each ongoing incident or outage
+
+  function schedule(delay) {
+    if (stopped) return;
+    if (timer !== null) clearTimer(timer);
+    nextAt = now() + delay;
+    // The promise is returned for injected test clocks; check() never rejects.
+    timer = setTimer(() => { timer = null; return check(); }, delay);
+    timer?.unref?.();
+  }
+
+  function apply(next, at) {
+    // An incident that may not touch this dashboard is listed as information:
+    // it neither turns the badge red nor counts as an outage.
+    const conditions = new Map([
+      ...next.incidents.map((incident) => [`github:incident:${incident.id}`, {
+        text: `${incident.name} (${incident.status}, ${incident.impact} impact)`,
+        level: incident.relevant === false ? "info" : "problem" }]),
+      ...next.components.filter((component) => component.status !== "operational")
+        .map((component) => [`github:component:${component.name}`,
+          { text: `${component.name}: ${component.label}`, level: "problem" }]),
+    ]);
+    // A changed text is an update of the same open entry, not a new one.
+    for (const [key, { text, level }] of conditions) {
+      if (open.get(key)?.text !== text) log.record({ key, level, source: "GitHub status", text, at });
+    }
+    for (const key of open.keys()) if (!conditions.has(key)) log.end(key, at);
+    open = conditions;
+  }
+
+  async function check() {
+    if (stopped || inFlight) return inFlight;
+    lastAttemptAt = now();
+    controller = new AbortController();
+    inFlight = (async () => {
+      const outcome = await fetchGitHubStatus({ url: config.url, etag, signal: controller.signal, fetchImpl });
+      if (stopped) return;
+      const at = now();
+      if (outcome.status === "unavailable") {
+        if (!unavailable) {
+          log.record({ key: "github:unavailable", level: "info", source: "GitHub status",
+            text: "GitHub status page unavailable", at });
+        }
+        unavailable = true;
+        schedule(GITHUB_STATUS_BACKOFF_MS);
+      } else if (outcome.status === "not-modified" && !summary) {
+        // Nothing cached to reuse: drop the validator and ask again in a minute.
+        etag = null;
+        schedule(GITHUB_STATUS_MIN_GAP_MS);
+      } else {
+        if (unavailable) log.end("github:unavailable", at);
+        unavailable = false;
+        if (outcome.status === "ok") {
+          etag = outcome.etag;
+          summary = outcome.summary;
+          apply(summary, at);
+        }
+        schedule(GITHUB_STATUS_INTERVAL_MS);
+      }
+      try { onChange(); } catch { /* a render callback must not break polling */ }
+    })().finally(() => {
+      inFlight = null;
+      controller = null;
+    });
+    return inFlight;
+  }
+
+  const ready = stopped ? Promise.resolve() : check();
+  return {
+    ready,
+    async checkNow() {
+      if (stopped || inFlight || now() - lastAttemptAt < GITHUB_STATUS_MIN_GAP_MS) return false;
+      await check();
+      return true;
+    },
+    stop() {
+      stopped = true;
+      controller?.abort();
+      if (timer !== null) clearTimer(timer);
+      timer = null;
+    },
+    current: () => ({ enabled: Boolean(config?.enabled), reason: config?.reason ?? null, summary,
+      unavailable, nextAt, outage: [...open.values()].some((condition) => condition.level === "problem") }),
+  };
+}
+
 function recoveryLedgerSummary(scope, resource, nowMs = Date.now()) {
   if (!scope?.path || !RATE_RESOURCES.includes(resource)) return null;
   const loaded = readGovernorState(scope.path, nowMs, { persistMigration: false });
@@ -17219,63 +17979,87 @@ const MIN_TABLE_WIDTH = Math.max(...TABS.map((t) => minimumWidthFor(t.header)));
 // status line survive at any width a terminal is realistically set to.
 const MIN_COMPACT_WIDTH = Math.max(...TABS.map((t) => minimumWidthFor(t.compactHeader)));
 
-// The tab bar is laid out independently of the table and wraps at its own
-// width. Full labels need ~77 columns; short labels ~57. Hysteresis on the
+// The tab bar is laid out independently of the table. Full labels for the five
+// sections need ~97 columns; short labels ~77. Hysteresis on the full/short
 // breakpoint so a pane parked exactly on it does not flip labels on every
-// resize event and defeat the unchanged-frame optimization.
-const TAB_LABEL_FULL_WIDTH = 78;
+// resize event and defeat the unchanged-frame optimization. Below the short
+// width the bar drops names and keeps digits and counts (see tabBarEntries).
+const TAB_LABEL_FULL_WIDTH = 98;
 const TAB_LABEL_HYSTERESIS = 4;
+const NOTIFICATIONS_LABEL = Object.freeze({ full: "Notifications", short: "Notices" });
 
 function tabFailureSuffix({ count, failed, brokenCI }) {
   if (count == null) return failed ? " x" : "";
   return ` (${count}${brokenCI ? "!" : ""}${failed ? "x" : ""})`;
 }
 
-function TabBar({ activeIndex, counts, brokenCI, firstLoad, failed, spin, useShort }) {
+function tabBarWidth(entries) {
+  return entries.reduce((sum, entry) => sum + entry.label.length + entry.margin, 0);
+}
+
+// Four data sections plus Notifications on one row. The widest tier that fits
+// `cols` wins: full names, short names, digits with counts, the same without
+// gaps, then bare digits that keep only the Notifications badge -- so every
+// section key stays visible, and the row never wraps, down to a ~20-column pane.
+function tabBarEntries({ cols, counts, brokenCI, firstLoad, failed, spin, useShort, activeIndex,
+  notifications = { unread: 0, tone: "none" } }) {
+  const sections = TABS.map((tab) => {
+    const count = counts[tab.key];
+    // A tab that has never resolved shows the spinner where its count will
+    // go, so the first load reads as "working" rather than "empty".
+    const suffix = count == null && firstLoad[tab.key] ? ` ${spin}`
+      : tabFailureSuffix({ count, failed: failed[tab.key], brokenCI: count == null ? false : brokenCI[tab.key] });
+    // A tab whose fetches are failing kept rendering its last good count at
+    // full confidence, and the error banner is only visible on the tab you
+    // have selected -- so a background tab could fail for an hour with
+    // nothing on screen to say so.
+    return { key: tab.key, full: tab.label, short: tab.short, suffix,
+      color: failed[tab.key] ? "redBright" : undefined, quiet: !failed[tab.key] };
+  });
+  const { unread, tone } = notifications;
+  sections.push({ key: "notifications", ...NOTIFICATIONS_LABEL,
+    suffix: unread > 0 ? ` (${unread})` : "",
+    color: tone === "red" ? "redBright" : tone === "yellow" ? ATTENTION : undefined,
+    quiet: tone !== "red" && tone !== "yellow" });
+  const build = (tier) => sections.map((section, index) => {
+    const active = index === activeIndex;
+    const named = tier === "full" || tier === "short";
+    const suffix = tier === "digits" && section.key !== "notifications" ? "" : section.suffix;
+    const body = named ? `${index + 1}:${section[tier]}${suffix}` : `${index + 1}${suffix.trimStart()}`;
+    // Bold and inverse are both stripped at chalk level 0 (NO_COLOR, or a
+    // dumb terminal), which left no indication at all of which tab was
+    // selected. Brackets survive; the padding they replace keeps the width
+    // identical, so the bar does not shift between the two modes.
+    return { key: section.key, active, label: active ? `[${body}]` : ` ${body} `,
+      margin: index === sections.length - 1 || tier === "tight" || tier === "digits" ? 0 : tier === "full" ? 2 : 1,
+      color: section.color, dim: !active && section.quiet };
+  });
+  for (const tier of [...useShort ? [] : ["full"], "short", "compact", "tight"]) {
+    const entries = build(tier);
+    if (tabBarWidth(entries) <= cols) return entries;
+  }
+  return build("digits");
+}
+
+function TabBar({ entries }) {
   return e(
     Box,
     { flexDirection: "row" },
-    ...TABS.map((tab, i) => {
-      const active = i === activeIndex;
-      const count = counts[tab.key];
-      // A tab that has never resolved shows the spinner where its count will
-      // go, so the first load reads as "working" rather than "empty".
-      const suffix =
-        count == null
-          ? firstLoad[tab.key]
-            ? ` ${spin}`
-            : tabFailureSuffix({ count, failed: failed[tab.key], brokenCI: false })
-          : tabFailureSuffix({
-              count,
-              failed: failed[tab.key],
-              brokenCI: brokenCI[tab.key],
-            });
-      const name = useShort ? tab.short : tab.label;
-      // Bold and inverse are both stripped at chalk level 0 (NO_COLOR, or a
-      // dumb terminal), which left no indication at all of which tab was
-      // selected. Brackets survive; the padding they replace keeps the width
-      // identical, so the bar does not shift between the two modes.
-      const label = active ? `[${i + 1}:${name}${suffix}]` : ` ${i + 1}:${name}${suffix} `;
-      return e(
-        Box,
-        { key: tab.key, marginRight: 2 },
-        e(
-          Text,
-          {
-            bold: active,
-            inverse: active,
-            // A tab whose fetches are failing kept rendering its last good
-            // count at full confidence, and the error banner is only visible on
-            // the tab you have selected -- so a background tab could fail for an
-            // hour with nothing on screen to say so.
-            color: failed[tab.key] ? "redBright" : undefined,
-            dimColor: !active && !failed[tab.key],
-            wrap: "truncate-end",
-          },
-          label,
-        ),
-      );
-    }),
+    ...entries.map((entry) => e(
+      Box,
+      { key: entry.key, marginRight: entry.margin },
+      e(
+        Text,
+        {
+          bold: entry.active,
+          inverse: entry.active,
+          color: entry.color,
+          dimColor: entry.dim,
+          wrap: "truncate-end",
+        },
+        entry.label,
+      ),
+    )),
   );
 }
 
@@ -18472,6 +19256,108 @@ function App({ onCreateRemote = () => {} } = {}) {
   const { isRawModeSupported } = useStdin();
   const { exit, suspendTerminal } = useApp();
   const [activeIndex, setActiveIndex] = useState(runtime.initialTabIndex);
+  // Notifications is a view, not a data tab: `activeIndex` keeps naming the
+  // last data tab, so polling, cache and per-tab state never see a fifth key.
+  const [notificationsOpen, setNotificationsOpen] = useState(false);
+  const notificationsOpenRef = useRef(notificationsOpen);
+  notificationsOpenRef.current = notificationsOpen;
+  const [notificationsOffset, setNotificationsOffset] = useState(0);
+  const notificationLogRef = useRef(null);
+  notificationLogRef.current ??= createNotificationLog();
+  // Only the badge lives in state, and it changes only when the unread count or
+  // tone does: routine refreshes never re-render a closed view, which keeps an
+  // idle dashboard's frames byte-identical.
+  const [notificationBadge, setNotificationBadge] = useState(() => notificationLogRef.current.summary());
+  const notificationBadgeRef = useRef(notificationBadge);
+  const [, setNotificationVersion] = useState(0);
+  const notificationSnapshotRef = useRef(null);
+  const notificationDiffRef = useRef(null);
+  const notificationTimerRef = useRef(null);
+  const syncNotificationsRef = useRef(null);
+  const notificationInputsRef = useRef(null);
+  syncNotificationsRef.current = ({ force = false } = {}) => {
+    const log = notificationLogRef.current;
+    const nowMs = Date.now();
+    // Spinner and clock renders change none of the inputs; skip their diff.
+    const inputs = notificationSnapshotRef.current.inputs;
+    const previousInputs = notificationInputsRef.current;
+    const unchanged = !force && previousInputs?.length === inputs.length &&
+      inputs.every((value, index) => Object.is(value, previousInputs[index]));
+    notificationInputsRef.current = inputs;
+    const result = unchanged ? { begin: [], end: [], pending: notificationTimerRef.current?.due ?? null }
+      : diffNotificationSnapshots(notificationDiffRef.current, notificationSnapshotRef.current, nowMs);
+    if (!unchanged) notificationDiffRef.current = result.state;
+    for (const event of result.begin) log.record(event);
+    for (const key of result.end) log.end(key, nowMs);
+    // A condition can become due with nothing else re-rendering the pane.
+    if ((notificationTimerRef.current?.due ?? null) !== result.pending) {
+      clearTimeout(notificationTimerRef.current?.id);
+      notificationTimerRef.current = result.pending === null ? null : {
+        due: result.pending,
+        id: setTimeout(() => {
+          notificationTimerRef.current = null;
+          syncNotificationsRef.current?.({ force: true });
+        }, Math.max(0, result.pending - nowMs)),
+      };
+      notificationTimerRef.current?.id.unref?.();
+    }
+    if (notificationsOpenRef.current && !showHelpRef.current) {
+      log.markSeen();
+      if (result.begin.length > 0 || result.end.length > 0) setNotificationVersion((version) => version + 1);
+    }
+    // A failing tab is the moment GitHub's own status is worth a look.
+    if (result.begin.some((event) => event.level === "problem" || event.code === "network-outage")) {
+      void githubStatusRef.current?.checkNow();
+    }
+    const badge = log.summary();
+    if (badge.unread !== notificationBadgeRef.current.unread || badge.tone !== notificationBadgeRef.current.tone) {
+      notificationBadgeRef.current = badge;
+      setNotificationBadge(badge);
+    }
+  };
+  useEffect(() => { syncNotificationsRef.current(); });
+  const notificationPageRef = useRef({ pageRows: 1, maxOffset: 0 });
+  // GitHub platform status: started only here, inside the mounted dashboard,
+  // so --doctor, --version, --help and other non-TUI paths never request it.
+  const githubStatusRef = useRef(null);
+  const githubStatusConfigRef = useRef(null);
+  githubStatusConfigRef.current ??= githubStatusConfig(process.env, effectiveRuntimeHost());
+  const [githubStatus, setGithubStatus] = useState(() => ({ enabled: githubStatusConfigRef.current.enabled,
+    reason: githubStatusConfigRef.current.reason, summary: null, unavailable: false, nextAt: null, outage: false }));
+  useEffect(() => {
+    const monitor = createGitHubStatusMonitor({ config: githubStatusConfigRef.current,
+      log: notificationLogRef.current,
+      onChange: () => setGithubStatus(monitor.current()) });
+    githubStatusRef.current = monitor;
+    return () => {
+      monitor.stop();
+      githubStatusRef.current = null;
+    };
+  }, []);
+  const openNotifications = () => {
+    notificationLogRef.current.markSeen();
+    setNotificationsOffset(0);
+    setNotificationsOpen(true);
+    void githubStatusRef.current?.checkNow();
+  };
+  // Five positions: the four data tabs, then Notifications.
+  const selectPosition = (position) => {
+    if (position === TABS.length) {
+      if (!notificationsOpenRef.current) openNotifications();
+      return;
+    }
+    setNotificationsOpen(false);
+    setActiveIndex(position);
+  };
+  const stepPosition = (direction) => {
+    const positions = TABS.length + 1;
+    const current = notificationsOpenRef.current ? TABS.length : activeIndexRef.current;
+    selectPosition((current + direction + positions) % positions);
+  };
+  useEffect(() => () => {
+    clearTimeout(notificationTimerRef.current?.id);
+    syncNotificationsRef.current = null;
+  }, []);
   const [preferencePath] = useState(() => widthPreferencesPath());
   const [loadedWidthPreferences] = useState(() => loadWidthPreferences(preferencePath));
   const [widthOverrides, setWidthOverrides] = useState(() => loadedWidthPreferences.preferences);
@@ -18525,6 +19411,7 @@ function App({ onCreateRemote = () => {} } = {}) {
       host: runtimeIdentityCoordinator?.current()?.host ?? effectiveRuntimeHost(),
       cwd: process.cwd(),
       account: sshCacheIdentity ?? runtimeIdentityCoordinator?.current()?.accessKey ?? "unverified",
+      remoteUrls: runtimeRemoteUrls,
     }),
   );
   const [loadedCache] = useState(() => loadDashboardCache(cachePath, cacheTarget));
@@ -18865,14 +19752,9 @@ function App({ onCreateRemote = () => {} } = {}) {
   const noticeCause = activeRecovery ?? (noticeReason ? recoveryCause({
     reason: noticeReason === "other" ? "network-outage" : noticeReason,
     resource: noticeResource, sourceAt: noticeSourceAt,
-    retryAt: activeGovernorDecision?.retryAt ?? activeGovernorDecision?.resetMs ??
-      activeGovernorDecision?.notBefore ?? null,
+    retryAt: decisionRetryAt(activeGovernorDecision),
     origin: tabError ? "source" : "coordination", tab: tabError ? tab.key : null,
   }) : null);
-  const recoveryLines = showCoordinationNotice && noticeCause
-    ? presentRecovery(noticeCause, { nowMs: now.getTime(), cols, hasSnapshot: items !== null })
-    : [!remoteSetup && displayError ? displayError : ""];
-  const noticeTone = showCoordinationNotice ? ATTENTION : displayError ? ERROR_TEXT : undefined;
   // Data can be arbitrarily old without anything on screen saying so: a failing
   // poll only surfaces on the tab you have selected, and after a laptop sleep
   // every pane is plausible and wrong. Threshold-gated and minute-granular on
@@ -18970,34 +19852,74 @@ function App({ onCreateRemote = () => {} } = {}) {
       : ['CI evidence',...ciLines].flatMap(line=>wrapPanelText(line,Math.max(1,cols-5))).slice(0,Math.max(1,rows-6))
     : contextualPanelLayout(presentation, { cols, rows });
 
+  // One snapshot per render feeds the notification history; diffing it in an
+  // effect avoids instrumenting every error, recovery and Security-note writer.
+  const notificationDisconnected = statusDisconnected ? runtime.connect === null ? "identity-unavailable"
+    : activeGovernorDecision?.reason === "app-auth" ? "app-auth" : "disconnected" : null;
+  notificationSnapshotRef.current = {
+    // Everything the snapshot is built from, compared by identity before diffing.
+    inputs: [errors, acquisitionFailures, governorDecisions, recoveryCauses, securityNotes, failureContext,
+      notificationDisconnected, ...TABS.map(({ key }) => lastOkRef.current[key] ?? null)],
+    tabs: Object.fromEntries(TABS.map(({ key }) => {
+      const decision = governorDecisions[key];
+      return [key, { lastOk: lastOkRef.current[key] ?? null, error: errors[key],
+        failure: acquisitionFailures[key] ?? null,
+        paused: decision?.mode === "paused" || decision?.coordinationError ? decision.reason ?? null : null }];
+    })),
+    recovery: recoveryCauses,
+    securityNotes,
+    failureContext,
+    disconnected: notificationDisconnected,
+  };
+
   const tableVisible = !ciView && !attentionView && Array.isArray(items) && items.length > 0;
   const tableNoticeCapacity = Math.max(0, rows - 9);
-  const needsTableContext = ["failed", "overdue", "waiting"].includes(presentation.state);
-  const shortAction = /gh-glance --doctor/.test(presentation.action) ? "gh-glance --doctor"
-    : /gh auth/.test(presentation.action) ? "Run gh auth status" : presentation.action;
-  const tableNotices = needsTableContext
-    ? tableNoticeCapacity < 4
-      ? tableNoticeCapacity === 1 ? [shortAction]
-        : showCoordinationNotice && noticeCause
-          ? [noticeCause.summary, shortAction, presentation.sourceCheck]
-          : [shortAction, presentation.sourceCheck, presentation.title]
-      : [presentation.title, presentation.sourceCheck, ...recoveryLines.filter(Boolean)]
-    : recoveryLines;
+  // Only what needs the user's hand takes rows from a visible table; every
+  // other status event is in the Notifications view.
+  const critical = criticalInlineLines({ cause: noticeCause, showCause: showCoordinationNotice,
+    tabError: remoteSetup ? null : tabError, displayError, capacity: tableNoticeCapacity,
+    nowMs: now.getTime(), cols, hasSnapshot: items !== null });
+  const noticeTone = critical.source === "cause" ? ATTENTION : critical.source === "error" ? ERROR_TEXT : undefined;
   const featureLines = focus ? [presentation.title, ...(focus.error ? [focus.error] : []),
     ...focusDisclosureLines(focusMessage,focus.semantic?.message).flatMap(line=>line.split(/(?<=\.) /u)), ...featureKeyLines(focus)]
     .flatMap(line=>wrapPanelText(line, Math.max(1,cols-5))) : [];
-  const noticeLines = [...new Set([...(focus ? featureLines : []), ...(showCoordinationNotice ? tableNotices : []),
+  const noticeLines = [...new Set([...(focus ? featureLines : []), ...critical.lines,
     ...(setupView?.title ? [setupView.title, setupView.action, ...setupView.notes] : []),
-    ...tableNotices, ...(!focus && featureNotice ? [featureNotice] : [])])].filter(Boolean).slice(0, tableNoticeCapacity);
-  const visibleSecurityLines = tab.key === "security"
-    ? securityLines.slice(0, Math.max(0, tableNoticeCapacity - noticeLines.length)) : [];
-  const extraLines = !showHelp && !remoteSetup && tableVisible
-    ? noticeLines.length + visibleSecurityLines.length : 0;
+    ...(!focus && featureNotice ? [featureNotice] : [])])].filter(Boolean).slice(0, tableNoticeCapacity);
+  const extraLines = !showHelp && !remoteSetup && tableVisible ? noticeLines.length : 0;
   // Tab strip, divider, frame edges, footer and terminal guard use six rows.
   // Table headers alone need two more. The same budget drives navigation.
   const bodyRows = Math.max(1, rows - 6 - (tableVisible && !showHelp ? 2 : 0) - extraLines);
+  const notificationRows = Math.max(1, rows - 6);
+  const notificationStatusLine = notificationsOpen ? githubStatusLine(githubStatus, now.getTime()) : "";
+  let notificationView = null;
+  if (notificationsOpen) {
+    // Open waits show when they retry next, from the live cause or hold.
+    const liveRetry = {};
+    for (const cause of Object.values(recoveryCauses)) {
+      if (cause?.code && Number.isFinite(cause.retryAt)) liveRetry[cause.code] = cause.retryAt;
+    }
+    for (const decision of Object.values(governorDecisions)) {
+      const retryAt = decisionRetryAt(decision);
+      if (decision?.reason && Number.isFinite(retryAt)) liveRetry[decision.reason] ??= retryAt;
+    }
+    notificationView = notificationViewLines({
+      entries: notificationLogRef.current.list(), statusLine: notificationStatusLine, nowMs: now.getTime(),
+      capacity: notificationRows, offset: notificationsOffset, liveRetry,
+    });
+  }
+  notificationPageRef.current = { pageRows: notificationView?.pageRows ?? 1,
+    maxOffset: notificationView?.maxOffset ?? 0 };
   let helpPages = [];
-  if (showHelp) {
+  if (showHelp && notificationsOpen) {
+    helpPages = contextHelpPages({ view: {
+      title: NOTIFICATIONS_LABEL.full,
+      action: "Press 1-4 or Esc to return to a section; Up/Down scroll; r checks GitHub status.",
+      sourceCheck: notificationStatusLine,
+      explanation: "Lines above a table appear only when you must act. Waits, refreshes, failed refreshes and cleared causes are listed here, newest first.",
+      notes: [],
+    }, target: selectedTarget, tab: "notifications" }, keyTableLines(), cols - 5, bodyRows);
+  } else if (showHelp) {
     const fullDiagnostic = formatTabError(tabError, failureContext);
     const helpView = { ...presentation, notes: [
       ...(fullDiagnostic ? [fullDiagnostic] : []),
@@ -19434,6 +20356,33 @@ function App({ onCreateRemote = () => {} } = {}) {
         }
         // Width mode owns every other key. In particular, digits, arrows, Tab,
         // Enter and r must never fall through to their ordinary meanings.
+      } else if (notificationsOpenRef.current && !showHelpRef.current) {
+        // The view owns its keys; data-tab actions (Enter, /, s, g, w, d, a)
+        // have nothing to act on here and are ignored rather than applied to
+        // the hidden tab.
+        const { pageRows, maxOffset } = notificationPageRef.current;
+        if (input === "?") {
+          setHelpPage(0);
+          setShowHelp(true);
+        } else if (key.escape) {
+          setNotificationsOpen(false);
+        } else if (input.length === 1 && input >= "1" && input <= String(TABS.length)) {
+          selectPosition(Number(input) - 1);
+        } else if (key.tab && key.shift || key.leftArrow) {
+          stepPosition(-1);
+        } else if (key.tab || key.rightArrow) {
+          stepPosition(1);
+        } else if (key.downArrow || input === "j" || key.upArrow || input === "k" || key.pageDown || key.pageUp) {
+          const step = key.pageDown ? pageRows : key.pageUp ? -pageRows
+            : key.downArrow || input === "j" ? 1 : -1;
+          setNotificationsOffset((current) => Math.max(0, Math.min(maxOffset, current + step)));
+        } else if (input === "r" || input === "R") {
+          // In this view, r asks GitHub's status page, not the hidden data tab.
+          void githubStatusRef.current?.checkNow();
+        }
+      } else if (key.escape && showHelpRef.current && notificationsOpenRef.current) {
+        // The view's help says Esc returns; it must not quit from here.
+        setShowHelp(false);
       } else if (key.escape && showHelpRef.current && featureRef.current) {
         setShowHelp(false);
       } else if (key.escape && featureRef.current?.semantic?.consent) {
@@ -19522,6 +20471,7 @@ function App({ onCreateRemote = () => {} } = {}) {
       } else if (input==='d' && TABS[activeIndexRef.current].key==='actions') {
         void ciEvidenceRef.current?.('open');
       } else if (featureRef.current?.mode==='ci' && input==='r') {
+        retryPausedTransport(runtimeIdentityCoordinator);
         ciControllerRef.current?.abort();attentionControllerRef.current?.abort();jevOperationRef.current=null;runtimeJevSession?.clear();setFeature(null);void fetchTabRef.current?.('actions',manualRefreshRequest(refreshIntent(input)));
       } else if (featureRef.current?.mode==='focus' && input==='x') {
         jevOperationRef.current=null;const current=featureRef.current;
@@ -19570,15 +20520,16 @@ function App({ onCreateRemote = () => {} } = {}) {
         // validators: `r` on a quiet repository answers 304 and costs nothing,
         // which is exactly when the key is most likely to be pressed.
         const request = manualRefreshRequest(refreshIntent(input));
+        // The explicit retry a paused transport waits for. A collector client has
+        // no local coordinator; its collector resumes on the refresh it receives.
+        if (request) retryPausedTransport(runtimeIdentityCoordinator);
         if (request) fetchTabRef.current?.(TABS[activeIndexRef.current].key, request);
-      } else if (input.length === 1 && input >= "1" && input <= String(TABS.length)) {
-        setActiveIndex(Number(input) - 1);
-      } else if (key.tab && key.shift) {
-        setActiveIndex((i) => (i - 1 + TABS.length) % TABS.length);
+      } else if (input.length === 1 && input >= "1" && input <= String(TABS.length + 1)) {
+        selectPosition(Number(input) - 1);
+      } else if (key.tab && key.shift || key.leftArrow) {
+        stepPosition(-1);
       } else if (key.tab || key.rightArrow) {
-        setActiveIndex((i) => (i + 1) % TABS.length);
-      } else if (key.leftArrow) {
-        setActiveIndex((i) => (i - 1 + TABS.length) % TABS.length);
+        stepPosition(1);
       }
     },
     // `isActive` has to be coerced: ink only skips raw mode when the flag is
@@ -20054,6 +21005,17 @@ function App({ onCreateRemote = () => {} } = {}) {
             setSecurityBlind(true);
             return;
           }
+          // Every Security source replayed its capability backoff: no request
+          // was made, so nothing was observed. Keep the displayed rows, the
+          // freshness clock and the peers' snapshot as they are (plan D6), and
+          // let the ordinary cadence retry. The request itself is answered.
+          if (result?.sourceObserved === false) {
+            await cancelAcquisition(acquisition);
+            requestedTabs.delete(key);
+            rescheduleTab(key, completedAt);
+            setErrors((x) => (x[key] === null ? x : { ...x, [key]: null }));
+            return;
+          }
           // The shared nonce/generation is the publication fence. A superseded
           // owner must not update any local freshness, rows, cadence, or cache.
           const publicationView = stagedAcquisitionPublicationView({
@@ -20152,7 +21114,9 @@ function App({ onCreateRemote = () => {} } = {}) {
             const recovery = requestFailureRecovery(err, verdict);
             recordRuntimeRecovery(key, recovery.reason, { origin: recovery.origin, retryAt });
           }
-          if (verdict === "rate-limited") {
+          // A secondary limit is held by the shared transport cooldown, not by a
+          // resource block until the primary reset.
+          if (verdict === "rate-limited" && !secondaryThrottleEvidence(err)) {
             const snapshot = inspectGovernor(scope, Date.now());
             const costs = tabRequestCost(key);
             const blocks = [];
@@ -20237,6 +21201,7 @@ function App({ onCreateRemote = () => {} } = {}) {
     const inFlightStartedAt = {};
     const wakeScheduler = createWakeScheduler();
     let scope = null;
+    let notificationsSeeded = false;
     let scopeFailure = null;
     let cleanupScope = null;
     let registeredScopeHash = null;
@@ -20304,6 +21269,10 @@ function App({ onCreateRemote = () => {} } = {}) {
         entityRef.current.set(entity.key, { etag: entity.etag, body: entity.body });
       }
       const sameRows = JSON.stringify(dataRef.current[key]) === JSON.stringify(snapshot.rows);
+      const sameContent = sameRows && (key !== "security" ||
+        JSON.stringify(securityNotesRef.current) === JSON.stringify(snapshot.securityNotes ?? []) &&
+        securityBlindRef.current === (snapshot.securityBlind === true));
+      rawRef.current[key] = adoptedAcquisitionRaw(rawRef.current[key], snapshot, sameContent);
       if (!sameRows) setData((current) => ({ ...current, [key]: snapshot.rows }));
       setMeta((current) => current[key]?.at === snapshotMeta.at &&
         current[key]?.truncated === snapshotMeta.truncated
@@ -20312,7 +21281,7 @@ function App({ onCreateRemote = () => {} } = {}) {
         const accessKey = identity()?.accessKey;
         if (accessKey) {
           for (const [sourceKey, capability] of Object.entries(snapshot.capabilities ?? {})) {
-            alertBackoff.set(`${accessKey}\0${sourceKey}`, {
+            alertBackoff.set(backoffStorageKey(sourceKey, accessKey), {
               ...capability,
               until: performance.now() + Math.max(0, capability.until - Date.now()),
             });
@@ -20860,10 +21829,16 @@ function App({ onCreateRemote = () => {} } = {}) {
         scope = createQuotaScope(current, { root: runtimeIdentityCoordinator.root, identityProvider: identity });
         cleanupScope = { ...scope, identityProvider: null };
         const savedRecovery = readRecoveryTransitions(scope);
+        // Earlier transitions become dimmed history, once per pane, from the
+        // journal just read; collector clients have no journal and start empty.
+        if (!notificationsSeeded) {
+          notificationsSeeded = true;
+          seedNotificationsFromJournal(notificationLogRef.current, scope, () => savedRecovery);
+        }
         recoveryRef.current = savedRecovery.status === "healthy"
           ? { ...savedRecovery.current } : { core: null, graphql: null };
         setRecoveryCauses(recoveryRef.current);
-        const nextTarget = dashboardCacheTarget({ repo: runtime.repo, ghRepo: process.env.GH_REPO, host: current.host, account: current.accessKey });
+        const nextTarget = dashboardCacheTarget({ repo: runtime.repo, ghRepo: process.env.GH_REPO, host: current.host, account: current.accessKey, remoteUrls: runtimeRemoteUrls });
         // The mount-time target had to guess the account, and guesses
         // "unverified" whenever the bounded warm resolution above did not land
         // in time -- so a session that has rows on disk can start with none.
@@ -21985,6 +22960,21 @@ function App({ onCreateRemote = () => {} } = {}) {
     return () => clearInterval(timer);
   }, [showCachedAge]);
 
+  // Collector mode returns from the acquisition effect before any standalone
+  // wake can advance `now`, which froze running TIME and every UPDATED age
+  // while connected. Apply the standalone rule from a display-only timer: every
+  // second while a run is in progress, otherwise at most once a minute (a same
+  // Date leaves React's render bail-out intact). It never feeds freshness.
+  const collectorDisplayClock = runtime.connect !== null;
+  useEffect(() => {
+    if (!collectorDisplayClock) return;
+    const timer = setInterval(() => setNow((previous) => {
+      const at = Date.now();
+      return hasInProgressRef.current || at - previous.getTime() >= 60_000 ? new Date(at) : previous;
+    }), 1000);
+    return () => clearInterval(timer);
+  }, [collectorDisplayClock]);
+
   const allItems = items ?? [];
   const tabOffsetRaw = offset[tab.key] ?? 0;
   const selectedKey = selected[tab.key] ?? null;
@@ -22024,8 +23014,11 @@ function App({ onCreateRemote = () => {} } = {}) {
   }, [reconciledSelection.key, reconciledSelection.offset, selectedKey, tabOffsetRaw, tab.key]);
   // Bottom-right of the frame, lazygit style: how much of the tab you can
   // currently see out of how much there is.
-  const countLabel =
-    !tableVisible
+  const notificationSummary = notificationsOpen ? notificationLogRef.current.summary() : null;
+  const countLabel = notificationSummary
+    ? notificationSummary.truncated ? `Showing the latest ${NOTIFICATION_LOG_MAX} events`
+      : `${notificationSummary.size} ${notificationSummary.size === 1 ? "event" : "events"}`
+    : !tableVisible
       ? null
       : tabOffset > 0
         ? `${tabOffset + 1}-${tabOffset + visibleItems.length} of ${counts[tab.key]}`
@@ -22041,8 +23034,9 @@ function App({ onCreateRemote = () => {} } = {}) {
 
   // The existing resolver also supplies inferred targets without another lookup.
   // Complete target and host remain reachable in help when this edge is short.
-  const withTarget = `${tab.label} · ${selectedTarget.label}`;
-  const topLabel = frameCols - 3 - withTarget.length >= 0 ? withTarget : tab.label;
+  const viewLabel = notificationsOpen ? NOTIFICATIONS_LABEL.full : tab.label;
+  const withTarget = `${viewLabel} · ${selectedTarget.label}`;
+  const topLabel = frameCols - 3 - withTarget.length >= 0 ? withTarget : viewLabel;
 
   // Fixed columns deliberately do not shrink, so BRANCH and TIME stay readable
   // at ordinary widths. Narrow panes drop columns instead, which keeps the
@@ -22131,13 +23125,18 @@ function App({ onCreateRemote = () => {} } = {}) {
     Box,
     { flexDirection: "column", width: frameCols, height: frameRows },
     e(TabBar, {
-      activeIndex,
-      counts,
-      brokenCI,
-      firstLoad,
-      failed,
-      spin,
-      useShort: useShortLabels,
+      entries: tabBarEntries({
+        cols: frameCols,
+        counts,
+        brokenCI,
+        firstLoad,
+        failed,
+        spin,
+        useShort: useShortLabels,
+        activeIndex: notificationsOpen ? TABS.length : activeIndex,
+        // An active GitHub outage keeps the badge red even after it was read.
+        notifications: githubStatus.outage ? { ...notificationBadge, tone: "red" } : notificationBadge,
+      }),
     }),
     e(Divider, { width: frameCols }),
     e(PanelEdge, { width: frameCols, top: true, label: topLabel, labelColor: TITLE_COLOR }),
@@ -22167,20 +23166,20 @@ function App({ onCreateRemote = () => {} } = {}) {
       showHelp &&
         (helpPages[visibleHelpPage] ?? [])
           .map((line, i) => e(Text, { key: `help${i}`, wrap: "truncate-end" }, line)),
+      !showHelp && notificationView &&
+        notificationView.lines.map((line, index) => e(Text, {
+          key: `notification:${index}`, wrap: "truncate-end", dimColor: line.dim,
+          color: line.level === "status" ? TITLE_COLOR : line.dim ? undefined
+            : line.level === "wait" ? ATTENTION : ["action", "problem"].includes(line.level) ? ERROR_TEXT : undefined,
+        }, line.text)),
       !showHelp &&
+        !notificationsOpen &&
         tooNarrow &&
         e(Text, { dimColor: true, wrap: "truncate-end" }, "too narrow"),
-      ...(showHelp || !tableVisible ? [] : noticeLines).map((line, index) =>
+      ...(showHelp || notificationsOpen || !tableVisible ? [] : noticeLines).map((line, index) =>
         e(Text, { key: `recovery:${index}`, color: noticeTone, wrap: "truncate-end" }, line)),
       !showHelp &&
-        !tooNarrow &&
-        !remoteSetup &&
-        tableVisible &&
-        tab.key === "security" &&
-        visibleSecurityLines.map((note, i) =>
-          e(Text, { key: i, dimColor: true, wrap: "truncate-end" }, note),
-        ),
-      !showHelp &&
+        !notificationsOpen &&
         !tooNarrow &&
         remoteSetup &&
         (interactive ? REMOTE_SETUP_LINES : REMOTE_SETUP_NONINTERACTIVE_LINES).map(
@@ -22198,6 +23197,7 @@ function App({ onCreateRemote = () => {} } = {}) {
             ),
         ),
       !showHelp &&
+        !notificationsOpen &&
         !tooNarrow &&
         !remoteSetup &&
         tableVisible &&
@@ -22206,7 +23206,7 @@ function App({ onCreateRemote = () => {} } = {}) {
           selectedWidthKey: resizeRef.current.active ? selectedWidthKey : null,
           headerRef,
         }),
-      ...(tooNarrow || showHelp || remoteSetup || ciView || attentionView ? [] : visibleItems).map((item) => {
+      ...(tooNarrow || showHelp || notificationsOpen || remoteSetup || ciView || attentionView ? [] : visibleItems).map((item) => {
         const key = itemKey(item);
         return e(
           RowBoundary,
@@ -22227,7 +23227,7 @@ function App({ onCreateRemote = () => {} } = {}) {
           }),
         );
       }),
-      !showHelp && !remoteSetup && !tableVisible &&
+      !showHelp && !notificationsOpen && !remoteSetup && !tableVisible &&
         panelLines.map((line, index) => e(Text, {
           key: `context:${index}`, wrap: "truncate-end",
           bold: index === 0, color: index === 0 ? TITLE_COLOR : undefined,
@@ -22247,17 +23247,18 @@ function App({ onCreateRemote = () => {} } = {}) {
       nowMs: now.getTime(),
       interactive,
       cols: frameCols,
-      remoteSetup,
-      feature: attentionView ?? ciView ?? focus,
+      remoteSetup: remoteSetup && !notificationsOpen,
+      feature: notificationsOpen ? null : attentionView ?? ciView ?? focus,
       widthMode: resizeRef.current.active,
       widthColumn: selectedWidthColumn,
       widthSaveError,
-      canMove: allItems.length > 0,
+      canMove: notificationsOpen ? (notificationView?.maxOffset ?? 0) > 0 : allItems.length > 0,
       canOpen:
+        !notificationsOpen &&
         selectedKey !== null &&
         OPENABLE.includes(tab.key) &&
         allItems.some((item) => itemKey(item) === selectedKey),
-      canResize: fullHeaderVisible,
+      canResize: !notificationsOpen && fullHeaderVisible,
     }),
   );
 }
@@ -22637,12 +23638,14 @@ export {
   maintainControlLease,
   claimProbe,
   classifyThrottle,
+  secondaryThrottleEvidence,
   applyTransportCooldown,
   clearTransportThrottle,
   emptyTransportThrottle,
   throttleLadderMs,
   transportCooldownDeadline,
   retryThrottledTransport,
+  retryPausedTransport,
   THROTTLE_LADDER_MS,
   THROTTLE_PAUSE_AFTER,
   MANUAL_GRANT_STREAK_LIMIT,
@@ -22806,6 +23809,7 @@ export {
   saveDashboardCache,
   mergeDashboardCacheSnapshots,
   nextSecurityRaw,
+  adoptedAcquisitionRaw,
   shouldCheckpointFreshness,
   ACQUISITION_STORE_VERSION,
   ACQUISITION_CLAIM_TTL_MS,
@@ -22876,6 +23880,25 @@ export {
   collectorSourceAdvanced,
   cleanupQueueForResource,
   presentRecovery,
+  RECOVERY_COPY,
+  NOTICE_LEVELS,
+  NOTIFICATION_LOG_MAX,
+  noticeLevel,
+  fetchErrorLevel,
+  createNotificationLog,
+  notificationConditions,
+  diffNotificationSnapshots,
+  seedNotificationsFromJournal,
+  criticalInlineLines,
+  notificationViewLines,
+  tabBarEntries,
+  tabBarWidth,
+  GITHUB_STATUS_URL,
+  GITHUB_STATUS_MAX_BYTES,
+  githubStatusConfig,
+  fetchGitHubStatus,
+  githubStatusLine,
+  createGitHubStatusMonitor,
   dashboardPresentation,
   contextualPanelLayout,
   dashboardTarget,