diff --git a/AGENTS.md b/AGENTS.md
index 357af3f67..76021a292 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -79,6 +79,8 @@ The WebView root component is assigned to `globalThis.webViewComponent` (not exp
 
 Drafts are loaded and saved through [AnalysisRepository](src/types/analysis-repository.ts), the seam a later storage backend implements. [DraftRepository](src/services/draftRepository.ts) implements it over the draft envelope and its per-book shards, and rewrites only the books that changed. It imports nothing from PAPI and reaches storage only through a `KeyValueStorage`. That lets the perf harness run it in Node, straight over the storage files ([perf/storage.ts](perf/storage.ts)).
 
+Saved projects are listed through [ProjectSummaries](src/services/projectSummaries.ts): one record holding every project's summary, rewritten on each project write so listing reads no analysis. It is PAPI-free in the same way.
+
 ### Components
 
 Prefer Platform.Bible's `platform-bible-react` components (`Button`, `Input`, `Textarea`, `Label`, `Switch`, `RadioGroup`, `Popover`, `Tooltip`, etc.) over hand-rolled raw HTML (`<button>`, `<input>`, `<textarea>`, `<label>`, custom dropdowns) wherever an equivalent exists — this keeps the UI visually and behaviorally consistent with the host app and gives us theming and accessibility for free. Reserve raw elements for cases where the platform component can't preserve behavior the extension depends on (e.g. `field-sizing: content` gloss inputs); when you do, add a comment explaining why. When a raw element is replaced by a platform component in tests, extend `__mocks__/platform-bible-react.tsx` to stub the newly-used component.
diff --git a/e2e-tests/tests/perf/app-perf.spec.ts b/e2e-tests/tests/perf/app-perf.spec.ts
index a0d4c4aec..38fbbb102 100644
--- a/e2e-tests/tests/perf/app-perf.spec.ts
+++ b/e2e-tests/tests/perf/app-perf.spec.ts
@@ -220,10 +220,11 @@ async function measureTier(
   const manifest = readManifest(tier.name);
   const draftJson = readDraftJson(tier.name);
   const draftWire = wireBytes(draftJson);
+  const wire: Record<string, number> = { draft: draftWire };
   Object.assign(result, {
     viewBook: tier.viewBook,
     dataset: { counts: manifest.counts, bytes: manifest.bytes },
-    wireBytes: { draft: draftWire, projectsForSource: draftWire * tier.savedProjects },
+    wireBytes: wire,
   });
   if (draftWire > MAX_WEBSOCKET_PAYLOAD_BYTES) {
     result.skipped = `The draft is ${(draftWire / 1e6).toFixed(1)} MB on the wire, over the websocket's per-message cap; the app cannot load it.`;
@@ -367,6 +368,10 @@ async function measureTier(
     await expect(dialog).toHaveCount(0);
   }
   result.picker = picker.summary();
+  const projectsJson = await sendCommand(page, 'interlinearizer.getProjectsForSource', projectId);
+  if (typeof projectsJson !== 'string')
+    throw new Error(`getProjectsForSource returned ${typeof projectsJson}, not a JSON string`);
+  wire.projectsForSource = wireBytes(projectsJson);
   await recordMemory('afterPicker');
 
   // Save: writing the draft's analysis to the project it was opened from.
diff --git a/e2e-tests/tests/perf/view-driver.ts b/e2e-tests/tests/perf/view-driver.ts
index 488d7bc93..f65507224 100644
--- a/e2e-tests/tests/perf/view-driver.ts
+++ b/e2e-tests/tests/perf/view-driver.ts
@@ -41,7 +41,7 @@ export const HOST_CALLS = {
   getProjectsForSource: {
     measure: 'projects-fetch',
     command: 'getProjectsForSource',
-    phasePrefixes: ['getProjectsForSource', 'listProjects'],
+    phasePrefixes: ['getProjectsForSource'],
   },
   saveAnalysis: {
     measure: 'save',
diff --git a/perf/storage.ts b/perf/storage.ts
index 36c0a1e37..074a4e9b6 100644
--- a/perf/storage.ts
+++ b/perf/storage.ts
@@ -3,13 +3,10 @@ import fs from 'fs/promises';
 import type { DraftProject, InterlinearProject } from 'interlinearizer';
 import path from 'path';
 import { DraftRepository } from '../src/services/draftRepository';
+import { ProjectSummaries, summarizeProject } from '../src/services/projectSummaries';
 import { projectKey } from '../src/services/storageKeys';
 import type { KeyValueStorage } from '../src/types/analysis-repository';
 import { CURRENT_MODEL_VERSION } from '../src/types/model-version';
-import { isStringArray } from '../src/types/type-guards';
-
-/** Key of the index listing every saved project's id. */
-const PROJECT_IDS_KEY = 'projectIds';
 
 function isNotFound(e: unknown): boolean {
   return !!e && typeof e === 'object' && 'code' in e && e.code === 'ENOENT';
@@ -64,7 +61,8 @@ export async function writeDraft(dir: string, draft: DraftProject): Promise<void
  * in `dir`.
  *
  * @returns The new project's id.
- * @throws If the project index is not an array of ids, or a record cannot be read or written.
+ * @throws If the stored project summaries are corrupt or from a newer build, or a record cannot be
+ *   read or written.
  */
 export async function addSavedProject(
   dir: string,
@@ -84,8 +82,6 @@ export async function addSavedProject(
     analysis: draft.analysis,
   };
   await storage.write(projectKey(project.id), JSON.stringify(project));
-  const index: unknown = JSON.parse((await storage.read(PROJECT_IDS_KEY)) ?? '[]');
-  if (!isStringArray(index)) throw new Error(`${PROJECT_IDS_KEY} is not an array of ids`);
-  await storage.write(PROJECT_IDS_KEY, JSON.stringify([...index, project.id]));
+  await new ProjectSummaries(storage).add(summarizeProject(project));
   return project.id;
 }
diff --git a/src/__tests__/main.test.ts b/src/__tests__/main.test.ts
index 5be293661..245906c19 100644
--- a/src/__tests__/main.test.ts
+++ b/src/__tests__/main.test.ts
@@ -9,6 +9,7 @@ import * as hostPerf from '../services/hostPerf';
 import * as projectStorage from '../services/projectStorage';
 import * as pt9ImportService from '../services/pt9ImportService';
 import { emptyAnalysis, emptyDraft } from '../types/empty-factories';
+import { toProjectSummary } from '../types/interlinear-project-summary';
 import { createTestActivationContext, makeStubProject } from './test-helpers';
 
 jest.mock('../services/bookService');
@@ -1055,8 +1056,8 @@ describe('main', () => {
   });
 
   describe('interlinearizer.getProjectsForSource command', () => {
-    const mockGetProjectsForSource = jest.mocked(projectStorage.getProjectsForSource);
-    const stubProject = makeStubProject('proj-id');
+    const mockGetSummaries = jest.mocked(projectStorage.getProjectSummariesForSource);
+    const summary = toProjectSummary(makeStubProject('proj-id'));
 
     it('registers the interlinearizer.getProjectsForSource command', async () => {
       const context = createTestActivationContext();
@@ -1070,32 +1071,18 @@ describe('main', () => {
       );
     });
 
-    it("returns summaries of the matching projects, describing each one's analysis", async () => {
-      mockGetProjectsForSource.mockResolvedValue([stubProject]);
-      const handler = await getProjectsForSourceHandler();
-
-      const result = await handler('src-project');
-
-      expect(JSON.parse(result)).toEqual([
-        expect.objectContaining({
-          id: stubProject.id,
-          books: [],
-          tokenAnalysisCount: 0,
-        }),
-      ]);
-    });
-
-    it('omits each project analysis, which the list never reads and would ship whole', async () => {
-      mockGetProjectsForSource.mockResolvedValue([stubProject]);
+    it("returns the stored summaries of the source's projects", async () => {
+      mockGetSummaries.mockResolvedValue([summary]);
       const handler = await getProjectsForSourceHandler();
 
       const result = await handler('src-project');
 
-      expect(result).not.toContain('"analysis"');
+      expect(mockGetSummaries).toHaveBeenCalledWith(expect.anything(), 'src-project');
+      expect(JSON.parse(result)).toEqual([summary]);
     });
 
     it('throws and logs an error when storage throws', async () => {
-      mockGetProjectsForSource.mockRejectedValue(new Error('disk full'));
+      mockGetSummaries.mockRejectedValue(new Error('disk full'));
       const handler = await getProjectsForSourceHandler();
 
       await expect(handler('src-project')).rejects.toThrow('disk full');
diff --git a/src/__tests__/services/projectStorage.test.ts b/src/__tests__/services/projectStorage.test.ts
index 80912b13e..3801a539a 100644
--- a/src/__tests__/services/projectStorage.test.ts
+++ b/src/__tests__/services/projectStorage.test.ts
@@ -1,17 +1,16 @@
 /// <reference types="jest" />
 
 import papiBackendMock from '@papi/backend';
-import type { DraftProject, TextAnalysis } from 'interlinearizer';
+import type { DraftProject, InterlinearProject, TextAnalysis } from 'interlinearizer';
 import {
   createEditableCopy,
   createProject,
   deleteProject,
   getDraft,
   getProject,
-  getProjectsForSource,
+  getProjectSummariesForSource,
   getPt9ImportForSource,
   hasDraft,
-  listProjects,
   resetQueuesForTesting,
   saveDraft,
   savePt9Import,
@@ -28,6 +27,7 @@ import {
   FIXTURE_STAMPS,
   makePhraseLink,
   makeStubProject,
+  storedSummaries,
 } from '../test-helpers';
 
 /**
@@ -85,6 +85,48 @@ function writtenKeys(): string[] {
   return __mockWriteUserData.mock.calls.map(([, key]) => (typeof key === 'string' ? key : ''));
 }
 
+/** Serves each record as the stored JSON for its key; any other key reads as never written. */
+function mockStore(records: Record<string, string>): void {
+  __mockReadUserData.mockImplementation((_t: unknown, key: unknown) => {
+    if (typeof key === 'string' && key in records) return Promise.resolve(records[key]);
+    return Promise.reject(enoentError());
+  });
+}
+
+/** Serves `records`, keeping every write and serving it back to later reads. */
+function writeThroughStore(records: Record<string, string> = {}): void {
+  const stored = new Map(Object.entries(records));
+  __mockWriteUserData.mockImplementation(async (_t: unknown, key: string, value: string) => {
+    stored.set(key, value);
+  });
+  __mockReadUserData.mockImplementation(async (_t: unknown, key: string) => {
+    const value = stored.get(key);
+    if (value === undefined) throw enoentError();
+    return value;
+  });
+}
+
+/** Stores `project` as its record, and lists it. */
+function mockListedProject(project: InterlinearProject): void {
+  mockStore({
+    [`project:${project.id}`]: JSON.stringify(project),
+    projectSummaries: storedSummaries(project),
+  });
+}
+
+/** The project summaries the last write of them held. */
+function writtenSummaries(): { id: string }[] {
+  const writes = __mockWriteUserData.mock.calls.filter(([, key]) => key === 'projectSummaries');
+  const json: unknown = writes[writes.length - 1]?.[2];
+  if (typeof json !== 'string') throw new Error('Expected a write of the project summaries');
+  return JSON.parse(json).summaries;
+}
+
+/** The ids the last write of the project summaries listed. */
+function writtenSummaryIds(): string[] {
+  return writtenSummaries().map(({ id }) => id);
+}
+
 /** Total characters of JSON handed to storage across every write of the current test. */
 function bytesWritten(): number {
   return __mockWriteUserData.mock.calls.reduce(
@@ -217,35 +259,27 @@ describe('projectStorage', () => {
       );
     });
 
-    it('creates a new index when none exists', async () => {
+    it('lists the project when no summaries are stored', async () => {
       __mockReadUserData.mockRejectedValue(enoentError());
 
       await createProject(token, 'src-proj', ['en']);
 
-      expect(__mockWriteUserData).toHaveBeenCalledWith(
-        token,
-        'projectIds',
-        JSON.stringify(['00000000-0000-0000-0000-000000000001']),
-      );
+      expect(writtenSummaryIds()).toEqual(['00000000-0000-0000-0000-000000000001']);
     });
 
-    it('appends to an existing index', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(['existing-id']));
+    it('lists the project after those already listed', async () => {
+      mockStore({ projectSummaries: storedSummaries(makeStubProject('existing-id')) });
 
       await createProject(token, 'src-proj', ['en']);
 
-      expect(__mockWriteUserData).toHaveBeenCalledWith(
-        token,
-        'projectIds',
-        JSON.stringify(['existing-id', '00000000-0000-0000-0000-000000000001']),
-      );
+      expect(writtenSummaryIds()).toEqual(['existing-id', '00000000-0000-0000-0000-000000000001']);
     });
 
-    it('rolls back the project write and rethrows when the index write fails', async () => {
+    it('rolls back the project write and rethrows when listing the project fails', async () => {
       __mockReadUserData.mockRejectedValue(enoentError());
       __mockWriteUserData
         .mockResolvedValueOnce(undefined) // project write succeeds
-        .mockRejectedValueOnce(new Error('disk full')); // index write fails
+        .mockRejectedValueOnce(new Error('disk full')); // summaries write fails
 
       await expect(createProject(token, 'src-proj', ['en'])).rejects.toThrow('disk full');
 
@@ -259,7 +293,7 @@ describe('projectStorage', () => {
       __mockReadUserData.mockRejectedValue(enoentError());
       __mockWriteUserData
         .mockResolvedValueOnce(undefined) // project write succeeds
-        .mockRejectedValueOnce(new Error('disk full')); // index write fails
+        .mockRejectedValueOnce(new Error('disk full')); // summaries write fails
       __mockDeleteUserData.mockRejectedValue(new Error('rollback failed'));
 
       await expect(createProject(token, 'src-proj', ['en'])).rejects.toThrow('disk full');
@@ -268,11 +302,11 @@ describe('projectStorage', () => {
     });
 
     it('records the orphaned project for cleanup when rollback fails', async () => {
-      // Index read (ENOENT → []) and the later pendingCleanup read (ENOENT → []) both miss.
+      // Summaries read and the later pendingCleanup read both miss.
       __mockReadUserData.mockRejectedValue(enoentError());
       __mockWriteUserData
         .mockResolvedValueOnce(undefined) // project write succeeds
-        .mockRejectedValueOnce(new Error('disk full')); // index write fails
+        .mockRejectedValueOnce(new Error('disk full')); // summaries write fails
       __mockDeleteUserData.mockRejectedValue(new Error('rollback failed'));
 
       await expect(createProject(token, 'src-proj', ['en'])).rejects.toThrow('disk full');
@@ -284,9 +318,9 @@ describe('projectStorage', () => {
       );
     });
 
-    it('logs and swallows a failure to record the orphan so the index error still surfaces', async () => {
+    it('logs and swallows a failure to record the orphan so the listing error still surfaces', async () => {
       __mockReadUserData.mockRejectedValue(enoentError());
-      // project write ok; index write fails; pendingCleanup write also fails.
+      // project write ok; summaries write fails; pendingCleanup write also fails.
       __mockWriteUserData
         .mockResolvedValueOnce(undefined)
         .mockRejectedValueOnce(new Error('disk full'))
@@ -303,7 +337,7 @@ describe('projectStorage', () => {
 
     it('does not re-record an orphan already in the pending-cleanup set', async () => {
       const orphanId = '00000000-0000-0000-0000-000000000001';
-      // Index read → ENOENT ([]); pendingCleanup read → already contains this orphan.
+      // Summaries read misses; pendingCleanup read → already contains this orphan.
       __mockReadUserData.mockImplementation((_t: unknown, key: unknown) =>
         key === 'pendingCleanup'
           ? Promise.resolve(JSON.stringify([orphanId]))
@@ -311,7 +345,7 @@ describe('projectStorage', () => {
       );
       __mockWriteUserData
         .mockResolvedValueOnce(undefined) // project write succeeds
-        .mockRejectedValueOnce(new Error('disk full')); // index write fails
+        .mockRejectedValueOnce(new Error('disk full')); // summaries write fails
       __mockDeleteUserData.mockRejectedValue(new Error('rollback failed'));
 
       await expect(createProject(token, 'src-proj', ['en'])).rejects.toThrow('disk full');
@@ -323,11 +357,48 @@ describe('projectStorage', () => {
       );
     });
 
+    it('unlists a project whose listing persisted though its write failed', async () => {
+      const created = makeStubProject('00000000-0000-0000-0000-000000000001');
+      mockStore({ projectSummaries: storedSummaries(created) });
+      __mockWriteUserData
+        .mockResolvedValueOnce(undefined) // project write succeeds
+        .mockRejectedValueOnce(new Error('disk full')); // summaries write fails
+
+      await expect(createProject(token, 'src-proj', ['en'])).rejects.toThrow('disk full');
+
+      expect(writtenSummaryIds()).toEqual([]);
+    });
+
+    it('keeps the record when the rollback cannot unlist the project', async () => {
+      __mockReadUserData.mockRejectedValue(new Error('disk unreadable'));
+      __mockWriteUserData.mockResolvedValueOnce(undefined); // project write succeeds
+
+      await expect(createProject(token, 'src-proj', ['en'])).rejects.toThrow('disk unreadable');
+
+      expect(__mockDeleteUserData).not.toHaveBeenCalled();
+    });
+
+    it('records the project for cleanup when the rollback cannot unlist it', async () => {
+      __mockReadUserData.mockImplementation((_t: unknown, key: unknown) =>
+        key === 'projectSummaries'
+          ? Promise.reject(new Error('disk unreadable'))
+          : Promise.reject(enoentError()),
+      );
+
+      await expect(createProject(token, 'src-proj', ['en'])).rejects.toThrow('disk unreadable');
+
+      expect(__mockWriteUserData).toHaveBeenCalledWith(
+        token,
+        'pendingCleanup',
+        JSON.stringify(['00000000-0000-0000-0000-000000000001']),
+      );
+    });
+
     it('does not record the orphan when the rollback delete succeeds', async () => {
       __mockReadUserData.mockRejectedValue(enoentError());
       __mockWriteUserData
         .mockResolvedValueOnce(undefined) // project write succeeds
-        .mockRejectedValueOnce(new Error('disk full')); // index write fails
+        .mockRejectedValueOnce(new Error('disk full')); // summaries write fails
       // deleteUserData resolves (default mock) → rollback succeeds, nothing to record.
 
       await expect(createProject(token, 'src-proj', ['en'])).rejects.toThrow('disk full');
@@ -474,41 +545,6 @@ describe('projectStorage', () => {
     });
   });
 
-  describe('listProjects', () => {
-    it('returns an empty array when no index exists', async () => {
-      __mockReadUserData.mockRejectedValue(enoentError());
-
-      const result = await listProjects(token);
-
-      expect(result).toEqual([]);
-    });
-
-    it('returns all projects listed in the index', async () => {
-      const p1 = makeStubProject('id-1');
-      const p2 = { ...p1, id: 'id-2' };
-      __mockReadUserData
-        .mockResolvedValueOnce(JSON.stringify(['id-1', 'id-2']))
-        .mockResolvedValueOnce(JSON.stringify(p1))
-        .mockResolvedValueOnce(JSON.stringify(p2));
-
-      const result = await listProjects(token);
-
-      expect(result).toEqual([p1, p2]);
-    });
-
-    it('omits projects whose storage keys are missing', async () => {
-      const p1 = makeStubProject('id-1');
-      __mockReadUserData
-        .mockResolvedValueOnce(JSON.stringify(['id-1', 'id-missing']))
-        .mockResolvedValueOnce(JSON.stringify(p1))
-        .mockRejectedValueOnce(enoentError());
-
-      const result = await listProjects(token);
-
-      expect(result).toEqual([p1]);
-    });
-  });
-
   describe('updateProjectMetadata', () => {
     const storedProject = makeStubProject('proj-id');
     // `updateProjectMetadata` stamps `updatedAt` with `new Date()`; freeze the clock so the exact
@@ -524,7 +560,7 @@ describe('projectStorage', () => {
     });
 
     it('returns the updated project with the new name and description', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       const result = await updateProjectMetadata(token, 'proj-id', 'My Name', 'My Desc', ['en']);
 
@@ -532,7 +568,7 @@ describe('projectStorage', () => {
     });
 
     it('writes the updated project to storage', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       await updateProjectMetadata(token, 'proj-id', 'My Name', 'My Desc', ['en']);
 
@@ -550,15 +586,44 @@ describe('projectStorage', () => {
     });
 
     it('refreshes updatedAt to the current time', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       const result = await updateProjectMetadata(token, 'proj-id', 'My Name', 'My Desc', ['en']);
 
       expect(result?.updatedAt).toBe(UPDATE_TIME);
     });
 
+    it("brings the project's listed summary up to date", async () => {
+      mockListedProject(storedProject);
+
+      await updateProjectMetadata(token, 'proj-id', 'My Name', 'My Desc', ['en']);
+
+      expect(writtenSummaries()).toEqual([
+        expect.objectContaining({ id: 'proj-id', name: 'My Name', updatedAt: UPDATE_TIME }),
+      ]);
+    });
+
+    it('resolves with the written project when its summary fails to refresh', async () => {
+      mockListedProject(storedProject);
+      __mockWriteUserData.mockImplementation((_t: unknown, key: unknown) =>
+        key === 'projectSummaries' ? Promise.reject(new Error('disk full')) : Promise.resolve(),
+      );
+
+      const result = await updateProjectMetadata(token, 'proj-id', 'My Name', 'My Desc', ['en']);
+
+      expect(result).toMatchObject({ id: 'proj-id', name: 'My Name' });
+    });
+
+    it('returns undefined for an unlisted project whose record remains', async () => {
+      mockStore({ 'project:proj-id': JSON.stringify(storedProject) });
+
+      const result = await updateProjectMetadata(token, 'proj-id', 'My Name', 'My Desc', ['en']);
+
+      expect(result).toBeUndefined();
+    });
+
     it('stamps the current model version over an older one', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify({ ...storedProject, modelVersion: 0 }));
+      mockListedProject({ ...storedProject, modelVersion: 0 });
 
       const result = await updateProjectMetadata(token, 'proj-id', 'My Name', 'My Desc', ['en']);
 
@@ -589,7 +654,7 @@ describe('projectStorage', () => {
 
     it('removes name and description when called with undefined', async () => {
       const withMeta = { ...storedProject, name: 'Old', description: 'Old desc' };
-      __mockReadUserData.mockResolvedValue(JSON.stringify(withMeta));
+      mockListedProject(withMeta);
 
       const result = await updateProjectMetadata(token, 'proj-id', undefined, undefined, ['en']);
 
@@ -614,7 +679,7 @@ describe('projectStorage', () => {
     });
 
     it('overwrites analysisLanguages with the provided value', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       const result = await updateProjectMetadata(token, 'proj-id', 'Name', 'Desc', ['fr', 'de']);
 
@@ -628,7 +693,7 @@ describe('projectStorage', () => {
     });
 
     it('leaves analysisLanguages unchanged when the current value is passed back', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       const result = await updateProjectMetadata(token, 'proj-id', 'Name', 'Desc', ['en']);
 
@@ -636,7 +701,7 @@ describe('projectStorage', () => {
     });
 
     it('sets targetProjectId when a value is provided', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       const result = await updateProjectMetadata(
         token,
@@ -652,7 +717,7 @@ describe('projectStorage', () => {
 
     it('clears targetProjectId when undefined is passed', async () => {
       const withTarget = { ...storedProject, targetProjectId: 'tgt-proj' };
-      __mockReadUserData.mockResolvedValue(JSON.stringify(withTarget));
+      mockListedProject(withTarget);
 
       const result = await updateProjectMetadata(token, 'proj-id', 'Name', 'Desc', ['en']);
 
@@ -667,72 +732,107 @@ describe('projectStorage', () => {
   });
 
   describe('deleteProject', () => {
+    const listed = storedSummaries(makeStubProject('to-delete'), makeStubProject('other'));
+
     it('deletes the project key from storage', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(['to-delete', 'other']));
+      mockStore({ projectSummaries: listed });
 
       await deleteProject(token, 'to-delete');
 
       expect(__mockDeleteUserData).toHaveBeenCalledWith(token, 'project:to-delete');
     });
 
-    it('removes the project ID from the index', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(['to-delete', 'other']));
+    it('unlists the project', async () => {
+      mockStore({ projectSummaries: listed });
 
       await deleteProject(token, 'to-delete');
 
-      expect(__mockWriteUserData).toHaveBeenCalledWith(
-        token,
-        'projectIds',
-        JSON.stringify(['other']),
-      );
+      expect(writtenSummaryIds()).toEqual(['other']);
     });
 
-    it('writes an empty index when the deleted project was the only one', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(['to-delete']));
+    it('writes no summaries when the project is not listed', async () => {
+      mockStore({ projectSummaries: listed });
+
+      await deleteProject(token, 'nonexistent');
+
+      expect(__mockWriteUserData).not.toHaveBeenCalled();
+    });
+
+    it('unlists the project when its record is already missing', async () => {
+      __mockDeleteUserData.mockRejectedValue(enoentError());
+      mockStore({ projectSummaries: listed });
 
       await deleteProject(token, 'to-delete');
 
-      expect(__mockWriteUserData).toHaveBeenCalledWith(token, 'projectIds', JSON.stringify([]));
+      expect(writtenSummaryIds()).toEqual(['other']);
     });
 
-    it('no-ops silently when the project is not in the index', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(['other']));
+    it('resolves when the unlisted record fails to delete', async () => {
+      __mockDeleteUserData.mockRejectedValue(new Error('permission denied'));
+      mockStore({ projectSummaries: listed });
 
-      await deleteProject(token, 'nonexistent');
+      await expect(deleteProject(token, 'to-delete')).resolves.toBeUndefined();
+    });
 
-      expect(__mockWriteUserData).toHaveBeenCalledWith(
-        token,
-        'projectIds',
-        JSON.stringify(['other']),
+    it('logs a failure to delete the unlisted record', async () => {
+      __mockDeleteUserData.mockRejectedValue(new Error('permission denied'));
+      mockStore({ projectSummaries: listed });
+
+      await deleteProject(token, 'to-delete');
+
+      expect(__mockLogger.error).toHaveBeenCalledWith(
+        expect.stringContaining('unlisted project to-delete'),
+        expect.any(Error),
       );
     });
 
-    it('completes index cleanup when the project file is already missing', async () => {
-      __mockDeleteUserData.mockRejectedValue(enoentError());
-      __mockReadUserData.mockResolvedValue(JSON.stringify(['to-delete', 'other']));
+    it('keeps the record when unlisting fails', async () => {
+      __mockWriteUserData.mockRejectedValue(new Error('disk full'));
+      mockStore({ projectSummaries: listed });
 
-      await deleteProject(token, 'to-delete');
+      await expect(deleteProject(token, 'to-delete')).rejects.toThrow('disk full');
+
+      expect(__mockDeleteUserData).not.toHaveBeenCalled();
+    });
+
+    it('records the project for cleanup when unlisting fails', async () => {
+      __mockWriteUserData.mockRejectedValueOnce(new Error('disk full'));
+      mockStore({ projectSummaries: listed });
+
+      await expect(deleteProject(token, 'to-delete')).rejects.toThrow('disk full');
 
       expect(__mockWriteUserData).toHaveBeenCalledWith(
         token,
-        'projectIds',
-        JSON.stringify(['other']),
+        'pendingCleanup',
+        JSON.stringify(['to-delete']),
       );
     });
 
-    it('propagates unexpected errors from deleteUserData', async () => {
+    it('records the unlisted project for cleanup when its deletion fails', async () => {
       __mockDeleteUserData.mockRejectedValue(new Error('permission denied'));
-      __mockReadUserData.mockResolvedValue(JSON.stringify(['to-delete']));
+      mockStore({ projectSummaries: listed });
 
-      await expect(deleteProject(token, 'to-delete')).rejects.toThrow('permission denied');
+      await deleteProject(token, 'to-delete');
+
+      expect(__mockWriteUserData).toHaveBeenCalledWith(
+        token,
+        'pendingCleanup',
+        JSON.stringify(['to-delete']),
+      );
     });
 
-    it('completes successfully when the project index does not exist', async () => {
-      __mockReadUserData.mockRejectedValue(enoentError());
+    it('logs and swallows a failure to record the undeleted project so the unlisting error still surfaces', async () => {
+      __mockWriteUserData
+        .mockRejectedValueOnce(new Error('disk full'))
+        .mockRejectedValueOnce(new Error('cleanup write failed'));
+      mockStore({ projectSummaries: listed });
 
-      await deleteProject(token, 'nonexistent-id');
+      await expect(deleteProject(token, 'to-delete')).rejects.toThrow('disk full');
 
-      expect(__mockWriteUserData).toHaveBeenCalledWith(token, 'projectIds', JSON.stringify([]));
+      expect(__mockLogger.error).toHaveBeenCalledWith(
+        expect.stringContaining('record undeleted project'),
+        expect.any(Error),
+      );
     });
   });
 
@@ -818,13 +918,12 @@ describe('projectStorage', () => {
       expect(__mockWriteUserData).not.toHaveBeenCalled();
     });
 
-    it('never deletes the record of an id still present in the index', async () => {
-      // 'live' is both recorded for cleanup and still in the index (e.g. an index write that
+    it('never deletes the record of an id still listed', async () => {
+      // 'live' is both recorded for cleanup and still listed (e.g. a summaries write that
       // persisted but reported failure). Its backing record must not be deleted.
-      __mockReadUserData.mockImplementation((_t: unknown, key: unknown) => {
-        if (key === 'pendingCleanup') return Promise.resolve(JSON.stringify(['live', 'orphan']));
-        if (key === 'projectIds') return Promise.resolve(JSON.stringify(['live']));
-        return Promise.reject(enoentError());
+      mockStore({
+        pendingCleanup: JSON.stringify(['live', 'orphan']),
+        projectSummaries: storedSummaries(makeStubProject('live')),
       });
 
       const cleaned = await sweepPendingCleanup(token);
@@ -836,10 +935,9 @@ describe('projectStorage', () => {
     });
 
     it('drops a live id from the set without counting or deleting it', async () => {
-      __mockReadUserData.mockImplementation((_t: unknown, key: unknown) => {
-        if (key === 'pendingCleanup') return Promise.resolve(JSON.stringify(['live']));
-        if (key === 'projectIds') return Promise.resolve(JSON.stringify(['live']));
-        return Promise.reject(enoentError());
+      mockStore({
+        pendingCleanup: JSON.stringify(['live']),
+        projectSummaries: storedSummaries(makeStubProject('live')),
       });
 
       const cleaned = await sweepPendingCleanup(token);
@@ -900,7 +998,7 @@ describe('projectStorage', () => {
     });
 
     it('returns the updated project with the new analysis', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       const result = await updateAnalysis(token, 'proj-id', newAnalysis);
 
@@ -908,7 +1006,7 @@ describe('projectStorage', () => {
     });
 
     it('reports an invariant violation the incoming analysis carries', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       await updateAnalysis(token, 'proj-id', analysisWithDanglingLink());
 
@@ -918,7 +1016,7 @@ describe('projectStorage', () => {
     });
 
     it('writes an analysis that violates an invariant rather than refusing it', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       const result = await updateAnalysis(token, 'proj-id', analysisWithDanglingLink());
 
@@ -927,7 +1025,7 @@ describe('projectStorage', () => {
     });
 
     it('writes the updated project to storage', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       await updateAnalysis(token, 'proj-id', newAnalysis);
 
@@ -944,15 +1042,59 @@ describe('projectStorage', () => {
     });
 
     it('refreshes updatedAt to the current time', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
 
       const result = await updateAnalysis(token, 'proj-id', newAnalysis);
 
       expect(result?.updatedAt).toBe(UPDATE_TIME);
     });
 
+    it("brings the project's listed summary up to date", async () => {
+      mockListedProject(storedProject);
+
+      await updateAnalysis(token, 'proj-id', newAnalysis);
+
+      expect(writtenSummaries()).toEqual([
+        expect.objectContaining({ id: 'proj-id', tokenAnalysisCount: 1, updatedAt: UPDATE_TIME }),
+      ]);
+    });
+
+    it('resolves with the written project when its summary fails to refresh', async () => {
+      mockListedProject(storedProject);
+      __mockWriteUserData.mockImplementation((_t: unknown, key: unknown) =>
+        key === 'projectSummaries' ? Promise.reject(new Error('disk full')) : Promise.resolve(),
+      );
+
+      const result = await updateAnalysis(token, 'proj-id', newAnalysis);
+
+      expect(result).toMatchObject({ id: 'proj-id', analysis: newAnalysis });
+      expect(writtenKeys()).toEqual(['project:proj-id', 'projectSummaries']);
+    });
+
+    it('logs a failure to refresh the summary', async () => {
+      mockListedProject(storedProject);
+      __mockWriteUserData.mockImplementation((_t: unknown, key: unknown) =>
+        key === 'projectSummaries' ? Promise.reject(new Error('disk full')) : Promise.resolve(),
+      );
+
+      await updateAnalysis(token, 'proj-id', newAnalysis);
+
+      expect(__mockLogger.error).toHaveBeenCalledWith(
+        'Interlinearizer: failed to refresh the listed summary of project proj-id:',
+        expect.any(Error),
+      );
+    });
+
+    it('returns undefined for an unlisted project whose record remains', async () => {
+      mockStore({ 'project:proj-id': JSON.stringify(storedProject) });
+
+      const result = await updateAnalysis(token, 'proj-id', newAnalysis);
+
+      expect(result).toBeUndefined();
+    });
+
     it('stamps the current model version over an older one', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify({ ...storedProject, modelVersion: 0 }));
+      mockListedProject({ ...storedProject, modelVersion: 0 });
 
       const result = await updateAnalysis(token, 'proj-id', newAnalysis);
 
@@ -995,7 +1137,7 @@ describe('projectStorage', () => {
     });
 
     it('writes a provided segmentation delta onto the project', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify(storedProject));
+      mockListedProject(storedProject);
       const segmentation = { removedVerseStarts: ['GEN 1:2:0'], addedStarts: [] };
 
       const result = await updateAnalysis(token, 'proj-id', newAnalysis, segmentation);
@@ -1019,7 +1161,7 @@ describe('projectStorage', () => {
         ...storedProject,
         segmentation: { removedVerseStarts: ['GEN 1:2:0'], addedStarts: [] },
       };
-      __mockReadUserData.mockResolvedValue(JSON.stringify(projectWithBoundaries));
+      mockListedProject(projectWithBoundaries);
 
       // eslint-disable-next-line no-null/no-null -- explicit "clear boundaries" sentinel under test
       const result = await updateAnalysis(token, 'proj-id', newAnalysis, null);
@@ -1032,7 +1174,7 @@ describe('projectStorage', () => {
         ...storedProject,
         segmentation: { removedVerseStarts: ['GEN 1:2:0'], addedStarts: [] },
       };
-      __mockReadUserData.mockResolvedValue(JSON.stringify(projectWithBoundaries));
+      mockListedProject(projectWithBoundaries);
 
       const result = await updateAnalysis(token, 'proj-id', newAnalysis);
 
@@ -1040,33 +1182,47 @@ describe('projectStorage', () => {
     });
   });
 
-  describe('getProjectsForSource', () => {
-    const baseProject = { ...makeStubProject('id-1'), sourceProjectId: 'src-a' };
+  describe('getProjectSummariesForSource', () => {
+    const inSource = (id: string, sourceProjectId: string) => ({
+      ...makeStubProject(id),
+      sourceProjectId,
+    });
+
+    it("returns only the source's projects", async () => {
+      mockStore({
+        projectSummaries: storedSummaries(
+          inSource('id-1', 'src-a'),
+          inSource('id-2', 'src-b'),
+          inSource('id-3', 'src-a'),
+        ),
+      });
+
+      const result = await getProjectSummariesForSource(token, 'src-a');
 
-    it('returns only projects whose sourceProjectId matches', async () => {
-      const p1 = { ...baseProject, id: 'id-1' };
-      const p2 = { ...baseProject, id: 'id-2', sourceProjectId: 'src-b' };
-      const p3 = { ...baseProject, id: 'id-3' };
-      __mockReadUserData
-        .mockResolvedValueOnce(JSON.stringify(['id-1', 'id-2', 'id-3']))
-        .mockResolvedValueOnce(JSON.stringify(p1))
-        .mockResolvedValueOnce(JSON.stringify(p2))
-        .mockResolvedValueOnce(JSON.stringify(p3));
+      expect(result.map(({ id }) => id)).toEqual(['id-1', 'id-3']);
+    });
+
+    it('reads no project record', async () => {
+      mockStore({
+        projectSummaries: storedSummaries(inSource('id-1', 'src-a')),
+        'project:id-1': JSON.stringify(inSource('id-1', 'src-a')),
+      });
 
-      const result = await getProjectsForSource(token, 'src-a');
+      await getProjectSummariesForSource(token, 'src-a');
 
-      expect(result).toEqual([p1, p3]);
+      expect(__mockReadUserData.mock.calls.map(([, key]) => key)).toEqual(['projectSummaries']);
     });
 
     it('returns an empty array when no projects match the source', async () => {
-      const p1 = { ...baseProject, id: 'id-1', sourceProjectId: 'src-b' };
-      __mockReadUserData
-        .mockResolvedValueOnce(JSON.stringify(['id-1']))
-        .mockResolvedValueOnce(JSON.stringify(p1));
+      mockStore({ projectSummaries: storedSummaries(inSource('id-1', 'src-b')) });
+
+      await expect(getProjectSummariesForSource(token, 'src-a')).resolves.toEqual([]);
+    });
 
-      const result = await getProjectsForSource(token, 'src-a');
+    it('propagates corrupt summaries rather than listing nothing', async () => {
+      mockStore({ projectSummaries: JSON.stringify([]) });
 
-      expect(result).toEqual([]);
+      await expect(getProjectSummariesForSource(token, 'src-a')).rejects.toThrow('is corrupt');
     });
   });
 
@@ -1084,12 +1240,12 @@ describe('projectStorage', () => {
         readCallCount += 1;
         ops.push(`read:${readCallCount}`);
         if (readCallCount === 1) return firstIndexReadGate;
-        return Promise.resolve(JSON.stringify([]));
+        return Promise.resolve(storedSummaries());
       });
       __mockWriteUserData.mockImplementation(
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         (_t: unknown, key: unknown, _v: unknown): Promise<void> => {
-          if (key === 'projectIds') ops.push('write:index');
+          if (key === 'projectSummaries') ops.push('write:index');
           return Promise.resolve();
         },
       );
@@ -1102,7 +1258,7 @@ describe('projectStorage', () => {
       const p1 = createProject(token, 'src', ['en']);
       const p2 = createProject(token, 'src', ['en']);
 
-      resolveFirstIndexRead(JSON.stringify([]));
+      resolveFirstIndexRead(storedSummaries());
 
       await Promise.all([p1, p2]);
 
@@ -1111,7 +1267,7 @@ describe('projectStorage', () => {
   });
 
   describe('error propagation', () => {
-    it('propagates non-ENOENT errors from readIds', async () => {
+    it('propagates non-ENOENT errors from reading the summaries', async () => {
       __mockReadUserData.mockRejectedValue(new Error('disk full'));
 
       await expect(createProject(token, 'src', ['en'])).rejects.toThrow('disk full');
@@ -1122,72 +1278,6 @@ describe('projectStorage', () => {
 
       await expect(getProject(token, 'abc')).rejects.toThrow('disk full');
     });
-
-    it('propagates a JSON parse error from readIds as a corrupt-index signal', async () => {
-      __mockReadUserData.mockResolvedValue('not valid json');
-
-      await expect(listProjects(token)).rejects.toThrow(SyntaxError);
-    });
-
-    it('throws a corruption error when the projectIds index is not an array', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify({ not: 'an array' }));
-
-      await expect(listProjects(token)).rejects.toThrow(/index is corrupt/);
-    });
-
-    it('throws a corruption error when the projectIds index holds non-strings', async () => {
-      __mockReadUserData.mockResolvedValue(JSON.stringify([1, 2, 3]));
-
-      await expect(listProjects(token)).rejects.toThrow(/index is corrupt/);
-    });
-
-    it('skips a project whose storage value is corrupt JSON and logs the error', async () => {
-      __mockReadUserData
-        .mockResolvedValueOnce(JSON.stringify(['abc']))
-        .mockResolvedValueOnce('not valid json');
-
-      const result = await listProjects(token);
-
-      expect(result).toEqual([]);
-      expect(__mockLogger.error).toHaveBeenCalledWith(
-        expect.stringContaining('abc'),
-        expect.any(SyntaxError),
-      );
-    });
-
-    it('skips a project whose record cannot be read and logs the error', async () => {
-      __mockReadUserData
-        .mockResolvedValueOnce(JSON.stringify(['broken', 'abc']))
-        .mockRejectedValueOnce(new Error('permission denied'))
-        .mockResolvedValueOnce(JSON.stringify(makeStubProject('abc')));
-
-      const result = await listProjects(token);
-
-      expect(result.map((p) => p.id)).toEqual(['abc']);
-      expect(__mockLogger.error).toHaveBeenCalledWith(
-        expect.stringContaining('broken'),
-        expect.objectContaining({ message: 'permission denied' }),
-      );
-    });
-
-    it('skips a project written by a newer build rather than failing the whole list', async () => {
-      const fromNewerBuild = {
-        ...makeStubProject('future-proj'),
-        modelVersion: CURRENT_MODEL_VERSION + 1,
-      };
-      __mockReadUserData
-        .mockResolvedValueOnce(JSON.stringify(['future-proj', 'abc']))
-        .mockResolvedValueOnce(JSON.stringify(fromNewerBuild))
-        .mockResolvedValueOnce(JSON.stringify(makeStubProject('abc')));
-
-      const result = await listProjects(token);
-
-      expect(result.map((p) => p.id)).toEqual(['abc']);
-      expect(__mockLogger.error).toHaveBeenCalledWith(
-        expect.stringContaining('future-proj'),
-        expect.objectContaining({ message: expect.stringContaining('newer than this build') }),
-      );
-    });
   });
 
   describe('hasDraft', () => {
@@ -2136,10 +2226,10 @@ describe('projectStorage', () => {
       expect(typeof json === 'string' && JSON.parse(json).modelVersion).toBe(CURRENT_MODEL_VERSION);
     });
 
-    it('never writes the projectIds index key', async () => {
+    it('never writes the project summaries', async () => {
       await saveDraft(token, 'src-proj', emptyDraft('src-proj'));
 
-      expect(__mockWriteUserData).not.toHaveBeenCalledWith(token, 'projectIds', expect.anything());
+      expect(writtenKeys()).not.toContain('projectSummaries');
     });
 
     it('replaces a stored draft this build can read', async () => {
@@ -2286,18 +2376,9 @@ describe('projectStorage', () => {
     };
     const SAVE_TIME = '2026-08-21T12:00:00.000Z';
 
-    /** Serves each record as the stored JSON for its key; any other key reads as never written. */
-    function mockStore(records: Record<string, unknown>): void {
-      __mockReadUserData.mockImplementation((_t: unknown, key: unknown) => {
-        if (typeof key === 'string' && key in records)
-          return Promise.resolve(JSON.stringify(records[key]));
-        return Promise.reject(enoentError());
-      });
-    }
-
     describe('freeze guard', () => {
       it('rejects updateAnalysis without writing', async () => {
-        mockStore({ 'project:import-id': importedProject });
+        mockStore({ 'project:import-id': JSON.stringify(importedProject) });
 
         await expect(updateAnalysis(token, 'import-id', emptyAnalysis())).rejects.toThrow(
           'Paratext 9 import and is read-only',
@@ -2306,7 +2387,7 @@ describe('projectStorage', () => {
       });
 
       it('rejects updateProjectMetadata without writing', async () => {
-        mockStore({ 'project:import-id': importedProject });
+        mockStore({ 'project:import-id': JSON.stringify(importedProject) });
 
         await expect(
           updateProjectMetadata(token, 'import-id', 'new name', undefined, ['en']),
@@ -2315,7 +2396,10 @@ describe('projectStorage', () => {
       });
 
       it('still allows deleteProject', async () => {
-        mockStore({ 'project:import-id': importedProject, projectIds: ['import-id'] });
+        mockStore({
+          'project:import-id': JSON.stringify(importedProject),
+          projectSummaries: storedSummaries(importedProject),
+        });
 
         await deleteProject(token, 'import-id');
 
@@ -2326,9 +2410,9 @@ describe('projectStorage', () => {
     describe('getPt9ImportForSource', () => {
       it('returns the import among the source projects', async () => {
         mockStore({
-          projectIds: ['plain-id', 'import-id'],
-          'project:plain-id': makeStubProject('plain-id'),
-          'project:import-id': importedProject,
+          projectSummaries: storedSummaries(makeStubProject('plain-id'), importedProject),
+          'project:plain-id': JSON.stringify(makeStubProject('plain-id')),
+          'project:import-id': JSON.stringify(importedProject),
         });
 
         const result = await getPt9ImportForSource(token, 'src-project');
@@ -2338,8 +2422,8 @@ describe('projectStorage', () => {
 
       it('returns undefined when no source project carries pt9Import', async () => {
         mockStore({
-          projectIds: ['plain-id'],
-          'project:plain-id': makeStubProject('plain-id'),
+          projectSummaries: storedSummaries(makeStubProject('plain-id')),
+          'project:plain-id': JSON.stringify(makeStubProject('plain-id')),
         });
 
         await expect(getPt9ImportForSource(token, 'src-project')).resolves.toBeUndefined();
@@ -2360,8 +2444,8 @@ describe('projectStorage', () => {
         jest.useFakeTimers().setSystemTime(new Date(SAVE_TIME));
       });
 
-      it('creates the import and indexes it when the source has none', async () => {
-        mockStore({ projectIds: [] });
+      it('creates the import and lists it when the source has none', async () => {
+        mockStore({});
 
         const project = await savePt9Import(
           token,
@@ -2384,15 +2468,11 @@ describe('projectStorage', () => {
           analysis: newAnalysis,
           pt9Import: NEW_PROVENANCE,
         });
-        expect(__mockWriteUserData).toHaveBeenCalledWith(
-          token,
-          'projectIds',
-          JSON.stringify(['00000000-0000-0000-0000-000000000001']),
-        );
+        expect(writtenSummaryIds()).toEqual(['00000000-0000-0000-0000-000000000001']);
       });
 
       it('reports an invariant violation the imported analysis carries', async () => {
-        mockStore({ projectIds: [] });
+        mockStore({});
 
         await savePt9Import(
           token,
@@ -2411,8 +2491,11 @@ describe('projectStorage', () => {
 
       it('replaces the existing import wholesale, keeping only id and createdAt', async () => {
         mockStore({
-          projectIds: ['import-id'],
-          'project:import-id': { ...importedProject, targetProjectId: 'stray-target' },
+          projectSummaries: storedSummaries(importedProject),
+          'project:import-id': JSON.stringify({
+            ...importedProject,
+            targetProjectId: 'stray-target',
+          }),
         });
 
         const project = await savePt9Import(
@@ -2426,7 +2509,7 @@ describe('projectStorage', () => {
         );
 
         expect(project.id).toBe('import-id');
-        expect(__mockWriteUserData).toHaveBeenCalledTimes(1);
+        expect(writtenKeys()).toEqual(['project:import-id', 'projectSummaries']);
         expect(__mockWriteUserData).toHaveBeenCalledWith(
           token,
           'project:import-id',
@@ -2445,17 +2528,36 @@ describe('projectStorage', () => {
         );
       });
 
-      it('creates a fresh record when the import is deleted between lookup and write', async () => {
-        let importReads = 0;
-        __mockReadUserData.mockImplementation((_t: unknown, key: unknown) => {
-          if (key === 'projectIds') return Promise.resolve(JSON.stringify(['import-id']));
-          if (key === 'project:import-id') {
-            importReads += 1;
-            if (importReads === 1) return Promise.resolve(JSON.stringify(importedProject));
-          }
-          return Promise.reject(enoentError());
+      it("brings the import's listed summary up to date", async () => {
+        mockStore({
+          projectSummaries: storedSummaries(importedProject),
+          'project:import-id': JSON.stringify(importedProject),
         });
 
+        await savePt9Import(
+          token,
+          'src-project',
+          'Paratext 9 Interlinear',
+          'Imported from Paratext 9.',
+          ['en'],
+          newAnalysis,
+          NEW_PROVENANCE,
+        );
+
+        expect(writtenSummaries()).toEqual([
+          expect.objectContaining({
+            id: 'import-id',
+            name: 'Paratext 9 Interlinear',
+            tokenAnalysisCount: 1,
+            pt9Import: NEW_PROVENANCE,
+          }),
+        ]);
+      });
+
+      it('creates a fresh record when the import is deleted between lookup and write', async () => {
+        // Still listed, but its record is gone by the time the replace reads it.
+        mockStore({ projectSummaries: storedSummaries(importedProject) });
+
         const project = await savePt9Import(
           token,
           'src-project',
@@ -2473,13 +2575,72 @@ describe('projectStorage', () => {
           expect.stringContaining('"pt9Import"'),
         );
       });
+
+      it('unlists an import whose record is missing', async () => {
+        writeThroughStore({ projectSummaries: storedSummaries(importedProject) });
+
+        await savePt9Import(
+          token,
+          'src-project',
+          'Paratext 9 Interlinear',
+          'Imported from Paratext 9.',
+          ['en'],
+          newAnalysis,
+          NEW_PROVENANCE,
+        );
+
+        expect(writtenSummaryIds()).toEqual(['00000000-0000-0000-0000-000000000001']);
+      });
+
+      it('replaces the import it created in place of one whose record was missing', async () => {
+        writeThroughStore({ projectSummaries: storedSummaries(importedProject) });
+        const sync = () =>
+          savePt9Import(
+            token,
+            'src-project',
+            'Paratext 9 Interlinear',
+            'Imported from Paratext 9.',
+            ['en'],
+            newAnalysis,
+            NEW_PROVENANCE,
+          );
+
+        const created = await sync();
+        const replaced = await sync();
+
+        expect(replaced.id).toBe(created.id);
+        expect(writtenSummaryIds()).toEqual([created.id]);
+      });
+
+      it('creates a fresh import when the existing one is unlisted between lookup and write', async () => {
+        // Listed at lookup only; its record outlives the deletion that unlisted it.
+        const summaryReads = [storedSummaries(importedProject)];
+        __mockReadUserData.mockImplementation(async (_t: unknown, key: unknown) => {
+          if (key === 'project:import-id') return JSON.stringify(importedProject);
+          const listed = key === 'projectSummaries' ? summaryReads.shift() : undefined;
+          if (listed === undefined) throw enoentError();
+          return listed;
+        });
+
+        const project = await savePt9Import(
+          token,
+          'src-project',
+          'Paratext 9 Interlinear',
+          'Imported from Paratext 9.',
+          ['en'],
+          newAnalysis,
+          NEW_PROVENANCE,
+        );
+
+        expect(project.id).toBe('00000000-0000-0000-0000-000000000001');
+      });
     });
 
     describe('createEditableCopy', () => {
       it('creates an editable project carrying the analysis and no pt9Import', async () => {
         mockStore({
-          projectIds: ['import-id'],
-          'project:import-id': importedProject,
+          projectSummaries: storedSummaries(importedProject),
+          'project:import-id': JSON.stringify(importedProject),
         });
 
         const copy = await createEditableCopy(token, 'import-id', 'My Copy', 'my description');
@@ -2493,15 +2654,14 @@ describe('projectStorage', () => {
           analysis: importedProject.analysis,
         });
         expect(copy).not.toHaveProperty('pt9Import');
-        expect(__mockWriteUserData).toHaveBeenCalledWith(
-          token,
-          'projectIds',
-          JSON.stringify(['import-id', '00000000-0000-0000-0000-000000000001']),
-        );
+        expect(writtenSummaryIds()).toEqual(['import-id', '00000000-0000-0000-0000-000000000001']);
       });
 
       it('omits the description when none is given', async () => {
-        mockStore({ projectIds: ['import-id'], 'project:import-id': importedProject });
+        mockStore({
+          projectSummaries: storedSummaries(importedProject),
+          'project:import-id': JSON.stringify(importedProject),
+        });
 
         const copy = await createEditableCopy(token, 'import-id', 'My Copy');
 
@@ -2518,7 +2678,7 @@ describe('projectStorage', () => {
       });
 
       it('throws when the project is not a Paratext 9 import', async () => {
-        mockStore({ 'project:plain-id': makeStubProject('plain-id') });
+        mockStore({ 'project:plain-id': JSON.stringify(makeStubProject('plain-id')) });
 
         await expect(createEditableCopy(token, 'plain-id', 'My Copy')).rejects.toThrow(
           'not a Paratext 9 import',
@@ -2544,19 +2704,6 @@ describe('projectStorage', () => {
         ],
       };
 
-      /** Keeps every write, serving it back to later reads. */
-      function writeThroughStore(): void {
-        const records = new Map<string, string>();
-        __mockWriteUserData.mockImplementation(async (_t: unknown, key: string, value: string) => {
-          records.set(key, value);
-        });
-        __mockReadUserData.mockImplementation(async (_t: unknown, key: string) => {
-          const value = records.get(key);
-          if (value === undefined) throw enoentError();
-          return value;
-        });
-      }
-
       /** Imports {@link IMPORTED} and makes an editable copy of it. */
       async function importAndCopy() {
         writeThroughStore();
diff --git a/src/__tests__/services/projectSummaries.test.ts b/src/__tests__/services/projectSummaries.test.ts
new file mode 100644
index 000000000..956f4b282
--- /dev/null
+++ b/src/__tests__/services/projectSummaries.test.ts
@@ -0,0 +1,209 @@
+/// <reference types="jest" />
+
+import type { InterlinearProject } from 'interlinearizer';
+import { ProjectSummaries, summarizeProject } from '../../services/projectSummaries';
+import type { KeyValueStorage } from '../../types/analysis-repository';
+import { CURRENT_MODEL_VERSION } from '../../types/model-version';
+import { FIXTURE_STAMPS, makeStubProject } from '../test-helpers';
+
+const KEY = 'projectSummaries';
+
+/** Storage held in a map, recording every write in order. */
+function memoryStorage(initial: Record<string, string> = {}) {
+  const records = new Map(Object.entries(initial));
+  const writes: string[] = [];
+  const storage: KeyValueStorage = {
+    read: async (key) => records.get(key),
+    write: async (key, data) => {
+      writes.push(key);
+      records.set(key, data);
+    },
+    delete: async (key) => {
+      records.delete(key);
+    },
+  };
+  return { storage, records, writes };
+}
+
+/** A project of `sourceProjectId` with one approved analysis in EXO and one in GEN. */
+function analyzedProject(id: string, sourceProjectId = 'src-project'): InterlinearProject {
+  const project = { ...makeStubProject(id), sourceProjectId };
+  ['EXO', 'GEN'].forEach((book) => {
+    project.analysis.tokenAnalyses.push({
+      id: `ta-${book}`,
+      ...FIXTURE_STAMPS,
+      surfaceText: 'word',
+      gloss: { en: 'gloss' },
+    });
+    project.analysis.tokenAnalysisLinks.push({
+      id: `tl-${book}`,
+      analysisId: `ta-${book}`,
+      ...FIXTURE_STAMPS,
+      status: 'approved',
+      token: { tokenRef: `${book} 1:1!0`, surfaceText: 'word' },
+    });
+  });
+  return project;
+}
+
+describe('ProjectSummaries', () => {
+  it('lists nothing when no summaries are stored', async () => {
+    const { storage } = memoryStorage();
+
+    await expect(new ProjectSummaries(storage).list()).resolves.toEqual([]);
+  });
+
+  it('lists added projects in the order they were added', async () => {
+    const summaries = new ProjectSummaries(memoryStorage().storage);
+    await summaries.add(summarizeProject(makeStubProject('first')));
+    await summaries.add(summarizeProject(makeStubProject('second')));
+
+    expect((await summaries.list()).map(({ id }) => id)).toEqual(['first', 'second']);
+  });
+
+  it('stamps the model version this build writes', async () => {
+    const { storage, records } = memoryStorage();
+    await new ProjectSummaries(storage).add(summarizeProject(makeStubProject('p1')));
+
+    expect(JSON.parse(records.get(KEY) ?? '{}').modelVersion).toBe(CURRENT_MODEL_VERSION);
+  });
+
+  it("lists only the given source's projects", async () => {
+    const summaries = new ProjectSummaries(memoryStorage().storage);
+    await summaries.add(summarizeProject(analyzedProject('a1', 'src-a')));
+    await summaries.add(summarizeProject(analyzedProject('b1', 'src-b')));
+    await summaries.add(summarizeProject(analyzedProject('a2', 'src-a')));
+
+    expect((await summaries.listForSource('src-a')).map(({ id }) => id)).toEqual(['a1', 'a2']);
+  });
+
+  it("brings a listed project's summary up to date in place", async () => {
+    const summaries = new ProjectSummaries(memoryStorage().storage);
+    await summaries.add(summarizeProject(makeStubProject('first')));
+    await summaries.add(summarizeProject(makeStubProject('second')));
+
+    await summaries.replace(summarizeProject({ ...analyzedProject('first'), name: 'Renamed' }));
+
+    expect(await summaries.list()).toEqual([
+      expect.objectContaining({ id: 'first', name: 'Renamed', tokenAnalysisCount: 2 }),
+      expect.objectContaining({ id: 'second' }),
+    ]);
+  });
+
+  it('leaves a project that is not listed unlisted when replacing it', async () => {
+    const { storage, writes } = memoryStorage();
+    const summaries = new ProjectSummaries(storage);
+    await summaries.add(summarizeProject(makeStubProject('listed')));
+
+    await summaries.replace(summarizeProject(makeStubProject('unlisted')));
+
+    expect((await summaries.list()).map(({ id }) => id)).toEqual(['listed']);
+    expect(writes).toHaveLength(1);
+  });
+
+  it('answers true when replacing a listed project', async () => {
+    const summaries = new ProjectSummaries(memoryStorage().storage);
+    await summaries.add(summarizeProject(makeStubProject('listed')));
+
+    await expect(summaries.replace(summarizeProject(makeStubProject('listed')))).resolves.toBe(
+      true,
+    );
+  });
+
+  it('answers false when replacing a project that is not listed', async () => {
+    const summaries = new ProjectSummaries(memoryStorage().storage);
+
+    await expect(summaries.replace(summarizeProject(makeStubProject('unlisted')))).resolves.toBe(
+      false,
+    );
+  });
+
+  it('unlists a removed project', async () => {
+    const summaries = new ProjectSummaries(memoryStorage().storage);
+    await summaries.add(summarizeProject(makeStubProject('kept')));
+    await summaries.add(summarizeProject(makeStubProject('removed')));
+
+    await summaries.remove('removed');
+
+    expect((await summaries.list()).map(({ id }) => id)).toEqual(['kept']);
+  });
+
+  it('writes nothing when removing a project that is not listed', async () => {
+    const { storage, writes } = memoryStorage();
+
+    await new ProjectSummaries(storage).remove('missing');
+
+    expect(writes).toEqual([]);
+  });
+
+  it('refuses summaries written by a newer build', async () => {
+    const { storage } = memoryStorage({
+      [KEY]: JSON.stringify({ modelVersion: CURRENT_MODEL_VERSION + 1, summaries: [] }),
+    });
+
+    await expect(new ProjectSummaries(storage).list()).rejects.toThrow('newer than this build');
+  });
+
+  it('leaves summaries written by a newer build unwritten', async () => {
+    const { storage, writes } = memoryStorage({
+      [KEY]: JSON.stringify({ modelVersion: CURRENT_MODEL_VERSION + 1, summaries: [] }),
+    });
+
+    await expect(
+      new ProjectSummaries(storage).add(summarizeProject(makeStubProject('p1'))),
+    ).rejects.toThrow();
+    expect(writes).toEqual([]);
+  });
+
+  it('throws on summaries holding invalid JSON', async () => {
+    const { storage } = memoryStorage({ [KEY]: '{ not json' });
+
+    await expect(new ProjectSummaries(storage).list()).rejects.toThrow(SyntaxError);
+  });
+
+  it('throws on summaries carrying no model version', async () => {
+    const { storage } = memoryStorage({ [KEY]: JSON.stringify({ summaries: [] }) });
+
+    await expect(new ProjectSummaries(storage).list()).rejects.toThrow('is corrupt');
+  });
+
+  it('throws on summaries that are not a list', async () => {
+    const { storage } = memoryStorage({
+      [KEY]: JSON.stringify({ modelVersion: CURRENT_MODEL_VERSION, summaries: {} }),
+    });
+
+    await expect(new ProjectSummaries(storage).list()).rejects.toThrow('is corrupt');
+  });
+
+  it('throws on summaries holding an entry that is not a project summary', async () => {
+    const { storage } = memoryStorage({
+      [KEY]: JSON.stringify({ modelVersion: CURRENT_MODEL_VERSION, summaries: [{ id: 'p1' }] }),
+    });
+
+    await expect(new ProjectSummaries(storage).list()).rejects.toThrow('is corrupt');
+  });
+
+  it('leaves corrupt summaries unwritten', async () => {
+    const { storage, writes } = memoryStorage({ [KEY]: 'null' });
+
+    await expect(
+      new ProjectSummaries(storage).add(summarizeProject(makeStubProject('p1'))),
+    ).rejects.toThrow('is corrupt');
+    expect(writes).toEqual([]);
+  });
+});
+
+describe('summarizeProject', () => {
+  it("describes a project's analysis by its books and payload count", () => {
+    expect(summarizeProject(analyzedProject('p1'))).toEqual(
+      expect.objectContaining({ id: 'p1', books: ['GEN', 'EXO'], tokenAnalysisCount: 2 }),
+    );
+  });
+
+  it("carries no part of a project's analysis", () => {
+    const summary = JSON.stringify(summarizeProject(analyzedProject('p1')));
+
+    expect(summary).not.toContain('"analysis"');
+    expect(summary).not.toContain('tokenAnalysisLinks');
+  });
+});
diff --git a/src/__tests__/services/pt9ImportService.test.ts b/src/__tests__/services/pt9ImportService.test.ts
index d3e65730c..497e14a71 100644
--- a/src/__tests__/services/pt9ImportService.test.ts
+++ b/src/__tests__/services/pt9ImportService.test.ts
@@ -11,7 +11,12 @@ import type {
 } from 'platform-scripture';
 import { hasNoInterlinearizerState, importPt9Project } from '../../services/pt9ImportService';
 import { resetQueuesForTesting } from '../../services/projectStorage';
-import { createTestActivationContext, enoentError, makeStubProject } from '../test-helpers';
+import {
+  createTestActivationContext,
+  enoentError,
+  makeStubProject,
+  storedSummaries,
+} from '../test-helpers';
 
 /**
  * The backend-mock jest fns this suite drives: the PAPI boundary (project data providers,
@@ -234,7 +239,7 @@ describe('importPt9Project', () => {
       pt9Import: { fileHashes: { 'Lexicon.xml': 'old' }, importedAt: '2026-08-01T00:00:00.000Z' },
     };
     __mockReadUserData.mockImplementation((_t: unknown, key: unknown) => {
-      if (key === 'projectIds') return Promise.resolve(JSON.stringify(['import-id']));
+      if (key === 'projectSummaries') return Promise.resolve(storedSummaries(existing));
       if (key === 'project:import-id') return Promise.resolve(JSON.stringify(existing));
       return Promise.reject(enoentError());
     });
@@ -281,7 +286,7 @@ describe('importPt9Project', () => {
       pt9Import: { fileHashes: { 'Lexicon.xml': 'old' }, importedAt: '2026-08-01T00:00:00.000Z' },
     };
     __mockReadUserData.mockImplementation((_t: unknown, key: unknown) => {
-      if (key === 'projectIds') return Promise.resolve(JSON.stringify(['import-id']));
+      if (key === 'projectSummaries') return Promise.resolve(storedSummaries(existing));
       if (key === 'project:import-id') return Promise.resolve(JSON.stringify(existing));
       return Promise.reject(enoentError());
     });
@@ -323,7 +328,7 @@ describe('importPt9Project', () => {
       pt9Import: { fileHashes: { 'Lexicon.xml': 'old' }, importedAt: '2026-08-01T00:00:00.000Z' },
     };
     __mockReadUserData.mockImplementation((_t: unknown, key: unknown) => {
-      if (key === 'projectIds') return Promise.resolve(JSON.stringify(['import-id']));
+      if (key === 'projectSummaries') return Promise.resolve(storedSummaries(existing));
       if (key === 'project:import-id') return Promise.resolve(JSON.stringify(existing));
       return Promise.reject(enoentError());
     });
@@ -495,7 +500,7 @@ describe('importPt9Project', () => {
       pt9Import: { fileHashes: { 'Lexicon.xml': 'old' }, importedAt: '2026-08-01T00:00:00.000Z' },
     };
     __mockReadUserData.mockImplementation((_t: unknown, key: unknown) => {
-      if (key === 'projectIds') return Promise.resolve(JSON.stringify(['import-id']));
+      if (key === 'projectSummaries') return Promise.resolve(storedSummaries(existing));
       if (key === 'project:import-id') return Promise.resolve(JSON.stringify(existing));
       return Promise.reject(enoentError());
     });
@@ -574,8 +579,7 @@ describe('hasNoInterlinearizerState', () => {
 
   it('answers false when a project already exists for the source', async () => {
     seedStorage({
-      projectIds: JSON.stringify(['p1']),
-      'project:p1': JSON.stringify(makeStubProject('p1')),
+      projectSummaries: storedSummaries(makeStubProject('p1')),
     });
 
     await expect(hasNoInterlinearizerState(token, 'src-project')).resolves.toBe(false);
diff --git a/src/__tests__/test-helpers.ts b/src/__tests__/test-helpers.ts
index 4dc98de72..417689f75 100644
--- a/src/__tests__/test-helpers.ts
+++ b/src/__tests__/test-helpers.ts
@@ -10,6 +10,7 @@ import {
   type PhraseStripContextValue,
 } from '../components/PhraseStripContext';
 import type { SegmentPages } from '../hooks/useSegmentPages';
+import { summarizeProject } from '../services/projectSummaries';
 import { emptyAnalysis } from '../types/empty-factories';
 import { CURRENT_MODEL_VERSION } from '../types/model-version';
 import type { InterlinearProjectSummary } from '../types/interlinear-project-summary';
@@ -381,6 +382,14 @@ export function makeStubProject(id = 'proj-id'): InterlinearProject {
   };
 }
 
+/** The stored project summaries JSON listing `projects`, in order. */
+export function storedSummaries(...projects: InterlinearProject[]): string {
+  return JSON.stringify({
+    modelVersion: CURRENT_MODEL_VERSION,
+    summaries: projects.map(summarizeProject),
+  });
+}
+
 /**
  * Builds a minimal word token for use in component tests. Called without a surface text, it reuses
  * the ref as one, which is appropriate for tests that only need a syntactically valid token and do
diff --git a/src/main.ts b/src/main.ts
index de66e23d6..94c9f0695 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -16,10 +16,8 @@ import { readHostPerf, setHostPerfMarks } from './services/hostPerf';
 import * as projectStorage from './services/projectStorage';
 import * as pt9ImportService from './services/pt9ImportService';
 import type { Pt9ImportResult } from './services/pt9ImportService';
-import { toProjectSummary } from './types/interlinear-project-summary';
 import { isDraftProject, isSegmentationDelta, isTextAnalysis } from './types/type-guards';
 import { perfTime, perfTimeAsync } from './utils/perf-marks';
-import { summarizeAnalysis } from './utils/project-analysis-summary';
 
 // #region WebView provider
 
@@ -222,12 +220,12 @@ async function createInterlinearProject(
  * from the WebView via `papi.commands.sendCommand` when the user deletes a project from the
  * select-project modal.
  *
- * @throws {SyntaxError} If the project-IDs index contains invalid JSON.
- * @throws {Error} If the stored project-IDs index is not an array of strings (a corrupt index).
- * @throws If `papi.storage.readUserData` rejects for a non-ENOENT reason while reading the index,
- *   if `papi.storage.deleteUserData` rejects for a non-ENOENT reason, or if
- *   `papi.storage.writeUserData` rejects when updating the index. All storage errors are logged and
- *   shown as a notification before being re-thrown so the caller can handle failure UX.
+ * @throws {SyntaxError} If the stored project summaries contain invalid JSON.
+ * @throws {Error} If the stored project summaries were written by a newer build, or are corrupt.
+ * @throws If `papi.storage.readUserData` rejects for a non-ENOENT reason while reading the
+ *   summaries, or if `papi.storage.writeUserData` rejects when updating them. All storage errors
+ *   are logged and shown as a notification before being re-thrown so the caller can handle failure
+ *   UX.
  */
 async function deleteInterlinearProject(interlinearProjectId: string): Promise<void> {
   try {
@@ -592,28 +590,22 @@ async function saveInterlinearDraft(sourceProjectId: string, draftJson: string):
  * The WebView deserializes this to populate its project picker and to decide whether to prompt
  * "create new" or "select existing" when the user opens the project menu.
  *
- * Each project's analysis is summarized rather than sent whole, so the response grows with the
- * number of projects and not with the size of their analyses; opening one fetches it by id.
+ * Neither the read nor the response grows with the size of the projects' analyses.
  *
  * @param sourceProjectId - Platform.Bible project ID of the source text to query.
- * @throws {SyntaxError} If the project-IDs index contains invalid JSON. Corrupted individual
- *   project records are logged and skipped, not thrown.
- * @throws {Error} If the stored project-IDs index is not an array of strings (a corrupt index).
+ * @throws {SyntaxError} If the stored project summaries contain invalid JSON.
+ * @throws {Error} If the stored project summaries were written by a newer build, or are corrupt.
  * @throws If `papi.storage.readUserData` rejects for a non-ENOENT reason. Callers can use this to
  *   distinguish a storage outage from a legitimately empty list.
  */
 async function getProjectsForSource(sourceProjectId: string): Promise<string> {
   try {
     return await perfTimeAsync('getProjectsForSource', async () => {
-      const projects = await projectStorage.getProjectsForSource(executionToken, sourceProjectId);
-      return perfTime('getProjectsForSource:serialize', () =>
-        JSON.stringify(
-          projects.map((project) => ({
-            ...toProjectSummary(project),
-            ...summarizeAnalysis(project.analysis),
-          })),
-        ),
+      const summaries = await projectStorage.getProjectSummariesForSource(
+        executionToken,
+        sourceProjectId,
       );
+      return perfTime('getProjectsForSource:serialize', () => JSON.stringify(summaries));
     });
   } catch (e) {
     logger.error('Interlinearizer: failed to list projects for source', e);
diff --git a/src/services/projectStorage.ts b/src/services/projectStorage.ts
index 305800a13..f090134cb 100644
--- a/src/services/projectStorage.ts
+++ b/src/services/projectStorage.ts
@@ -8,27 +8,27 @@ import type {
 } from 'interlinearizer';
 import type { KeyValueStorage } from '../types/analysis-repository';
 import { emptyAnalysis } from '../types/empty-factories';
+import type { InterlinearProjectSummary } from '../types/interlinear-project-summary';
 import { assertSupportedModelVersion, CURRENT_MODEL_VERSION } from '../types/model-version';
 import { hasLinkWithoutId, isStringArray } from '../types/type-guards';
 import { reportAnalysisViolations } from '../utils/analysis-violations';
-import { perfTime, perfTimeAsync, perfTimeAsyncExcluding } from '../utils/perf-marks';
+import { perfTime, perfTimeAsync } from '../utils/perf-marks';
 import { DraftRepository } from './draftRepository';
+import { ProjectSummaries, summarizeProject } from './projectSummaries';
 import { draftKey, projectKey } from './storageKeys';
 
-const PROJECT_IDS_KEY = 'projectIds';
-
 /**
  * Storage key holding the set of project IDs whose records were orphaned by a failed rollback (see
- * {@link createProject}). Each entry is a `project:{id}` record that was written but never added to
- * the index and could not be deleted at the time; {@link sweepPendingCleanup} retries their
- * deletion.
+ * {@link createProject}) or a failed deletion (see {@link deleteProject}). Each entry is an unlisted
+ * `project:{id}` record that could not be deleted at the time; {@link sweepPendingCleanup} retries
+ * their deletion.
  */
 const PENDING_CLEANUP_KEY = 'pendingCleanup';
 
 /**
- * Serializes all read-modify-write operations on the shared `projectIds` index. Every operation
- * that reads then writes the index must be enqueued here so concurrent calls (e.g. from two open
- * WebView tabs) cannot interleave at await boundaries and silently overwrite each other's updates.
+ * Serializes all read-modify-write operations on the shared project summaries. Every operation that
+ * reads then writes them must be enqueued here so concurrent calls (e.g. from two open WebView
+ * tabs) cannot interleave at await boundaries and silently overwrite each other's updates.
  */
 let indexQueue: Promise<unknown> = Promise.resolve();
 
@@ -74,6 +74,32 @@ function userDataStorage(token: ExecutionToken): KeyValueStorage {
   };
 }
 
+function projectSummaries(token: ExecutionToken): ProjectSummaries {
+  return new ProjectSummaries(userDataStorage(token));
+}
+
+/**
+ * Brings the listed summary of a project whose record was just written up to date. A failure is
+ * logged rather than thrown, leaving the summary stale until the project's next write.
+ *
+ * @returns `false` when the project is unlisted, so deleted, and `true` when it is listed or the
+ *   refresh failed.
+ */
+async function refreshSummary(
+  token: ExecutionToken,
+  summary: InterlinearProjectSummary,
+): Promise<boolean> {
+  try {
+    return await enqueueIndexOp(() => projectSummaries(token).replace(summary));
+  } catch (e) {
+    logger.error(
+      `Interlinearizer: failed to refresh the listed summary of project ${summary.id}:`,
+      e,
+    );
+    return true;
+  }
+}
+
 /** The source project's draft repository, created over `token`'s user data on first use. */
 function draftRepositoryFor(token: ExecutionToken, sourceProjectId: string): DraftRepository {
   const existing = draftRepositories.get(sourceProjectId);
@@ -221,31 +247,6 @@ async function readJsonArray(token: ExecutionToken, key: string): Promise<unknow
   }
 }
 
-/**
- * Reads the stored list of project IDs. Unlike the pending-cleanup set, a corrupt index is never
- * silently reset to an empty array — that would drop every project's id at once and orphan all
- * their records — so a stored value that is not an array of strings throws a clear corruption error
- * rather than being coerced into subtle downstream failures (e.g. spreading a string into
- * characters in {@link createProject}, or calling `.filter` on a non-array in
- * {@link deleteProject}).
- *
- * @returns The stored project ID array, or an empty array if `projectIds` has never been written
- *   (ENOENT).
- * @throws {SyntaxError} If the `projectIds` storage value contains invalid JSON.
- * @throws {Error} If the parsed `projectIds` value is not an array of strings (a corrupt index).
- * @throws If `papi.storage.readUserData` rejects for any non-ENOENT reason (e.g. permission denied,
- *   I/O error).
- */
-async function readIds(token: ExecutionToken): Promise<string[]> {
-  const parsed = await readJsonArray(token, PROJECT_IDS_KEY);
-  if (!isStringArray(parsed)) {
-    throw new Error(
-      `Interlinearizer: '${PROJECT_IDS_KEY}' index is corrupt (expected an array of strings)`,
-    );
-  }
-  return parsed;
-}
-
 /**
  * Outcome of reading the pending-cleanup set, distinguishing a genuinely-empty (or well-formed) set
  * from a corrupt stored value. {@link sweepPendingCleanup} uses `corrupt` to decide whether it must
@@ -308,18 +309,17 @@ function recordPendingCleanup(token: ExecutionToken, id: string): Promise<void>
 
 /**
  * Retries deleting the orphaned project records recorded in the `pendingCleanup` set (see
- * {@link createProject}). For each recorded id:
+ * {@link createProject} and {@link deleteProject}). For each recorded id:
  *
- * - If the id is still present in the `projectIds` index, it belongs to a live project — its record
- *   must not be deleted. The id is dropped from the set without touching its record; it should
- *   never have been recorded (or has since become live) and is not an orphan to clean.
+ * - If the id is still listed among the project summaries, it belongs to a live project — its record
+ *   must not be deleted. The id is dropped from the set without touching its record.
  * - Otherwise the record is an orphan: its `project:{id}` deletion is attempted, treating ENOENT as
  *   success (already gone). On success the id is dropped from the set; on failure it is retained
  *   for the next attempt and logged.
  *
- * Consulting the index guards against destroying a live project's record if an id ever lands in the
- * set while still indexed (e.g. an index write that persists but then reports failure). Intended to
- * run opportunistically at activation.
+ * Consulting the summaries guards against destroying a live project's record when an id lands in
+ * the set while still listed, as a failed unlisting or a summaries write that persists but reports
+ * failure leaves it. Intended to run opportunistically at activation.
  *
  * The whole read-delete-rewrite cycle is serialized with every other write to the set, so it cannot
  * interleave with a concurrent {@link recordPendingCleanup} and drop a newly recorded orphan. The
@@ -328,9 +328,9 @@ function recordPendingCleanup(token: ExecutionToken, id: string): Promise<void>
  *
  * @returns A promise resolving to the number of orphaned records successfully deleted this pass
  *   (live ids dropped from the set without deleting their record are not counted).
- * @throws {SyntaxError} If the `projectIds` storage value contains invalid JSON.
- * @throws {Error} If the stored `projectIds` value is not an array of strings (a corrupt index).
- * @throws If reading the set or the index, or rewriting the set (`papi.storage.writeUserData`),
+ * @throws {SyntaxError} If the stored project summaries contain invalid JSON.
+ * @throws {Error} If the stored project summaries were written by a newer build, or are corrupt.
+ * @throws If reading the set or the summaries, or rewriting the set (`papi.storage.writeUserData`),
  *   rejects for a non-ENOENT reason. A per-record delete failure is not thrown; the id is retained
  *   instead.
  */
@@ -343,19 +343,21 @@ export function sweepPendingCleanup(token: ExecutionToken): Promise<number> {
       if (corrupt) await papi.storage.writeUserData(token, PENDING_CLEANUP_KEY, JSON.stringify([]));
       return 0;
     }
-    // Read the index directly rather than on the index queue: this snapshot is consulted only
-    // to protect live projects from deletion, and both directions of a stale read are safe. A read
-    // that misses a just-created project is harmless (a live project's id is never in the
-    // pending-cleanup work set), and a read that still shows a since-deleted project only makes the
+    // Read the summaries directly rather than on the index queue: this snapshot is consulted only
+    // to protect live projects from deletion, and both directions of a stale read are safe. An id
+    // is recorded only after its listing or unlisting has settled, so a read made after the set
+    // cannot miss a listed one, and a read that still shows a since-deleted project only makes the
     // sweep conservatively skip a deletion. A stale snapshot can never make the sweep delete a
     // record it should keep, so serializing this read would add contention for no benefit.
-    const indexed = new Set(await readIds(token));
+    const indexed = new Set((await projectSummaries(token).list()).map(({ id }) => id));
     // For each id, decide whether to keep it in the set and whether its record was cleaned.
     const outcomes = await Promise.all(
       ids.map(async (id) => {
         if (indexed.has(id)) {
           // Live project: never delete its record. Drop it from the set as a non-orphan.
-          logger.warn(`Interlinearizer: pending-cleanup id ${id} is a live project; not deleting`);
+          logger.warn(
+            `Interlinearizer: project ${id} is still listed; dropping it from pending cleanup and keeping its record`,
+          );
           return { keep: false, cleaned: false };
         }
         try {
@@ -378,8 +380,8 @@ export function sweepPendingCleanup(token: ExecutionToken): Promise<number> {
 
 /**
  * Creates a new interlinearizer project with empty analysis data and writes it to extension
- * storage. Appends the project ID to the stored index. `createdAt` and `updatedAt` are set to the
- * same creation timestamp.
+ * storage, listing its summary after every other project's. `createdAt` and `updatedAt` are set to
+ * the same creation timestamp.
  *
  * @param token - The execution token for storage access.
  * @param sourceProjectId - The Platform.Bible project ID of the source text.
@@ -390,10 +392,11 @@ export function sweepPendingCleanup(token: ExecutionToken): Promise<number> {
  *   when omitted the project is analysis-only and `links` is left undefined.
  * @param name - Optional user-facing name for the project.
  * @param description - Optional user-facing description for the project.
- * @throws {SyntaxError} If the `projectIds` storage value contains invalid JSON.
- * @throws {Error} If the stored `projectIds` value is not an array of strings (a corrupt index).
- * @throws If `papi.storage.readUserData` rejects for any non-ENOENT reason when reading the index.
- * @throws If the project or index `papi.storage.writeUserData` rejects. On an index-write failure
+ * @throws {SyntaxError} If the stored project summaries contain invalid JSON.
+ * @throws {Error} If the stored project summaries were written by a newer build, or are corrupt.
+ * @throws If `papi.storage.readUserData` rejects for any non-ENOENT reason when reading the
+ *   summaries.
+ * @throws If the project or summaries `papi.storage.writeUserData` rejects. On a summaries failure
  *   the original error is rethrown after best-effort rollback; a failed rollback does not throw —
  *   the orphaned record is instead recorded for a later {@link sweepPendingCleanup} (and a failure
  *   to even record it is logged and swallowed).
@@ -427,30 +430,29 @@ export async function createProject(
 }
 
 /**
- * Writes a newly built project record and appends its ID to the stored index, keeping the two in
- * step: on an index-write failure the record is rolled back (or, failing that, recorded for a later
- * {@link sweepPendingCleanup}) before the index error is rethrown, so no successful return leaves an
- * indexed-but-missing or written-but-unindexed project behind.
+ * Writes a newly built project record and lists its summary, keeping the two in step: on a failure
+ * to list it the project is unlisted and its record rolled back (or, failing that, recorded for a
+ * later {@link sweepPendingCleanup}) before the error is rethrown. No outcome leaves a
+ * listed-but-missing project behind, and no successful return leaves a written-but-unlisted one.
  */
 async function persistNewProject(
   token: ExecutionToken,
   project: InterlinearProject,
 ): Promise<void> {
   const { id } = project;
+  const summary = summarizeProject(project);
   await papi.storage.writeUserData(token, projectKey(id), JSON.stringify(project));
   try {
-    await enqueueIndexOp(async () => {
-      const ids = await readIds(token);
-      await papi.storage.writeUserData(token, PROJECT_IDS_KEY, JSON.stringify([...ids, id]));
-    });
+    await enqueueIndexOp(() => projectSummaries(token).add(summary));
   } catch (indexError) {
     try {
+      // A failed summaries write may still have persisted, so the record goes only once unlisted.
+      await enqueueIndexOp(() => projectSummaries(token).remove(id));
       await papi.storage.deleteUserData(token, projectKey(id));
     } catch (rollbackError) {
       logger.error(`Failed to roll back project ${id} after index write failure:`, rollbackError);
-      // The orphaned record was written but never indexed and could not be deleted. Record it so a
-      // later sweep retries the deletion; a failure to even record it is logged and swallowed so it
-      // never masks the original index error the caller needs to see.
+      // A later sweep deletes the record once the project is unlisted; a failure to record it must
+      // not mask the listing error.
       await recordPendingCleanup(token, id).catch((recordError) => {
         logger.error(`Failed to record orphaned project ${id} for cleanup:`, recordError);
       });
@@ -460,20 +462,20 @@ async function persistNewProject(
 }
 
 /**
- * Reads the single Paratext 9 import project for the given source project, or `undefined` when the
- * source has none. At most one project per source carries `pt9Import` (the import replaces it in
- * place rather than creating another), so the first match is the only match.
+ * Reads the summary of the single Paratext 9 import project for the given source project, or
+ * `undefined` when the source has none. At most one project per source carries `pt9Import` (the
+ * import replaces it in place rather than creating another), so the first match is the only match.
  *
- * @throws {SyntaxError} If a project's storage value contains invalid JSON.
- * @throws {Error} If a stored record was written by a newer build.
+ * @throws {SyntaxError} If the stored project summaries contain invalid JSON.
+ * @throws {Error} If the stored project summaries were written by a newer build, or are corrupt.
  * @throws If `papi.storage.readUserData` rejects for any non-ENOENT reason.
  */
 export async function getPt9ImportForSource(
   token: ExecutionToken,
   sourceProjectId: string,
-): Promise<InterlinearProject | undefined> {
-  const projects = await getProjectsForSource(token, sourceProjectId);
-  return projects.find((project) => project.pt9Import !== undefined);
+): Promise<InterlinearProjectSummary | undefined> {
+  const summaries = await getProjectSummariesForSource(token, sourceProjectId);
+  return summaries.find((summary) => summary.pt9Import !== undefined);
 }
 
 /**
@@ -491,9 +493,11 @@ export async function getPt9ImportForSource(
  * @param analysis - The converted analysis layer.
  * @param pt9Import - Provenance to store: per-file hashes and the import timestamp.
  * @throws {SyntaxError} If a read storage value contains invalid JSON.
- * @throws {Error} If a stored record was written by a newer build.
+ * @throws {Error} If a stored record was written by a newer build, or the stored project summaries
+ *   are corrupt.
  * @throws If `papi.storage.readUserData` or `papi.storage.writeUserData` rejects for a non-ENOENT
- *   reason. On a create, an index-write failure rolls back the record as in {@link createProject}.
+ *   reason. On a create, a failure to list the project rolls back the record as in
+ *   {@link createProject}.
  */
 export async function savePt9Import(
   token: ExecutionToken,
@@ -526,17 +530,21 @@ export async function savePt9Import(
   if (existing) {
     const replaced = await enqueueProjectOp(existing.id, async () => {
       const current = await getProject(token, existing.id);
-      if (!current) return undefined;
+      if (!current) {
+        // Listed without a record: unlisted so later syncs stop finding it.
+        await enqueueIndexOp(() => projectSummaries(token).remove(existing.id));
+        return undefined;
+      }
       const updated: InterlinearProject = {
         ...buildNew(),
         id: current.id,
         createdAt: current.createdAt,
       };
       await papi.storage.writeUserData(token, projectKey(current.id), JSON.stringify(updated));
-      return updated;
+      return (await refreshSummary(token, summarizeProject(updated))) ? updated : undefined;
     });
     if (replaced) return replaced;
-    // The import was deleted between the lookup and the queued write; fall through and create.
+    // The import is deleted, or was listed without a record.
   }
 
   const project = buildNew();
@@ -557,9 +565,12 @@ export async function savePt9Import(
  * @throws {Error} If no project with the given ID exists.
  * @throws {Error} If the project is not a Paratext 9 import - only frozen imports need an editable
  *   copy; ordinary projects are already editable.
- * @throws {SyntaxError} If the project's storage value contains invalid JSON.
- * @throws If storage reads or writes reject for a non-ENOENT reason. On an index-write failure the
- *   new record rolls back as in {@link createProject}.
+ * @throws {SyntaxError} If the project's storage value or the stored project summaries contain
+ *   invalid JSON.
+ * @throws {Error} If the project's record or the stored project summaries were written by a newer
+ *   build, or the summaries are corrupt.
+ * @throws If storage reads or writes reject for a non-ENOENT reason. On a failure to list the copy
+ *   the new record rolls back as in {@link createProject}.
  */
 export async function createEditableCopy(
   token: ExecutionToken,
@@ -650,53 +661,18 @@ function parseProject(raw: string, id: string): InterlinearProject {
 }
 
 /**
- * Returns all stored projects in creation order. Projects whose storage keys are missing (e.g.
- * after a failed delete) are silently omitted. Projects that fail to read or parse are logged and
- * skipped so a single corrupted record does not prevent access to the rest; a project written by a
- * newer build is one of those failures, and is omitted rather than reported.
- *
- * @throws {SyntaxError} If `projectIds` contains invalid JSON.
- * @throws {Error} If the stored `projectIds` value is not an array of strings (a corrupt index).
- * @throws If `papi.storage.readUserData` rejects for any non-ENOENT reason when reading the index.
- */
-export async function listProjects(token: ExecutionToken): Promise<InterlinearProject[]> {
-  const projects = await perfTimeAsyncExcluding(
-    'listProjects:read',
-    'listProjects:parse',
-    async () => {
-      const ids = await readIds(token);
-      return Promise.all(
-        ids.map(async (id) => {
-          try {
-            const raw = await readRecord(token, projectKey(id));
-            return raw === undefined
-              ? undefined
-              : perfTime('listProjects:parse', () => parseProject(raw, id));
-          } catch (e) {
-            logger.error(`Interlinearizer: failed to read project ${id}:`, e);
-            return undefined;
-          }
-        }),
-      );
-    },
-  );
-  return projects.filter((p): p is InterlinearProject => p !== undefined);
-}
-
-/**
- * Returns all interlinearizer projects whose `sourceProjectId` matches the given value, in creation
- * order.
+ * Returns the summaries of the interlinearizer projects analyzing `sourceProjectId`, in creation
+ * order, without reading any project record.
  *
- * @throws {SyntaxError} If `projectIds` or any project's storage value contains invalid JSON.
- * @throws {Error} If the stored `projectIds` value is not an array of strings (a corrupt index).
+ * @throws {SyntaxError} If the stored project summaries contain invalid JSON.
+ * @throws {Error} If the stored project summaries were written by a newer build, or are corrupt.
  * @throws If `papi.storage.readUserData` rejects for any non-ENOENT reason.
  */
-export async function getProjectsForSource(
+export function getProjectSummariesForSource(
   token: ExecutionToken,
   sourceProjectId: string,
-): Promise<InterlinearProject[]> {
-  const all = await listProjects(token);
-  return all.filter((p) => p.sourceProjectId === sourceProjectId);
+): Promise<InterlinearProjectSummary[]> {
+  return projectSummaries(token).listForSource(sourceProjectId);
 }
 
 /**
@@ -708,7 +684,8 @@ export async function getProjectsForSource(
  * @param analysis - The new `TextAnalysis` to persist.
  * @param segmentation - The new boundary delta to persist (`SegmentationDelta`), `null` to clear
  *   any stored boundaries, or `undefined` to leave the project's existing boundaries unchanged.
- * @returns The updated project record, or `undefined` if no project with the given ID exists.
+ * @returns The updated project record, or `undefined` if no project with the given ID exists or it
+ *   is unlisted.
  * @throws {SyntaxError} If the project's storage value contains invalid JSON.
  * @throws {Error} If the stored record was written by a newer build; nothing is written.
  * @throws {Error} If the project is a Paratext 9 import (`pt9Import` present); imports are
@@ -742,7 +719,8 @@ export async function updateAnalysis(
     await perfTimeAsync('updateAnalysis:write', () =>
       papi.storage.writeUserData(token, projectKey(id), JSON.stringify(updated)),
     );
-    return updated;
+    const summary = perfTime('updateAnalysis:summary', () => summarizeProject(updated));
+    return (await refreshSummary(token, summary)) ? updated : undefined;
   });
 }
 
@@ -758,7 +736,8 @@ export async function updateAnalysis(
  *   pass the current value to leave the field unchanged (it cannot be cleared).
  * @param targetProjectId - New target-project ID. `undefined` removes the target binding (the
  *   project becomes analysis-only); a string overwrites the existing value.
- * @returns The updated project record, or `undefined` if no project with the given ID exists.
+ * @returns The updated project record, or `undefined` if no project with the given ID exists or it
+ *   is unlisted.
  * @throws {SyntaxError} If the project's storage value contains invalid JSON.
  * @throws {Error} If the stored record was written by a newer build; nothing is written.
  * @throws {Error} If the project is a Paratext 9 import (`pt9Import` present); imports are
@@ -800,32 +779,42 @@ export async function updateProjectMetadata(
       updated.targetProjectId = targetProjectId;
     }
     await papi.storage.writeUserData(token, projectKey(id), JSON.stringify(updated));
-    return updated;
+    return (await refreshSummary(token, summarizeProject(updated))) ? updated : undefined;
   });
 }
 
 /**
- * Deletes the project with the given ID from storage and removes it from the index. No-ops silently
- * if the project does not exist.
+ * Unlists the project with the given ID and deletes its record. No-ops silently if the project does
+ * not exist. The deletion is committed once the project is unlisted: a record that then fails to
+ * delete is logged and left to a later {@link sweepPendingCleanup}, not reported.
  *
- * @throws {SyntaxError} If the `projectIds` storage value contains invalid JSON.
- * @throws {Error} If the stored `projectIds` value is not an array of strings (a corrupt index).
- * @throws If `papi.storage.readUserData` rejects for any non-ENOENT reason when reading the index.
- * @throws If `papi.storage.deleteUserData` throws for a reason other than ENOENT.
- * @throws If `papi.storage.writeUserData` rejects when updating `PROJECT_IDS_KEY`.
+ * @throws {SyntaxError} If the stored project summaries contain invalid JSON.
+ * @throws {Error} If the stored project summaries were written by a newer build, or are corrupt.
+ * @throws If `papi.storage.readUserData` rejects for any non-ENOENT reason when reading the
+ *   summaries.
+ * @throws If `papi.storage.writeUserData` rejects when updating the summaries; the record is kept
+ *   for a later {@link sweepPendingCleanup}, which deletes it only once it is unlisted.
  */
 export async function deleteProject(token: ExecutionToken, id: string): Promise<void> {
+  const recordForCleanup = () =>
+    recordPendingCleanup(token, id).catch((recordError) => {
+      logger.error(`Failed to record undeleted project ${id} for cleanup:`, recordError);
+    });
   await enqueueProjectOp(id, async () => {
+    try {
+      await enqueueIndexOp(() => projectSummaries(token).remove(id));
+    } catch (e) {
+      // A failed summaries write may still have persisted, leaving the record unlisted.
+      await recordForCleanup();
+      throw e;
+    }
     try {
       await papi.storage.deleteUserData(token, projectKey(id));
     } catch (e) {
-      if (!isNotFound(e)) throw e;
+      if (isNotFound(e)) return;
+      logger.error(`Failed to delete the record of unlisted project ${id}:`, e);
+      await recordForCleanup();
     }
-    await enqueueIndexOp(async () => {
-      const ids = await readIds(token);
-      const updated = ids.filter((i) => i !== id);
-      await papi.storage.writeUserData(token, PROJECT_IDS_KEY, JSON.stringify(updated));
-    });
   });
 }
 
@@ -849,8 +838,8 @@ export async function hasDraft(token: ExecutionToken, sourceProjectId: string):
  * Reads the draft working buffer for a source project, returning a fresh empty draft when none has
  * been written yet (ENOENT), when the stored draft fails validation, or when it belongs to a
  * different source project — the invalid draft is logged and silently discarded. Drafts are never
- * added to the `projectIds` index, so they stay out of {@link listProjects} and
- * {@link getProjectsForSource} and never appear in the project picker.
+ * listed among the project summaries, so they stay out of {@link getProjectSummariesForSource} and
+ * never appear in the project picker.
  *
  * A draft written by a newer build is refused rather than discarded, leaving it intact for the
  * build that can read it; {@link saveDraft} refuses to overwrite that same record.
diff --git a/src/services/projectSummaries.ts b/src/services/projectSummaries.ts
new file mode 100644
index 000000000..f4aae8438
--- /dev/null
+++ b/src/services/projectSummaries.ts
@@ -0,0 +1,117 @@
+import type { InterlinearProject } from 'interlinearizer';
+import type { KeyValueStorage } from '../types/analysis-repository';
+import { toProjectSummary } from '../types/interlinear-project-summary';
+import type { InterlinearProjectSummary } from '../types/interlinear-project-summary';
+import { assertSupportedModelVersion, CURRENT_MODEL_VERSION } from '../types/model-version';
+import { isInterlinearProjectSummary } from '../types/type-guards';
+import { summarizeAnalysis } from '../utils/project-analysis-summary';
+
+const PROJECT_SUMMARIES_KEY = 'projectSummaries';
+
+/** The summaries record as stored. */
+interface StoredSummaries {
+  modelVersion: number;
+  /** In creation order. */
+  summaries: InterlinearProjectSummary[];
+}
+
+function isStoredSummaries(value: unknown): value is StoredSummaries {
+  return (
+    !!value &&
+    typeof value === 'object' &&
+    'modelVersion' in value &&
+    typeof value.modelVersion === 'number' &&
+    'summaries' in value &&
+    Array.isArray(value.summaries) &&
+    value.summaries.every(isInterlinearProjectSummary)
+  );
+}
+
+/** What a project list shows about `project`, its analysis described rather than carried. */
+export function summarizeProject(project: InterlinearProject): InterlinearProjectSummary {
+  return { ...toProjectSummary(project), ...summarizeAnalysis(project.analysis) };
+}
+
+/**
+ * The summary of every saved project, for listing projects without reading their analyses. A
+ * project is listed exactly when this holds its summary.
+ *
+ * Writes must not overlap.
+ */
+export class ProjectSummaries {
+  private readonly storage: KeyValueStorage;
+
+  constructor(storage: KeyValueStorage) {
+    this.storage = storage;
+  }
+
+  /**
+   * Every listed project's summary, in creation order.
+   *
+   * @throws {SyntaxError} If the stored record contains invalid JSON.
+   * @throws {Error} If the stored record was written by a newer build, or is not a list of
+   *   summaries.
+   * @throws If storage rejects the read.
+   */
+  async list(): Promise<InterlinearProjectSummary[]> {
+    const raw = await this.storage.read(PROJECT_SUMMARIES_KEY);
+    if (raw === undefined) return [];
+    const parsed: unknown = JSON.parse(raw);
+    assertSupportedModelVersion(parsed, 'the project summaries');
+    if (!isStoredSummaries(parsed))
+      throw new Error(
+        `Interlinearizer: '${PROJECT_SUMMARIES_KEY}' is corrupt (expected a list of project summaries)`,
+      );
+    return parsed.summaries;
+  }
+
+  /**
+   * The summaries of the projects analyzing `sourceProjectId`, in creation order.
+   *
+   * @throws As {@link list} does.
+   */
+  async listForSource(sourceProjectId: string): Promise<InterlinearProjectSummary[]> {
+    return (await this.list()).filter((summary) => summary.sourceProjectId === sourceProjectId);
+  }
+
+  /**
+   * Lists a new project after every listed one.
+   *
+   * @throws As {@link list} does, writing nothing.
+   * @throws If storage rejects the write.
+   */
+  async add(summary: InterlinearProjectSummary): Promise<void> {
+    await this.write([...(await this.list()), summary]);
+  }
+
+  /**
+   * Replaces a listed project's summary with `summary`. A project not listed stays unlisted.
+   *
+   * @returns Whether the project is listed.
+   * @throws As {@link list} does, writing nothing.
+   * @throws If storage rejects the write.
+   */
+  async replace(summary: InterlinearProjectSummary): Promise<boolean> {
+    const summaries = await this.list();
+    if (!summaries.some(({ id }) => id === summary.id)) return false;
+    await this.write(summaries.map((listed) => (listed.id === summary.id ? summary : listed)));
+    return true;
+  }
+
+  /**
+   * Unlists project `id`, if listed.
+   *
+   * @throws As {@link list} does, writing nothing.
+   * @throws If storage rejects the write.
+   */
+  async remove(id: string): Promise<void> {
+    const summaries = await this.list();
+    const kept = summaries.filter((summary) => summary.id !== id);
+    if (kept.length !== summaries.length) await this.write(kept);
+  }
+
+  private async write(summaries: InterlinearProjectSummary[]): Promise<void> {
+    const stored: StoredSummaries = { modelVersion: CURRENT_MODEL_VERSION, summaries };
+    await this.storage.write(PROJECT_SUMMARIES_KEY, JSON.stringify(stored));
+  }
+}
diff --git a/src/services/pt9ImportService.ts b/src/services/pt9ImportService.ts
index 6498dee09..851f27fe0 100644
--- a/src/services/pt9ImportService.ts
+++ b/src/services/pt9ImportService.ts
@@ -48,7 +48,7 @@ export async function hasNoInterlinearizerState(
 ): Promise<boolean> {
   try {
     if (await projectStorage.hasDraft(token, sourceProjectId)) return false;
-    return (await projectStorage.getProjectsForSource(token, sourceProjectId)).length === 0;
+    return (await projectStorage.getProjectSummariesForSource(token, sourceProjectId)).length === 0;
   } catch (e) {
     logger.warn('Interlinearizer: Paratext 9 convert-offer state check failed; not offering', e);
     return false;
diff --git a/src/types/interlinearizer.d.ts b/src/types/interlinearizer.d.ts
index 24754cd83..eea1c47af 100644
--- a/src/types/interlinearizer.d.ts
+++ b/src/types/interlinearizer.d.ts
@@ -90,9 +90,11 @@ declare module 'papi-shared-types' {
      * existing" on first open.
      *
      * @param sourceProjectId - Platform.Bible project ID of the source text to query.
-     * @returns A JSON string containing an `InterlinearProject[]`; `"[]"` when none exist.
-     * @throws {SyntaxError} If the project-IDs index or any stored project record contains invalid
-     *   JSON.
+     * @returns A JSON string containing the projects' summaries, with no analysis; `"[]"` when none
+     *   exist.
+     * @throws {SyntaxError} If the stored project summaries contain invalid JSON.
+     * @throws {Error} If the stored project summaries were written by a newer build, or are
+     *   corrupt.
      * @throws If `papi.storage.readUserData` rejects for a reason other than the file not existing
      *   (propagated from the storage layer). Callers can use this to distinguish a storage outage
      *   from a legitimately empty list.
@@ -1484,7 +1486,7 @@ declare module 'interlinearizer' {
    *
    * Projects are stored via `papi.storage` (extension-host only) under two keys:
    *
-   * - `'projectIds'` — ordered `string[]` of all project UUIDs.
+   * - `'projectSummaries'` — the summary of every project, in creation order.
    * - `'project:{id}'` — JSON-serialized `InterlinearProject` for each project.
    */
   export interface InterlinearProject {
@@ -1591,7 +1593,7 @@ declare module 'interlinearizer' {
   /**
    * The always-present, auto-saved working buffer for a single source project. Decoupled from the
    * user's saved {@link InterlinearProject}s: it is stored under its own `draft:{sourceProjectId}`
-   * key, is never added to the `projectIds` index, and is never shown in the project picker.
+   * key, is never listed among the project summaries, and is never shown in the project picker.
    *
    * The draft is the runtime source of truth for the analysis being edited. Every gloss / phrase
    * write is persisted here (so work is never lost), independent of the active project. The active