fix: honour track readiness in the picker, scope cache invalidation

- page.tsx: /api/tracks returns per-track `ready` and a top-level `default`,
  but mapApiTracks dropped both — so nothing was preselected and a track whose
  Moss index is not loaded stayed selectable, failing later at /health. Both
  fields are carried through now: selection keeps a still-valid choice, else
  adopts the backend default, else the first ready track; unready tracks are
  disabled and labelled. A track without `ready` is treated as usable so an
  older backend does not grey out everything.

- moss-vscode: the finally added in e733c8f cleared the persisted cache on any
  non-ready outcome, including a failure *before* rebuild() deleted anything
  (session setup, workspace scan) — where the previous documents are still
  intact and dropping the cache just forces a needless full re-index. The
  indexer now exposes hasDiscardedPreviousIndex(), set when deletion begins and
  reset on a ready finish, and the caller gates on it.

- tracks.py: "optimising" -> "optimizing", matching US spelling elsewhere.

Verified: track selection over 7 shapes (default unready, none ready, current
gone unready, legacy backend without the field); and cache invalidation across
fail-before-deletion, fail-after-deletion, cancelled and successful runs — only
the first is now preserved.

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

Author: samanyugoyal2010

apps/moss-interview-coach/backend/tracks.py

@@ -61,7 +61,7 @@
         "label": "Machine Learning Concepts",
         "blurb": "ML fundamentals, evaluation, training, and model systems.",
         "fallback_tips": [
-            "Name the metric you are optimising and why it fits the problem.",
+            "Name the metric you are optimizing and why it fits the problem.",
             "Separate training-time choices from inference-time constraints.",
             "Say how you would detect the model degrading in production.",
         ],

apps/moss-interview-coach/frontend/app/page.tsx

@@ -10,6 +10,8 @@ type InterviewTrack = {
   id: string;
   label: string;
   blurb: string;
+  /** False when the track's Moss index is not loaded on the backend. */
+  ready: boolean;
 };
 
 type GradeFeedback = {
@@ -109,13 +111,16 @@ function extractQuestionFromBotText(text: string): string {
   return (questions.at(-1) ?? parts.at(-1) ?? cleaned).trim();
 }
 
-function mapApiTracks(
-  apiTracks: Array<{ id: string; label: string; blurb?: string }>,
-): InterviewTrack[] {
+type ApiTrack = { id: string; label: string; blurb?: string; ready?: boolean };
+
+function mapApiTracks(apiTracks: ApiTrack[]): InterviewTrack[] {
   return apiTracks.map((track) => ({
     id: track.id,
     label: track.label,
     blurb: track.blurb ?? "",
+    // Absent means the backend did not report readiness; treat as usable so an
+    // older backend does not render every track unselectable.
+    ready: track.ready !== false,
   }));
 }
 
@@ -165,19 +170,26 @@ export default function HomePage() {
         if (cancelled) return;
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         const data = (await res.json()) as {
-          tracks?: Array<{ id: string; label: string; blurb?: string }>;
+          tracks?: ApiTrack[];
+          default?: string;
         };
         if (cancelled) return;
         if (!Array.isArray(data.tracks) || data.tracks.length === 0) {
           throw new Error("no tracks returned");
         }
         const mapped = mapApiTracks(data.tracks);
         setTracks(mapped);
-        // Drop a selection whose track vanished from the refreshed list, so
-        // Start cannot fire an id the backend would normalise to the default.
-        setSelectedTrack((current) =>
-          current && mapped.some((t) => t.id === current) ? current : null,
-        );
+        // Keep a still-valid selection; otherwise adopt the backend's default,
+        // falling back to the first usable track. Anything unready is skipped,
+        // and a selection whose track vanished is dropped so Start cannot fire
+        // an id the backend would normalise to something else.
+        setSelectedTrack((current) => {
+          if (current && mapped.some((t) => t.id === current && t.ready)) {
+            return current;
+          }
+          const preferred = mapped.find((t) => t.id === data.default && t.ready);
+          return (preferred ?? mapped.find((t) => t.ready))?.id ?? null;
+        });
         setTracksStatus("ready");
       } catch {
         if (cancelled) return;
@@ -713,23 +725,42 @@ function IdleView({
           <ul className="space-y-1 border-y border-[var(--cream)]/10 py-2">
             {tracks.map((track) => {
               const selected = selectedTrack === track.id;
+              // The backend reports whether this track's Moss index is loaded.
+              // Starting an unready one only fails later at /health, so show it
+              // as unavailable rather than letting it be picked.
+              const unavailable = !track.ready;
               return (
                 <li key={track.id}>
                   <button
                     type="button"
                     aria-pressed={selected}
+                    disabled={unavailable}
+                    title={unavailable ? "Moss index not loaded for this track" : undefined}
                     onClick={() => onSelectTrack(track.id)}
                     className={`flex w-full items-baseline justify-between gap-6 px-1 py-3 text-left transition ${
-                      selected
-                        ? "text-[var(--accent)]"
-                        : "text-[var(--cream)] hover:text-[var(--accent)]"
+                      unavailable
+                        ? "cursor-not-allowed text-[var(--cream)]/35"
+                        : selected
+                          ? "text-[var(--accent)]"
+                          : "text-[var(--cream)] hover:text-[var(--accent)]"
                     }`}
                   >
-                    <span className="font-display text-2xl md:text-[1.75rem]">{track.label}</span>
+                    <span className="font-display text-2xl md:text-[1.75rem]">
+                      {track.label}
+                      {unavailable ? (
+                        <span className="ml-3 align-middle text-xs tracking-wide text-[var(--warn)]">
+                          index not loaded
+                        </span>
+                      ) : null}
+                    </span>
                     {track.blurb ? (
                       <span
                         className={`max-w-[14rem] text-right text-xs leading-snug md:max-w-xs md:text-sm ${
-                          selected ? "text-[var(--accent)]/80" : "text-[var(--fog)]"
+                          unavailable
+                            ? "text-[var(--fog)]/50"
+                            : selected
+                              ? "text-[var(--accent)]/80"
+                              : "text-[var(--fog)]"
                         }`}
                       >
                         {track.blurb}

apps/moss-vscode/src/extension.ts

@@ -512,14 +512,17 @@ async function runCreateIndex(
       statusBarItem.tooltip = message;
     }
   } finally {
-    // rebuild() deletes the previous documents before scanning, so *any* run
-    // that does not end in a ready index leaves the on-disk cache describing
+    // rebuild() deletes the previous documents before scanning, so any run that
+    // got that far and did not end ready leaves the on-disk cache describing
     // documents that no longer exist — cancelled, or thrown from
     // readFileForIndex()/addDocs() midway. persistIndex() refuses to write
     // while unindexed, so drop the cache here instead, in a finally so the
-    // throw path cannot skip it; otherwise the next launch restores stale
-    // metadata for an index that is gone.
-    if (!indexer.isIndexed()) {
+    // throw path cannot skip it.
+    //
+    // Gated on hasDiscardedPreviousIndex() so a failure *before* deletion began
+    // (session setup, workspace scan) keeps the cache — those documents are
+    // still intact and re-indexing from scratch would be wasted work.
+    if (!indexer.isIndexed() && indexer.hasDiscardedPreviousIndex()) {
       await clearIndexCache(context).catch(() => undefined);
       log("Index not ready; cleared stale index cache.");
     }

apps/moss-vscode/src/indexer/indexer.ts

@@ -24,6 +24,8 @@ export class CodebaseIndexer {
   private watchers: vscode.Disposable[] = [];
   private indexing = false;
   private watchingEnabled = false;
+  /** True once rebuild() has begun destroying the previous index. */
+  private discardedPreviousIndex = false;
   private onPersist: (() => void) | undefined;
 
   setPersistHandler(handler: (() => void) | undefined): void {
@@ -44,6 +46,16 @@ export class CodebaseIndexer {
     return Object.fromEntries(this.pathChunkCounts.entries());
   }
 
+  /**
+   * Whether the last rebuild got far enough to destroy the previous index.
+   *
+   * Lets the caller decide if a non-ready outcome must also invalidate the
+   * persisted cache, or whether the old documents are still intact.
+   */
+  hasDiscardedPreviousIndex(): boolean {
+    return this.discardedPreviousIndex;
+  }
+
   isIndexed(): boolean {
     return this.status.state === "ready" && this.pathChunkCounts.size > 0;
   }
@@ -97,6 +109,7 @@ export class CodebaseIndexer {
       return;
     }
     this.indexing = true;
+    this.discardedPreviousIndex = false;
 
     try {
       const files = await scanWorkspaceFiles(token);
@@ -109,6 +122,11 @@ export class CodebaseIndexer {
           staleIds.push(`${rel}#chunk-${i}`);
         }
       }
+      // Past this point the previous index is being destroyed, so any exit that
+      // is not "ready" leaves the persisted cache describing documents that no
+      // longer exist. A failure *before* here (scan, session setup) leaves the
+      // old documents intact, and the cache with them.
+      this.discardedPreviousIndex = true;
       if (staleIds.length) {
         await this.deleteInBatches(staleIds);
       }
@@ -215,6 +233,7 @@ export class CodebaseIndexer {
         return;
       }
       this.watchingEnabled = true;
+      this.discardedPreviousIndex = false;
       this.setStatus({
         state: "ready",
         files: this.pathChunkCounts.size,