@@ -25,6 +25,7 @@ import {
 } from "../../sidebarProjectGrouping";
 import { useEnvironments, usePrimaryEnvironmentId } from "../../state/environments";
 import { useThreadShells, waitForProjectRemoval } from "../../state/entities";
+import { refreshProjectFaviconUrl } from "../../state/assets";
 import { projectEnvironment } from "../../state/projects";
 import { ProjectFavicon } from "../ProjectFavicon";
 import { Alert, AlertDescription } from "../ui/alert";
@@ -257,7 +258,18 @@ function ProjectDetail({
     if (savingFaviconRef.current) return;
     savingFaviconRef.current = true;
     setIsSavingFavicon(true);
-    await updateAllMembers(input, "Failed to update project icon");
+    const result = await updateAllMembers(input, "Failed to update project icon");
+    if (result._tag === "Success") {
+      for (const member of group.memberProjects) {
+        const update = typeof input === "function" ? input(member) : input;
+        if (update.faviconPath === undefined || update.projectIcon) continue;
+        refreshProjectFaviconUrl({
+          environmentId: member.environmentId,
+          cwd: member.workspaceRoot,
+          faviconPath: update.faviconPath,
+        });
+      }
+    }
     savingFaviconRef.current = false;
     setIsSavingFavicon(false);
   };
 
@@ -1,10 +1,13 @@
+import type { ProjectFaviconTarget } from "@t3tools/client-runtime/project-favicon-cache";
 import {
   createAssetEnvironmentAtoms,
   createProjectFaviconUrlAtomFamily,
+  projectFaviconResource,
 } from "@t3tools/client-runtime/state/assets";
 import { Atom } from "effect/reactivity";
 
 import { connectionAtomRuntime } from "../connection/runtime";
+import { appAtomRegistry } from "../rpc/atomRegistry";
 import { projectFaviconCache } from "../assets/projectFaviconCache";
 import { isElectron } from "../env";
 import { primaryEnvironmentIdAtom } from "./primaryEnvironment";
@@ -33,3 +36,16 @@ export const projectFaviconUrlAtom = createProjectFaviconUrlAtomFamily({
   preparedConnection: environmentSession.preparedConnectionValueAtom,
   projectClones: environmentProjectClonesAtom,
 });
+
+/**
+ * Asks the server for a project's icon again. Choosing the icon path a project had before would
+ * otherwise reuse that path's cached URL, which says "missing" if the file did not exist then.
+ */
+export function refreshProjectFaviconUrl(target: ProjectFaviconTarget) {
+  appAtomRegistry.refresh(
+    assetEnvironment.createUrl({
+      environmentId: target.environmentId,
+      input: { resource: projectFaviconResource(target.cwd, target.faviconPath) },
+    }),
+  );
+}
@@ -1,10 +1,10 @@
 import { describe, expect, it } from "@effect/vitest";
-import { type AssetCreateUrlResult, EnvironmentId } from "@t3tools/contracts";
+import { type AssetCreateUrlResult, type AssetResource, EnvironmentId } from "@t3tools/contracts";
 import * as Cause from "effect/Cause";
 import * as Option from "effect/Option";
 import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
 
-import { createProjectFaviconUrlAtomFamily } from "./assets.ts";
+import { createProjectFaviconUrlAtomFamily, projectFaviconResource } from "./assets.ts";
 
 describe("project favicon URL cache", () => {
   it("does not reuse another environment, workspace, or selected icon's cached URL", () => {
@@ -37,4 +37,45 @@ describe("project favicon URL cache", () => {
       registry.dispose();
     }
   });
+
+  it("resolves the icon again when its resource's URL query is refreshed", () => {
+    const registry = AtomRegistry.make();
+    const answers = ["/api/assets/token/project-favicon-missing", "/api/assets/token/v1-icon.svg"];
+    const query = Atom.family((key: string) =>
+      Atom.make(() =>
+        AsyncResult.success({ expiresAt: 4_000_000_000_000, relativeUrl: answers.shift()! }),
+      ).pipe(Atom.withLabel(key)),
+    );
+    const createUrl = (target: {
+      readonly environmentId: EnvironmentId;
+      readonly input: { readonly resource: AssetResource };
+    }) => query(JSON.stringify([target.environmentId, target.input.resource]));
+    const favicon = createProjectFaviconUrlAtomFamily({
+      createUrl,
+      preparedConnection: () => Atom.make(Option.some({ httpBaseUrl: "https://remote.test" })),
+    });
+    const target = {
+      environmentId: EnvironmentId.make("remote"),
+      cwd: "/workspace",
+      faviconPath: "icon.svg",
+    };
+    const unmount = registry.mount(favicon(target));
+    try {
+      expect(registry.get(favicon(target))).toBe(
+        "https://remote.test/api/assets/token/project-favicon-missing",
+      );
+      registry.refresh(
+        createUrl({
+          environmentId: target.environmentId,
+          input: { resource: projectFaviconResource(target.cwd, target.faviconPath) },
+        }),
+      );
+      expect(registry.get(favicon(target))).toBe(
+        "https://remote.test/api/assets/token/v1-icon.svg",
+      );
+    } finally {
+      unmount();
+      registry.dispose();
+    }
+  });
 });
@@ -200,6 +200,14 @@ export function createAssetEnvironmentAtoms<R, E>(
   };
 }
 
+/**
+ * The resource a project's icon URL is minted for. Refreshing the `createUrl` query for it makes
+ * the server resolve the icon again instead of serving a cached answer.
+ */
+export function projectFaviconResource(cwd: string, path: string | null | undefined) {
+  return { _tag: "project-favicon" as const, cwd, ...(path ? { path } : {}) };
+}
+
 export function createProjectFaviconUrlAtomFamily(input: {
   readonly imageCache?: ProjectFaviconCache;
   readonly createUrl: (target: {
@@ -219,8 +227,10 @@ export function createProjectFaviconUrlAtomFamily(input: {
   const projectClones = input.projectClones;
   const family = Atom.family((key: string) => {
     const [environmentId, cwd, path] = decodeKey(JSON.parse(key));
-    const resource = { _tag: "project-favicon" as const, cwd, ...(path ? { path } : {}) };
-    const query = input.createUrl({ environmentId, input: { resource } });
+    const query = input.createUrl({
+      environmentId,
+      input: { resource: projectFaviconResource(cwd, path) },
+    });
     // A cloned project exists before its files do, and the server reports its
     // icon missing until the clone lands. Ask again whenever the clone's phase
     // changes: the first list a client sees may already say done.