feat(chat): add starred models to the agent model picker

src/features/chat/capabilities/ConversationComposerCapability.tsx

@@ -361,6 +361,7 @@ export function ConversationComposerCapability({
         currentModel: controller.currentModelName ?? undefined,
         currentExecutionTarget: controller.currentExecutionTarget,
         availableModels: controller.availableModels,
+        favoriteModels: controller.favoriteModels,
         modelsLoading: controller.modelsLoading,
         modelStatusMessage: controller.modelStatusMessage,
         onModelChange: controller.handleModelChange,

src/features/chat/hooks/useAgentModelPickerState.ts

@@ -114,6 +114,16 @@ export function useAgentModelPickerState({
     () => getModelsForAgent(selectedAgentId),
     [getModelsForAgent, selectedAgentId],
   );
+  const favoriteModels = useMemo(
+    () =>
+      pickerAgents.flatMap((agent) =>
+        getModelsForAgent(agent.id).map((model) => ({
+          agentId: agent.id,
+          model,
+        })),
+      ),
+    [getModelsForAgent, pickerAgents],
+  );
 
   const providerIdsForSelectedAgent = useMemo(
     () =>
@@ -211,6 +221,7 @@ export function useAgentModelPickerState({
     selectedAgentId,
     pickerAgents,
     availableModels,
+    favoriteModels,
     getModelsForAgent,
     isModelInventoryAuthoritative,
     modelsLoading,

src/features/chat/hooks/useChatSessionController.ts

@@ -1162,6 +1162,7 @@ export function useChatSessionController({
     selectedAgentId,
     pickerAgents,
     availableModels,
+    favoriteModels,
     getModelsForAgent,
     modelsLoading,
     modelStatusMessage,
@@ -3556,6 +3557,7 @@ export function useChatSessionController({
     currentModelName: effectiveModelSelection?.name ?? null,
     currentExecutionTarget: session?.executionTarget,
     availableModels,
+    favoriteModels,
     modelsLoading,
     modelStatusMessage,
     handleModelChange: handleModelChangeWithContextReset,

src/features/chat/hooks/useResolvedAgentModelPicker.ts

@@ -336,6 +336,7 @@ export function useResolvedAgentModelPicker({
   const {
     pickerAgents,
     availableModels,
+    favoriteModels,
     getModelsForAgent,
     isModelInventoryAuthoritative,
     modelsLoading,
@@ -816,6 +817,7 @@ export function useResolvedAgentModelPicker({
     selectedAgentId,
     pickerAgents,
     availableModels,
+    favoriteModels,
     getModelsForAgent,
     modelsLoading,
     modelStatusMessage,

src/features/chat/hooks/useStarredModels.ts

@@ -0,0 +1,70 @@
+import { useCallback, useSyncExternalStore } from "react";
+import {
+  getStarredModelKeys,
+  modelStarKey,
+  STARRED_MODELS_ENTRY_PREFIX,
+  STARRED_MODELS_EVENT,
+  toggleModelStar,
+} from "../lib/starredModels";
+
+let cachedSnapshot: Set<string> | null = null;
+const serverSnapshot = new Set<string>();
+
+/** Invalidate the in-memory snapshot cache. Intended for tests. */
+export function __resetStarredModelsCacheForTests(): void {
+  cachedSnapshot = null;
+}
+
+function getSnapshot(): Set<string> {
+  if (cachedSnapshot === null) {
+    cachedSnapshot = getStarredModelKeys();
+  }
+  return cachedSnapshot;
+}
+
+function subscribe(callback: () => void): () => void {
+  const handleChange = () => {
+    cachedSnapshot = null;
+    callback();
+  };
+  const handleStorage = (event: StorageEvent) => {
+    // Star entries live under per-key storage, so any entry write or removal
+    // in another window changes the set. `key === null` covers localStorage
+    // clears.
+    if (
+      event.key === null ||
+      event.key.startsWith(STARRED_MODELS_ENTRY_PREFIX)
+    ) {
+      handleChange();
+    }
+  };
+
+  window.addEventListener(STARRED_MODELS_EVENT, handleChange);
+  window.addEventListener("storage", handleStorage);
+  // No listener exists while the store has no subscribers. Invalidate after
+  // attaching both listeners so a remount rereads changes made during that gap.
+  cachedSnapshot = null;
+  return () => {
+    window.removeEventListener(STARRED_MODELS_EVENT, handleChange);
+    window.removeEventListener("storage", handleStorage);
+  };
+}
+
+export function useStarredModels() {
+  const starredKeys = useSyncExternalStore(
+    subscribe,
+    getSnapshot,
+    () => serverSnapshot,
+  );
+  const isStarred = useCallback(
+    (scopeId: string, modelId: string) =>
+      starredKeys.has(modelStarKey(scopeId, modelId)),
+    [starredKeys],
+  );
+  const toggleStar = useCallback(
+    (scopeId: string, modelId: string) => toggleModelStar(scopeId, modelId),
+    [],
+  );
+
+  return { isStarred, toggleStar, starredKeys };
+}

src/features/chat/lib/starredModels.ts

@@ -0,0 +1,102 @@
+import { toast } from "sonner";
+import { i18n } from "@/shared/i18n";
+
+export const STARRED_MODELS_ENTRY_PREFIX = "goose:starredModels:v1:entry:";
+const STARRED_MODELS_ENTRY_VALUE = "1";
+const STARRED_MODELS_CHANGED_EVENT = "goose:starred-models-changed";
+
+type StarredModelSet = Set<string>;
+
+export function modelStarKey(scopeId: string, modelId: string): string {
+  return JSON.stringify([scopeId, modelId]);
+}
+
+/** localStorage key of the single entry that records one starred model. */
+export function starredModelStorageKey(starKey: string): string {
+  return STARRED_MODELS_ENTRY_PREFIX + encodeURIComponent(starKey);
+}
+
+function readStarredModels(): StarredModelSet {
+  if (typeof window === "undefined") {
+    return new Set();
+  }
+
+  try {
+    const storage = window.localStorage;
+    const starred = new Set<string>();
+    for (let i = 0; i < storage.length; i += 1) {
+      const storageKey = storage.key(i);
+      if (!storageKey?.startsWith(STARRED_MODELS_ENTRY_PREFIX)) {
+        continue;
+      }
+      try {
+        starred.add(
+          decodeURIComponent(
+            storageKey.slice(STARRED_MODELS_ENTRY_PREFIX.length),
+          ),
+        );
+      } catch {
+        // Skip a malformed entry rather than dropping every star.
+      }
+    }
+    return starred;
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * Write or clear exactly one star entry. Touching a single key (instead of
+ * rewriting an aggregate array) removes the cross-window read-modify-write
+ * race where concurrent toggles from different windows could drop each
+ * other's stars. Note that two windows toggling the same model at the same
+ * instant can still interleave; per-model state stays consistent either way.
+ */
+function persistStarEntry(starKey: string, starred: boolean): boolean {
+  if (typeof window === "undefined") {
+    return false;
+  }
+
+  try {
+    const storageKey = starredModelStorageKey(starKey);
+    if (starred) {
+      window.localStorage.setItem(storageKey, STARRED_MODELS_ENTRY_VALUE);
+    } else {
+      window.localStorage.removeItem(storageKey);
+    }
+  } catch {
+    // The write did not land (storage unavailable or over quota). Tell the
+    // user instead of letting the toggle silently bounce back.
+    toast.error(i18n.t("chat:notifications.starredModelsPersistError"));
+    window.dispatchEvent(new CustomEvent(STARRED_MODELS_CHANGED_EVENT));
+    return false;
+  }
+
+  window.dispatchEvent(new CustomEvent(STARRED_MODELS_CHANGED_EVENT));
+  return true;
+}
+
+export function getStarredModelKeys(): StarredModelSet {
+  return readStarredModels();
+}
+
+export function toggleModelStar(scopeId: string, modelId: string): boolean {
+  if (typeof window === "undefined") {
+    return false;
+  }
+
+  const starKey = modelStarKey(scopeId, modelId);
+
+  try {
+    const starred =
+      window.localStorage.getItem(starredModelStorageKey(starKey)) !== null;
+    return persistStarEntry(starKey, !starred);
+  } catch {
+    // Storage is unavailable, so the toggle cannot be applied at all. The
+    // write path reports its own failures; report this one too.
+    toast.error(i18n.t("chat:notifications.starredModelsPersistError"));
+    return false;
+  }
+}
+
+export const STARRED_MODELS_EVENT = STARRED_MODELS_CHANGED_EVENT;

src/features/chat/types.ts

@@ -150,6 +150,7 @@ export interface ChatInputAgentModelPicker {
   currentModel?: string;
   currentExecutionTarget?: SessionExecutionTarget;
   availableModels?: ModelOption[];
+  favoriteModels?: Array<{ agentId: string; model: ModelOption }>;
   modelsLoading?: boolean;
   modelStatusMessage?: string | null;
   onModelChange?: (modelId: string, model?: ModelOption) => void;