fix(server): keep the cell index fresh on add / update / remove

The name→bbox index could drift: build() skipped already-indexed cells (so a
re-imported cell kept stale bounds) and never dropped entries for removed cells.
Now build() reconciles against ENC_ROOT — pruning entries whose cell is no longer
on disk — and an import forget()s the cells it re-caches so the rebuild re-parses
their bounds. (Search results were already remove-safe: serveCells lists live
ENC_ROOT dirs, looking up bbox in the index, so a removed cell never appears even
before the prune.) Add/update/remove all covered; verified by test.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: beetlebugorg

internal/engine/server/cellindex.go

@@ -102,14 +102,16 @@ func (ci *cellIndex) build() {
 		ci.mu.Unlock()
 		return
 	}
-	n, added := 0, 0
+	present := make(map[string]bool, len(entries))
+	added := 0
 	for _, e := range entries {
 		if !e.IsDir() || !isCellName(e.Name()) {
 			continue
 		}
 		name := e.Name()
+		present[name] = true
 		if _, ok := ci.get(name); ok {
-			continue // already indexed
+			continue // already indexed (forget() drops a re-imported cell so it re-parses)
 		}
 		data, err := os.ReadFile(filepath.Join(ci.encRoot, name, name+".000"))
 		if err != nil {
@@ -127,10 +129,30 @@ func (ci *cellIndex) build() {
 		if added%200 == 0 {
 			ci.save() // periodic checkpoint for a long backfill
 		}
-		n++
 	}
-	if added > 0 {
+	// Reconcile: drop entries for cells no longer on disk (removed packs/cells), so
+	// the index never reports a chart that isn't installed anymore.
+	removed := 0
+	ci.mu.Lock()
+	for name := range ci.bbox {
+		if !present[name] {
+			delete(ci.bbox, name)
+			removed++
+		}
+	}
+	ci.mu.Unlock()
+	if added > 0 || removed > 0 {
 		ci.save()
-		log.Printf("cell index: backfilled %d cell bound(s) → %s", added, ci.path)
+		log.Printf("cell index: +%d / -%d cell bound(s) → %s", added, removed, ci.path)
 	}
 }
+
+// forget drops cells from the index so the next build re-parses them — used when
+// an import re-caches a cell whose bounds may have changed.
+func (ci *cellIndex) forget(names []string) {
+	ci.mu.Lock()
+	for _, n := range names {
+		delete(ci.bbox, n)
+	}
+	ci.mu.Unlock()
+}

internal/engine/server/cellindex_test.go

@@ -53,3 +53,43 @@ func TestCellIndexBuild(t *testing.T) {
 		t.Errorf("reload mismatch: %v vs %v (ok=%v)", bb2, bb, ok)
 	}
 }
+
+// TestCellIndexFreshness: rebuild prunes a removed cell, and forget() drops one so
+// it re-indexes — the add/update/remove freshness contract.
+func TestCellIndexFreshness(t *testing.T) {
+	const cell = "US4MD81M"
+	data, err := os.ReadFile("../../../testdata/" + cell + ".000")
+	if err != nil {
+		t.Skipf("testdata cell absent: %v", err)
+	}
+	dir := t.TempDir()
+	cdir := filepath.Join(dir, "ENC_ROOT", cell)
+	if err := os.MkdirAll(cdir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(cdir, cell+".000"), data, 0o644); err != nil {
+		t.Fatal(err)
+	}
+	ci := newCellIndex(dir)
+	ci.build()
+	if _, ok := ci.get(cell); !ok {
+		t.Fatal("not indexed")
+	}
+	// forget → re-build re-parses it (update path).
+	ci.forget([]string{cell})
+	if _, ok := ci.get(cell); ok {
+		t.Fatal("forget did not drop the entry")
+	}
+	ci.rebuild()
+	if _, ok := ci.get(cell); !ok {
+		t.Fatal("rebuild did not re-index after forget")
+	}
+	// remove the cell on disk → rebuild prunes it (remove path).
+	if err := os.RemoveAll(cdir); err != nil {
+		t.Fatal(err)
+	}
+	ci.rebuild()
+	if _, ok := ci.get(cell); ok {
+		t.Error("rebuild did not prune a removed cell")
+	}
+}

internal/engine/server/import.go

@@ -330,7 +330,12 @@ func (s *Server) cacheCells(cells map[string]baker.CellData) {
 		}
 	}
 	if s.cellIdx != nil {
-		go s.cellIdx.rebuild() // index the newly-cached cells' bounds in the background
+		stems := make([]string, 0, len(cells))
+		for name := range cells {
+			stems = append(stems, strings.TrimSuffix(name, ".000"))
+		}
+		s.cellIdx.forget(stems) // re-imported cells: drop stale bounds so the rebuild re-parses
+		go s.cellIdx.rebuild()  // index the (re-)cached cells' bounds in the background
 	}
 }