@@ -172,9 +172,37 @@ func (s *composeService) ensureImagesDown(ctx context.Context, project *types.Pr
 			})
 		})
 	}
+
+	if pruneOpts.Mode != ImagePruneNone {
+		ops = append(ops, func() error {
+			return s.pruneDanglingProjectImages(ctx, imagePruner)
+		})
+	}
 	return ops, nil
 }
 
+// pruneDanglingProjectImages removes the project's dangling images as a
+// single grouped operation (a raw image ID is meaningless on its own),
+// tolerating individual removal failures so one bad image doesn't abort down.
+func (s *composeService) pruneDanglingProjectImages(ctx context.Context, imagePruner *ImagePruner) error {
+	ids, err := imagePruner.danglingLocalImages(ctx)
+	if err != nil {
+		return err
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	const eventID = "Dangling images"
+	s.events.On(newEvent(eventID, api.Working, "Removing"))
+	for _, id := range ids {
+		if _, err := s.apiClient().ImageRemove(ctx, id, client.ImageRemoveOptions{}); err != nil {
+			logrus.Debugf("failed to remove dangling image %s: %v", id, err)
+		}
+	}
+	s.events.On(newEvent(eventID, api.Done, "Removed"))
+	return nil
+}
+
 func (s *composeService) ensureNetworksDown(ctx context.Context, project *types.Project) []downOp {
 	var ops []downOp
 	for key, n := range project.Networks {
 
@@ -323,6 +323,10 @@ func TestDownRemoveImages(t *testing.T) {
 		},
 	}}, nil).AnyTimes()
 
+	api.EXPECT().ImageList(gomock.Any(), client.ImageListOptions{
+		Filters: projectFilter(strings.ToLower(testProject)).Add("dangling", "true"),
+	}).Return(client.ImageListResult{}, nil).AnyTimes()
+
 	imagesToBeInspected := map[string]bool{
 		"testproject-local-anonymous":     true,
 		"local-named-image":               true,
@@ -413,6 +417,10 @@ func TestDownRemoveImages_NoLabel(t *testing.T) {
 		Filters: projectFilter(strings.ToLower(testProject)).Add("dangling", "false"),
 	}).Return(client.ImageListResult{}, nil)
 
+	api.EXPECT().ImageList(gomock.Any(), client.ImageListOptions{
+		Filters: projectFilter(strings.ToLower(testProject)).Add("dangling", "true"),
+	}).Return(client.ImageListResult{}, nil)
+
 	api.EXPECT().ImageInspect(gomock.Any(), "testproject-service1", gomock.Any()).Return(client.ImageInspectResult{}, nil)
 	api.EXPECT().ContainerStop(gomock.Any(), "123", client.ContainerStopOptions{}).Return(client.ContainerStopResult{}, nil)
 	api.EXPECT().ContainerRemove(gomock.Any(), "123", client.ContainerRemoveOptions{Force: true}).Return(client.ContainerRemoveResult{}, nil)
@@ -452,6 +460,66 @@ func prepareMocks(mockCtrl *gomock.Controller) (*mocks.MockAPIClient, *mocks.Moc
 	return api, cli
 }
 
+// TestPruneDanglingProjectImages_ReportsOnceAndToleratesFailures guards that
+// dangling images are reported as a single grouped event regardless of
+// count, and that one failed removal doesn't stop the others or the caller.
+func TestPruneDanglingProjectImages_ReportsOnceAndToleratesFailures(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
+	apiClient, cli := prepareMocks(mockCtrl)
+	rec := &capturingEvents{}
+	svcIface, err := NewComposeService(cli, WithEventProcessor(rec))
+	assert.NilError(t, err)
+	svc := svcIface.(*composeService)
+
+	pruner := NewImagePruner(apiClient, &types.Project{Name: "prj"})
+	apiClient.EXPECT().ImageList(gomock.Any(), client.ImageListOptions{
+		Filters: projectFilter("prj").Add("dangling", "true"),
+	}).Return(client.ImageListResult{Items: []image.Summary{
+		{ID: "sha256:aaa"},
+		{ID: "sha256:bbb"},
+	}}, nil)
+	apiClient.EXPECT().ImageRemove(gomock.Any(), "sha256:aaa", client.ImageRemoveOptions{}).
+		Return(client.ImageRemoveResult{}, nil)
+	apiClient.EXPECT().ImageRemove(gomock.Any(), "sha256:bbb", client.ImageRemoveOptions{}).
+		Return(client.ImageRemoveResult{}, errdefs.ErrNotFound.WithMessage("already removed"))
+
+	err = svc.pruneDanglingProjectImages(t.Context(), pruner)
+	assert.NilError(t, err)
+
+	events := make([]string, len(rec.resources))
+	for i, e := range rec.resources {
+		events[i] = e.ID + ": " + e.Text
+	}
+	assert.DeepEqual(t, events, []string{
+		"Dangling images: Removing",
+		"Dangling images: Removed",
+	})
+}
+
+// TestPruneDanglingProjectImages_NoneFound guards that no event is reported
+// when there's nothing to prune.
+func TestPruneDanglingProjectImages_NoneFound(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
+	apiClient, cli := prepareMocks(mockCtrl)
+	rec := &capturingEvents{}
+	svcIface, err := NewComposeService(cli, WithEventProcessor(rec))
+	assert.NilError(t, err)
+	svc := svcIface.(*composeService)
+
+	pruner := NewImagePruner(apiClient, &types.Project{Name: "prj"})
+	apiClient.EXPECT().ImageList(gomock.Any(), client.ImageListOptions{
+		Filters: projectFilter("prj").Add("dangling", "true"),
+	}).Return(client.ImageListResult{}, nil)
+
+	err = svc.pruneDanglingProjectImages(t.Context(), pruner)
+	assert.NilError(t, err)
+	assert.Equal(t, len(rec.resources), 0)
+}
+
 // TestDownRemovesRetainedPreStartHookContainers verifies that compose down finds and
 // removes pre_start hook containers that were retained after a failed hook run.
 // These containers lack ConfigHashLabel so the normal getContainers path never sees them.
 
@@ -150,12 +150,6 @@ func (p *ImagePruner) namedImages(ctx context.Context) ([]string, error) {
 // created from the project + service name.
 func (p *ImagePruner) labeledLocalImages(ctx context.Context) ([]image.Summary, error) {
 	res, err := p.client.ImageList(ctx, client.ImageListOptions{
-		// TODO(milas): we should really clean up the dangling images as
-		// well (historically we have NOT); need to refactor this to handle
-		// it gracefully without producing confusing CLI output, i.e. we
-		// do not want to print out a bunch of untagged/dangling image IDs,
-		// they should be grouped into a logical operation for the relevant
-		// service
 		Filters: projectFilter(p.project.Name).Add("dangling", "false"),
 	})
 	if err != nil {
@@ -164,6 +158,24 @@ func (p *ImagePruner) labeledLocalImages(ctx context.Context) ([]image.Summary,
 	return res.Items, nil
 }
 
+// danglingLocalImages are untagged images left behind by earlier local
+// builds of the project (e.g. superseded by a rebuild). They carry no name
+// usable in CLI progress output, so callers should report their removal as
+// a single grouped operation rather than one row per image ID.
+func (p *ImagePruner) danglingLocalImages(ctx context.Context) ([]string, error) {
+	res, err := p.client.ImageList(ctx, client.ImageListOptions{
+		Filters: projectFilter(p.project.Name).Add("dangling", "true"),
+	})
+	if err != nil {
+		return nil, err
+	}
+	ids := make([]string, len(res.Items))
+	for i, img := range res.Items {
+		ids[i] = img.ID
+	}
+	return ids, nil
+}
+
 // unlabeledLocalImages are images that match the implicit naming convention
 // for locally-built images but did not get labeled, presumably because they
 // were produced by an older version of Compose.
 
@@ -0,0 +1,62 @@
+/*
+   Copyright 2026 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"testing"
+
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/moby/moby/api/types/image"
+	"github.com/moby/moby/client"
+	"go.uber.org/mock/gomock"
+	"gotest.tools/v3/assert"
+
+	"github.com/docker/compose/v5/pkg/mocks"
+)
+
+func TestImagePruner_DanglingLocalImages(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	t.Cleanup(mockCtrl.Finish)
+	apiClient := mocks.NewMockAPIClient(mockCtrl)
+	pruner := NewImagePruner(apiClient, &types.Project{Name: "prj"})
+
+	apiClient.EXPECT().ImageList(gomock.Any(), client.ImageListOptions{
+		Filters: projectFilter("prj").Add("dangling", "true"),
+	}).Return(client.ImageListResult{Items: []image.Summary{
+		{ID: "sha256:aaa"},
+		{ID: "sha256:bbb"},
+	}}, nil)
+
+	ids, err := pruner.danglingLocalImages(t.Context())
+	assert.NilError(t, err)
+	assert.DeepEqual(t, ids, []string{"sha256:aaa", "sha256:bbb"})
+}
+
+func TestImagePruner_DanglingLocalImages_NoneFound(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	t.Cleanup(mockCtrl.Finish)
+	apiClient := mocks.NewMockAPIClient(mockCtrl)
+	pruner := NewImagePruner(apiClient, &types.Project{Name: "prj"})
+
+	apiClient.EXPECT().ImageList(gomock.Any(), client.ImageListOptions{
+		Filters: projectFilter("prj").Add("dangling", "true"),
+	}).Return(client.ImageListResult{}, nil)
+
+	ids, err := pruner.danglingLocalImages(t.Context())
+	assert.NilError(t, err)
+	assert.Equal(t, len(ids), 0)
+}