github-issue-tower-defence-management 1.166.6 → 1.168.0

package/src/adapter/entry-points/cli/index.ts

@@ -472,6 +472,7 @@ program
       manager,
       codexHomeCandidates,
       labelsAsLlmAgentName: config.labelsAsLlmAgentName ?? null,
+      agents: config.agents ?? null,
     });
     if (preparationResult.rotationOrder !== null) {
       writeRotationOrderFile(preparationResult.rotationOrder);

package/src/adapter/entry-points/console/ui/public/sw.js

@@ -0,0 +1,60 @@
+const SHELL_CACHE = 'console-shell-v1';
+
+self.addEventListener('install', (event) => {
+  event.waitUntil(caches.open(SHELL_CACHE).then((cache) => cache.add('/')));
+  self.skipWaiting();
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(
+    caches
+      .keys()
+      .then((names) =>
+        Promise.all(
+          names
+            .filter((name) => name !== SHELL_CACHE)
+            .map((name) => caches.delete(name)),
+        ),
+      ),
+  );
+  self.clients.claim();
+});
+
+self.addEventListener('fetch', (event) => {
+  if (event.request.method !== 'GET') {
+    return;
+  }
+  const url = new URL(event.request.url);
+  if (url.origin !== self.location.origin) {
+    return;
+  }
+  if (
+    url.pathname.startsWith('/projects/') ||
+    url.pathname.startsWith('/api/')
+  ) {
+    return;
+  }
+  event.respondWith(
+    fetch(event.request)
+      .then((response) => {
+        if (response.ok) {
+          caches
+            .open(SHELL_CACHE)
+            .then((cache) => cache.put(event.request, response.clone()))
+            .catch((e) => console.warn('Shell cache put failed:', e));
+        }
+        return response;
+      })
+      .catch(async () => {
+        const cached = await caches.match(event.request);
+        if (cached !== undefined) {
+          return cached;
+        }
+        const root = await caches.match('/');
+        if (root !== undefined) {
+          return root;
+        }
+        return Response.error();
+      }),
+  );
+});

package/src/adapter/entry-points/console/ui/src/features/console/components/layout/ConsoleTabList.stories.tsx

@@ -9,6 +9,7 @@ const meta: Meta<typeof ConsoleTabList> = {
   args: {
     pjcode: 'acme',
     generatedAt: '2026-06-19T08:42:11.000Z',
+    fromCache: false,
     tabHref: (tab: ConsoleTabName) => `/projects/acme/${tab}`,
     onSelectTab: () => {},
   },
@@ -85,6 +86,14 @@ export const AfterAutoAdvanceToNextTab: Story = {
   },
 };
 
+export const CachedSnapshot: Story = {
+  args: {
+    activeTab: 'prs',
+    counts,
+    fromCache: true,
+  },
+};
+
 export const Interactive: Story = {
   render: (args) => {
     const [activeTab, setActiveTab] = useState<ConsoleTabName>('prs');

package/src/adapter/entry-points/console/ui/src/features/console/components/layout/ConsoleTabList.test.tsx

@@ -16,6 +16,7 @@ const counts: Record<ConsoleTabName, number> = {
 const baseProps = {
   pjcode: 'acme',
   generatedAt: '2026-06-19T08:42:11.000Z',
+  fromCache: false,
   tabHref: (tab: ConsoleTabName) => `/projects/acme/${tab}`,
   onSelectTab: () => {},
 };
@@ -116,4 +117,34 @@ describe('ConsoleTabList', () => {
     fireEvent.click(getByText('Unread'));
     expect(onSelectTab).toHaveBeenCalledWith('unread');
   });
+
+  it('prefixes the snapshot info with "(cached)" and sets data-from-cache when data is from cache', () => {
+    const { getByText } = render(
+      <ConsoleTabList
+        {...baseProps}
+        activeTab="prs"
+        counts={counts}
+        fromCache={true}
+      />,
+    );
+    const genInfo = getByText('(cached) snapshot: 2026-06-19T08:42:11.000Z');
+    expect(genInfo).toBeInTheDocument();
+    expect(genInfo).toHaveAttribute('data-from-cache', 'true');
+  });
+
+  it('omits the cache prefix and data-from-cache attribute when data is from the network', () => {
+    const { getByText, queryByText } = render(
+      <ConsoleTabList
+        {...baseProps}
+        activeTab="prs"
+        counts={counts}
+        fromCache={false}
+      />,
+    );
+    expect(getByText('snapshot: 2026-06-19T08:42:11.000Z')).toBeInTheDocument();
+    expect(
+      queryByText('(cached) snapshot: 2026-06-19T08:42:11.000Z'),
+    ).toBeNull();
+    expect(document.querySelector('[data-from-cache]')).toBeNull();
+  });
 });

package/src/adapter/entry-points/console/ui/src/features/console/components/layout/ConsoleTabList.tsx

@@ -5,6 +5,7 @@ export type ConsoleTabBarProps = {
   counts: Record<ConsoleTabName, number>;
   pjcode: string | null;
   generatedAt: string | null;
+  fromCache: boolean;
   tabHref: (tab: ConsoleTabName) => string;
   onSelectTab: (tab: ConsoleTabName) => void;
 };
@@ -14,6 +15,7 @@ export const ConsoleTabList = ({
   counts,
   pjcode,
   generatedAt,
+  fromCache,
   tabHref,
   onSelectTab,
 }: ConsoleTabBarProps) => {
@@ -59,7 +61,12 @@ export const ConsoleTabList = ({
       })}
       {pjcode !== null && <span className="console-tab-pjname">{pjcode}</span>}
       {generatedAt !== null && (
-        <span className="console-tab-geninfo">snapshot: {generatedAt}</span>
+        <span
+          className="console-tab-geninfo"
+          data-from-cache={fromCache ? 'true' : undefined}
+        >
+          {fromCache ? '(cached) ' : ''}snapshot: {generatedAt}
+        </span>
       )}
     </nav>
   );

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleTabData.test.ts

@@ -5,27 +5,72 @@ import {
   useConsoleTabData,
 } from './useConsoleTabData';
 
+const makeTabPayload = (overrides: Record<string, unknown> = {}) => ({
+  pjcode: 'acme',
+  generatedAt: '2026-06-19T00:00:00.000Z',
+  statusOptions: [{ id: 's1', name: 'Unread', color: 'ORANGE' }],
+  storyColors: {},
+  items: [],
+  ...overrides,
+});
+
+const installNetworkFetch = (
+  perTabItems: (url: string) => unknown[] = () => [],
+): jest.Mock => {
+  const fetchMock = jest.fn(async (url: string) => ({
+    ok: true,
+    status: 200,
+    json: async () =>
+      makeTabPayload({
+        items: url.includes('/prs/') ? perTabItems(url) : [],
+      }),
+  }));
+  global.fetch = fetchMock as unknown as typeof fetch;
+  return fetchMock;
+};
+
+type MockCacheEntry = { json: jest.Mock };
+type MockCache = {
+  match: jest.Mock<Promise<MockCacheEntry | undefined>>;
+  put: jest.Mock<Promise<void>>;
+};
+
+const installMockCaches = (
+  matchResult: MockCacheEntry | undefined,
+): MockCache => {
+  const mockCache: MockCache = {
+    match: jest.fn(async () => matchResult),
+    put: jest.fn(async () => undefined),
+  };
+  Object.defineProperty(global, 'caches', {
+    value: { open: jest.fn(async () => mockCache) },
+    writable: true,
+    configurable: true,
+  });
+  return mockCache;
+};
+
+const removeMockCaches = (): void => {
+  Reflect.deleteProperty(global as Record<string, unknown>, 'caches');
+};
+
 describe('useConsoleTabData', () => {
   beforeEach(() => {
     localStorage.clear();
     window.history.replaceState({}, '', '/?k=token');
+    removeMockCaches();
+  });
+
+  afterEach(() => {
+    removeMockCaches();
   });
 
   it('fetches every tab once at startup and parses snapshots', async () => {
-    const fetchMock = jest.fn(async (url: string) => ({
-      ok: true,
-      status: 200,
-      json: async () => ({
-        pjcode: 'acme',
-        generatedAt: '2026-06-19T00:00:00.000Z',
-        statusOptions: [{ id: 's1', name: 'Unread', color: 'ORANGE' }],
-        storyColors: {},
-        items: url.includes('/prs/')
-          ? [{ number: 1, itemId: 'PVTI_1', projectItemId: 'PVTI_1' }]
-          : [],
-      }),
-    }));
-    global.fetch = fetchMock as unknown as typeof fetch;
+    const fetchMock = installNetworkFetch((url) =>
+      url.includes('/prs/')
+        ? [{ number: 1, itemId: 'PVTI_1', projectItemId: 'PVTI_1' }]
+        : [],
+    );
 
     const { result } = renderHook(() => useConsoleTabData('acme'));
     await waitFor(() => {
@@ -41,6 +86,15 @@ describe('useConsoleTabData', () => {
     );
   });
 
+  it('sets fromCache false when data is loaded from the network', async () => {
+    installNetworkFetch();
+    const { result } = renderHook(() => useConsoleTabData('acme'));
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+    expect(result.current.snapshots.prs?.fromCache).toBe(false);
+  });
+
   it('normalizes relatedOpenPullRequestUrls for a snapshot written before the field existed', async () => {
     const fetchMock = jest.fn(async (url: string) => ({
       ok: true,
@@ -116,7 +170,7 @@ describe('useConsoleTabData', () => {
     jest.useRealTimers();
   });
 
-  it('surfaces an error when a tab fetch fails', async () => {
+  it('surfaces an error when a tab fetch fails and no cache is available', async () => {
     const fetchMock = jest.fn(async () => ({
       ok: false,
       status: 500,
@@ -129,6 +183,48 @@ describe('useConsoleTabData', () => {
     });
   });
 
+  it('serves board data from cache and sets fromCache true when every network fetch rejects', async () => {
+    const cachedPayload = makeTabPayload({
+      generatedAt: '2026-06-10T00:00:00.000Z',
+      items: [{ number: 1, itemId: 'PVTI_1', projectItemId: 'PVTI_1' }],
+    });
+    const cacheEntry = { json: jest.fn(async () => cachedPayload) };
+    installMockCaches(cacheEntry);
+
+    global.fetch = jest
+      .fn()
+      .mockRejectedValue(new Error('Network error')) as unknown as typeof fetch;
+
+    const { result } = renderHook(() => useConsoleTabData('acme'));
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.error).toBeNull();
+    expect(result.current.snapshots.prs?.fromCache).toBe(true);
+    expect(result.current.snapshots.prs?.generatedAt).toBe(
+      '2026-06-10T00:00:00.000Z',
+    );
+    expect(result.current.snapshots.prs?.items.length).toBe(1);
+  });
+
+  it('surfaces an error when network rejects and no cache entry exists', async () => {
+    installMockCaches(undefined);
+    global.fetch = jest
+      .fn()
+      .mockRejectedValue(new Error('offline')) as unknown as typeof fetch;
+
+    const { result } = renderHook(() => useConsoleTabData('acme'));
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.error).toBe('offline');
+    expect(
+      Object.values(result.current.snapshots).every((s) => s === null),
+    ).toBe(true);
+  });
+
   it('reports an error and fetches nothing when no pjcode is in the URL', async () => {
     const fetchMock = jest.fn();
     global.fetch = fetchMock as unknown as typeof fetch;

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleTabData.ts

@@ -16,6 +16,7 @@ export type ConsoleTabSnapshot = {
   storyColors: ConsoleStoryColorSource;
   stories: ConsoleStoryEntry[];
   defaultNameWithOwner: string | null;
+  fromCache: boolean;
 };
 
 export type ConsoleTabDataState = {
@@ -61,7 +62,9 @@ const parseStoryEntries = (value: unknown): ConsoleStoryEntry[] => {
   return value.filter(isRecord) as unknown as ConsoleStoryEntry[];
 };
 
-const parseSnapshot = (payload: unknown): ConsoleTabSnapshot => ({
+const parseSnapshotData = (
+  payload: unknown,
+): Omit<ConsoleTabSnapshot, 'fromCache'> => ({
   items: parseItems(payload),
   generatedAt:
     isRecord(payload) && typeof payload.generatedAt === 'string'
@@ -96,24 +99,106 @@ const buildListUrl = (pjcode: string, tab: ConsoleTabName): string =>
 
 export const CONSOLE_TAB_REFRESH_INTERVAL_MS = 60000;
 
+const CONSOLE_LIST_CACHE_NAME = 'console-list-v1';
+
+const persistListSnapshot = (url: string, payload: unknown): void => {
+  try {
+    if (!('caches' in globalThis)) {
+      return;
+    }
+    globalThis.caches
+      .open(CONSOLE_LIST_CACHE_NAME)
+      .then((cache) =>
+        cache.put(
+          url,
+          new Response(JSON.stringify(payload), {
+            headers: { 'Content-Type': 'application/json' },
+          }),
+        ),
+      )
+      .catch((e: unknown) => {
+        console.warn('Failed to persist tab snapshot to cache:', e);
+      });
+  } catch (e: unknown) {
+    console.warn('Failed to access cache storage:', e);
+  }
+};
+
+const loadListSnapshotFromCache = async (
+  url: string,
+): Promise<ConsoleTabSnapshot | null> => {
+  if (!('caches' in globalThis)) {
+    return null;
+  }
+  try {
+    const cache = await globalThis.caches.open(CONSOLE_LIST_CACHE_NAME);
+    const cached = await cache.match(url);
+    if (cached === undefined) {
+      return null;
+    }
+    const payload: unknown = await cached.json();
+    return { ...parseSnapshotData(payload), fromCache: true };
+  } catch {
+    return null;
+  }
+};
+
+const fetchSingleSnapshot = async (
+  pjcode: string,
+  tabName: ConsoleTabName,
+): Promise<{ snapshot: ConsoleTabSnapshot | null; error: Error | null }> => {
+  const url = buildListUrl(pjcode, tabName);
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const payload: unknown = await response.json();
+    persistListSnapshot(url, payload);
+    return {
+      snapshot: { ...parseSnapshotData(payload), fromCache: false },
+      error: null,
+    };
+  } catch (e: unknown) {
+    const cached = await loadListSnapshotFromCache(url);
+    if (cached !== null) {
+      return { snapshot: cached, error: null };
+    }
+    return {
+      snapshot: null,
+      error: e instanceof Error ? e : new Error(String(e)),
+    };
+  }
+};
+
 const fetchSnapshots = async (
   pjcode: string,
-): Promise<Record<ConsoleTabName, ConsoleTabSnapshot | null>> => {
-  const entries = await Promise.all(
+): Promise<{
+  snapshots: Record<ConsoleTabName, ConsoleTabSnapshot | null>;
+  firstError: Error | null;
+}> => {
+  const results = await Promise.all(
     CONSOLE_TABS.map(async (tab) => {
-      const response = await fetch(buildListUrl(pjcode, tab.name));
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const payload: unknown = await response.json();
-      return [tab.name, parseSnapshot(payload)] as const;
+      const { snapshot, error } = await fetchSingleSnapshot(pjcode, tab.name);
+      return { tabName: tab.name, snapshot, error };
     }),
   );
-  const next = emptySnapshots();
-  for (const [name, snapshot] of entries) {
-    next[name] = snapshot;
+
+  const snapshots = emptySnapshots();
+  let firstError: Error | null = null;
+
+  for (const { tabName, snapshot, error } of results) {
+    snapshots[tabName] = snapshot;
+    if (error !== null && firstError === null) {
+      firstError = error;
+    }
   }
-  return next;
+
+  const allNull = Object.values(snapshots).every((s) => s === null);
+  return {
+    snapshots,
+    firstError: allNull ? firstError : null,
+  };
 };
 
 export const useConsoleTabData = (
@@ -140,12 +225,12 @@ export const useConsoleTabData = (
 
     const load = (): void => {
       fetchSnapshots(pjcode)
-        .then((next) => {
+        .then(({ snapshots: next, firstError }) => {
           if (cancelled) {
             return;
           }
           setSnapshots(next);
-          setError(null);
+          setError(firstError !== null ? firstError.message : null);
           setIsLoading(false);
         })
         .catch((cause: unknown) => {

package/src/adapter/entry-points/console/ui/src/features/console/lib/consoleApi.test.ts

@@ -25,7 +25,40 @@ const mockFetchFailureOnce = (status: number, rawBody: string): jest.Mock => {
   return fetchMock;
 };
 
+type MockCacheEntry = { json: jest.Mock };
+type MockCache = {
+  match: jest.Mock<Promise<MockCacheEntry | undefined>>;
+  put: jest.Mock<Promise<void>>;
+};
+
+const installMockCaches = (
+  matchResult: MockCacheEntry | undefined,
+): MockCache => {
+  const mockCache: MockCache = {
+    match: jest.fn(async () => matchResult),
+    put: jest.fn(async () => undefined),
+  };
+  Object.defineProperty(global, 'caches', {
+    value: { open: jest.fn(async () => mockCache) },
+    writable: true,
+    configurable: true,
+  });
+  return mockCache;
+};
+
+const removeMockCaches = (): void => {
+  Reflect.deleteProperty(global as Record<string, unknown>, 'caches');
+};
+
 describe('createConsoleApiClient', () => {
+  beforeEach(() => {
+    removeMockCaches();
+  });
+
+  afterEach(() => {
+    removeMockCaches();
+  });
+
   it('reads the item body from the api root without a token query', async () => {
     const fetchMock = mockFetchOnce({ body: '# Title' });
     const client = createConsoleApiClient();
@@ -243,13 +276,49 @@ describe('createConsoleApiClient', () => {
     });
   });
 
-  it('throws on a non-ok response', async () => {
+  it('throws on a non-ok response when no cache is available', async () => {
     mockFetchOnce({}, false);
     const client = createConsoleApiClient();
     await expect(
       client.fetchComments('https://github.com/o/r/issues/1'),
     ).rejects.toThrow('HTTP 500');
   });
+
+  it('returns cached comments when the network fetch rejects', async () => {
+    const cachedBody = {
+      comments: [
+        {
+          author: 'alice',
+          body: 'hello',
+          createdAt: '2026-06-19T00:00:00.000Z',
+        },
+      ],
+    };
+    installMockCaches({ json: jest.fn(async () => cachedBody) });
+    global.fetch = jest
+      .fn()
+      .mockRejectedValue(new Error('offline')) as unknown as typeof fetch;
+
+    const client = createConsoleApiClient();
+    const comments = await client.fetchComments(
+      'https://github.com/o/r/issues/1',
+    );
+    expect(comments).toEqual([
+      { author: 'alice', body: 'hello', createdAt: '2026-06-19T00:00:00.000Z' },
+    ]);
+  });
+
+  it('throws when the network fails and no cache entry exists', async () => {
+    installMockCaches(undefined);
+    global.fetch = jest
+      .fn()
+      .mockRejectedValue(new Error('offline')) as unknown as typeof fetch;
+
+    const client = createConsoleApiClient();
+    await expect(
+      client.fetchComments('https://github.com/o/r/issues/1'),
+    ).rejects.toThrow('offline');
+  });
 });
 
 describe('postConsoleOperation', () => {

package/src/adapter/entry-points/console/ui/src/features/console/lib/consoleApi.ts

@@ -70,17 +70,53 @@ const getNumber = (value: unknown): number =>
 
 const getBoolean = (value: unknown): boolean => value === true;
 
+const CONSOLE_API_CACHE_NAME = 'console-api-v1';
+
 const requestJson = async (
   apiPath: string,
   resourceUrl: string,
 ): Promise<unknown> => {
-  const response = await fetch(
-    `${apiPath}?url=${encodeURIComponent(resourceUrl)}`,
-  );
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
+  const url = `${apiPath}?url=${encodeURIComponent(resourceUrl)}`;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const payload: unknown = await response.json();
+    try {
+      if ('caches' in globalThis) {
+        globalThis.caches
+          .open(CONSOLE_API_CACHE_NAME)
+          .then((cache) =>
+            cache.put(
+              url,
+              new Response(JSON.stringify(payload), {
+                headers: { 'Content-Type': 'application/json' },
+              }),
+            ),
+          )
+          .catch((e: unknown) => {
+            console.warn('Failed to persist API response to cache:', e);
+          });
+      }
+    } catch (e: unknown) {
+      console.warn('Failed to access cache storage:', e);
+    }
+    return payload;
+  } catch (e: unknown) {
+    try {
+      if ('caches' in globalThis) {
+        const cache = await globalThis.caches.open(CONSOLE_API_CACHE_NAME);
+        const cached = await cache.match(url);
+        if (cached !== undefined) {
+          return cached.json();
+        }
+      }
+    } catch {
+      // cache read failure, fall through to original error
+    }
+    throw e;
   }
-  return response.json();
 };
 
 const parseComments = (payload: unknown): ConsoleComment[] => {

package/src/adapter/entry-points/console/ui/src/features/console/pages/ConsolePage.tsx

@@ -126,6 +126,7 @@ export const ConsolePage = () => {
   const statusOptions = activeSnapshot?.statusOptions ?? [];
   const storyOptions = activeSnapshot?.storyOptions ?? [];
   const generatedAt = activeSnapshot?.generatedAt ?? null;
+  const fromCache = activeSnapshot?.fromCache ?? false;
 
   const selectedItem = useMemo<ConsoleListItem | null>(() => {
     if (selectedItemKey === null || activeSnapshot === null) {
@@ -274,6 +275,7 @@ export const ConsolePage = () => {
         counts={counts}
         pjcode={pjcode}
         generatedAt={generatedAt}
+        fromCache={fromCache}
         tabHref={navigation.tabHref}
         onSelectTab={navigation.selectTab}
       />

package/src/adapter/entry-points/console/ui/src/main.tsx

@@ -3,6 +3,12 @@ import { createRoot } from 'react-dom/client';
 import { ConsolePage } from '@/features/console/pages/ConsolePage';
 import './index.css';
 
+if ('serviceWorker' in navigator) {
+  navigator.serviceWorker.register('/sw.js').catch((e: unknown) => {
+    console.warn('Service worker registration failed:', e);
+  });
+}
+
 const container = document.getElementById('root');
 if (container === null) {
   throw new Error('Root container #root not found');