@dxos/plugin-github 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/plugin-github",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "DXOS plugin that integrates GitHub as a sync source via the generic Integration mechanism.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -134,42 +134,42 @@
     "@codemirror/state": "^6.7.6",
     "@codemirror/view": "^6.43.13",
     "effect": "4.0.0",
-    "@dxos/ai": "0.13.0",
-    "@dxos/app-framework": "0.13.0",
-    "@dxos/app-graph": "0.13.0",
-    "@dxos/app-toolkit": "0.13.0",
-    "@dxos/compute": "0.13.0",
-    "@dxos/echo": "0.13.0",
-    "@dxos/echo-query": "0.13.0",
-    "@dxos/echo-react": "0.13.0",
-    "@dxos/effect": "0.13.0",
-    "@dxos/errors": "0.13.0",
-    "@dxos/graph": "0.13.0",
-    "@dxos/keys": "0.13.0",
-    "@dxos/link": "0.13.0",
-    "@dxos/lit-ui": "0.13.0",
-    "@dxos/log": "0.13.0",
-    "@dxos/plugin-connector": "0.13.0",
-    "@dxos/plugin-crx": "0.13.0",
-    "@dxos/plugin-markdown": "0.13.0",
-    "@dxos/plugin-preview": "0.13.0",
-    "@dxos/plugin-space": "0.13.0",
-    "@dxos/protocols": "0.13.0",
-    "@dxos/react-client": "0.13.0",
-    "@dxos/react-ui": "0.13.0",
-    "@dxos/react-ui-attention": "0.13.0",
-    "@dxos/react-ui-components": "0.13.0",
-    "@dxos/react-ui-editor": "0.13.0",
-    "@dxos/react-ui-form": "0.13.0",
-    "@dxos/react-ui-list": "0.13.0",
-    "@dxos/react-ui-markdown": "0.13.0",
-    "@dxos/react-ui-masonry": "0.13.0",
-    "@dxos/react-ui-menu": "0.13.0",
-    "@dxos/react-ui-query": "0.13.0",
-    "@dxos/types": "0.13.0",
-    "@dxos/ui-editor": "0.13.0",
-    "@dxos/ui-types": "0.13.0",
-    "@dxos/util": "0.13.0"
+    "@dxos/ai": "0.14.0",
+    "@dxos/app-framework": "0.14.0",
+    "@dxos/app-graph": "0.14.0",
+    "@dxos/app-toolkit": "0.14.0",
+    "@dxos/compute": "0.14.0",
+    "@dxos/echo": "0.14.0",
+    "@dxos/echo-query": "0.14.0",
+    "@dxos/echo-react": "0.14.0",
+    "@dxos/effect": "0.14.0",
+    "@dxos/errors": "0.14.0",
+    "@dxos/graph": "0.14.0",
+    "@dxos/keys": "0.14.0",
+    "@dxos/link": "0.14.0",
+    "@dxos/lit-ui": "0.14.0",
+    "@dxos/log": "0.14.0",
+    "@dxos/plugin-connector": "0.14.0",
+    "@dxos/plugin-crx": "0.14.0",
+    "@dxos/plugin-markdown": "0.14.0",
+    "@dxos/plugin-preview": "0.14.0",
+    "@dxos/plugin-space": "0.14.0",
+    "@dxos/protocols": "0.14.0",
+    "@dxos/react-client": "0.14.0",
+    "@dxos/react-ui": "0.14.0",
+    "@dxos/react-ui-attention": "0.14.0",
+    "@dxos/react-ui-components": "0.14.0",
+    "@dxos/react-ui-editor": "0.14.0",
+    "@dxos/react-ui-form": "0.14.0",
+    "@dxos/react-ui-list": "0.14.0",
+    "@dxos/react-ui-markdown": "0.14.0",
+    "@dxos/react-ui-menu": "0.14.0",
+    "@dxos/react-ui-masonry": "0.14.0",
+    "@dxos/react-ui-query": "0.14.0",
+    "@dxos/types": "0.14.0",
+    "@dxos/ui-editor": "0.14.0",
+    "@dxos/ui-types": "0.14.0",
+    "@dxos/util": "0.14.0"
   },
   "devDependencies": {
     "@effect/atom-react": "4.0.0",
@@ -179,11 +179,11 @@
     "react": "~19.2.7",
     "react-dom": "~19.2.7",
     "vite": "^8.2.2",
-    "@dxos/echo-client": "0.13.0",
-    "@dxos/plugin-client": "0.13.0",
-    "@dxos/plugin-testing": "0.13.0",
-    "@dxos/random": "0.13.0",
-    "@dxos/react-ui-editor": "0.13.0"
+    "@dxos/echo-client": "0.14.0",
+    "@dxos/plugin-client": "0.14.0",
+    "@dxos/plugin-testing": "0.14.0",
+    "@dxos/random": "0.14.0",
+    "@dxos/react-ui-editor": "0.14.0"
   },
   "peerDependencies": {
     "@effect/atom-react": "4.0.0",

package/src/components/PullRequestOverview/ArtifactPill.tsx

@@ -67,7 +67,7 @@ export const ArtifactPill = ({ artifact, children }: ArtifactPillProps) => {
           size='sm'
           classNames='bg-input-surface text-fg font-normal ring-inset ring ring-neutral-border hover:bg-hover-surface hover:ring-info-border align-baseline'
           icon={artifactIcon[artifact.kind]}
-          iconClassNames={artifact.kind === 'video' ? 'text-violet-500' : 'text-sky-500'}
+          iconClassNames={artifact.kind === 'video' ? 'text-violet-text' : 'text-sky-text'}
           label={label}
           data-testid='pull-request.artifact.pill'
         />

package/src/components/PullRequestOverview/CheckRunList.test.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { formatDuration } from './CheckRunList.tsx';
+
+describe('formatDuration', () => {
+  const startedAt = '2026-10-08T10:00:00Z';
+
+  test('measures a finished run from start to completion', ({ expect }) => {
+    expect(formatDuration(startedAt, '2026-10-08T10:04:12Z')).toBe('4m 12s');
+    expect(formatDuration(startedAt, '2026-10-08T10:00:42Z')).toBe('42s');
+  });
+
+  test('measures a running run up to now', ({ expect }) => {
+    expect(formatDuration(startedAt, undefined, Date.parse('2026-10-08T10:12:05Z'))).toBe('12m 5s');
+  });
+
+  test('prefers completion over now', ({ expect }) => {
+    expect(formatDuration(startedAt, '2026-10-08T10:01:00Z', Date.parse('2026-10-08T11:00:00Z'))).toBe('1m 0s');
+  });
+
+  test('is undefined without a start, or without an end of either kind', ({ expect }) => {
+    expect(formatDuration(undefined, '2026-10-08T10:01:00Z')).toBeUndefined();
+    expect(formatDuration(startedAt)).toBeUndefined();
+  });
+});

package/src/components/PullRequestOverview/CheckRunList.tsx

@@ -2,7 +2,7 @@
 // Copyright 2026 DXOS.org
 //
 
-import React, { useMemo } from 'react';
+import React, { useEffect, useMemo, useState } from 'react';
 
 import { Listbox } from '@dxos/react-ui-list';
 import * as Hooks from '@dxos/react-ui/Hooks';
@@ -22,12 +22,16 @@ const outcomeIcon: Record<GitHubOperation.CheckOutcome, { icon: string; classNam
 // What needs attention first: a failure is the reason to open the list, a running check the next.
 const outcomeOrder: GitHubOperation.CheckOutcome[] = ['failure', 'pending', 'success', 'neutral', 'skipped'];
 
-/** `4m 12s`, or undefined for a run that has not both started and finished. */
-export const formatDuration = (startedAt?: string, completedAt?: string): string | undefined => {
-  if (!startedAt || !completedAt) {
+/**
+ * `4m 12s` from start to finish, or to `now` for a run still in progress;
+ * undefined for a run that has not started, or has not finished when no `now` is given.
+ */
+export const formatDuration = (startedAt?: string, completedAt?: string, now?: number): string | undefined => {
+  const end = completedAt ? Date.parse(completedAt) : now;
+  if (!startedAt || end === undefined) {
     return undefined;
   }
-  const seconds = Math.max(0, Math.round((Date.parse(completedAt) - Date.parse(startedAt)) / 1000));
+  const seconds = Math.max(0, Math.round((end - Date.parse(startedAt)) / 1000));
   if (Number.isNaN(seconds)) {
     return undefined;
   }
@@ -35,6 +39,20 @@ export const formatDuration = (startedAt?: string, completedAt?: string): string
   return minutes > 0 ? `${minutes}m ${seconds % 60}s` : `${seconds}s`;
 };
 
+/** The current time, re-rendering once a second while `active` so elapsed times stay current. */
+const useNow = (active: boolean): number => {
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    if (!active) {
+      return;
+    }
+    setNow(Date.now());
+    const interval = setInterval(() => setNow(Date.now()), 1_000);
+    return () => clearInterval(interval);
+  }, [active]);
+  return now;
+};
+
 /** Sorts runs by what needs attention, then by name so shards read in order. */
 export const sortCheckRuns = (runs: readonly GitHubOperation.CheckRun[]): GitHubOperation.CheckRun[] =>
   [...runs].sort(
@@ -53,6 +71,7 @@ export const CheckRunList = ({ runs }: CheckRunListProps) => {
   const { t } = Hooks.useTranslation(meta.profile.key);
   const sorted = useMemo(() => (runs ? sortCheckRuns(runs) : undefined), [runs]);
   const summary = useCheckSummary(runs);
+  const now = useNow(runs?.some((run) => run.outcome === 'pending' && run.startedAt) ?? false);
 
   if (!sorted || sorted.length === 0) {
     return <Status.Empty>{t(sorted ? 'no-checks.message' : 'checks-loading.message')}</Status.Empty>;
@@ -63,7 +82,7 @@ export const CheckRunList = ({ runs }: CheckRunListProps) => {
       <Listbox.Content aria-label={summary} data-testid='pull-request.checks'>
         {sorted.map((run) => {
           const { icon, classNames } = outcomeIcon[run.outcome];
-          const duration = formatDuration(run.startedAt, run.completedAt);
+          const duration = formatDuration(run.startedAt, run.completedAt, run.outcome === 'pending' ? now : undefined);
           // GitHub's own word when it says more than the outcome: `timed out` rather than `failed`.
           const detail =
             run.conclusion && run.conclusion !== run.outcome && run.conclusion !== 'failure'
@@ -72,7 +91,9 @@ export const CheckRunList = ({ runs }: CheckRunListProps) => {
           const outcome =
             run.outcome === 'skipped'
               ? t('check-outcome.skipped.label')
-              : (duration ?? t(`check-outcome.${run.outcome}.label`));
+              : run.outcome === 'pending'
+                ? [t('check-outcome.pending.label'), duration].filter(Boolean).join(' · ')
+                : (duration ?? t(`check-outcome.${run.outcome}.label`));
           const url = run.url;
           return (
             <Listbox.Item

package/src/components/PullRequestStatus/PullRequestStatus.tsx

@@ -5,6 +5,7 @@
 import React from 'react';
 
 import * as Hooks from '@dxos/react-ui/Hooks';
+import * as Layout from '@dxos/react-ui/Layout';
 import { type PullRequest } from '@dxos/types';
 
 import { meta } from '#meta';
@@ -43,16 +44,18 @@ export type PullRequestStatusProps = {
 export const PullRequestStatus = ({ reference, title, state, review, ci }: PullRequestStatusProps) => {
   const { t } = Hooks.useTranslation(meta.profile.key);
   return (
-    <div
+    <Layout.Flex
+      align='center'
+      gap='sm'
       role='status'
-      className='flex items-center gap-2 px-3 py-1.5 border-b border-separator-subtle text-sm min-w-0'
+      classNames='px-3 py-1.5 border-b border-separator-subtle text-sm min-w-0'
       data-testid='pull-request.status'
     >
       <span className='dx-tag dx-tag-inline shrink-0' data-hue='neutral'>
         {reference}
       </span>
       {title && <span className='truncate grow'>{title}</span>}
-      <div className='flex items-center gap-2 shrink-0 ml-auto'>
+      <Layout.Flex align='center' gap='sm' classNames='shrink-0 ml-auto'>
         {state && (
           <span className='dx-tag dx-tag-inline' data-hue={stateHue[state]} data-testid='pull-request.status.state'>
             {t(`pull-request-state.${state}.label`)}
@@ -75,7 +78,7 @@ export const PullRequestStatus = ({ reference, title, state, review, ci }: PullR
           {ci ? t(`ci-status.${ci.state}.label`) : t('ci-status.unknown.label')}
           {ci && ci.checks.total > 0 && ` ${ci.checks.passed}/${ci.checks.total}`}
         </span>
-      </div>
-    </div>
+      </Layout.Flex>
+    </Layout.Flex>
   );
 };

package/src/operations/import-pull-request.ts

@@ -8,6 +8,7 @@ import * as Layer from 'effect/Layer';
 
 import * as Operation from '@dxos/compute/Operation';
 import { Database, Filter, Ref } from '@dxos/echo';
+import { log } from '@dxos/log';
 import * as SpaceOperation from '@dxos/plugin-space/SpaceOperation';
 import { PullRequest } from '@dxos/types';
 
@@ -18,6 +19,7 @@ import { type PullRequestReference, parsePullRequestReference } from '../github-
 import { toPullRequestProps } from '../pull-request.ts';
 import { GitHubApi } from '../services/index.ts';
 import { githubToken } from './pull-request.ts';
+import { ensureRefreshTrigger } from './refresh.ts';
 
 /**
  * Statuses that may report the token's reach rather than the repository's absence, and so are worth
@@ -133,6 +135,12 @@ const handler: Operation.WithHandler<typeof GitHubOperation.ImportPullRequest> =
         return yield* Effect.die(new GitHubPullRequestReferenceError({ context: { reference } }));
       }
 
+      // The first pull request a space holds is what makes refreshing them worth a schedule.
+      yield* ensureRefreshTrigger().pipe(
+        // The import already succeeded; a missing schedule is recovered the next time a pull request opens.
+        Effect.catchDefect((defect) => Effect.sync(() => log.warn('refresh trigger setup failed', { defect }))),
+      );
+
       return { pullRequest: Ref.make(object), imported: true };
     }, Effect.provide(FetchHttpClient.layer)),
   ),

package/src/operations/index.ts

@@ -25,5 +25,6 @@ export const GitHubOperationHandlerSet = OperationHandlerSet.lazy([
   ),
   GitHubOperation.GetPullRequestStatus.pipe(Operation.lazyHandler(() => import('./get-pull-request-status.ts'))),
   GitHubOperation.SyncPullRequest.pipe(Operation.lazyHandler(() => import('./sync-pull-request.ts'))),
+  GitHubOperation.RefreshPullRequests.pipe(Operation.lazyHandler(() => import('./refresh-pull-requests.ts'))),
   GitHubOperation.GetPullRequestDiff.pipe(Operation.lazyHandler(() => import('./get-pull-request-diff.ts'))),
 ]);

package/src/operations/refresh-pull-requests.ts

@@ -0,0 +1,69 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Clock from 'effect/Clock';
+import * as Effect from 'effect/Effect';
+import * as FetchHttpClient from 'effect/http/FetchHttpClient';
+
+import * as Operation from '@dxos/compute/Operation';
+import { log } from '@dxos/log';
+
+import { GitHubOperation } from '#types';
+
+import { githubToken } from './pull-request.ts';
+import { ensureRefreshTrigger, queryInFlightPullRequests, refreshPullRequest, selectRefreshBatch } from './refresh.ts';
+
+/** Bounded so a space with many open pull requests does not burst GitHub's secondary rate limit. */
+const REFRESH_CONCURRENCY = 2;
+
+/** The hourly `REFRESH_CRON` period, so each scheduled run lands in its own batch window. */
+const REFRESH_INTERVAL_MS = 60 * 60 * 1000;
+
+const handler: Operation.WithHandler<typeof GitHubOperation.RefreshPullRequests> =
+  GitHubOperation.RefreshPullRequests.pipe(
+    Operation.withHandler(
+      Effect.fn(function* () {
+        // Collapses any duplicate a racing peer created, so the space keeps one schedule.
+        yield* ensureRefreshTrigger();
+        const inFlight = yield* queryInFlightPullRequests();
+        if (inFlight.length === 0) {
+          return { checked: 0, updated: 0, failed: 0 };
+        }
+
+        const window = Math.floor((yield* Clock.currentTimeMillis) / REFRESH_INTERVAL_MS);
+        const pullRequests = selectRefreshBatch(inFlight, window);
+
+        const token = yield* githubToken();
+        const results = yield* Effect.forEach(
+          pullRequests,
+          (pullRequest) =>
+            // One deleted or unreachable pull request must not fail the run: EDGE disables a trigger
+            // after repeated failures, which would stop refreshing every other one.
+            refreshPullRequest(pullRequest, token).pipe(
+              Effect.map((updated) => (updated.length > 0 ? 'updated' : 'unchanged')),
+              Effect.catchDefect((cause) =>
+                Effect.sync(() => {
+                  log.warn('pull request refresh failed', {
+                    owner: pullRequest.owner,
+                    repo: pullRequest.repo,
+                    number: pullRequest.number,
+                    cause,
+                  });
+                  return 'failed' as const;
+                }),
+              ),
+            ),
+          { concurrency: REFRESH_CONCURRENCY },
+        );
+
+        return {
+          checked: pullRequests.length,
+          updated: results.filter((result) => result === 'updated').length,
+          failed: results.filter((result) => result === 'failed').length,
+        };
+      }, Effect.provide(FetchHttpClient.layer)),
+    ),
+  );
+
+export default handler;

package/src/operations/refresh.test.ts

@@ -0,0 +1,112 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import { afterEach, beforeEach, describe, test } from 'vitest';
+
+import * as Trigger from '@dxos/compute/Trigger';
+import { Database, Filter, Obj, Ref } from '@dxos/echo';
+import { EchoTestBuilder } from '@dxos/echo-client/testing';
+import * as EffectEx from '@dxos/effect/EffectEx';
+import { PullRequest } from '@dxos/types';
+
+import { GitHubOperation } from '#types';
+
+import { REFRESH_CRON, ensureRefreshTrigger, queryInFlightPullRequests, selectRefreshBatch } from './refresh.ts';
+
+describe('pull request refresh', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  const setup = async () => {
+    const { db, graph } = await builder.createDatabase();
+    graph.registry.add([Trigger.Trigger, PullRequest.PullRequest]);
+    return db;
+  };
+
+  const run = <T>(db: Database.Database, effect: Effect.Effect<T, never, Database.Service>) =>
+    effect.pipe(Effect.provide(Database.layer(db)), EffectEx.runAndForwardErrors);
+
+  test('a space gets one remote timer trigger, however often it is ensured', async ({ expect }) => {
+    const db = await setup();
+    const first = await run(db, ensureRefreshTrigger());
+    const second = await run(db, ensureRefreshTrigger());
+
+    expect(second.id).toBe(first.id);
+    const triggers = await db.query(Filter.type(Trigger.Trigger)).run();
+    expect(triggers).toHaveLength(1);
+    expect(first.remote).toBe(true);
+    expect(first.enabled).toBe(true);
+    expect(first.spec).toEqual({ kind: 'timer', cron: REFRESH_CRON });
+    expect(first.runnable?.uri).toBe(GitHubOperation.RefreshPullRequests.meta.key.toString());
+  });
+
+  test('a disabled refresh trigger is left disabled', async ({ expect }) => {
+    const db = await setup();
+    const trigger = await run(db, ensureRefreshTrigger());
+    Obj.update(trigger, (trigger) => {
+      trigger.enabled = false;
+    });
+
+    const ensured = await run(db, ensureRefreshTrigger());
+    expect(ensured.id).toBe(trigger.id);
+    expect(ensured.enabled).toBe(false);
+  });
+
+  test('only pull requests GitHub can still change are refreshed', async ({ expect }) => {
+    const db = await setup();
+    const make = (number: number, state: PullRequest.State) =>
+      db.add(PullRequest.make({ owner: 'dxos', repo: 'dxos', number, title: `#${number}`, state }));
+    make(1, 'open');
+    make(2, 'draft');
+    make(3, 'closed');
+    make(4, 'merged');
+
+    const inFlight = await run(db, queryInFlightPullRequests());
+    expect(inFlight.map((pullRequest) => pullRequest.number).sort()).toEqual([1, 2]);
+  });
+
+  test('duplicates a racing peer created collapse to the lowest-id trigger', async ({ expect }) => {
+    const db = await setup();
+    const make = () =>
+      db.add(
+        Trigger.make({
+          enabled: true,
+          remote: true,
+          spec: Trigger.specTimer(REFRESH_CRON),
+          runnable: Ref.fromURI(GitHubOperation.RefreshPullRequests.meta.key),
+          input: {},
+        }),
+      );
+    const ids = [make().id, make().id].sort();
+
+    const kept = await run(db, ensureRefreshTrigger());
+    expect(kept.id).toBe(ids[0]);
+    const triggers = await db.query(Filter.type(Trigger.Trigger)).run();
+    expect(triggers.map((trigger) => trigger.id)).toEqual([ids[0]]);
+  });
+
+  test('successive runs walk every open pull request in bounded batches', async ({ expect }) => {
+    const db = await setup();
+    const pullRequests = Array.from({ length: 5 }, (_, index) =>
+      db.add(PullRequest.make({ owner: 'dxos', repo: 'dxos', number: index, title: `#${index}`, state: 'open' })),
+    );
+
+    expect(selectRefreshBatch(pullRequests, 0, 10)).toHaveLength(5);
+    const seen = new Set<string>();
+    for (let window = 0; window < 3; window++) {
+      const batch = selectRefreshBatch(pullRequests, window, 2);
+      expect(batch).toHaveLength(2);
+      batch.forEach((pullRequest) => seen.add(pullRequest.id));
+    }
+    expect(seen.size).toBe(5);
+  });
+});

package/src/operations/refresh.ts

@@ -0,0 +1,111 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as Trigger from '@dxos/compute/Trigger';
+import { Database, Filter, Obj, Ref } from '@dxos/echo';
+import { PullRequest } from '@dxos/types';
+
+import { GitHubOperation } from '#types';
+
+import { pullRequestChanges } from '../pull-request.ts';
+import { fetchPullRequestWithFallback } from './import-pull-request.ts';
+
+/**
+ * How often the space's refresh trigger polls its open pull requests: hourly, at an off-the-hour minute
+ * so the fleet of spaces does not land on EDGE's busiest tick, and because every open pull request
+ * costs a GitHub request against the connection's rate limit.
+ */
+export const REFRESH_CRON = '17 * * * *';
+
+/** States GitHub can still move a pull request out of; a closed or merged one is settled. */
+const IN_FLIGHT_STATES: readonly PullRequest.State[] = ['open', 'draft'];
+
+/**
+ * Re-read one stored pull request from GitHub and write back the fields that changed.
+ *
+ * Uses the anonymous fallback, so a public pull request still refreshes behind a revoked token.
+ * Returns the names of the changed fields.
+ */
+export const refreshPullRequest = Effect.fn('refreshPullRequest')(function* (
+  pullRequest: PullRequest.PullRequest,
+  token: string,
+) {
+  const pull = yield* fetchPullRequestWithFallback(pullRequest, token);
+  const changes = pullRequestChanges(pullRequest, pull);
+  const updated = Object.keys(changes);
+  if (updated.length > 0) {
+    Obj.update(pullRequest, (pullRequest) => {
+      Object.assign(pullRequest, changes);
+    });
+  }
+
+  return updated;
+});
+
+/** Code-unit order, so every peer and EDGE agree on it regardless of locale. */
+const byId = (left: { id: string }, right: { id: string }): number =>
+  left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+
+/** Most pull requests one run refreshes, so a run stays within GitHub's rate limit and EDGE's subrequest budget. */
+export const REFRESH_BATCH_SIZE = 20;
+
+/**
+ * The slice of `pullRequests` the run in window `window` refreshes: consecutive windows walk the list in
+ * id order and wrap, so every pull request is refreshed once every `ceil(count / size)` runs without
+ * storing a cursor.
+ */
+export const selectRefreshBatch = (
+  pullRequests: readonly PullRequest.PullRequest[],
+  window: number,
+  size = REFRESH_BATCH_SIZE,
+): PullRequest.PullRequest[] => {
+  if (pullRequests.length <= size) {
+    return [...pullRequests];
+  }
+  const ordered = [...pullRequests].sort(byId);
+  const start = (window * size) % ordered.length;
+  return Array.from({ length: size }, (_, index) => ordered[(start + index) % ordered.length]);
+};
+
+/** The space's pull requests GitHub may still change. */
+export const queryInFlightPullRequests = () =>
+  Database.query(Filter.type(PullRequest.PullRequest)).run.pipe(
+    Effect.map((pullRequests) => pullRequests.filter((pullRequest) => IN_FLIGHT_STATES.includes(pullRequest.state))),
+    Effect.orDie,
+  );
+
+const isRefreshTrigger = (trigger: Trigger.Trigger): boolean =>
+  trigger.runnable?.uri === GitHubOperation.RefreshPullRequests.meta.key.toString();
+
+/**
+ * Give the space its one pull-request refresh trigger, unless it has one already — including one the
+ * user disabled, which stays disabled.
+ *
+ * Peers that race to create it each add their own, so every caller converges on the same keeper (the
+ * lowest id) and removes the rest. The trigger runs on EDGE, so pull requests keep refreshing while no
+ * client has the space open.
+ */
+export const ensureRefreshTrigger = Effect.fn('ensureRefreshTrigger')(function* () {
+  const triggers = yield* Database.query(Filter.type(Trigger.Trigger)).run.pipe(Effect.orDie);
+  const [keeper, ...duplicates] = triggers.filter(isRefreshTrigger).sort(byId);
+  for (const duplicate of duplicates) {
+    yield* Database.remove(duplicate);
+  }
+  if (keeper) {
+    return keeper;
+  }
+
+  return yield* Database.add(
+    Trigger.make({
+      enabled: true,
+      remote: true,
+      spec: Trigger.specTimer(REFRESH_CRON),
+      // Statically defined in the registry, so referred to by key rather than copied into the space.
+      runnable: Ref.fromURI(GitHubOperation.RefreshPullRequests.meta.key),
+      input: {},
+    }),
+  );
+});

package/src/operations/sync-pull-request.ts

@@ -6,29 +6,26 @@ import * as Effect from 'effect/Effect';
 import * as FetchHttpClient from 'effect/http/FetchHttpClient';
 
 import * as Operation from '@dxos/compute/Operation';
-import { Database, Obj } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { log } from '@dxos/log';
 
 import { GitHubOperation } from '#types';
 
-import { pullRequestChanges } from '../pull-request.ts';
-import { fetchPullRequestWithFallback } from './import-pull-request.ts';
 import { githubToken, resolvePullRequest } from './pull-request.ts';
+import { ensureRefreshTrigger, refreshPullRequest } from './refresh.ts';
 
 const handler: Operation.WithHandler<typeof GitHubOperation.SyncPullRequest> = GitHubOperation.SyncPullRequest.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ pullRequest: ref }) {
       const { pullRequest, db } = yield* resolvePullRequest(ref);
       const token = yield* githubToken().pipe(Effect.provide(Database.layer(db)));
-      // With the anonymous fallback, so a public pull request still refreshes behind a revoked token.
-      const pull = yield* fetchPullRequestWithFallback(pullRequest, token);
-      const changes = pullRequestChanges(pullRequest, pull);
-      const updated = Object.keys(changes);
-      if (updated.length > 0) {
-        Obj.update(pullRequest, (pullRequest) => {
-          Object.assign(pullRequest, changes);
-        });
-      }
-
+      const updated = yield* refreshPullRequest(pullRequest, token);
+      // Spaces that imported pull requests before the scheduled refresh existed get it on next open.
+      yield* ensureRefreshTrigger().pipe(
+        Effect.provide(Database.layer(db)),
+        // The refresh already succeeded; the schedule is retried on the next open.
+        Effect.catchDefect((defect) => Effect.sync(() => log.warn('refresh trigger setup failed', { defect }))),
+      );
       return { updated };
     }, Effect.provide(FetchHttpClient.layer)),
   ),

package/src/stories/PullRequestOverview.stories.tsx

@@ -83,7 +83,7 @@ export const FailingChecks: Story = {
       ...PULL_REQUEST_13348_RUNS.slice(2),
       { ...PULL_REQUEST_13348_RUNS[0], name: 'Check / test (shard=6)', outcome: 'failure', conclusion: 'failure' },
       { ...PULL_REQUEST_13348_RUNS[1], name: 'Check / e2e (shard=7)', outcome: 'failure', conclusion: 'timed_out' },
-      { name: 'Check / storybook', outcome: 'pending' },
+      { name: 'Check / storybook', outcome: 'pending', startedAt: new Date(Date.now() - 252_000).toISOString() },
     ],
   },
   play: async ({ canvasElement }) => {
@@ -92,6 +92,7 @@ export const FailingChecks: Story = {
     await expect(first).toHaveAttribute('data-outcome', 'failure');
     await expect(second).toHaveAttribute('data-outcome', 'failure');
     await expect(third).toHaveAttribute('data-outcome', 'pending');
+    await expect(third).toHaveTextContent(/Running · \d+m \d+s/);
   },
 };