Fix refreshIndexList() to respect fixed mode allowlist

In fixed mode (when indexNames are specified via CLI), calling list_indexes
would trigger refreshIndexList() which overwrote this.indexNames with ALL
indexes from the store, bypassing the original allowlist.

Changes:
- Add readonly originalIndexNames field to MultiIndexRunner to store the
  original allowlist in fixed mode
- In constructor, save the original indexNames if provided
- In refreshIndexList(), filter results to only include indexes in the
  original allowlist when in fixed mode

This ensures that in fixed mode (-i pytorch -i react), list_indexes only
returns the originally specified indexes, even if other indexes exist in
the store. In discovery mode (--discovery), all indexes are returned as
before.

Tests added to verify:
- Discovery mode includes all indexes from store
- Fixed mode respects the original allowlist
- Fixed mode handles missing indexes gracefully

Agent-Id: agent-cf0760a8-47e4-4742-a697-7de4bf2367e6

Author: richhankins

src/clients/multi-index-runner.test.ts

@@ -1,18 +1,17 @@
 /**
- * Tests for createSourceFromState
+ * Tests for MultiIndexRunner
  *
- * These tests verify that createSourceFromState correctly uses resolvedRef
+ * Tests for createSourceFromState verify that it correctly uses resolvedRef
  * from state metadata when creating source instances.
  *
- * We mock GitHub and Website sources to capture what config gets passed
- * to the constructors, without needing API credentials.
- *
- * Since all VCS sources (GitHub, GitLab, BitBucket) use the same getRef() logic,
- * we only test GitHub as the representative case.
+ * Tests for MultiIndexRunner.refreshIndexList verify that it respects
+ * the fixed mode allowlist when refreshing the index list.
  */
 
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { IndexStateSearchOnly, SourceMetadata } from "../core/types.js";
+import type { IndexStateSearchOnly, SourceMetadata, IndexState } from "../core/types.js";
+import type { IndexStoreReader } from "../stores/types.js";
+import { MultiIndexRunner } from "./multi-index-runner.js";
 
 // Mock only the sources we actually test
 vi.mock("../sources/github.js", () => ({
@@ -113,3 +112,128 @@ describe("createSourceFromState", () => {
     );
   });
 });
+
+describe("MultiIndexRunner.refreshIndexList", () => {
+  // Helper to create a mock store with multiple indexes
+  const createMockStoreWithIndexes = (indexNames: string[]): IndexStoreReader => {
+    const mockState = (name: string): IndexState => ({
+      version: 1,
+      contextState: { version: 1 } as any,
+      source: {
+        type: "github",
+        config: { owner: "test", repo: name },
+        syncedAt: new Date().toISOString(),
+      },
+    });
+
+    return {
+      loadState: vi.fn(),
+      loadSearch: vi.fn().mockImplementation((name: string) => {
+        if (indexNames.includes(name)) {
+          return Promise.resolve(mockState(name));
+        }
+        return Promise.resolve(null);
+      }),
+      list: vi.fn().mockResolvedValue(indexNames),
+    };
+  };
+
+  it("in discovery mode, refreshIndexList includes all indexes from store", async () => {
+    const store = createMockStoreWithIndexes(["pytorch", "react", "docs"]);
+
+    const runner = await MultiIndexRunner.create({
+      store,
+      // No indexNames = discovery mode
+    });
+
+    expect(runner.indexNames).toEqual(["pytorch", "react", "docs"]);
+
+    // Simulate store gaining a new index
+    (store.list as any).mockResolvedValue(["pytorch", "react", "docs", "vue"]);
+    (store.loadSearch as any).mockImplementation((name: string) => {
+      if (["pytorch", "react", "docs", "vue"].includes(name)) {
+        return Promise.resolve({
+          version: 1,
+          contextState: { version: 1 } as any,
+          source: {
+            type: "github",
+            config: { owner: "test", repo: name },
+            syncedAt: new Date().toISOString(),
+          },
+        });
+      }
+      return Promise.resolve(null);
+    });
+
+    await runner.refreshIndexList();
+    expect(runner.indexNames).toEqual(["pytorch", "react", "docs", "vue"]);
+  });
+
+  it("in fixed mode, refreshIndexList respects the original allowlist", async () => {
+    const store = createMockStoreWithIndexes(["pytorch", "react", "docs"]);
+
+    // Create runner in fixed mode with only pytorch and react
+    const runner = await MultiIndexRunner.create({
+      store,
+      indexNames: ["pytorch", "react"],
+    });
+
+    expect(runner.indexNames).toEqual(["pytorch", "react"]);
+
+    // Simulate store gaining a new index (docs is already there, vue is new)
+    (store.list as any).mockResolvedValue(["pytorch", "react", "docs", "vue"]);
+    (store.loadSearch as any).mockImplementation((name: string) => {
+      if (["pytorch", "react", "docs", "vue"].includes(name)) {
+        return Promise.resolve({
+          version: 1,
+          contextState: { version: 1 } as any,
+          source: {
+            type: "github",
+            config: { owner: "test", repo: name },
+            syncedAt: new Date().toISOString(),
+          },
+        });
+      }
+      return Promise.resolve(null);
+    });
+
+    await runner.refreshIndexList();
+
+    // Should still only include pytorch and react, not docs or vue
+    expect(runner.indexNames).toEqual(["pytorch", "react"]);
+  });
+
+  it("in fixed mode, refreshIndexList handles missing indexes gracefully", async () => {
+    const store = createMockStoreWithIndexes(["pytorch", "react"]);
+
+    // Create runner in fixed mode with pytorch, react, and a missing index
+    const runner = await MultiIndexRunner.create({
+      store,
+      indexNames: ["pytorch", "react"],
+    });
+
+    expect(runner.indexNames).toEqual(["pytorch", "react"]);
+
+    // Simulate pytorch being deleted from store
+    (store.list as any).mockResolvedValue(["react"]);
+    (store.loadSearch as any).mockImplementation((name: string) => {
+      if (name === "react") {
+        return Promise.resolve({
+          version: 1,
+          contextState: { version: 1 } as any,
+          source: {
+            type: "github",
+            config: { owner: "test", repo: name },
+            syncedAt: new Date().toISOString(),
+          },
+        });
+      }
+      return Promise.resolve(null);
+    });
+
+    await runner.refreshIndexList();
+
+    // Should only include react (pytorch is gone from store)
+    expect(runner.indexNames).toEqual(["react"]);
+  });
+});

src/clients/multi-index-runner.ts

@@ -92,6 +92,7 @@ export class MultiIndexRunner {
   private readonly searchOnly: boolean;
   private clientUserAgent?: string;
   private readonly clientCache = new Map<string, SearchClient>();
+  private readonly originalIndexNames: string[] | undefined;
 
   /** Available index names */
   indexNames: string[];
@@ -104,13 +105,15 @@ export class MultiIndexRunner {
     indexNames: string[],
     indexes: IndexInfo[],
     searchOnly: boolean,
-    clientUserAgent?: string
+    clientUserAgent?: string,
+    originalIndexNames?: string[]
   ) {
     this.store = store;
     this.indexNames = indexNames;
     this.indexes = indexes;
     this.searchOnly = searchOnly;
     this.clientUserAgent = clientUserAgent;
+    this.originalIndexNames = originalIndexNames;
   }
 
   /**
@@ -124,6 +127,9 @@ export class MultiIndexRunner {
     const allIndexNames = await store.list();
     const indexNames = config.indexNames ?? allIndexNames;
 
+    // In fixed mode, save the original allowlist for later filtering
+    const originalIndexNames = config.indexNames ? [...config.indexNames] : undefined;
+
     // Validate requested indexes exist
     const missingIndexes = indexNames.filter((n) => !allIndexNames.includes(n));
     if (missingIndexes.length > 0) {
@@ -153,7 +159,7 @@ export class MultiIndexRunner {
     }
 
     // Allow empty - server can start with no indexes and user can add via CLI
-    return new MultiIndexRunner(store, validIndexNames, indexes, searchOnly, config.clientUserAgent);
+    return new MultiIndexRunner(store, validIndexNames, indexes, searchOnly, config.clientUserAgent, originalIndexNames);
   }
 
   /**
@@ -200,13 +206,22 @@ export class MultiIndexRunner {
   /**
    * Refresh the list of available indexes from the store.
    * Call after adding or removing indexes.
+   *
+   * In fixed mode (when originalIndexNames is set), only includes indexes
+   * from the original allowlist, even if other indexes exist in the store.
    */
   async refreshIndexList(): Promise<void> {
     const allIndexNames = await this.store.list();
+
+    // In fixed mode, filter to only the original allowlist
+    const indexNamesToLoad = this.originalIndexNames
+      ? allIndexNames.filter(name => this.originalIndexNames!.includes(name))
+      : allIndexNames;
+
     const newIndexes: IndexInfo[] = [];
     const newIndexNames: string[] = [];
 
-    for (const name of allIndexNames) {
+    for (const name of indexNamesToLoad) {
       try {
         const state = await this.store.loadSearch(name);
         if (state) {