only check attached networks on running containers

Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>
2026-02-11 11:09:23 +08:00 · 2024-11-27 09:20:16 +01:00
376 changed files with 5187 additions and 12935 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,2 +0,0 @@
-# global rules
-* @docker/compose-maintainers
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -12,12 +12,6 @@ body:
        Include both the current behavior (what you are seeing) as well as what you expected to happen.
    validations:
      required: true
-  - type: markdown
-    attributes:
-      value: |
-        [Docker Swarm](https://www.mirantis.com/software/swarm/) uses a distinct compose file parser and 
-        as such doesn't support some of the recent features of Docker Compose. Please contact Mirantis
-        if you need assistance with compose file support in Docker Swarm.
  - type: textarea
    attributes:
      label: Steps To Reproduce
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -56,7 +56,7 @@ jobs:
        uses: actions/checkout@v4
      -
        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2
      -
        name: Run
        run: |
@@ -71,47 +71,29 @@ jobs:
      matrix:
        platform: ${{ fromJson(needs.prepare.outputs.matrix) }}
    steps:
+      -
+        name: Prepare
+        run: |
+          platform=${{ matrix.platform }}
+          echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV
      -
        name: Checkout
        uses: actions/checkout@v4
-      -
-        name: Prepare
-        run: |
-          platform=${MATRIX_PLATFORM}
-          echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV
-        env:
-          MATRIX_PLATFORM: ${{ matrix.platform }}
      -
        name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v2
      -
        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2
      -
        name: Build
-        uses: docker/bake-action@v6
+        uses: docker/bake-action@v2
        with:
-          source: .
          targets: release
-          provenance: mode=max
-          sbom: true
          set: |
            *.platform=${{ matrix.platform }}
            *.cache-from=type=gha,scope=binary-${{ env.PLATFORM_PAIR }}
            *.cache-to=type=gha,scope=binary-${{ env.PLATFORM_PAIR }},mode=max
-      -
-        name: Rename provenance and sbom
-        working-directory: ./bin/release
-        run: |
-          binname=$(find . -name 'docker-compose-*')
-          filename=$(basename "$binname" | sed -E 's/\.exe$//')
-          mv "provenance.json" "${filename}.provenance.json"
-          mv "sbom-binary.spdx.json" "${filename}.sbom.json"
-          find . -name 'sbom*.json' -exec rm {} \;
-      -
-        name: List artifacts
-        run: |
-          tree -nh ./bin/release
      -
        name: Upload artifacts
        uses: actions/upload-artifact@v4
@@ -123,12 +105,15 @@ jobs:
  test:
    runs-on: ubuntu-latest
    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v4
      -
        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2
      -
        name: Test
-        uses: docker/bake-action@v6
+        uses: docker/bake-action@v2
        with:
          targets: test
          set: |
@@ -156,18 +141,19 @@ jobs:
          - plugin
          - standalone
        engine:
-          - 27 # old stable (latest major - 1)
-          - 28 # current stable
+          - 24.0.9
+          - 25.0.5
+          - 26.1.4
+          - 27.4.0
    steps:
      - name: Prepare
        run: |
          mode=${{ matrix.mode }}
          engine=${{ matrix.engine }}
          echo "MODE_ENGINE_PAIR=${mode}-${engine}" >> $GITHUB_ENV
-
-      - name: Checkout
+      -
+        name: Checkout
        uses: actions/checkout@v4
-
      - name: Install Docker ${{ matrix.engine }}
        run: |
          sudo systemctl stop docker.service
@@ -175,32 +161,22 @@ jobs:
          sudo apt-get install curl
          curl -fsSL https://test.docker.com -o get-docker.sh
          sudo sh ./get-docker.sh --version ${{ matrix.engine }}
-
      - name: Check Docker Version
        run: docker --version
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Set up Docker Model
-        run: |
-          sudo apt-get install docker-model-plugin
-          docker model version
-
-      - name: Set up Go
+      -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      -
+        name: Set up Go
        uses: actions/setup-go@v5
        with:
          go-version-file: 'go.mod'
          check-latest: true
          cache: true
-
-      - name: Build example provider
-        run: make example-provider
-
-      - name: Build
-        uses: docker/bake-action@v6
+      -
+        name: Build
+        uses: docker/bake-action@v2
        with:
-          source: .
          targets: binary-with-coverage
          set: |
            *.cache-from=type=gha,scope=binary-linux-amd64
@@ -208,37 +184,37 @@ jobs:
            *.cache-to=type=gha,scope=binary-e2e-${{ matrix.mode }},mode=max
        env:
          BUILD_TAGS: e2e
-
-      - name: Setup tmate session
+      -
+        name: Setup tmate session
        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled }}
        uses: mxschmitt/action-tmate@8b4e4ac71822ed7e0ad5fb3d1c33483e9e8fb270 # v3.11
        with:
          limit-access-to-actor: true
          github-token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Test plugin mode
+      -
+        name: Test plugin mode
        if: ${{ matrix.mode == 'plugin' }}
        run: |
          rm -rf ./bin/coverage/e2e
          mkdir -p ./bin/coverage/e2e
          make e2e-compose GOCOVERDIR=bin/coverage/e2e TEST_FLAGS="-v"
-
-      - name: Gather coverage data
+      -
+        name: Gather coverage data
        if: ${{ matrix.mode == 'plugin' }}
        uses: actions/upload-artifact@v4
        with:
          name: coverage-data-e2e-${{ env.MODE_ENGINE_PAIR }}
          path: bin/coverage/e2e/
          if-no-files-found: error
-
-      - name: Test standalone mode
+      -
+        name: Test standalone mode
        if: ${{ matrix.mode == 'standalone' }}
        run: |
          rm -f /usr/local/bin/docker-compose
          cp bin/build/docker-compose /usr/local/bin
          make e2e-compose-standalone
-
-      - name: e2e Test Summary
+      - 
+        name: e2e Test Summary
        uses: test-summary/action@v2
        with:
          paths: /tmp/report/report.xml       
@@ -308,11 +284,10 @@ jobs:
          find . -type f -print0 | sort -z | xargs -r0 shasum -a 256 -b | sed 's# \*\./# *#' > $RUNNER_TEMP/checksums.txt
          shasum -a 256 -U -c $RUNNER_TEMP/checksums.txt
          mv $RUNNER_TEMP/checksums.txt .
-          cat checksums.txt | while read sum file; do
-            if [[ "${file#\*}" == docker-compose-* && "${file#\*}" != *.provenance.json && "${file#\*}" != *.sbom.json ]]; then
-              echo "$sum $file" > ${file#\*}.sha256
-            fi
-          done
+          cat checksums.txt | while read sum file; do echo "$sum $file" > ${file#\*}.sha256; done
+      -
+        name: License
+        run: cp packaging/* ./bin/release/
      -
        name: List artifacts
        run: |
--- a/.github/workflows/docs-upstream.yml
+++ b/.github/workflows/docs-upstream.yml
@@ -44,7 +44,7 @@ jobs:
          retention-days: 1

  validate:
-    uses: docker/docs/.github/workflows/validate-upstream.yml@main
+    uses: docker/docs/.github/workflows/validate-upstream.yml@919a9b9104a34a40b30d116529bcce589a544d1c  # pin for artifact v4 support: https://github.com/docker/docs/pull/19220
    needs:
      - docs-yaml
    with:
--- a/.github/workflows/merge.yml
+++ b/.github/workflows/merge.yml
@@ -79,35 +79,19 @@ jobs:
    outputs:
      digest: ${{ fromJSON(steps.bake.outputs.metadata).image-cross['containerimage.digest'] }}
    steps:
-      -
-        name: Free disk space
-        uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be # v1.3.1
-        with:
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          swap-storage: true
      -
        name: Checkout
        uses: actions/checkout@v4
-      -
-        name: Login to DockerHub
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERPUBLICBOT_USERNAME }}
-          password: ${{ secrets.DOCKERPUBLICBOT_WRITE_PAT }}
      -
        name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v2
      -
        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2
      -
        name: Docker meta
        id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v4
        with:
          images: |
            ${{ env.REPO_SLUG }}
@@ -115,22 +99,28 @@ jobs:
            type=ref,event=tag
            type=edge
          bake-target: meta-helper
+      -
+        name: Login to DockerHub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERPUBLICBOT_USERNAME }}
+          password: ${{ secrets.DOCKERPUBLICBOT_WRITE_PAT }}
      -
        name: Build and push image
-        uses: docker/bake-action@v6
+        uses: docker/bake-action@v2
        id: bake
        with:
-          source: .
          files: |
            ./docker-bake.hcl
            ${{ steps.meta.outputs.bake-file }}
          targets: image-cross
          push: ${{ github.event_name != 'pull_request' }}
-          sbom: true
-          provenance: mode=max
          set: |
            *.cache-from=type=gha,scope=bin-image
            *.cache-to=type=gha,scope=bin-image,mode=max
+            *.attest=type=sbom
+            *.attest=type=provenance,mode=max,builder-id=https://github.com/${{ env.GITHUB_REPOSITORY }}/actions/runs/${{ env.GITHUB_RUN_ID }}

  desktop-edge-test:
    runs-on: ubuntu-latest
@@ -139,16 +129,14 @@ jobs:
      -
        name: Generate Token
        id: generate_token
-        uses: actions/create-github-app-token@v1
+        uses: tibdex/github-app-token@v1
        with:
-          app-id: ${{ vars.DOCKERDESKTOP_APP_ID }}
-          private-key: ${{ secrets.DOCKERDESKTOP_APP_PRIVATEKEY }}
-          owner: docker
-          repositories: |
-            ${{ secrets.DOCKERDESKTOP_REPO }}
+          app_id: ${{ vars.DOCKERDESKTOP_APP_ID }}
+          private_key: ${{ secrets.DOCKERDESKTOP_APP_PRIVATEKEY }}
+          repository: docker/${{ secrets.DOCKERDESKTOP_REPO }}
      -
        name: Trigger Docker Desktop e2e with edge version
-        uses: actions/github-script@v7
+        uses: actions/github-script@v6
        with:
          github-token: ${{ steps.generate_token.outputs.token }}
          script: |
--- a/.github/workflows/scorecards.yml
+++ b/.github/workflows/scorecards.yml
@@ -7,6 +7,9 @@ on:
  push:
    branches: [ "main" ]

+# Declare default permissions as read only.
+permissions: read-all
+
 jobs:
  analysis:
    name: Scorecards analysis
@@ -16,27 +19,15 @@ jobs:
      security-events: write
      # Used to receive a badge.
      id-token: write
-      # read permissions to all the other objects
-      actions: read
-      attestations: read
-      checks: read
-      contents: read
-      deployments: read
-      issues: read
-      discussions: read
-      packages: read
-      pages: read
-      pull-requests: read
-      statuses: read
    
    steps:
      - name: "Checkout code"
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.4.2
+        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846 # tag=v3.0.0
        with:
          persist-credentials: false

      - name: "Run analysis"
-        uses: ossf/scorecard-action@62b2cac7ed8198b15735ed49ab1e5cf35480ba46 # tag=v2.4.0
+        uses: ossf/scorecard-action@99c53751e09b9529366343771cc321ec74e9bd3d # tag=v2.0.6
        with:
          results_file: results.sarif
          results_format: sarif
@@ -50,7 +41,7 @@ jobs:
      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
      # format to the repository Actions tab.
      - name: "Upload artifact"
-        uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b # tag=v4.5.0
+        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535 # tag=v3.0.0
        with:
          name: SARIF file
          path: results.sarif
@@ -58,6 +49,6 @@ jobs:
      
      # Upload the results to GitHub's code scanning dashboard.
      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@3096afedf9873361b2b2f65e1445b13272c83eb8 # tag=v2.20.00
+        uses: github/codeql-action/upload-sarif@5f532563584d71fdef14ee64d17bafb34f751ce5 # tag=v1.0.26
        with:
          sarif_file: results.sarif
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,89 +1,82 @@
-version: "2"
 run:
  concurrency: 2
+  timeout: 10m
 linters:
-  default: none
+  enable-all: false
+  disable-all: true
  enable:
-    - copyloopvar
    - depguard
    - errcheck
    - errorlint
    - gocritic
    - gocyclo
+    - gofmt
+    - goimports
    - gomodguard
+    - revive
+    - gosimple
    - govet
    - ineffassign
    - lll
    - misspell
    - nakedret
    - nolintlint
-    - revive
    - staticcheck
    - testifylint
+    - typecheck
    - unconvert
    - unparam
    - unused
-  settings:
-    depguard:
-      rules:
-        all:
-          deny:
-            - pkg: io/ioutil
-              desc: io/ioutil package has been deprecated
-            - pkg: github.com/docker/docker/errdefs
-              desc: use github.com/containerd/errdefs instead.
-            - pkg: golang.org/x/exp/maps
-              desc: use stdlib maps package
-            - pkg: golang.org/x/exp/slices
-              desc: use stdlib slices package
-            - pkg: gopkg.in/yaml.v2
-              desc: compose-go uses yaml.v3
-    gocritic:
-      disabled-checks:
-        - paramTypeCombine
-        - unnamedResult
-        - whyNoLint
-      enabled-tags:
-        - diagnostic
-        - opinionated
-        - style
-    gocyclo:
-      min-complexity: 16
-    gomodguard:
-      blocked:
-        modules:
-          - github.com/pkg/errors:
-              recommendations:
-                - errors
-                - fmt
-        versions:
-          - github.com/distribution/distribution:
-              reason: use distribution/reference
-          - gotest.tools:
-              version: < 3.0.0
-              reason: deprecated, pre-modules version
-    lll:
-      line-length: 200
-    revive:
-      rules:
-        - name: package-comments
-          disabled: true
-  exclusions:
-    generated: lax
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
+linters-settings:
+  revive:
+    rules:
+      - name: package-comments
+        disabled: true
+  depguard:
+    rules:
+      all:
+        deny:
+          - pkg: io/ioutil
+            desc: 'io/ioutil package has been deprecated'
+          - pkg: gopkg.in/yaml.v2
+            desc: 'compose-go uses yaml.v3'
+  gomodguard:
+    blocked:
+      modules:
+        - github.com/pkg/errors:
+            recommendations:
+              - errors
+              - fmt
+      versions:
+        - github.com/distribution/distribution:
+            reason: "use distribution/reference"
+        - gotest.tools:
+            version: "< 3.0.0"
+            reason: "deprecated, pre-modules version"
+  gocritic:
+    # Enable multiple checks by tags, run `GL_DEBUG=gocritic golangci-lint run` to see all tags and checks.
+    # Empty list by default. See https://github.com/go-critic/go-critic#usage -> section "Tags".
+    enabled-tags:
+      - diagnostic
+      - opinionated
+      - style
+    disabled-checks:
+      - paramTypeCombine
+      - unnamedResult
+      - whyNoLint
+  gocyclo:
+    min-complexity: 16
+  lll:
+    line-length: 200
 issues:
+  # golangci hides some golint warnings (the warning about exported things
+  # without documentation for example), this will make it show them anyway.
+  exclude-use-default: false
+  # Maximum issues count per one linter.
+  # Set to 0 to disable.
+  # Default: 50
  max-issues-per-linter: 0
+  # Maximum count of issues with the same text.
+  # Set to 0 to disable.
+  # Default: 3
  max-same-issues: 0
-formatters:
-  enable:
-    - gofumpt
-    - goimports
-  exclusions:
-    generated: lax
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -2,17 +2,14 @@
 ### Prerequisites

 * Windows:
-  * [Docker Desktop](https://docs.docker.com/desktop/setup/install/windows-install/)
+  * [Docker Desktop](https://hub.docker.com/editions/community/docker-ce-desktop-windows)
  * make
-  * go (see [go.mod](go.mod) for minimum version)
 * macOS:
-  * [Docker Desktop](https://docs.docker.com/desktop/setup/install/mac-install/)
+  * [Docker Desktop](https://hub.docker.com/editions/community/docker-ce-desktop-mac)
  * make
-  * go (see [go.mod](go.mod) for minimum version)
 * Linux:
  * [Docker 20.10 or later](https://docs.docker.com/engine/install/)
  * make
-  * go (see [go.mod](go.mod) for minimum version)

 ### Building the CLI

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,7 +2,7 @@

 Want to hack on Docker? Awesome!  We have a contributor's guide that explains
 [setting up a Docker development environment and the contribution
-process](https://docs.docker.com/contribute/).
+process](https://docs.docker.com/contribute/overview/).

 This page contains information about reporting issues as well as some tips and
 guidelines useful to experienced open source contributors. Finally, make sure
@@ -95,7 +95,7 @@ don't get discouraged!
  <tr>
    <td>Community Slack</td>
    <td>
-      The Docker Community has a dedicated Slack chat to discuss features and issues.  You can sign-up <a href="https://www.docker.com/community/" target="_blank">with this link</a>.
+      The Docker Community has a dedicated Slack chat to discuss features and issues.  You can sign-up <a href="https://www.docker.com/docker-community" target="_blank">with this link</a>.
    </td>
  </tr>
  <tr>
@@ -118,7 +118,7 @@ don't get discouraged!
    <td>Stack Overflow</td>
    <td>
      Stack Overflow has over 17000 Docker questions listed. We regularly
-      monitor <a href="https://stackoverflow.com/questions/tagged/docker" target="_blank">Docker questions</a>
+      monitor <a href="https://stackoverflow.com/search?tab=newest&q=docker" target="_blank">Docker questions</a>
      and so do many other knowledgeable Docker users.
    </td>
  </tr>
@@ -200,7 +200,7 @@ For more details, see the [MAINTAINERS](MAINTAINERS) page.
 The sign-off is a simple line at the end of the explanation for the patch. Your
 signature certifies that you wrote the patch or otherwise have the right to pass
 it on as an open-source patch. The rules are pretty simple: if you can certify
-the below (from [developercertificate.org](https://developercertificate.org/)):
+the below (from [developercertificate.org](http://developercertificate.org/)):

 ```
 Developer Certificate of Origin
@@ -252,7 +252,7 @@ commit automatically with `git commit -s`.
 ### How can I become a maintainer?

 The procedures for adding new maintainers are explained in the global
-[MAINTAINERS](https://github.com/docker/opensource/blob/main/MAINTAINERS)
+[MAINTAINERS](https://github.com/docker/opensource/blob/master/MAINTAINERS)
 file in the
 [https://github.com/docker/opensource/](https://github.com/docker/opensource/)
 repository.
@@ -311,8 +311,8 @@ The rules:
 2. All code should pass the default levels of
   [`golint`](https://github.com/golang/lint).
 3. All code should follow the guidelines covered in [Effective
-   Go](https://go.dev/doc/effective_go) and [Go Code Review
-   Comments](https://go.dev/wiki/CodeReviewComments).
+   Go](http://golang.org/doc/effective_go.html) and [Go Code Review
+   Comments](https://github.com/golang/go/wiki/CodeReviewComments).
 4. Include code comments. Tell us the why, the history and the context.
 5. Document _all_ declarations and methods, even private ones. Declare
   expectations, caveats and anything else that may be important. If a type
@@ -334,6 +334,6 @@ The rules:
    guidelines. Since you've read all the rules, you now know that.

 If you are having trouble getting into the mood of idiomatic Go, we recommend
-reading through [Effective Go](https://go.dev/doc/effective_go). The
-[Go Blog](https://go.dev/blog/) is also a great resource. Drinking the
+reading through [Effective Go](https://golang.org/doc/effective_go.html). The
+[Go Blog](https://blog.golang.org) is also a great resource. Drinking the
 kool-aid is a lot easier than going thirsty.
--- a/6
+++ b/6
@@ -15,9 +15,9 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.

-ARG GO_VERSION=1.24.9
-ARG XX_VERSION=1.6.1
-ARG GOLANGCI_LINT_VERSION=v2.0.2
+ARG GO_VERSION=1.22.8
+ARG XX_VERSION=1.2.1
+ARG GOLANGCI_LINT_VERSION=v1.60.2
 ARG ADDLICENSE_VERSION=v1.0.0

 ARG BUILD_TAGS="e2e"
--- a/124
+++ b/124
@@ -0,0 +1,124 @@
+# Docker maintainers file
+#
+# This file describes who runs the docker/compose project and how.
+# This is a living document - if you see something out of date or missing, speak up!
+#
+# It is structured to be consumable by both humans and programs.
+# To extract its contents programmatically, use any TOML-compliant
+# parser.
+#
+# This file is compiled into the MAINTAINERS file in docker/opensource.
+#
+[Org]
+
+	[Org."Core maintainers"]
+
+	# The Core maintainers are the ghostbusters of the project: when there's a problem others
+	# can't solve, they show up and fix it with bizarre devices and weaponry.
+	# They have final say on technical implementation and coding style.
+	# They are ultimately responsible for quality in all its forms: usability polish,
+	# bugfixes, performance, stability, etc. When ownership  can cleanly be passed to
+	# a subsystem, they are responsible for doing so and holding the
+	# subsystem maintainers accountable. If ownership is unclear, they are the de facto owners.
+
+		people = [
+			"glours",
+			"jhrotko",
+			"milas",
+			"ndeloof",
+			"nicksieger",
+			"StefanScherer",
+			"ulyssessouza"
+		]
+
+	[Org."Regular maintainers"]
+	# The Regular maintainers are people who aren't Core maintainers but are around
+	# to help reviewing and fixing bugs, just on a less regular basis than previously.
+	# Most of them were previously Core maintainers of Compose.
+		people = [
+			"aiordache",
+			"chris-crone",
+			"gtardif",
+			"laurazard",
+			"maxcleme",
+			"rumpl",
+			"thaJeztah"
+		]
+
+[people]
+
+# A reference list of all people associated with the project.
+# All other sections should refer to people by their canonical key
+# in the people section.
+
+	# ADD YOURSELF HERE IN ALPHABETICAL ORDER
+
+	[people.aiordache]
+	Name = "Anca Iordache"
+	Email = "anca.iordache@docker.com"
+	GitHub = "aiordache "
+
+	[people.chris-crone]
+	Name = "Christopher Crone"
+	Email = "christopher.crone@docker.com"
+	GitHub = "chris-crone"
+
+	[people.glours]
+	Name = "Guillaume Lours"
+	Email = "guillaume.lours@docker.com"
+	GitHub = "glours"
+
+	[people.gtardif]
+	Name = "Guillaume Tardif"
+	Email = "guillaume.tardif@docker.com"
+	GitHub = "gtardif"
+
+	[people.jhrotko]
+	Name = "Joana Hrotko"
+	Email = "joana.hrotko@docker.com"
+	Github = "jhrotko"
+
+	[people.laurazard]
+	Name = "Laura Brehm"
+	Email = "laura.brehm@docker.com"
+	GitHub = "laurazard"
+
+	[people.maxcleme]
+	Name = "Maxime Clement"
+	Email = "maxime.clement@docker.com"
+	GitHub = "maxcleme"
+
+	[people.milas]
+	Name = "Milas Bowman"
+	Email = "milas.bowman@docker.com"
+	GitHub = "milas"
+
+	[people.nicksieger]
+	Name = "Nick Sieger"
+	Email = "nick.sieger@docker.com"
+	GitHub = "nicksieger"
+
+	[people.ndeloof]
+	Name = "Nicolas Deloof"
+	Email = "nicolas.deloof@docker.com"
+	GitHub = "ndeloof"
+
+	[people.rumpl]
+	Name = "Djordje Lukic"
+	Email = "djordje.lukic@docker.com"
+	GitHub = "rumpl"
+
+	[people.thaJeztah]
+	Name = "Sebastiaan van Stijn"
+	Email = "sebastiaan.vanstijn@docker.com"
+	GitHub = "thaJeztah "
+
+	[people.StefanScherer]
+	Name = "Stefan Scherer"
+	Email = "stefan.scherer@docker.com"
+	GitHub = "StefanScherer"
+
+	[people.ulyssessouza]
+	Name = "Ulysses Souza"
+	Email = "<ulysses.souza@docker.com"
+	Github = "ulyssessouza"
--- a/11
+++ b/11
@@ -74,7 +74,7 @@ install: binary
 	install $(or $(DESTDIR),./bin/build)/docker-compose ~/.docker/cli-plugins/docker-compose

 .PHONY: e2e-compose
-e2e-compose: example-provider ## Run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
+e2e-compose: ## Run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
 	go run gotest.tools/gotestsum@latest --format testname --junitfile "/tmp/report/report.xml" -- -v $(TEST_FLAGS) -count=1 ./pkg/e2e

 .PHONY: e2e-compose-standalone
@@ -87,10 +87,6 @@ build-and-e2e-compose: build e2e-compose ## Compile the compose cli-plugin and r
 .PHONY: build-and-e2e-compose-standalone
 build-and-e2e-compose-standalone: build e2e-compose-standalone ## Compile the compose cli-plugin and run End to end local tests in standalone mode. Set E2E_TEST=TestName to run a single test

-.PHONY: example-provider
-example-provider: ## build example provider for e2e tests
-	go build -o bin/build/example-provider docs/examples/provider.go
-
 .PHONY: mocks
 mocks:
 	mockgen --version >/dev/null 2>&1 || go install go.uber.org/mock/mockgen@v0.4.0
@@ -120,11 +116,6 @@ cache-clear: ## Clear the builder cache
 lint: ## run linter(s)
 	$(BUILDX_CMD) bake lint

-.PHONY: fmt
-fmt:
-	gofumpt --version >/dev/null 2>&1 || go install mvdan.cc/gofumpt@latest
-	gofumpt -w .
-
 .PHONY: docs
 docs: ## generate documentation
 	$(eval $@_TMP_OUT := $(shell mktemp -d -t compose-output.XXXXXXXXXX))
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@
 - [Legacy](#legacy)
 # Docker Compose v2

-[![GitHub release](https://img.shields.io/github/v/release/docker/compose.svg?style=flat-square)](https://github.com/docker/compose/releases/latest)
+[![GitHub release](https://img.shields.io/github/release/docker/compose.svg?style=flat-square)](https://github.com/docker/compose/releases/latest)
 [![PkgGoDev](https://img.shields.io/badge/go.dev-docs-007d9c?style=flat-square&logo=go&logoColor=white)](https://pkg.go.dev/github.com/docker/compose/v2)
 [![Build Status](https://img.shields.io/github/actions/workflow/status/docker/compose/ci.yml?label=ci&logo=github&style=flat-square)](https://github.com/docker/compose/actions?query=workflow%3Aci)
 [![Go Report Card](https://goreportcard.com/badge/github.com/docker/compose/v2?style=flat-square)](https://goreportcard.com/report/github.com/docker/compose/v2)
@@ -23,18 +23,12 @@ your application are configured.
 Once you have a Compose file, you can create and start your application with a
 single command: `docker compose up`.

-> **Note**: About Docker Swarm
-> Docker Swarm used to rely on the legacy compose file format but did not adopted the compose specification
-> so is missing some of the recent enhancements in the compose syntax. After 
-> [acquisition by Mirantis](https://www.mirantis.com/software/swarm/) swarm isn't maintained by Docker Inc, and
-> as such some Docker Compose features aren't accessible to swarm users.
-
 # Where to get Docker Compose

 ### Windows and macOS

 Docker Compose is included in
-[Docker Desktop](https://www.docker.com/products/docker-desktop/)
+[Docker Desktop](https://www.docker.com/products/docker-desktop)
 for Windows and macOS.

 ### Linux
--- a/cmd/cmdtrace/cmd_span.go
+++ b/cmd/cmdtrace/cmd_span.go
@@ -55,10 +55,8 @@ func Setup(cmd *cobra.Command, dockerCli command.Cli, args []string) error {
 		ctx,
 		"cli/"+strings.Join(commandName(cmd), "-"),
 	)
-	cmdSpan.SetAttributes(
-		attribute.StringSlice("cli.flags", getFlags(cmd.Flags())),
-		attribute.Bool("cli.isatty", dockerCli.In().IsTerminal()),
-	)
+	cmdSpan.SetAttributes(attribute.StringSlice("cli.args", args))
+	cmdSpan.SetAttributes(attribute.StringSlice("cli.flags", getFlags(cmd.Flags())))

 	cmd.SetContext(ctx)
 	wrapRunE(cmd, cmdSpan, tracingShutdown)
@@ -117,14 +115,13 @@ func wrapRunE(c *cobra.Command, cmdSpan trace.Span, tracingShutdown tracing.Shut
 	}
 }

-// commandName returns the path components for a given command,
-// in reverse alphabetical order for consistent usage metrics.
+// commandName returns the path components for a given command.
 //
 // The root Compose command and anything before (i.e. "docker")
 // are not included.
 //
 // For example:
-//   - docker compose alpha watch -> [watch, alpha]
+//   - docker compose alpha watch -> [alpha, watch]
 //   - docker-compose up -> [up]
 func commandName(cmd *cobra.Command) []string {
 	var name []string
--- a/cmd/cmdtrace/cmd_span_test.go
+++ b/cmd/cmdtrace/cmd_span_test.go
@@ -20,8 +20,6 @@ import (
 	"reflect"
 	"testing"

-	commands "github.com/docker/compose/v2/cmd/compose"
-	"github.com/spf13/cobra"
 	flag "github.com/spf13/pflag"
 )

@@ -62,51 +60,5 @@ func TestGetFlags(t *testing.T) {
 			}
 		})
 	}
-}
-
-func TestCommandName(t *testing.T) {
-	tests := []struct {
-		name     string
-		setupCmd func() *cobra.Command
-		want     []string
-	}{
-		{
-			name: "docker compose alpha watch -> [watch, alpha]",
-			setupCmd: func() *cobra.Command {
-				dockerCmd := &cobra.Command{Use: "docker"}
-				composeCmd := &cobra.Command{Use: commands.PluginName}
-				alphaCmd := &cobra.Command{Use: "alpha"}
-				watchCmd := &cobra.Command{Use: "watch"}
-
-				dockerCmd.AddCommand(composeCmd)
-				composeCmd.AddCommand(alphaCmd)
-				alphaCmd.AddCommand(watchCmd)
-
-				return watchCmd
-			},
-			want: []string{"watch", "alpha"},
-		},
-		{
-			name: "docker-compose up -> [up]",
-			setupCmd: func() *cobra.Command {
-				dockerComposeCmd := &cobra.Command{Use: commands.PluginName}
-				upCmd := &cobra.Command{Use: "up"}
-
-				dockerComposeCmd.AddCommand(upCmd)
-
-				return upCmd
-			},
-			want: []string{"up"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cmd := tt.setupCmd()
-			got := commandName(cmd)
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("commandName() = %v, want %v", got, tt.want)
-			}
-		})
-	}
+
 }
--- a/cmd/compatibility/convert_test.go
+++ b/cmd/compatibility/convert_test.go
@@ -17,9 +17,6 @@
 package compatibility

 import (
-	"errors"
-	"os"
-	"os/exec"
 	"testing"

 	"gotest.tools/v3/assert"
@@ -27,10 +24,9 @@ import (

 func Test_convert(t *testing.T) {
 	tests := []struct {
-		name    string
-		args    []string
-		want    []string
-		wantErr bool
+		name string
+		args []string
+		want []string
 	}{
 		{
 			name: "compose only",
@@ -97,36 +93,11 @@ func Test_convert(t *testing.T) {
 			args: []string{"--project-name", "compose", "down", "--remove-orphans"},
 			want: []string{"compose", "--project-name", "compose", "down", "--remove-orphans"},
 		},
-		{
-			name: "completion command",
-			args: []string{"__complete", "up"},
-			want: []string{"__complete", "compose", "up"},
-		},
-		{
-			name:    "string flag without argument",
-			args:    []string{"--log-level"},
-			wantErr: true,
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if tt.wantErr {
-				if os.Getenv("BE_CRASHER") == "1" {
-					Convert(tt.args)
-					return
-				}
-				cmd := exec.Command(os.Args[0], "-test.run=^"+t.Name()+"$")
-				cmd.Env = append(os.Environ(), "BE_CRASHER=1")
-				err := cmd.Run()
-				var e *exec.ExitError
-				if errors.As(err, &e) && !e.Success() {
-					return
-				}
-				t.Fatalf("process ran with err %v, want exit status 1", err)
-			} else {
-				got := Convert(tt.args)
-				assert.DeepEqual(t, tt.want, got)
-			}
+			got := Convert(tt.args)
+			assert.DeepEqual(t, tt.want, got)
 		})
 	}
 }
--- a/cmd/compose/alpha.go
+++ b/cmd/compose/alpha.go
@@ -21,7 +21,7 @@ import (
 )

 // alphaCommand groups all experimental subcommands
-func alphaCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func alphaCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	cmd := &cobra.Command{
 		Short:  "Experimental commands",
 		Use:    "alpha [COMMAND]",
--- a/cmd/compose/attach.go
+++ b/cmd/compose/attach.go
@@ -35,7 +35,7 @@ type attachOpts struct {
 	proxy      bool
 }

-func attachCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func attachCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := attachOpts{
 		composeOptions: &composeOptions{
 			ProjectOptions: p,
@@ -63,7 +63,7 @@ func attachCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 	return runCmd
 }

-func runAttach(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts attachOpts) error {
+func runAttach(ctx context.Context, dockerCli command.Cli, backend api.Service, opts attachOpts) error {
 	projectName, err := opts.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
--- a/cmd/compose/bridge.go
+++ b/cmd/compose/bridge.go
@@ -1,149 +0,0 @@
-/*
-   Copyright 2020 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 (
-	"context"
-	"fmt"
-	"io"
-
-	"github.com/distribution/reference"
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/docker/api/types/image"
-	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/go-units"
-	"github.com/spf13/cobra"
-
-	"github.com/docker/compose/v2/cmd/formatter"
-	"github.com/docker/compose/v2/pkg/bridge"
-)
-
-func bridgeCommand(p *ProjectOptions, dockerCli command.Cli) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:              "bridge CMD [OPTIONS]",
-		Short:            "Convert compose files into another model",
-		TraverseChildren: true,
-	}
-	cmd.AddCommand(
-		convertCommand(p, dockerCli),
-		transformersCommand(dockerCli),
-	)
-	return cmd
-}
-
-func convertCommand(p *ProjectOptions, dockerCli command.Cli) *cobra.Command {
-	convertOpts := bridge.ConvertOptions{}
-	cmd := &cobra.Command{
-		Use:   "convert",
-		Short: "Convert compose files to Kubernetes manifests, Helm charts, or another model",
-		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runConvert(ctx, dockerCli, p, convertOpts)
-		}),
-	}
-	flags := cmd.Flags()
-	flags.StringVarP(&convertOpts.Output, "output", "o", "out", "The output directory for the Kubernetes resources")
-	flags.StringArrayVarP(&convertOpts.Transformations, "transformation", "t", nil, "Transformation to apply to compose model (default: docker/compose-bridge-kubernetes)")
-	flags.StringVar(&convertOpts.Templates, "templates", "", "Directory containing transformation templates")
-	return cmd
-}
-
-func runConvert(ctx context.Context, dockerCli command.Cli, p *ProjectOptions, opts bridge.ConvertOptions) error {
-	project, _, err := p.ToProject(ctx, dockerCli, nil)
-	if err != nil {
-		return err
-	}
-	return bridge.Convert(ctx, dockerCli, project, opts)
-}
-
-func transformersCommand(dockerCli command.Cli) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "transformations CMD [OPTIONS]",
-		Short: "Manage transformation images",
-	}
-	cmd.AddCommand(
-		listTransformersCommand(dockerCli),
-		createTransformerCommand(dockerCli),
-	)
-	return cmd
-}
-
-func listTransformersCommand(dockerCli command.Cli) *cobra.Command {
-	options := lsOptions{}
-	cmd := &cobra.Command{
-		Use:     "list",
-		Aliases: []string{"ls"},
-		Short:   "List available transformations",
-		RunE: Adapt(func(ctx context.Context, args []string) error {
-			transformers, err := bridge.ListTransformers(ctx, dockerCli)
-			if err != nil {
-				return err
-			}
-			return displayTransformer(dockerCli, transformers, options)
-		}),
-	}
-	cmd.Flags().StringVar(&options.Format, "format", "table", "Format the output. Values: [table | json]")
-	cmd.Flags().BoolVarP(&options.Quiet, "quiet", "q", false, "Only display transformer names")
-	return cmd
-}
-
-func displayTransformer(dockerCli command.Cli, transformers []image.Summary, options lsOptions) error {
-	if options.Quiet {
-		for _, t := range transformers {
-			if len(t.RepoTags) > 0 {
-				_, _ = fmt.Fprintln(dockerCli.Out(), t.RepoTags[0])
-			} else {
-				_, _ = fmt.Fprintln(dockerCli.Out(), t.ID)
-			}
-		}
-		return nil
-	}
-	return formatter.Print(transformers, options.Format, dockerCli.Out(),
-		func(w io.Writer) {
-			for _, img := range transformers {
-				id := stringid.TruncateID(img.ID)
-				size := units.HumanSizeWithPrecision(float64(img.Size), 3)
-				repo, tag := "<none>", "<none>"
-				if len(img.RepoTags) > 0 {
-					ref, err := reference.ParseDockerRef(img.RepoTags[0])
-					if err == nil {
-						// ParseDockerRef will reject a local image ID
-						repo = reference.FamiliarName(ref)
-						if tagged, ok := ref.(reference.Tagged); ok {
-							tag = tagged.Tag()
-						}
-					}
-				}
-
-				_, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", id, repo, tag, size)
-			}
-		},
-		"IMAGE ID", "REPO", "TAGS", "SIZE")
-}
-
-func createTransformerCommand(dockerCli command.Cli) *cobra.Command {
-	var opts bridge.CreateTransformerOptions
-	cmd := &cobra.Command{
-		Use:   "create [OPTION] PATH",
-		Short: "Create a new transformation",
-		RunE: Adapt(func(ctx context.Context, args []string) error {
-			opts.Dest = args[0]
-			return bridge.CreateTransformer(ctx, dockerCli, opts)
-		}),
-	}
-	cmd.Flags().StringVarP(&opts.From, "from", "f", "", "Existing transformation to copy (default: docker/compose-bridge-kubernetes)")
-	return cmd
-}
--- a/cmd/compose/build.go
+++ b/cmd/compose/build.go
@@ -27,6 +27,7 @@ import (
 	"github.com/docker/cli/cli/command"
 	cliopts "github.com/docker/cli/opts"
 	ui "github.com/docker/compose/v2/pkg/progress"
+	buildkit "github.com/moby/buildkit/util/progress/progressui"
 	"github.com/spf13/cobra"

 	"github.com/docker/compose/v2/pkg/api"
@@ -34,19 +35,15 @@ import (

 type buildOptions struct {
 	*ProjectOptions
-	quiet      bool
-	pull       bool
-	push       bool
-	args       []string
-	noCache    bool
-	memory     cliopts.MemBytes
-	ssh        string
-	builder    string
-	deps       bool
-	print      bool
-	check      bool
-	sbom       string
-	provenance string
+	quiet   bool
+	pull    bool
+	push    bool
+	args    []string
+	noCache bool
+	memory  cliopts.MemBytes
+	ssh     string
+	builder string
+	deps    bool
 }

 func (opts buildOptions) toAPIBuildOptions(services []string) (api.BuildOptions, error) {
@@ -70,27 +67,21 @@ func (opts buildOptions) toAPIBuildOptions(services []string) (api.BuildOptions,
 	if uiMode == ui.ModeJSON {
 		uiMode = "rawjson"
 	}
-
 	return api.BuildOptions{
-		Pull:       opts.pull,
-		Push:       opts.push,
-		Progress:   uiMode,
-		Args:       types.NewMappingWithEquals(opts.args),
-		NoCache:    opts.noCache,
-		Quiet:      opts.quiet,
-		Services:   services,
-		Deps:       opts.deps,
-		Memory:     int64(opts.memory),
-		Print:      opts.print,
-		Check:      opts.check,
-		SSHs:       SSHKeys,
-		Builder:    builderName,
-		SBOM:       opts.sbom,
-		Provenance: opts.provenance,
+		Pull:     opts.pull,
+		Push:     opts.push,
+		Progress: uiMode,
+		Args:     types.NewMappingWithEquals(opts.args),
+		NoCache:  opts.noCache,
+		Quiet:    opts.quiet,
+		Services: services,
+		Deps:     opts.deps,
+		SSHs:     SSHKeys,
+		Builder:  builderName,
 	}, nil
 }

-func buildCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func buildCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := buildOptions{
 		ProjectOptions: p,
 	}
@@ -121,14 +112,12 @@ func buildCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	}
 	flags := cmd.Flags()
 	flags.BoolVar(&opts.push, "push", false, "Push service images")
-	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Suppress the build output")
+	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Don't print anything to STDOUT")
 	flags.BoolVar(&opts.pull, "pull", false, "Always attempt to pull a newer version of the image")
 	flags.StringArrayVar(&opts.args, "build-arg", []string{}, "Set build-time variables for services")
 	flags.StringVar(&opts.ssh, "ssh", "", "Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent)")
 	flags.StringVar(&opts.builder, "builder", "", "Set builder to use")
 	flags.BoolVar(&opts.deps, "with-dependencies", false, "Also build dependencies (transitively)")
-	flags.StringVar(&opts.provenance, "provenance", "", `Add a provenance attestation`)
-	flags.StringVar(&opts.sbom, "sbom", "", `Add a SBOM attestation`)

 	flags.Bool("parallel", true, "Build images in parallel. DEPRECATED")
 	flags.MarkHidden("parallel") //nolint:errcheck
@@ -140,17 +129,14 @@ func buildCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	flags.Bool("no-rm", false, "Do not remove intermediate containers after a successful build. DEPRECATED")
 	flags.MarkHidden("no-rm") //nolint:errcheck
 	flags.VarP(&opts.memory, "memory", "m", "Set memory limit for the build container. Not supported by BuildKit.")
-	flags.StringVar(&p.Progress, "progress", "", fmt.Sprintf(`Set type of ui output (%s)`, strings.Join(printerModes, ", ")))
+	flags.StringVar(&p.Progress, "progress", string(buildkit.AutoMode), fmt.Sprintf(`Set type of ui output (%s)`, strings.Join(printerModes, ", ")))
 	flags.MarkHidden("progress") //nolint:errcheck
-	flags.BoolVar(&opts.print, "print", false, "Print equivalent bake file")
-	flags.BoolVar(&opts.check, "check", false, "Check build configuration")

 	return cmd
 }

-func runBuild(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts buildOptions, services []string) error {
-	opts.All = true // do not drop resources as build may involve some dependencies by additional_contexts
-	project, _, err := opts.ToProject(ctx, dockerCli, nil, cli.WithResolvedPaths(true), cli.WithoutEnvironmentResolution)
+func runBuild(ctx context.Context, dockerCli command.Cli, backend api.Service, opts buildOptions, services []string) error {
+	project, _, err := opts.ToProject(ctx, dockerCli, services, cli.WithResolvedPaths(true), cli.WithoutEnvironmentResolution)
 	if err != nil {
 		return err
 	}
@@ -163,7 +149,7 @@ func runBuild(ctx context.Context, dockerCli command.Cli, backend api.Compose, o
 	if err != nil {
 		return err
 	}
-	apiBuildOptions.Attestations = true

+	apiBuildOptions.Memory = int64(opts.memory)
 	return backend.Build(ctx, project, apiBuildOptions)
 }
--- a/cmd/compose/commit.go
+++ b/cmd/compose/commit.go
@@ -39,7 +39,7 @@ type commitOptions struct {
 	index int
 }

-func commitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func commitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	options := commitOptions{
 		ProjectOptions: p,
 	}
@@ -73,13 +73,13 @@ func commitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 	return cmd
 }

-func runCommit(ctx context.Context, dockerCli command.Cli, backend api.Compose, options commitOptions) error {
+func runCommit(ctx context.Context, dockerCli command.Cli, backend api.Service, options commitOptions) error {
 	projectName, err := options.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
 	}

-	return backend.Commit(ctx, projectName, api.CommitOptions{
+	commitOptions := api.CommitOptions{
 		Service:   options.service,
 		Reference: options.reference,
 		Pause:     options.pause,
@@ -87,5 +87,7 @@ func runCommit(ctx context.Context, dockerCli command.Cli, backend api.Compose,
 		Author:    options.author,
 		Changes:   options.changes,
 		Index:     options.index,
-	})
+	}
+
+	return backend.Commit(ctx, projectName, commitOptions)
 }
--- a/cmd/compose/completion.go
+++ b/cmd/compose/completion.go
@@ -52,7 +52,7 @@ func completeServiceNames(dockerCli command.Cli, p *ProjectOptions) validArgsFn
 	}
 }

-func completeProjectNames(backend api.Compose) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+func completeProjectNames(backend api.Service) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		list, err := backend.List(cmd.Context(), api.ListOptions{
 			All: true,
@@ -90,13 +90,3 @@ func completeProfileNames(dockerCli command.Cli, p *ProjectOptions) validArgsFn
 		return values, cobra.ShellCompDirectiveNoFileComp
 	}
 }
-
-func completeScaleArgs(cli command.Cli, p *ProjectOptions) cobra.CompletionFunc {
-	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		completions, directive := completeServiceNames(cli, p)(cmd, args, toComplete)
-		for i, completion := range completions {
-			completions[i] = completion + "="
-		}
-		return completions, directive
-	}
-}
--- a/cmd/compose/compose.go
+++ b/cmd/compose/compose.go
@@ -36,15 +36,19 @@ import (
 	composegoutils "github.com/compose-spec/compose-go/v2/utils"
 	"github.com/docker/buildx/util/logutil"
 	dockercli "github.com/docker/cli/cli"
-	"github.com/docker/cli/cli-plugins/metadata"
+	"github.com/docker/cli/cli-plugins/manager"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/pkg/kvfile"
 	"github.com/docker/compose/v2/cmd/formatter"
+	"github.com/docker/compose/v2/internal/desktop"
+	"github.com/docker/compose/v2/internal/experimental"
 	"github.com/docker/compose/v2/internal/tracing"
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/compose"
 	ui "github.com/docker/compose/v2/pkg/progress"
 	"github.com/docker/compose/v2/pkg/remote"
 	"github.com/docker/compose/v2/pkg/utils"
+	buildkit "github.com/moby/buildkit/util/progress/progressui"
 	"github.com/morikuni/aec"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -66,21 +70,20 @@ const (
 	ComposeEnvFiles = "COMPOSE_ENV_FILES"
 	// ComposeMenu defines if the navigation menu should be rendered. Can be also set via --menu
 	ComposeMenu = "COMPOSE_MENU"
-	// ComposeProgress defines type of progress output, if --progress isn't used
-	ComposeProgress = "COMPOSE_PROGRESS"
 )

 // rawEnv load a dot env file using docker/cli key=value parser, without attempt to interpolate or evaluate values
-func rawEnv(r io.Reader, filename string, vars map[string]string, lookup func(key string) (string, bool)) error {
+func rawEnv(r io.Reader, filename string, lookup func(key string) (string, bool)) (map[string]string, error) {
 	lines, err := kvfile.ParseFromReader(r, lookup)
 	if err != nil {
-		return fmt.Errorf("failed to parse env_file %s: %w", filename, err)
+		return nil, fmt.Errorf("failed to parse env_file %s: %w", filename, err)
 	}
+	vars := types.Mapping{}
 	for _, line := range lines {
 		key, value, _ := strings.Cut(line, "=")
 		vars[key] = value
 	}
-	return nil
+	return vars, nil
 }

 func init() {
@@ -89,6 +92,14 @@ func init() {
 	dotenv.RegisterFormat("raw", rawEnv)
 }

+type Backend interface {
+	api.Service
+
+	SetDesktopClient(cli *desktop.Client)
+
+	SetExperiments(experiments *experimental.State)
+}
+
 // Command defines a compose CLI command as a func with args
 type Command func(context.Context, []string) error

@@ -110,9 +121,17 @@ func AdaptCmd(fn CobraCommand) func(cmd *cobra.Command, args []string) error {
 		}()

 		err := fn(ctx, cmd, args)
+		var composeErr compose.Error
 		if api.IsErrCanceled(err) || errors.Is(ctx.Err(), context.Canceled) {
 			err = dockercli.StatusError{
 				StatusCode: 130,
+				Status:     compose.CanceledStatus,
+			}
+		}
+		if errors.As(err, &composeErr) {
+			err = dockercli.StatusError{
+				StatusCode: composeErr.GetMetricsFailureCategory().ExitCode,
+				Status:     err.Error(),
 			}
 		}
 		if ui.Mode == ui.ModeJSON {
@@ -160,7 +179,7 @@ func (o *ProjectOptions) WithServices(dockerCli command.Cli, fn ProjectServicesF
 	return Adapt(func(ctx context.Context, args []string) error {
 		options := []cli.ProjectOptionsFn{
 			cli.WithResolvedPaths(true),
-			cli.WithoutEnvironmentResolution,
+			cli.WithDiscardEnvFile,
 		}

 		project, metrics, err := o.ToProject(ctx, dockerCli, args, options...)
@@ -170,11 +189,6 @@ func (o *ProjectOptions) WithServices(dockerCli command.Cli, fn ProjectServicesF

 		ctx = context.WithValue(ctx, tracing.MetricsKey{}, metrics)

-		project, err = project.WithServicesEnvironmentResolved(true)
-		if err != nil {
-			return err
-		}
-
 		return fn(ctx, project, args)
 	})
 }
@@ -219,7 +233,7 @@ func (o *ProjectOptions) addProjectFlags(f *pflag.FlagSet) {
 	f.StringVar(&o.ProjectDir, "project-directory", "", "Specify an alternate working directory\n(default: the path of the, first specified, Compose file)")
 	f.StringVar(&o.WorkDir, "workdir", "", "DEPRECATED! USE --project-directory INSTEAD.\nSpecify an alternate working directory\n(default: the path of the, first specified, Compose file)")
 	f.BoolVar(&o.Compatibility, "compatibility", false, "Run compose in backward compatibility mode")
-	f.StringVar(&o.Progress, "progress", os.Getenv(ComposeProgress), fmt.Sprintf(`Set type of progress output (%s)`, strings.Join(printerModes, ", ")))
+	f.StringVar(&o.Progress, "progress", string(buildkit.AutoMode), fmt.Sprintf(`Set type of progress output (%s)`, strings.Join(printerModes, ", ")))
 	f.BoolVar(&o.All, "all-resources", false, "Include all resources, even those not used by services")
 	_ = f.MarkHidden("workdir")
 }
@@ -235,7 +249,7 @@ func (o *ProjectOptions) projectOrName(ctx context.Context, dockerCli command.Cl
 	name := o.ProjectName
 	var project *types.Project
 	if len(o.ConfigPaths) > 0 || o.ProjectName == "" {
-		p, _, err := o.ToProject(ctx, dockerCli, services, cli.WithDiscardEnvFile, cli.WithoutEnvironmentResolution)
+		p, _, err := o.ToProject(ctx, dockerCli, services, cli.WithDiscardEnvFile)
 		if err != nil {
 			envProjectName := os.Getenv(ComposeProjectName)
 			if envProjectName != "" {
@@ -293,7 +307,7 @@ func (o *ProjectOptions) ToProject(ctx context.Context, dockerCli command.Cli, s

 	options, err := o.toProjectOptions(po...)
 	if err != nil {
-		return nil, metrics, err
+		return nil, metrics, compose.WrapComposeError(err)
 	}

 	options.WithListeners(func(event string, metadata map[string]any) {
@@ -325,7 +339,7 @@ func (o *ProjectOptions) ToProject(ctx context.Context, dockerCli command.Cli, s

 	project, err := options.LoadProject(ctx)
 	if err != nil {
-		return nil, metrics, err
+		return nil, metrics, compose.WrapComposeError(err)
 	}

 	if project.Name == "" {
@@ -367,44 +381,31 @@ func (o *ProjectOptions) remoteLoaders(dockerCli command.Cli) []loader.ResourceL
 	if o.Offline {
 		return nil
 	}
-	git := remote.NewGitRemoteLoader(dockerCli, o.Offline)
+	git := remote.NewGitRemoteLoader(o.Offline)
 	oci := remote.NewOCIRemoteLoader(dockerCli, o.Offline)
 	return []loader.ResourceLoader{git, oci}
 }

 func (o *ProjectOptions) toProjectOptions(po ...cli.ProjectOptionsFn) (*cli.ProjectOptions, error) {
-	opts := []cli.ProjectOptionsFn{
-		cli.WithWorkingDirectory(o.ProjectDir),
-		// First apply os.Environment, always win
-		cli.WithOsEnv,
-	}
-
-	if _, present := os.LookupEnv("PWD"); !present {
-		if pwd, err := os.Getwd(); err != nil {
-			return nil, err
-		} else {
-			opts = append(opts, cli.WithEnv([]string{"PWD=" + pwd}))
-		}
-	}
-
-	opts = append(opts,
-		// Load PWD/.env if present and no explicit --env-file has been set
-		cli.WithEnvFiles(o.EnvFiles...),
-		// read dot env file to populate project environment
-		cli.WithDotEnv,
-		// get compose file path set by COMPOSE_FILE
-		cli.WithConfigFileEnv,
-		// if none was selected, get default compose.yaml file from current dir or parent folder
-		cli.WithDefaultConfigPath,
-		// .. and then, a project directory != PWD maybe has been set so let's load .env file
-		cli.WithEnvFiles(o.EnvFiles...),
-		cli.WithDotEnv,
-		// eventually COMPOSE_PROFILES should have been set
-		cli.WithDefaultProfiles(o.Profiles...),
-		cli.WithName(o.ProjectName),
-	)
-
-	return cli.NewProjectOptions(o.ConfigPaths, append(po, opts...)...)
+	return cli.NewProjectOptions(o.ConfigPaths,
+		append(po,
+			cli.WithWorkingDirectory(o.ProjectDir),
+			// First apply os.Environment, always win
+			cli.WithOsEnv,
+			// Load PWD/.env if present and no explicit --env-file has been set
+			cli.WithEnvFiles(o.EnvFiles...),
+			// read dot env file to populate project environment
+			cli.WithDotEnv,
+			// get compose file path set by COMPOSE_FILE
+			cli.WithConfigFileEnv,
+			// if none was selected, get default compose.yaml file from current dir or parent folder
+			cli.WithDefaultConfigPath,
+			// .. and then, a project directory != PWD maybe has been set so let's load .env file
+			cli.WithEnvFiles(o.EnvFiles...),
+			cli.WithDotEnv,
+			// eventually COMPOSE_PROFILES should have been set
+			cli.WithDefaultProfiles(o.Profiles...),
+			cli.WithName(o.ProjectName))...)
 }

 // PluginName is the name of the plugin
@@ -412,11 +413,11 @@ const PluginName = "compose"

 // RunningAsStandalone detects when running as a standalone program
 func RunningAsStandalone() bool {
-	return len(os.Args) < 2 || os.Args[1] != metadata.MetadataSubcommandName && os.Args[1] != PluginName
+	return len(os.Args) < 2 || os.Args[1] != manager.MetadataSubcommandName && os.Args[1] != PluginName
 }

 // RootCommand returns the compose command with its child commands
-func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //nolint:gocyclo
+func RootCommand(dockerCli command.Cli, backend Backend) *cobra.Command { //nolint:gocyclo
 	// filter out useless commandConn.CloseWrite warning message that can occur
 	// when using a remote context that is unreachable: "commandConn.CloseWrite: commandconn: failed to wait: signal: killed"
 	// https://github.com/docker/cli/blob/e1f24d3c93df6752d3c27c8d61d18260f141310c/cli/connhelper/commandconn/commandconn.go#L203-L215
@@ -427,6 +428,7 @@ func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //
 		"commandConn.CloseRead:",
 	))

+	experiments := experimental.NewState()
 	opts := ProjectOptions{}
 	var (
 		ansi     string
@@ -451,7 +453,7 @@ func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //
 			}
 			_ = cmd.Help()
 			return dockercli.StatusError{
-				StatusCode: 1,
+				StatusCode: compose.CommandSyntaxFailure.ExitCode,
 				Status:     fmt.Sprintf("unknown docker command: %q", "compose "+args[0]),
 			}
 		},
@@ -502,7 +504,8 @@ func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //
 			}

 			switch opts.Progress {
-			case "", ui.ModeAuto:
+			case ui.ModeAuto:
+				ui.Mode = ui.ModeAuto
 				if ansi == "never" {
 					ui.Mode = ui.ModePlain
 				}
@@ -544,7 +547,10 @@ func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //
 			}

 			composeCmd := cmd
-			for composeCmd.Name() != PluginName {
+			for {
+				if composeCmd.Name() == PluginName {
+					break
+				}
 				if !composeCmd.HasParent() {
 					return fmt.Errorf("error parsing command line, expected %q", PluginName)
 				}
@@ -570,6 +576,27 @@ func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //
 			}
 			cmd.SetContext(ctx)

+			// (6) Desktop integration
+			var desktopCli *desktop.Client
+			if !dryRun {
+				if desktopCli, err = desktop.NewFromDockerClient(ctx, dockerCli); desktopCli != nil {
+					logrus.Debugf("Enabled Docker Desktop integration (experimental) @ %s", desktopCli.Endpoint())
+					backend.SetDesktopClient(desktopCli)
+				} else if err != nil {
+					// not fatal, Compose will still work but behave as though
+					// it's not running as part of Docker Desktop
+					logrus.Debugf("failed to enable Docker Desktop integration: %v", err)
+				} else {
+					logrus.Trace("Docker Desktop integration not enabled")
+				}
+			}
+
+			// (7) experimental features
+			if err := experiments.Load(ctx, desktopCli); err != nil {
+				logrus.Debugf("Failed to query feature flags from Desktop: %v", err)
+			}
+			backend.SetExperiments(experiments)
+
 			return nil
 		},
 	}
@@ -607,10 +634,7 @@ func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //
 		scaleCommand(&opts, dockerCli, backend),
 		statsCommand(&opts, dockerCli),
 		watchCommand(&opts, dockerCli, backend),
-		publishCommand(&opts, dockerCli, backend),
 		alphaCommand(&opts, dockerCli, backend),
-		bridgeCommand(&opts, dockerCli),
-		volumesCommand(&opts, dockerCli, backend),
 	)

 	c.Flags().SetInterspersed(false)
@@ -635,10 +659,6 @@ func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //
 		"profile",
 		completeProfileNames(dockerCli, &opts),
 	)
-	c.RegisterFlagCompletionFunc( //nolint:errcheck
-		"progress",
-		cobra.FixedCompletions(printerModes, cobra.ShellCompDirectiveNoFileComp),
-	)

 	c.Flags().StringVar(&ansi, "ansi", "auto", `Control when to print ANSI control characters ("never"|"always"|"auto")`)
 	c.Flags().IntVar(&parallel, "parallel", -1, `Control max parallelism, -1 for unlimited`)
@@ -667,7 +687,7 @@ func setEnvWithDotEnv(opts ProjectOptions) error {
 		return nil
 	}
 	for k, v := range envFromFile {
-		if _, ok := os.LookupEnv(k); !ok && strings.HasPrefix(k, "COMPOSE_") {
+		if _, ok := os.LookupEnv(k); !ok {
 			if err = os.Setenv(k, v); err != nil {
 				return nil
 			}
@@ -683,3 +703,15 @@ var printerModes = []string{
 	ui.ModeJSON,
 	ui.ModeQuiet,
 }
+
+func SetUnchangedOption(name string, experimentalFlag bool) bool {
+	var value bool
+	// If the var is defined we use that value first
+	if envVar, ok := os.LookupEnv(name); ok {
+		value = utils.StringToBool(envVar)
+	} else {
+		// if not, we try to get it from experimental feature flag
+		value = experimentalFlag
+	}
+	return value
+}
--- a/cmd/compose/config.go
+++ b/cmd/compose/config.go
@@ -47,18 +47,14 @@ type configOptions struct {
 	noInterpolate       bool
 	noNormalize         bool
 	noResolvePath       bool
-	noResolveEnv        bool
 	services            bool
 	volumes             bool
-	networks            bool
-	models              bool
 	profiles            bool
 	images              bool
 	hash                string
 	noConsistency       bool
 	variables           bool
 	environment         bool
-	lockImageDigests    bool
 }

 func (o *configOptions) ToProject(ctx context.Context, dockerCli command.Cli, services []string, po ...cli.ProjectOptionsFn) (*types.Project, error) {
@@ -88,8 +84,9 @@ func configCommand(p *ProjectOptions, dockerCli command.Cli) *cobra.Command {
 		ProjectOptions: p,
 	}
 	cmd := &cobra.Command{
-		Use:   "config [OPTIONS] [SERVICE...]",
-		Short: "Parse, resolve and render compose file in canonical format",
+		Aliases: []string{"convert"}, // for backward compatibility with Cloud integrations
+		Use:     "config [OPTIONS] [SERVICE...]",
+		Short:   "Parse, resolve and render compose file in canonical format",
 		PreRunE: Adapt(func(ctx context.Context, args []string) error {
 			if opts.quiet {
 				devnull, err := os.Open(os.DevNull)
@@ -101,9 +98,6 @@ func configCommand(p *ProjectOptions, dockerCli command.Cli) *cobra.Command {
 			if p.Compatibility {
 				opts.noNormalize = true
 			}
-			if opts.lockImageDigests {
-				opts.resolveImageDigests = true
-			}
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
@@ -113,12 +107,6 @@ func configCommand(p *ProjectOptions, dockerCli command.Cli) *cobra.Command {
 			if opts.volumes {
 				return runVolumes(ctx, dockerCli, opts)
 			}
-			if opts.networks {
-				return runNetworks(ctx, dockerCli, opts)
-			}
-			if opts.models {
-				return runModels(ctx, dockerCli, opts)
-			}
 			if opts.hash != "" {
 				return runHash(ctx, dockerCli, opts)
 			}
@@ -135,28 +123,21 @@ func configCommand(p *ProjectOptions, dockerCli command.Cli) *cobra.Command {
 				return runEnvironment(ctx, dockerCli, opts, args)
 			}

-			if opts.Format == "" {
-				opts.Format = "yaml"
-			}
 			return runConfig(ctx, dockerCli, opts, args)
 		}),
 		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := cmd.Flags()
-	flags.StringVar(&opts.Format, "format", "", "Format the output. Values: [yaml | json]")
+	flags.StringVar(&opts.Format, "format", "yaml", "Format the output. Values: [yaml | json]")
 	flags.BoolVar(&opts.resolveImageDigests, "resolve-image-digests", false, "Pin image tags to digests")
-	flags.BoolVar(&opts.lockImageDigests, "lock-image-digests", false, "Produces an override file with image digests")
 	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Only validate the configuration, don't print anything")
 	flags.BoolVar(&opts.noInterpolate, "no-interpolate", false, "Don't interpolate environment variables")
 	flags.BoolVar(&opts.noNormalize, "no-normalize", false, "Don't normalize compose model")
 	flags.BoolVar(&opts.noResolvePath, "no-path-resolution", false, "Don't resolve file paths")
 	flags.BoolVar(&opts.noConsistency, "no-consistency", false, "Don't check model consistency - warning: may produce invalid Compose output")
-	flags.BoolVar(&opts.noResolveEnv, "no-env-resolution", false, "Don't resolve service env files")

 	flags.BoolVar(&opts.services, "services", false, "Print the service names, one per line.")
 	flags.BoolVar(&opts.volumes, "volumes", false, "Print the volume names, one per line.")
-	flags.BoolVar(&opts.networks, "networks", false, "Print the network names, one per line.")
-	flags.BoolVar(&opts.models, "models", false, "Print the model names, one per line.")
 	flags.BoolVar(&opts.profiles, "profiles", false, "Print the profile names, one per line.")
 	flags.BoolVar(&opts.images, "images", false, "Print the image names, one per line.")
 	flags.StringVar(&opts.hash, "hash", "", "Print the service config hash, one per line.")
@@ -209,13 +190,6 @@ func runConfigInterpolate(ctx context.Context, dockerCli command.Cli, opts confi
 		}
 	}

-	if !opts.noResolveEnv {
-		project, err = project.WithServicesEnvironmentResolved(true)
-		if err != nil {
-			return nil, err
-		}
-	}
-
 	if !opts.noConsistency {
 		err := project.CheckContainerNameUnicity()
 		if err != nil {
@@ -223,10 +197,6 @@ func runConfigInterpolate(ctx context.Context, dockerCli command.Cli, opts confi
 		}
 	}

-	if opts.lockImageDigests {
-		project = imagesOnly(project)
-	}
-
 	var content []byte
 	switch opts.Format {
 	case "json":
@@ -242,18 +212,6 @@ func runConfigInterpolate(ctx context.Context, dockerCli command.Cli, opts confi
 	return content, nil
 }

-// imagesOnly return project with all attributes removed but service.images
-func imagesOnly(project *types.Project) *types.Project {
-	digests := types.Services{}
-	for name, config := range project.Services {
-		digests[name] = types.ServiceConfig{
-			Image: config.Image,
-		}
-	}
-	project = &types.Project{Services: digests}
-	return project
-}
-
 func runConfigNoInterpolate(ctx context.Context, dockerCli command.Cli, opts configOptions, services []string) ([]byte, error) {
 	// we can't use ToProject, so the model we render here is only partially resolved
 	model, err := opts.ToModel(ctx, dockerCli, services)
@@ -268,23 +226,6 @@ func runConfigNoInterpolate(ctx context.Context, dockerCli command.Cli, opts con
 		}
 	}

-	if opts.lockImageDigests {
-		for key, e := range model {
-			if key != "services" {
-				delete(model, key)
-			} else {
-				for _, s := range e.(map[string]any) {
-					service := s.(map[string]any)
-					for key := range service {
-						if key != "image" {
-							delete(service, key)
-						}
-					}
-				}
-			}
-		}
-	}
-
 	return formatModel(model, opts.Format)
 }

@@ -377,30 +318,6 @@ func runVolumes(ctx context.Context, dockerCli command.Cli, opts configOptions)
 	return nil
 }

-func runNetworks(ctx context.Context, dockerCli command.Cli, opts configOptions) error {
-	project, err := opts.ToProject(ctx, dockerCli, nil, cli.WithoutEnvironmentResolution)
-	if err != nil {
-		return err
-	}
-	for n := range project.Networks {
-		_, _ = fmt.Fprintln(dockerCli.Out(), n)
-	}
-	return nil
-}
-
-func runModels(ctx context.Context, dockerCli command.Cli, opts configOptions) error {
-	project, err := opts.ToProject(ctx, dockerCli, nil, cli.WithoutEnvironmentResolution)
-	if err != nil {
-		return err
-	}
-	for _, model := range project.Models {
-		if model.Model != "" {
-			_, _ = fmt.Fprintln(dockerCli.Out(), model.Model)
-		}
-	}
-	return nil
-}
-
 func runHash(ctx context.Context, dockerCli command.Cli, opts configOptions) error {
 	var services []string
 	if opts.hash != "*" {
@@ -431,6 +348,7 @@ func runHash(ctx context.Context, dockerCli command.Cli, opts configOptions) err
 		}

 		hash, err := compose.ServiceHash(s)
+
 		if err != nil {
 			return err
 		}
@@ -482,16 +400,7 @@ func runVariables(ctx context.Context, dockerCli command.Cli, opts configOptions

 	variables := template.ExtractVariables(model, template.DefaultPattern)

-	if opts.Format == "yaml" {
-		result, err := yaml.Marshal(variables)
-		if err != nil {
-			return err
-		}
-		fmt.Print(string(result))
-		return nil
-	}
-
-	return formatter.Print(variables, opts.Format, dockerCli.Out(), func(w io.Writer) {
+	return formatter.Print(variables, "", dockerCli.Out(), func(w io.Writer) {
 		for name, variable := range variables {
 			_, _ = fmt.Fprintf(w, "%s\t%t\t%s\t%s\n", name, variable.Required, variable.DefaultValue, variable.PresenceValue)
 		}
--- a/cmd/compose/cp.go
+++ b/cmd/compose/cp.go
@@ -38,7 +38,7 @@ type copyOptions struct {
 	copyUIDGID  bool
 }

-func copyCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func copyCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := copyOptions{
 		ProjectOptions: p,
 	}
@@ -73,7 +73,7 @@ func copyCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return copyCmd
 }

-func runCopy(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts copyOptions) error {
+func runCopy(ctx context.Context, dockerCli command.Cli, backend api.Service, opts copyOptions) error {
 	name, err := opts.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
--- a/cmd/compose/create.go
+++ b/cmd/compose/create.go
@@ -26,9 +26,7 @@ import (

 	"github.com/compose-spec/compose-go/v2/types"
 	"github.com/docker/cli/cli/command"
-	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"

 	"github.com/docker/compose/v2/pkg/api"
 )
@@ -48,10 +46,9 @@ type createOptions struct {
 	timeout       int
 	quietPull     bool
 	scale         []string
-	AssumeYes     bool
 }

-func createCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func createCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := createOptions{}
 	buildOpts := buildOptions{
 		ProjectOptions: p,
@@ -83,19 +80,10 @@ func createCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 	flags.BoolVar(&opts.noRecreate, "no-recreate", false, "If containers already exist, don't recreate them. Incompatible with --force-recreate.")
 	flags.BoolVar(&opts.removeOrphans, "remove-orphans", false, "Remove containers for services not defined in the Compose file")
 	flags.StringArrayVar(&opts.scale, "scale", []string{}, "Scale SERVICE to NUM instances. Overrides the `scale` setting in the Compose file if present.")
-	flags.BoolVarP(&opts.AssumeYes, "yes", "y", false, `Assume "yes" as answer to all prompts and run non-interactively`)
-	flags.SetNormalizeFunc(func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		// assumeYes was introduced by mistake as `--y`
-		if name == "y" {
-			logrus.Warn("--y is deprecated, please use --yes instead")
-			name = "yes"
-		}
-		return pflag.NormalizedName(name)
-	})
 	return cmd
 }

-func runCreate(ctx context.Context, _ command.Cli, backend api.Compose, createOpts createOptions, buildOpts buildOptions, project *types.Project, services []string) error {
+func runCreate(ctx context.Context, _ command.Cli, backend api.Service, createOpts createOptions, buildOpts buildOptions, project *types.Project, services []string) error {
 	if err := createOpts.Apply(project); err != nil {
 		return err
 	}
@@ -119,7 +107,6 @@ func runCreate(ctx context.Context, _ command.Cli, backend api.Compose, createOp
 		Inherit:              !createOpts.noInherit,
 		Timeout:              createOpts.GetTimeout(),
 		QuietPull:            createOpts.quietPull,
-		AssumeYes:            createOpts.AssumeYes,
 	})
 }

@@ -208,9 +195,7 @@ func applyScaleOpts(project *types.Project, opts []string) error {
 }

 func (opts createOptions) isPullPolicyValid() bool {
-	pullPolicies := []string{
-		types.PullPolicyAlways, types.PullPolicyNever, types.PullPolicyBuild,
-		types.PullPolicyMissing, types.PullPolicyIfNotPresent,
-	}
+	pullPolicies := []string{types.PullPolicyAlways, types.PullPolicyNever, types.PullPolicyBuild,
+		types.PullPolicyMissing, types.PullPolicyIfNotPresent}
 	return slices.Contains(pullPolicies, opts.Pull)
 }
--- a/cmd/compose/create_test.go
+++ b/cmd/compose/create_test.go
@@ -40,9 +40,7 @@ func TestRunCreate(t *testing.T) {
 	)

 	createOpts := createOptions{}
-	buildOpts := buildOptions{
-		ProjectOptions: &ProjectOptions{},
-	}
+	buildOpts := buildOptions{}
 	project := sampleProject()
 	err := runCreate(ctx, nil, backend, createOpts, buildOpts, project, nil)
 	require.NoError(t, err)
@@ -60,9 +58,7 @@ func TestRunCreate_Build(t *testing.T) {
 	createOpts := createOptions{
 		Build: true,
 	}
-	buildOpts := buildOptions{
-		ProjectOptions: &ProjectOptions{},
-	}
+	buildOpts := buildOptions{}
 	project := sampleProject()
 	err := runCreate(ctx, nil, backend, createOpts, buildOpts, project, nil)
 	require.NoError(t, err)
--- a/cmd/compose/down.go
+++ b/cmd/compose/down.go
@@ -40,7 +40,7 @@ type downOptions struct {
 	images        string
 }

-func downCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func downCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := downOptions{
 		ProjectOptions: p,
 	}
@@ -77,7 +77,7 @@ func downCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return downCmd
 }

-func runDown(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts downOptions, services []string) error {
+func runDown(ctx context.Context, dockerCli command.Cli, backend api.Service, opts downOptions, services []string) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli, services...)
 	if err != nil {
 		return err
--- a/cmd/compose/events.go
+++ b/cmd/compose/events.go
@@ -29,12 +29,10 @@ import (

 type eventsOpts struct {
 	*composeOptions
-	json  bool
-	since string
-	until string
+	json bool
 }

-func eventsCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func eventsCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := eventsOpts{
 		composeOptions: &composeOptions{
 			ProjectOptions: p,
@@ -50,12 +48,10 @@ func eventsCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 	}

 	cmd.Flags().BoolVar(&opts.json, "json", false, "Output events as a stream of json objects")
-	cmd.Flags().StringVar(&opts.since, "since", "", "Show all events created since timestamp")
-	cmd.Flags().StringVar(&opts.until, "until", "", "Stream events until this timestamp")
 	return cmd
 }

-func runEvents(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts eventsOpts, services []string) error {
+func runEvents(ctx context.Context, dockerCli command.Cli, backend api.Service, opts eventsOpts, services []string) error {
 	name, err := opts.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
@@ -63,8 +59,6 @@ func runEvents(ctx context.Context, dockerCli command.Cli, backend api.Compose,

 	return backend.Events(ctx, name, api.EventsOptions{
 		Services: services,
-		Since:    opts.since,
-		Until:    opts.until,
 		Consumer: func(event api.Event) error {
 			if opts.json {
 				marshal, err := json.Marshal(map[string]interface{}{
--- a/cmd/compose/exec.go
+++ b/cmd/compose/exec.go
@@ -18,18 +18,13 @@ package compose

 import (
 	"context"
-	"errors"
-	"fmt"
-	"os"

 	"github.com/compose-spec/compose-go/v2/types"
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/compose"
-	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )

 type execOpts struct {
@@ -48,7 +43,7 @@ type execOpts struct {
 	interactive bool
 }

-func execCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func execCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := execOpts{
 		composeOptions: &composeOptions{
 			ProjectOptions: p,
@@ -64,15 +59,7 @@ func execCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			err := runExec(ctx, dockerCli, backend, opts)
-			if err != nil {
-				logrus.Debugf("%v", err)
-				var cliError cli.StatusError
-				if ok := errors.As(err, &cliError); ok {
-					os.Exit(err.(cli.StatusError).StatusCode) //nolint: errorlint
-				}
-			}
-			return err
+			return runExec(ctx, dockerCli, backend, opts)
 		}),
 		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
@@ -82,7 +69,7 @@ func execCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	runCmd.Flags().IntVar(&opts.index, "index", 0, "Index of the container if service has multiple replicas")
 	runCmd.Flags().BoolVarP(&opts.privileged, "privileged", "", false, "Give extended privileges to the process")
 	runCmd.Flags().StringVarP(&opts.user, "user", "u", "", "Run the command as this user")
-	runCmd.Flags().BoolVarP(&opts.noTty, "no-tty", "T", !dockerCli.Out().IsTerminal(), "Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.")
+	runCmd.Flags().BoolVarP(&opts.noTty, "no-TTY", "T", !dockerCli.Out().IsTerminal(), "Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.")
 	runCmd.Flags().StringVarP(&opts.workingDir, "workdir", "w", "", "Path to workdir directory for this command")

 	runCmd.Flags().BoolVarP(&opts.interactive, "interactive", "i", true, "Keep STDIN open even if not attached")
@@ -91,21 +78,15 @@ func execCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	runCmd.Flags().MarkHidden("tty") //nolint:errcheck

 	runCmd.Flags().SetInterspersed(false)
-	runCmd.Flags().SetNormalizeFunc(func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		if name == "no-TTY" { // legacy
-			name = "no-tty"
-		}
-		return pflag.NormalizedName(name)
-	})
 	return runCmd
 }

-func runExec(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts execOpts) error {
+func runExec(ctx context.Context, dockerCli command.Cli, backend api.Service, opts execOpts) error {
 	projectName, err := opts.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
 	}
-	projectOptions, err := opts.composeOptions.toProjectOptions() //nolint:staticcheck
+	projectOptions, err := opts.composeOptions.toProjectOptions()
 	if err != nil {
 		return err
 	}
@@ -128,8 +109,8 @@ func runExec(ctx context.Context, dockerCli command.Cli, backend api.Compose, op

 	exitCode, err := backend.Exec(ctx, projectName, execOpts)
 	if exitCode != 0 {
-		errMsg := fmt.Sprintf("exit status %d", exitCode)
-		if err != nil && err.Error() != "" {
+		errMsg := ""
+		if err != nil {
 			errMsg = err.Error()
 		}
 		return cli.StatusError{StatusCode: exitCode, Status: errMsg}
--- a/cmd/compose/export.go
+++ b/cmd/compose/export.go
@@ -33,7 +33,7 @@ type exportOptions struct {
 	index   int
 }

-func exportCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func exportCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	options := exportOptions{
 		ProjectOptions: p,
 	}
@@ -58,7 +58,7 @@ func exportCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 	return cmd
 }

-func runExport(ctx context.Context, dockerCli command.Cli, backend api.Compose, options exportOptions) error {
+func runExport(ctx context.Context, dockerCli command.Cli, backend api.Service, options exportOptions) error {
 	projectName, err := options.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
--- a/cmd/compose/generate.go
+++ b/cmd/compose/generate.go
@@ -30,7 +30,7 @@ type generateOptions struct {
 	Format string
 }

-func generateCommand(p *ProjectOptions, backend api.Compose) *cobra.Command {
+func generateCommand(p *ProjectOptions, backend api.Service) *cobra.Command {
 	opts := generateOptions{
 		ProjectOptions: p,
 	}
@@ -52,7 +52,7 @@ func generateCommand(p *ProjectOptions, backend api.Compose) *cobra.Command {
 	return cmd
 }

-func runGenerate(ctx context.Context, backend api.Compose, opts generateOptions, containers []string) error {
+func runGenerate(ctx context.Context, backend api.Service, opts generateOptions, containers []string) error {
 	_, _ = fmt.Fprintln(os.Stderr, "generate command is EXPERIMENTAL")
 	if len(containers) == 0 {
 		return fmt.Errorf("at least one container must be specified")
--- a/cmd/compose/images.go
+++ b/cmd/compose/images.go
@@ -20,12 +20,9 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"maps"
-	"slices"
+	"sort"
 	"strings"
-	"time"

-	"github.com/containerd/platforms"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/pkg/stringid"
 	"github.com/docker/go-units"
@@ -33,6 +30,7 @@ import (

 	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/utils"
 )

 type imageOptions struct {
@@ -41,7 +39,7 @@ type imageOptions struct {
 	Format string
 }

-func imagesCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func imagesCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := imageOptions{
 		ProjectOptions: p,
 	}
@@ -58,7 +56,7 @@ func imagesCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 	return imgCmd
 }

-func runImages(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts imageOptions, services []string) error {
+func runImages(ctx context.Context, dockerCli command.Cli, backend api.Service, opts imageOptions, services []string) error {
 	projectName, err := opts.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
@@ -78,7 +76,7 @@ func runImages(ctx context.Context, dockerCli command.Cli, backend api.Compose,
 			if i := strings.IndexRune(img.ID, ':'); i >= 0 {
 				id = id[i+1:]
 			}
-			if !slices.Contains(ids, id) {
+			if !utils.StringContains(ids, id) {
 				ids = append(ids, id)
 			}
 		}
@@ -87,46 +85,14 @@ func runImages(ctx context.Context, dockerCli command.Cli, backend api.Compose,
 		}
 		return nil
 	}
-	if opts.Format == "json" {

-		type img struct {
-			ID            string    `json:"ID"`
-			ContainerName string    `json:"ContainerName"`
-			Repository    string    `json:"Repository"`
-			Tag           string    `json:"Tag"`
-			Platform      string    `json:"Platform"`
-			Size          int64     `json:"Size"`
-			LastTagTime   time.Time `json:"LastTagTime"`
-		}
-		// Convert map to slice
-		var imageList []img
-		for ctr, i := range images {
-			lastTagTime := i.LastTagTime
-			if lastTagTime.IsZero() {
-				lastTagTime = i.Created
-			}
-			imageList = append(imageList, img{
-				ContainerName: ctr,
-				ID:            i.ID,
-				Repository:    i.Repository,
-				Tag:           i.Tag,
-				Platform:      platforms.Format(i.Platform),
-				Size:          i.Size,
-				LastTagTime:   lastTagTime,
-			})
-		}
-		json, err := formatter.ToJSON(imageList, "", "")
-		if err != nil {
-			return err
-		}
-		_, err = fmt.Fprintln(dockerCli.Out(), json)
-		return err
-	}
+	sort.Slice(images, func(i, j int) bool {
+		return images[i].ContainerName < images[j].ContainerName
+	})

 	return formatter.Print(images, opts.Format, dockerCli.Out(),
 		func(w io.Writer) {
-			for _, container := range slices.Sorted(maps.Keys(images)) {
-				img := images[container]
+			for _, img := range images {
 				id := stringid.TruncateID(img.ID)
 				size := units.HumanSizeWithPrecision(float64(img.Size), 3)
 				repo := img.Repository
@@ -137,10 +103,8 @@ func runImages(ctx context.Context, dockerCli command.Cli, backend api.Compose,
 				if tag == "" {
 					tag = "<none>"
 				}
-				created := units.HumanDuration(time.Now().UTC().Sub(img.LastTagTime)) + " ago"
-				_, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
-					container, repo, tag, platforms.Format(img.Platform), id, size, created)
+				_, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", img.ContainerName, repo, tag, id, size)
 			}
 		},
-		"CONTAINER", "REPOSITORY", "TAG", "PLATFORM", "IMAGE ID", "SIZE", "CREATED")
+		"CONTAINER", "REPOSITORY", "TAG", "IMAGE ID", "SIZE")
 }
--- a/cmd/compose/kill.go
+++ b/cmd/compose/kill.go
@@ -33,7 +33,7 @@ type killOptions struct {
 	signal        string
 }

-func killCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func killCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := killOptions{
 		ProjectOptions: p,
 	}
@@ -54,7 +54,7 @@ func killCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return cmd
 }

-func runKill(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts killOptions, services []string) error {
+func runKill(ctx context.Context, dockerCli command.Cli, backend api.Service, opts killOptions, services []string) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli, services...)
 	if err != nil {
 		return err
--- a/cmd/compose/list.go
+++ b/cmd/compose/list.go
@@ -38,7 +38,7 @@ type lsOptions struct {
 	Filter opts.FilterOpt
 }

-func listCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func listCommand(dockerCli command.Cli, backend api.Service) *cobra.Command {
 	lsOpts := lsOptions{Filter: opts.NewFilterOpt()}
 	lsCmd := &cobra.Command{
 		Use:   "ls [OPTIONS]",
@@ -50,7 +50,7 @@ func listCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command {
 		ValidArgsFunction: noCompletion(),
 	}
 	lsCmd.Flags().StringVar(&lsOpts.Format, "format", "table", "Format the output. Values: [table | json]")
-	lsCmd.Flags().BoolVarP(&lsOpts.Quiet, "quiet", "q", false, "Only display project names")
+	lsCmd.Flags().BoolVarP(&lsOpts.Quiet, "quiet", "q", false, "Only display IDs")
 	lsCmd.Flags().Var(&lsOpts.Filter, "filter", "Filter output based on conditions provided")
 	lsCmd.Flags().BoolVarP(&lsOpts.All, "all", "a", false, "Show all stopped Compose projects")

@@ -61,7 +61,7 @@ var acceptedListFilters = map[string]bool{
 	"name": true,
 }

-func runList(ctx context.Context, dockerCli command.Cli, backend api.Compose, lsOpts lsOptions) error {
+func runList(ctx context.Context, dockerCli command.Cli, backend api.Service, lsOpts lsOptions) error {
 	filters := lsOpts.Filter.Value()
 	err := filters.Validate(acceptedListFilters)
 	if err != nil {
--- a/cmd/compose/logs.go
+++ b/cmd/compose/logs.go
@@ -40,7 +40,7 @@ type logsOptions struct {
 	timestamps bool
 }

-func logsCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func logsCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := logsOptions{
 		ProjectOptions: p,
 	}
@@ -70,7 +70,7 @@ func logsCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return logsCmd
 }

-func runLogs(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts logsOptions, services []string) error {
+func runLogs(ctx context.Context, dockerCli command.Cli, backend api.Service, opts logsOptions, services []string) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli, services...)
 	if err != nil {
 		return err
--- a/cmd/compose/options.go
+++ b/cmd/compose/options.go
@@ -17,22 +17,10 @@
 package compose

 import (
-	"context"
 	"fmt"
-	"io"
-	"os"
-	"slices"
-	"sort"
-	"strings"
-	"text/tabwriter"

-	"github.com/compose-spec/compose-go/v2/cli"
-	"github.com/compose-spec/compose-go/v2/template"
 	"github.com/compose-spec/compose-go/v2/types"
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/compose/v2/cmd/prompt"
-	"github.com/docker/compose/v2/internal/tracing"
-	ui "github.com/docker/compose/v2/pkg/progress"
+	"github.com/docker/compose/v2/pkg/utils"
 )

 func applyPlatforms(project *types.Project, buildForSinglePlatform bool) error {
@@ -44,7 +32,7 @@ func applyPlatforms(project *types.Project, buildForSinglePlatform bool) error {

 		// default platform only applies if the service doesn't specify
 		if defaultPlatform != "" && service.Platform == "" {
-			if len(service.Build.Platforms) > 0 && !slices.Contains(service.Build.Platforms, defaultPlatform) {
+			if len(service.Build.Platforms) > 0 && !utils.StringContains(service.Build.Platforms, defaultPlatform) {
 				return fmt.Errorf("service %q build.platforms does not support value set by DOCKER_DEFAULT_PLATFORM: %s", name, defaultPlatform)
 			}
 			service.Platform = defaultPlatform
@@ -52,7 +40,7 @@ func applyPlatforms(project *types.Project, buildForSinglePlatform bool) error {

 		if service.Platform != "" {
 			if len(service.Build.Platforms) > 0 {
-				if !slices.Contains(service.Build.Platforms, service.Platform) {
+				if !utils.StringContains(service.Build.Platforms, service.Platform) {
 					return fmt.Errorf("service %q build configuration does not support platform: %s", name, service.Platform)
 				}
 			}
@@ -84,208 +72,3 @@ func applyPlatforms(project *types.Project, buildForSinglePlatform bool) error {
 	}
 	return nil
 }
-
-// isRemoteConfig checks if the main compose file is from a remote source (OCI or Git)
-func isRemoteConfig(dockerCli command.Cli, options buildOptions) bool {
-	if len(options.ConfigPaths) == 0 {
-		return false
-	}
-	remoteLoaders := options.remoteLoaders(dockerCli)
-	for _, loader := range remoteLoaders {
-		if loader.Accept(options.ConfigPaths[0]) {
-			return true
-		}
-	}
-	return false
-}
-
-// checksForRemoteStack handles environment variable prompts for remote configurations
-func checksForRemoteStack(ctx context.Context, dockerCli command.Cli, project *types.Project, options buildOptions, assumeYes bool, cmdEnvs []string) error {
-	if !isRemoteConfig(dockerCli, options) {
-		return nil
-	}
-	if metrics, ok := ctx.Value(tracing.MetricsKey{}).(tracing.Metrics); ok && metrics.CountIncludesRemote > 0 {
-		if err := confirmRemoteIncludes(dockerCli, options, assumeYes); err != nil {
-			return err
-		}
-	}
-	displayLocationRemoteStack(dockerCli, project, options)
-	return promptForInterpolatedVariables(ctx, dockerCli, options.ProjectOptions, assumeYes, cmdEnvs)
-}
-
-// Prepare the values map and collect all variables info
-type varInfo struct {
-	name         string
-	value        string
-	source       string
-	required     bool
-	defaultValue string
-}
-
-// promptForInterpolatedVariables displays all variables and their values at once,
-// then prompts for confirmation
-func promptForInterpolatedVariables(ctx context.Context, dockerCli command.Cli, projectOptions *ProjectOptions, assumeYes bool, cmdEnvs []string) error {
-	if assumeYes {
-		return nil
-	}
-
-	varsInfo, noVariables, err := extractInterpolationVariablesFromModel(ctx, dockerCli, projectOptions, cmdEnvs)
-	if err != nil {
-		return err
-	}
-
-	if noVariables {
-		return nil
-	}
-
-	displayInterpolationVariables(dockerCli.Out(), varsInfo)
-
-	// Prompt for confirmation
-	userInput := prompt.NewPrompt(dockerCli.In(), dockerCli.Out())
-	msg := "\nDo you want to proceed with these variables? [Y/n]: "
-	confirmed, err := userInput.Confirm(msg, true)
-	if err != nil {
-		return err
-	}
-
-	if !confirmed {
-		return fmt.Errorf("operation cancelled by user")
-	}
-
-	return nil
-}
-
-func extractInterpolationVariablesFromModel(ctx context.Context, dockerCli command.Cli, projectOptions *ProjectOptions, cmdEnvs []string) ([]varInfo, bool, error) {
-	cmdEnvMap := extractEnvCLIDefined(cmdEnvs)
-
-	// Create a model without interpolation to extract variables
-	opts := configOptions{
-		noInterpolate:  true,
-		ProjectOptions: projectOptions,
-	}
-
-	model, err := opts.ToModel(ctx, dockerCli, nil, cli.WithoutEnvironmentResolution)
-	if err != nil {
-		return nil, false, err
-	}
-
-	// Extract variables that need interpolation
-	variables := template.ExtractVariables(model, template.DefaultPattern)
-	if len(variables) == 0 {
-		return nil, true, nil
-	}
-
-	var varsInfo []varInfo
-	proposedValues := make(map[string]string)
-
-	for name, variable := range variables {
-		info := varInfo{
-			name:         name,
-			required:     variable.Required,
-			defaultValue: variable.DefaultValue,
-		}
-
-		// Determine value and source based on priority
-		if value, exists := cmdEnvMap[name]; exists {
-			info.value = value
-			info.source = "command-line"
-			proposedValues[name] = value
-		} else if value, exists := os.LookupEnv(name); exists {
-			info.value = value
-			info.source = "environment"
-			proposedValues[name] = value
-		} else if variable.DefaultValue != "" {
-			info.value = variable.DefaultValue
-			info.source = "compose file"
-			proposedValues[name] = variable.DefaultValue
-		} else {
-			info.value = "<unset>"
-			info.source = "none"
-		}
-
-		varsInfo = append(varsInfo, info)
-	}
-	return varsInfo, false, nil
-}
-
-func extractEnvCLIDefined(cmdEnvs []string) map[string]string {
-	// Parse command-line environment variables
-	cmdEnvMap := make(map[string]string)
-	for _, env := range cmdEnvs {
-		parts := strings.SplitN(env, "=", 2)
-		if len(parts) == 2 {
-			cmdEnvMap[parts[0]] = parts[1]
-		}
-	}
-	return cmdEnvMap
-}
-
-func displayInterpolationVariables(writer io.Writer, varsInfo []varInfo) {
-	// Display all variables in a table format
-	_, _ = fmt.Fprintln(writer, "\nFound the following variables in configuration:")
-
-	w := tabwriter.NewWriter(writer, 0, 0, 3, ' ', 0)
-	_, _ = fmt.Fprintln(w, "VARIABLE\tVALUE\tSOURCE\tREQUIRED\tDEFAULT")
-	sort.Slice(varsInfo, func(a, b int) bool {
-		return varsInfo[a].name < varsInfo[b].name
-	})
-	for _, info := range varsInfo {
-		required := "no"
-		if info.required {
-			required = "yes"
-		}
-		_, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n",
-			info.name,
-			info.value,
-			info.source,
-			required,
-			info.defaultValue,
-		)
-	}
-	_ = w.Flush()
-}
-
-func displayLocationRemoteStack(dockerCli command.Cli, project *types.Project, options buildOptions) {
-	mainComposeFile := options.ProjectOptions.ConfigPaths[0] //nolint:staticcheck
-	if ui.Mode != ui.ModeQuiet && ui.Mode != ui.ModeJSON {
-		_, _ = fmt.Fprintf(dockerCli.Out(), "Your compose stack %q is stored in %q\n", mainComposeFile, project.WorkingDir)
-	}
-}
-
-func confirmRemoteIncludes(dockerCli command.Cli, options buildOptions, assumeYes bool) error {
-	if assumeYes {
-		return nil
-	}
-
-	var remoteIncludes []string
-	remoteLoaders := options.ProjectOptions.remoteLoaders(dockerCli) //nolint:staticcheck
-	for _, cf := range options.ProjectOptions.ConfigPaths {          //nolint:staticcheck
-		for _, loader := range remoteLoaders {
-			if loader.Accept(cf) {
-				remoteIncludes = append(remoteIncludes, cf)
-				break
-			}
-		}
-	}
-
-	if len(remoteIncludes) == 0 {
-		return nil
-	}
-
-	_, _ = fmt.Fprintln(dockerCli.Out(), "\nWarning: This Compose project includes files from remote sources:")
-	for _, include := range remoteIncludes {
-		_, _ = fmt.Fprintf(dockerCli.Out(), "  - %s\n", include)
-	}
-	_, _ = fmt.Fprintln(dockerCli.Out(), "\nRemote includes could potentially be malicious. Make sure you trust the source.")
-
-	msg := "Do you want to continue? [y/N]: "
-	confirmed, err := prompt.NewPrompt(dockerCli.In(), dockerCli.Out()).Confirm(msg, false)
-	if err != nil {
-		return err
-	}
-	if !confirmed {
-		return fmt.Errorf("operation cancelled by user")
-	}
-
-	return nil
-}
--- a/cmd/compose/options_test.go
+++ b/cmd/compose/options_test.go
@@ -17,20 +17,10 @@
 package compose

 import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
 	"testing"

 	"github.com/compose-spec/compose-go/v2/types"
-	"github.com/docker/cli/cli/streams"
-	"github.com/docker/compose/v2/pkg/mocks"
 	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
 )

 func TestApplyPlatforms_InferFromRuntime(t *testing.T) {
@@ -138,257 +128,3 @@ func TestApplyPlatforms_UnsupportedPlatform(t *testing.T) {
 			`service "test" build.platforms does not support value set by DOCKER_DEFAULT_PLATFORM: commodore/64`)
 	})
 }
-
-func TestIsRemoteConfig(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	cli := mocks.NewMockCli(ctrl)
-
-	tests := []struct {
-		name        string
-		configPaths []string
-		want        bool
-	}{
-		{
-			name:        "empty config paths",
-			configPaths: []string{},
-			want:        false,
-		},
-		{
-			name:        "local file",
-			configPaths: []string{"docker-compose.yaml"},
-			want:        false,
-		},
-		{
-			name:        "OCI reference",
-			configPaths: []string{"oci://registry.example.com/stack:latest"},
-			want:        true,
-		},
-		{
-			name:        "GIT reference",
-			configPaths: []string{"git://github.com/user/repo.git"},
-			want:        true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			opts := buildOptions{
-				ProjectOptions: &ProjectOptions{
-					ConfigPaths: tt.configPaths,
-				},
-			}
-			got := isRemoteConfig(cli, opts)
-			require.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func TestDisplayLocationRemoteStack(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	cli := mocks.NewMockCli(ctrl)
-
-	buf := new(bytes.Buffer)
-	cli.EXPECT().Out().Return(streams.NewOut(buf)).AnyTimes()
-
-	project := &types.Project{
-		Name:       "test-project",
-		WorkingDir: "/tmp/test",
-	}
-
-	options := buildOptions{
-		ProjectOptions: &ProjectOptions{
-			ConfigPaths: []string{"oci://registry.example.com/stack:latest"},
-		},
-	}
-
-	displayLocationRemoteStack(cli, project, options)
-
-	output := buf.String()
-	require.Equal(t, output, fmt.Sprintf("Your compose stack %q is stored in %q\n", "oci://registry.example.com/stack:latest", "/tmp/test"))
-}
-
-func TestDisplayInterpolationVariables(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	// Create a temporary directory for the test
-	tmpDir, err := os.MkdirTemp("", "compose-test")
-	require.NoError(t, err)
-	defer func() { _ = os.RemoveAll(tmpDir) }()
-
-	// Create a temporary compose file
-	composeContent := `
-services:
-  app:
-    image: nginx
-    environment:
-      - TEST_VAR=${TEST_VAR:?required}  # required with default
-      - API_KEY=${API_KEY:?}            # required without default
-      - DEBUG=${DEBUG:-true}            # optional with default
-      - UNSET_VAR                       # optional without default
-`
-	composePath := filepath.Join(tmpDir, "docker-compose.yml")
-	err = os.WriteFile(composePath, []byte(composeContent), 0o644)
-	require.NoError(t, err)
-
-	buf := new(bytes.Buffer)
-	cli := mocks.NewMockCli(ctrl)
-	cli.EXPECT().Out().Return(streams.NewOut(buf)).AnyTimes()
-
-	// Create ProjectOptions with the temporary compose file
-	projectOptions := &ProjectOptions{
-		ConfigPaths: []string{composePath},
-	}
-
-	// Set up the context with necessary environment variables
-	ctx := context.Background()
-	_ = os.Setenv("TEST_VAR", "test-value")
-	_ = os.Setenv("API_KEY", "123456")
-	defer func() {
-		_ = os.Unsetenv("TEST_VAR")
-		_ = os.Unsetenv("API_KEY")
-	}()
-
-	// Extract variables from the model
-	info, noVariables, err := extractInterpolationVariablesFromModel(ctx, cli, projectOptions, []string{})
-	require.NoError(t, err)
-	require.False(t, noVariables)
-
-	// Display the variables
-	displayInterpolationVariables(cli.Out(), info)
-
-	// Expected output format with proper spacing
-	expected := "\nFound the following variables in configuration:\n" +
-		"VARIABLE   VALUE       SOURCE        REQUIRED   DEFAULT\n" +
-		"API_KEY    123456      environment   yes         \n" +
-		"DEBUG      true       compose file  no         true\n" +
-		"TEST_VAR   test-value  environment   yes         \n"
-
-	// Normalize spaces and newlines for comparison
-	normalizeSpaces := func(s string) string {
-		// Replace multiple spaces with a single space
-		s = strings.Join(strings.Fields(strings.TrimSpace(s)), " ")
-		return s
-	}
-
-	actualOutput := buf.String()
-
-	// Compare normalized strings
-	require.Equal(t,
-		normalizeSpaces(expected),
-		normalizeSpaces(actualOutput),
-		"\nExpected:\n%s\nGot:\n%s", expected, actualOutput)
-}
-
-func TestConfirmRemoteIncludes(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	cli := mocks.NewMockCli(ctrl)
-
-	tests := []struct {
-		name       string
-		opts       buildOptions
-		assumeYes  bool
-		userInput  string
-		wantErr    bool
-		errMessage string
-		wantPrompt bool
-		wantOutput string
-	}{
-		{
-			name: "no remote includes",
-			opts: buildOptions{
-				ProjectOptions: &ProjectOptions{
-					ConfigPaths: []string{
-						"docker-compose.yaml",
-						"./local/path/compose.yaml",
-					},
-				},
-			},
-			assumeYes:  false,
-			wantErr:    false,
-			wantPrompt: false,
-		},
-		{
-			name: "assume yes with remote includes",
-			opts: buildOptions{
-				ProjectOptions: &ProjectOptions{
-					ConfigPaths: []string{
-						"oci://registry.example.com/stack:latest",
-						"git://github.com/user/repo.git",
-					},
-				},
-			},
-			assumeYes:  true,
-			wantErr:    false,
-			wantPrompt: false,
-		},
-		{
-			name: "user confirms remote includes",
-			opts: buildOptions{
-				ProjectOptions: &ProjectOptions{
-					ConfigPaths: []string{
-						"oci://registry.example.com/stack:latest",
-						"git://github.com/user/repo.git",
-					},
-				},
-			},
-			assumeYes:  false,
-			userInput:  "y\n",
-			wantErr:    false,
-			wantPrompt: true,
-			wantOutput: "\nWarning: This Compose project includes files from remote sources:\n" +
-				"  - oci://registry.example.com/stack:latest\n" +
-				"  - git://github.com/user/repo.git\n" +
-				"\nRemote includes could potentially be malicious. Make sure you trust the source.\n" +
-				"Do you want to continue? [y/N]: ",
-		},
-		{
-			name: "user rejects remote includes",
-			opts: buildOptions{
-				ProjectOptions: &ProjectOptions{
-					ConfigPaths: []string{
-						"oci://registry.example.com/stack:latest",
-					},
-				},
-			},
-			assumeYes:  false,
-			userInput:  "n\n",
-			wantErr:    true,
-			errMessage: "operation cancelled by user",
-			wantPrompt: true,
-			wantOutput: "\nWarning: This Compose project includes files from remote sources:\n" +
-				"  - oci://registry.example.com/stack:latest\n" +
-				"\nRemote includes could potentially be malicious. Make sure you trust the source.\n" +
-				"Do you want to continue? [y/N]: ",
-		},
-	}
-
-	buf := new(bytes.Buffer)
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cli.EXPECT().Out().Return(streams.NewOut(buf)).AnyTimes()
-
-			if tt.wantPrompt {
-				inbuf := io.NopCloser(bytes.NewBufferString(tt.userInput))
-				cli.EXPECT().In().Return(streams.NewIn(inbuf)).AnyTimes()
-			}
-
-			err := confirmRemoteIncludes(cli, tt.opts, tt.assumeYes)
-
-			if tt.wantErr {
-				require.Error(t, err)
-				require.Equal(t, tt.errMessage, err.Error())
-			} else {
-				require.NoError(t, err)
-			}
-
-			if tt.wantOutput != "" {
-				require.Equal(t, tt.wantOutput, buf.String())
-			}
-			buf.Reset()
-		})
-	}
-}
--- a/cmd/compose/pause.go
+++ b/cmd/compose/pause.go
@@ -29,7 +29,7 @@ type pauseOptions struct {
 	*ProjectOptions
 }

-func pauseCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func pauseCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := pauseOptions{
 		ProjectOptions: p,
 	}
@@ -44,7 +44,7 @@ func pauseCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return cmd
 }

-func runPause(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts pauseOptions, services []string) error {
+func runPause(ctx context.Context, dockerCli command.Cli, backend api.Service, opts pauseOptions, services []string) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli, services...)
 	if err != nil {
 		return err
@@ -60,7 +60,7 @@ type unpauseOptions struct {
 	*ProjectOptions
 }

-func unpauseCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func unpauseCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := unpauseOptions{
 		ProjectOptions: p,
 	}
@@ -75,7 +75,7 @@ func unpauseCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compos
 	return cmd
 }

-func runUnPause(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts unpauseOptions, services []string) error {
+func runUnPause(ctx context.Context, dockerCli command.Cli, backend api.Service, opts unpauseOptions, services []string) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli, services...)
 	if err != nil {
 		return err
--- a/cmd/compose/port.go
+++ b/cmd/compose/port.go
@@ -35,7 +35,7 @@ type portOptions struct {
 	index    int
 }

-func portCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func portCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := portOptions{
 		ProjectOptions: p,
 	}
@@ -62,7 +62,7 @@ func portCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return cmd
 }

-func runPort(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts portOptions, service string) error {
+func runPort(ctx context.Context, dockerCli command.Cli, backend api.Service, opts portOptions, service string) error {
 	projectName, err := opts.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
--- a/cmd/compose/ps.go
+++ b/cmd/compose/ps.go
@@ -20,12 +20,12 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"slices"
 	"sort"
 	"strings"

 	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/utils"

 	"github.com/docker/cli/cli/command"
 	cliformatter "github.com/docker/cli/cli/command/formatter"
@@ -64,7 +64,7 @@ func (p *psOptions) parseFilter() error {
 	return nil
 }

-func psCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func psCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := psOptions{
 		ProjectOptions: p,
 	}
@@ -91,7 +91,7 @@ func psCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *c
 	return psCmd
 }

-func runPs(ctx context.Context, dockerCli command.Cli, backend api.Compose, services []string, opts psOptions) error {
+func runPs(ctx context.Context, dockerCli command.Cli, backend api.Service, services []string, opts psOptions) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli, services...)
 	if err != nil {
 		return err
@@ -101,7 +101,7 @@ func runPs(ctx context.Context, dockerCli command.Cli, backend api.Compose, serv
 		names := project.ServiceNames()
 		if len(services) > 0 {
 			for _, service := range services {
-				if !slices.Contains(names, service) {
+				if !utils.StringContains(names, service) {
 					return fmt.Errorf("no such service: %s", service)
 				}
 			}
@@ -139,7 +139,7 @@ func runPs(ctx context.Context, dockerCli command.Cli, backend api.Compose, serv
 		services := []string{}
 		for _, c := range containers {
 			s := c.Service
-			if !slices.Contains(services, s) {
+			if !utils.StringContains(services, s) {
 				services = append(services, s)
 			}
 		}
--- a/cmd/compose/publish.go
+++ b/cmd/compose/publish.go
@@ -18,26 +18,20 @@ package compose

 import (
 	"context"
-	"errors"

-	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/compose/v2/pkg/api"
-	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
+
+	"github.com/docker/compose/v2/pkg/api"
 )

 type publishOptions struct {
 	*ProjectOptions
 	resolveImageDigests bool
 	ociVersion          string
-	withEnvironment     bool
-	assumeYes           bool
-	app                 bool
 }

-func publishCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func publishCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := publishOptions{
 		ProjectOptions: p,
 	}
@@ -47,41 +41,22 @@ func publishCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compos
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runPublish(ctx, dockerCli, backend, opts, args[0])
 		}),
-		Args: cli.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 	}
 	flags := cmd.Flags()
 	flags.BoolVar(&opts.resolveImageDigests, "resolve-image-digests", false, "Pin image tags to digests")
-	flags.StringVar(&opts.ociVersion, "oci-version", "", "OCI image/artifact specification version (automatically determined by default)")
-	flags.BoolVar(&opts.withEnvironment, "with-env", false, "Include environment variables in the published OCI artifact")
-	flags.BoolVarP(&opts.assumeYes, "yes", "y", false, `Assume "yes" as answer to all prompts`)
-	flags.BoolVar(&opts.app, "app", false, "Published compose application (includes referenced images)")
-	flags.SetNormalizeFunc(func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		// assumeYes was introduced by mistake as `--y`
-		if name == "y" {
-			logrus.Warn("--y is deprecated, please use --yes instead")
-			name = "yes"
-		}
-		return pflag.NormalizedName(name)
-	})
-
+	flags.StringVar(&opts.ociVersion, "oci-version", "", "OCI Image/Artifact specification version (automatically determined by default)")
 	return cmd
 }

-func runPublish(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts publishOptions, repository string) error {
-	project, metrics, err := opts.ToProject(ctx, dockerCli, nil)
+func runPublish(ctx context.Context, dockerCli command.Cli, backend api.Service, opts publishOptions, repository string) error {
+	project, _, err := opts.ToProject(ctx, dockerCli, nil)
 	if err != nil {
 		return err
 	}

-	if metrics.CountIncludesLocal > 0 {
-		return errors.New("cannot publish compose file with local includes")
-	}
-
 	return backend.Publish(ctx, project, repository, api.PublishOptions{
-		ResolveImageDigests: opts.resolveImageDigests || opts.app,
-		Application:         opts.app,
+		ResolveImageDigests: opts.resolveImageDigests,
 		OCIVersion:          api.OCIVersion(opts.ociVersion),
-		WithEnvironment:     opts.withEnvironment,
-		AssumeYes:           opts.assumeYes,
 	})
 }
--- a/cmd/compose/pull.go
+++ b/cmd/compose/pull.go
@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"os"

-	"github.com/compose-spec/compose-go/v2/cli"
 	"github.com/compose-spec/compose-go/v2/types"
 	"github.com/docker/cli/cli/command"
 	"github.com/morikuni/aec"
@@ -42,22 +41,19 @@ type pullOptions struct {
 	policy             string
 }

-func pullCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func pullCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := pullOptions{
 		ProjectOptions: p,
 	}
 	cmd := &cobra.Command{
 		Use:   "pull [OPTIONS] [SERVICE...]",
 		Short: "Pull service images",
-		PreRunE: func(cmd *cobra.Command, args []string) error {
-			if cmd.Flags().Changed("no-parallel") {
+		PreRunE: Adapt(func(ctx context.Context, args []string) error {
+			if opts.noParallel {
 				fmt.Fprint(os.Stderr, aec.Apply("option '--no-parallel' is DEPRECATED and will be ignored.\n", aec.RedF))
 			}
-			if cmd.Flags().Changed("parallel") {
-				fmt.Fprint(os.Stderr, aec.Apply("option '--parallel' is DEPRECATED and will be ignored.\n", aec.RedF))
-			}
 			return nil
-		},
+		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runPull(ctx, dockerCli, backend, opts, args)
 		}),
@@ -68,7 +64,7 @@ func pullCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	cmd.Flags().BoolVar(&opts.includeDeps, "include-deps", false, "Also pull services declared as dependencies")
 	cmd.Flags().BoolVar(&opts.parallel, "parallel", true, "DEPRECATED pull multiple images in parallel")
 	flags.MarkHidden("parallel") //nolint:errcheck
-	cmd.Flags().BoolVar(&opts.noParallel, "no-parallel", true, "DEPRECATED disable parallel pulling")
+	cmd.Flags().BoolVar(&opts.parallel, "no-parallel", true, "DEPRECATED disable parallel pulling")
 	flags.MarkHidden("no-parallel") //nolint:errcheck
 	cmd.Flags().BoolVar(&opts.ignorePullFailures, "ignore-pull-failures", false, "Pull what it can and ignores images with pull failures")
 	cmd.Flags().BoolVar(&opts.noBuildable, "ignore-buildable", false, "Ignore images that can be built")
@@ -97,8 +93,8 @@ func (opts pullOptions) apply(project *types.Project, services []string) (*types
 	return project, nil
 }

-func runPull(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts pullOptions, services []string) error {
-	project, _, err := opts.ToProject(ctx, dockerCli, services, cli.WithoutEnvironmentResolution)
+func runPull(ctx context.Context, dockerCli command.Cli, backend api.Service, opts pullOptions, services []string) error {
+	project, _, err := opts.ToProject(ctx, dockerCli, services)
 	if err != nil {
 		return err
 	}
--- a/cmd/compose/push.go
+++ b/cmd/compose/push.go
@@ -34,7 +34,7 @@ type pushOptions struct {
 	Quiet          bool
 }

-func pushCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func pushCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := pushOptions{
 		ProjectOptions: p,
 	}
@@ -53,7 +53,7 @@ func pushCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return pushCmd
 }

-func runPush(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts pushOptions, services []string) error {
+func runPush(ctx context.Context, dockerCli command.Cli, backend api.Service, opts pushOptions, services []string) error {
 	project, _, err := opts.ToProject(ctx, dockerCli, services)
 	if err != nil {
 		return err
--- a/cmd/compose/remove.go
+++ b/cmd/compose/remove.go
@@ -31,7 +31,7 @@ type removeOptions struct {
 	volumes bool
 }

-func removeCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func removeCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := removeOptions{
 		ProjectOptions: p,
 	}
@@ -59,7 +59,7 @@ Any data which is not in a volume will be lost.`,
 	return cmd
 }

-func runRemove(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts removeOptions, services []string) error {
+func runRemove(ctx context.Context, dockerCli command.Cli, backend api.Service, opts removeOptions, services []string) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli, services...)
 	if err != nil {
 		return err
--- a/cmd/compose/restart.go
+++ b/cmd/compose/restart.go
@@ -33,7 +33,7 @@ type restartOptions struct {
 	noDeps      bool
 }

-func restartCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func restartCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := restartOptions{
 		ProjectOptions: p,
 	}
@@ -55,7 +55,7 @@ func restartCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compos
 	return restartCmd
 }

-func runRestart(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts restartOptions, services []string) error {
+func runRestart(ctx context.Context, dockerCli command.Cli, backend api.Service, opts restartOptions, services []string) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli)
 	if err != nil {
 		return err
--- a/cmd/compose/run.go
+++ b/cmd/compose/run.go
@@ -19,10 +19,8 @@ package compose
 import (
 	"context"
 	"fmt"
-	"os"
 	"strings"

-	"github.com/compose-spec/compose-go/v2/dotenv"
 	"github.com/compose-spec/compose-go/v2/format"
 	xprogress "github.com/moby/buildkit/util/progress/progressui"
 	"github.com/sirupsen/logrus"
@@ -46,10 +44,10 @@ type runOptions struct {
 	Service       string
 	Command       []string
 	environment   []string
-	envFiles      []string
 	Detach        bool
 	Remove        bool
 	noTty         bool
+	tty           bool
 	interactive   bool
 	user          string
 	workdir       string
@@ -66,7 +64,6 @@ type runOptions struct {
 	noDeps        bool
 	ignoreOrphans bool
 	removeOrphans bool
-	quiet         bool
 	quietPull     bool
 }

@@ -119,30 +116,7 @@ func (options runOptions) apply(project *types.Project) (*types.Project, error)
 	return project, nil
 }

-func (options runOptions) getEnvironment(resolve func(string) (string, bool)) (types.Mapping, error) {
-	environment := types.NewMappingWithEquals(options.environment).Resolve(resolve).ToMapping()
-	for _, file := range options.envFiles {
-		f, err := os.Open(file)
-		if err != nil {
-			return nil, err
-		}
-		vars, err := dotenv.ParseWithLookup(f, func(k string) (string, bool) {
-			value, ok := environment[k]
-			return value, ok
-		})
-		if err != nil {
-			return nil, nil
-		}
-		for k, v := range vars {
-			if _, ok := environment[k]; !ok {
-				environment[k] = v
-			}
-		}
-	}
-	return environment, nil
-}
-
-func runCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func runCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	options := runOptions{
 		composeOptions: &composeOptions{
 			ProjectOptions: p,
@@ -154,10 +128,6 @@ func runCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *
 	buildOpts := buildOptions{
 		ProjectOptions: p,
 	}
-	// We remove the attribute from the option struct and use a dedicated var, to limit confusion and avoid anyone to use options.tty.
-	// The tty flag is here for convenience and let user do "docker compose run -it" the same way as they use the "docker run" command.
-	var ttyFlag bool
-
 	cmd := &cobra.Command{
 		Use:   "run [OPTIONS] SERVICE [COMMAND] [ARGS...]",
 		Short: "Run a one-off command on a service",
@@ -181,34 +151,13 @@ func runCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *
 				if cmd.Flags().Changed("no-TTY") {
 					return fmt.Errorf("--tty and --no-TTY can't be used together")
 				} else {
-					options.noTty = !ttyFlag
+					options.noTty = !options.tty
 				}
-			} else if !cmd.Flags().Changed("no-TTY") && !cmd.Flags().Changed("interactive") && !dockerCli.In().IsTerminal() {
-				// while `docker run` requires explicit `-it` flags, Compose enables interactive mode and TTY by default
-				// but when compose is used from a scripr has stdin piped from another command, we just can't
-				// Here, we detect we run "by default" (user didn't passed explicit flags) and disable TTY allocation if
-				// we don't have an actual terminal to attach to for interactive mode
-				options.noTty = true
 			}
-
-			if options.quiet {
-				progress.Mode = progress.ModeQuiet
-				devnull, err := os.Open(os.DevNull)
-				if err != nil {
-					return err
-				}
-				os.Stdout = devnull
-			}
-			createOpts.pullChanged = cmd.Flags().Changed("pull")
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			project, _, err := p.ToProject(ctx, dockerCli, []string{options.Service}, cgo.WithResolvedPaths(true), cgo.WithoutEnvironmentResolution)
-			if err != nil {
-				return err
-			}
-
-			project, err = project.WithServicesEnvironmentResolved(true)
+			project, _, err := p.ToProject(ctx, dockerCli, []string{options.Service}, cgo.WithResolvedPaths(true), cgo.WithDiscardEnvFile)
 			if err != nil {
 				return err
 			}
@@ -225,7 +174,6 @@ func runCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *
 	flags := cmd.Flags()
 	flags.BoolVarP(&options.Detach, "detach", "d", false, "Run container in background and print container ID")
 	flags.StringArrayVarP(&options.environment, "env", "e", []string{}, "Set environment variables")
-	flags.StringArrayVar(&options.envFiles, "env-from-file", []string{}, "Set environment variables from file")
 	flags.StringArrayVarP(&options.labels, "label", "l", []string{}, "Add or override a label")
 	flags.BoolVar(&options.Remove, "rm", false, "Automatically remove the container when it exits")
 	flags.BoolVarP(&options.noTty, "no-TTY", "T", !dockerCli.Out().IsTerminal(), "Disable pseudo-TTY allocation (default: auto-detected)")
@@ -240,15 +188,12 @@ func runCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *
 	flags.StringArrayVarP(&options.publish, "publish", "p", []string{}, "Publish a container's port(s) to the host")
 	flags.BoolVar(&options.useAliases, "use-aliases", false, "Use the service's network useAliases in the network(s) the container connects to")
 	flags.BoolVarP(&options.servicePorts, "service-ports", "P", false, "Run command with all service's ports enabled and mapped to the host")
-	flags.StringVar(&createOpts.Pull, "pull", "policy", `Pull image before running ("always"|"missing"|"never")`)
-	flags.BoolVarP(&options.quiet, "quiet", "q", false, "Don't print anything to STDOUT")
-	flags.BoolVar(&buildOpts.quiet, "quiet-build", false, "Suppress progress output from the build process")
 	flags.BoolVar(&options.quietPull, "quiet-pull", false, "Pull without printing progress information")
 	flags.BoolVar(&createOpts.Build, "build", false, "Build image before starting container")
 	flags.BoolVar(&options.removeOrphans, "remove-orphans", false, "Remove containers for services not defined in the Compose file")

 	cmd.Flags().BoolVarP(&options.interactive, "interactive", "i", true, "Keep STDIN open even if not attached")
-	cmd.Flags().BoolVarP(&ttyFlag, "tty", "t", true, "Allocate a pseudo-TTY")
+	cmd.Flags().BoolVarP(&options.tty, "tty", "t", true, "Allocate a pseudo-TTY")
 	cmd.Flags().MarkHidden("tty") //nolint:errcheck

 	flags.SetNormalizeFunc(normalizeRunFlags)
@@ -266,7 +211,7 @@ func normalizeRunFlags(f *pflag.FlagSet, name string) pflag.NormalizedName {
 	return pflag.NormalizedName(name)
 }

-func runRun(ctx context.Context, backend api.Compose, project *types.Project, options runOptions, createOpts createOptions, buildOpts buildOptions, dockerCli command.Cli) error {
+func runRun(ctx context.Context, backend api.Service, project *types.Project, options runOptions, createOpts createOptions, buildOpts buildOptions, dockerCli command.Cli) error {
 	project, err := options.apply(project)
 	if err != nil {
 		return err
@@ -277,7 +222,19 @@ func runRun(ctx context.Context, backend api.Compose, project *types.Project, op
 		return err
 	}

-	if err := checksForRemoteStack(ctx, dockerCli, project, buildOpts, createOpts.AssumeYes, []string{}); err != nil {
+	err = progress.Run(ctx, func(ctx context.Context) error {
+		var buildForDeps *api.BuildOptions
+		if !createOpts.noBuild {
+			// allow dependencies needing build to be implicitly selected
+			bo, err := buildOpts.toAPIBuildOptions(nil)
+			if err != nil {
+				return err
+			}
+			buildForDeps = &bo
+		}
+		return startDependencies(ctx, backend, *project, buildForDeps, options)
+	}, dockerCli.Err())
+	if err != nil {
 		return err
 	}

@@ -292,26 +249,18 @@ func runRun(ctx context.Context, backend api.Compose, project *types.Project, op

 	var buildForRun *api.BuildOptions
 	if !createOpts.noBuild {
-		bo, err := buildOpts.toAPIBuildOptions(nil)
+		// dependencies have already been started above, so only the service
+		// being run might need to be built at this point
+		bo, err := buildOpts.toAPIBuildOptions([]string{options.Service})
 		if err != nil {
 			return err
 		}
 		buildForRun = &bo
 	}

-	environment, err := options.getEnvironment(project.Environment.Resolve)
-	if err != nil {
-		return err
-	}
-
 	// start container and attach to container streams
 	runOpts := api.RunOptions{
-		CreateOptions: api.CreateOptions{
-			Build:         buildForRun,
-			RemoveOrphans: options.removeOrphans,
-			IgnoreOrphans: options.ignoreOrphans,
-			QuietPull:     options.quietPull,
-		},
+		Build:             buildForRun,
 		Name:              options.name,
 		Service:           options.Service,
 		Command:           options.Command,
@@ -321,14 +270,15 @@ func runRun(ctx context.Context, backend api.Compose, project *types.Project, op
 		Interactive:       options.interactive,
 		WorkingDir:        options.workdir,
 		User:              options.user,
-		CapAdd:            options.capAdd.GetSlice(),
-		CapDrop:           options.capDrop.GetSlice(),
-		Environment:       environment.Values(),
+		CapAdd:            options.capAdd.GetAll(),
+		CapDrop:           options.capDrop.GetAll(),
+		Environment:       options.environment,
 		Entrypoint:        options.entrypointCmd,
 		Labels:            labels,
 		UseNetworkAliases: options.useAliases,
 		NoDeps:            options.noDeps,
 		Index:             0,
+		QuietPull:         options.quietPull,
 	}

 	for name, service := range project.Services {
@@ -348,3 +298,34 @@ func runRun(ctx context.Context, backend api.Compose, project *types.Project, op
 	}
 	return err
 }
+
+func startDependencies(ctx context.Context, backend api.Service, project types.Project, buildOpts *api.BuildOptions, options runOptions) error {
+	dependencies := types.Services{}
+	var requestedService types.ServiceConfig
+	for name, service := range project.Services {
+		if name != options.Service {
+			dependencies[name] = service
+		} else {
+			requestedService = service
+		}
+	}
+
+	project.Services = dependencies
+	project.DisabledServices[options.Service] = requestedService
+	err := backend.Create(ctx, &project, api.CreateOptions{
+		Build:         buildOpts,
+		IgnoreOrphans: options.ignoreOrphans,
+		RemoveOrphans: options.removeOrphans,
+		QuietPull:     options.quietPull,
+	})
+	if err != nil {
+		return err
+	}
+
+	if len(dependencies) > 0 {
+		return backend.Start(ctx, project.Name, api.StartOptions{
+			Project: &project,
+		})
+	}
+	return nil
+}
--- a/cmd/compose/scale.go
+++ b/cmd/compose/scale.go
@@ -19,13 +19,14 @@ package compose
 import (
 	"context"
 	"fmt"
-	"maps"
-	"slices"
 	"strconv"
 	"strings"

-	"github.com/compose-spec/compose-go/v2/types"
 	"github.com/docker/cli/cli/command"
+
+	"github.com/compose-spec/compose-go/v2/types"
+	"golang.org/x/exp/maps"
+
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/spf13/cobra"
 )
@@ -35,7 +36,7 @@ type scaleOptions struct {
 	noDeps bool
 }

-func scaleCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func scaleCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := scaleOptions{
 		ProjectOptions: p,
 	}
@@ -50,7 +51,7 @@ func scaleCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 			}
 			return runScale(ctx, dockerCli, backend, opts, serviceTuples)
 		}),
-		ValidArgsFunction: completeScaleArgs(dockerCli, p),
+		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
 	flags := scaleCmd.Flags()
 	flags.BoolVar(&opts.noDeps, "no-deps", false, "Don't start linked services")
@@ -58,8 +59,8 @@ func scaleCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return scaleCmd
 }

-func runScale(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts scaleOptions, serviceReplicaTuples map[string]int) error {
-	services := slices.Sorted(maps.Keys(serviceReplicaTuples))
+func runScale(ctx context.Context, dockerCli command.Cli, backend api.Service, opts scaleOptions, serviceReplicaTuples map[string]int) error {
+	services := maps.Keys(serviceReplicaTuples)
 	project, _, err := opts.ToProject(ctx, dockerCli, services)
 	if err != nil {
 		return err
@@ -91,6 +92,7 @@ func parseServicesReplicasArgs(args []string) (map[string]int, error) {
 			return nil, fmt.Errorf("invalid scale specifier: %s", arg)
 		}
 		intValue, err := strconv.Atoi(val)
+
 		if err != nil {
 			return nil, fmt.Errorf("invalid scale specifier: can't parse replica value as int: %v", arg)
 		}
--- a/cmd/compose/start.go
+++ b/cmd/compose/start.go
@@ -28,7 +28,7 @@ type startOptions struct {
 	*ProjectOptions
 }

-func startCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func startCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := startOptions{
 		ProjectOptions: p,
 	}
@@ -43,7 +43,7 @@ func startCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return startCmd
 }

-func runStart(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts startOptions, services []string) error {
+func runStart(ctx context.Context, dockerCli command.Cli, backend api.Service, opts startOptions, services []string) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli, services...)
 	if err != nil {
 		return err
--- a/cmd/compose/stats.go
+++ b/cmd/compose/stats.go
@@ -56,7 +56,7 @@ func statsCommand(p *ProjectOptions, dockerCli command.Cli) *cobra.Command {
 'table TEMPLATE':   Print output in table format using the given Go template
 'json':             Print in JSON format
 'TEMPLATE':         Print output using the given Go template.
-Refer to https://docs.docker.com/engine/cli/formatting/ for more information about formatting output with templates`)
+Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates`)
 	flags.BoolVar(&opts.noStream, "no-stream", false, "Disable streaming stats and only pull the first result")
 	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Do not truncate output")
 	return cmd
--- a/cmd/compose/stop.go
+++ b/cmd/compose/stop.go
@@ -32,7 +32,7 @@ type stopOptions struct {
 	timeout     int
 }

-func stopCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func stopCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := stopOptions{
 		ProjectOptions: p,
 	}
@@ -53,7 +53,7 @@ func stopCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return cmd
 }

-func runStop(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts stopOptions, services []string) error {
+func runStop(ctx context.Context, dockerCli command.Cli, backend api.Service, opts stopOptions, services []string) error {
 	project, name, err := opts.projectOrName(ctx, dockerCli, services...)
 	if err != nil {
 		return err
--- a/cmd/compose/top.go
+++ b/cmd/compose/top.go
@@ -34,7 +34,7 @@ type topOptions struct {
 	*ProjectOptions
 }

-func topCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func topCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := topOptions{
 		ProjectOptions: p,
 	}
@@ -49,12 +49,7 @@ func topCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *
 	return topCmd
 }

-type (
-	topHeader  map[string]int // maps a proc title to its output index
-	topEntries map[string]string
-)
-
-func runTop(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts topOptions, services []string) error {
+func runTop(ctx context.Context, dockerCli command.Cli, backend api.Service, opts topOptions, services []string) error {
 	projectName, err := opts.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
@@ -68,76 +63,30 @@ func runTop(ctx context.Context, dockerCli command.Cli, backend api.Compose, opt
 		return containers[i].Name < containers[j].Name
 	})

-	header, entries := collectTop(containers)
-	return topPrint(dockerCli.Out(), header, entries)
-}
-
-func collectTop(containers []api.ContainerProcSummary) (topHeader, []topEntries) {
-	// map column name to its header (should keep working if backend.Top returns
-	// varying columns for different containers)
-	header := topHeader{"SERVICE": 0, "#": 1}
-
-	// assume one process per container and grow if needed
-	entries := make([]topEntries, 0, len(containers))
-
 	for _, container := range containers {
-		for _, proc := range container.Processes {
-			entry := topEntries{
-				"SERVICE": container.Service,
-				"#":       container.Replica,
-			}
-			for i, title := range container.Titles {
-				if _, exists := header[title]; !exists {
-					header[title] = len(header)
+		_, _ = fmt.Fprintf(dockerCli.Out(), "%s\n", container.Name)
+		err := psPrinter(dockerCli.Out(), func(w io.Writer) {
+			for _, proc := range container.Processes {
+				info := []interface{}{}
+				for _, p := range proc {
+					info = append(info, p)
 				}
-				entry[title] = proc[i]
+				_, _ = fmt.Fprintf(w, strings.Repeat("%s\t", len(info))+"\n", info...)
+
 			}
-			entries = append(entries, entry)
+			_, _ = fmt.Fprintln(w)
+		},
+			container.Titles...)
+		if err != nil {
+			return err
 		}
 	}
-
-	// ensure CMD is the right-most column
-	if pos, ok := header["CMD"]; ok {
-		maxPos := pos
-		for h, i := range header {
-			if i > maxPos {
-				maxPos = i
-			}
-			if i > pos {
-				header[h] = i - 1
-			}
-		}
-		header["CMD"] = maxPos
-	}
-
-	return header, entries
+	return nil
 }

-func topPrint(out io.Writer, headers topHeader, rows []topEntries) error {
-	if len(rows) == 0 {
-		return nil
-	}
-
-	w := tabwriter.NewWriter(out, 4, 1, 2, ' ', 0)
-
-	// write headers in the order we've encountered them
-	h := make([]string, len(headers))
-	for title, index := range headers {
-		h[index] = title
-	}
-	_, _ = fmt.Fprintln(w, strings.Join(h, "\t"))
-
-	for _, row := range rows {
-		// write proc data in header order
-		r := make([]string, len(headers))
-		for title, index := range headers {
-			if v, ok := row[title]; ok {
-				r[index] = v
-			} else {
-				r[index] = "-"
-			}
-		}
-		_, _ = fmt.Fprintln(w, strings.Join(r, "\t"))
-	}
+func psPrinter(out io.Writer, printer func(writer io.Writer), headers ...string) error {
+	w := tabwriter.NewWriter(out, 5, 1, 3, ' ', 0)
+	_, _ = fmt.Fprintln(w, strings.Join(headers, "\t"))
+	printer(w)
 	return w.Flush()
 }
--- a/cmd/compose/top_test.go
+++ b/cmd/compose/top_test.go
@@ -1,329 +0,0 @@
-/*
-   Copyright 2024 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 (
-	"bytes"
-	"strings"
-	"testing"
-
-	"github.com/docker/compose/v2/pkg/api"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-var topTestCases = []struct {
-	name   string
-	titles []string
-	procs  [][]string
-
-	header  topHeader
-	entries []topEntries
-	output  string
-}{
-	{
-		name:    "noprocs",
-		titles:  []string{"UID", "PID", "PPID", "C", "STIME", "TTY", "TIME", "CMD"},
-		procs:   [][]string{},
-		header:  topHeader{"SERVICE": 0, "#": 1},
-		entries: []topEntries{},
-		output:  "",
-	},
-	{
-		name:   "simple",
-		titles: []string{"UID", "PID", "PPID", "C", "STIME", "TTY", "TIME", "CMD"},
-		procs:  [][]string{{"root", "1", "1", "0", "12:00", "?", "00:00:01", "/entrypoint"}},
-		header: topHeader{
-			"SERVICE": 0,
-			"#":       1,
-			"UID":     2,
-			"PID":     3,
-			"PPID":    4,
-			"C":       5,
-			"STIME":   6,
-			"TTY":     7,
-			"TIME":    8,
-			"CMD":     9,
-		},
-		entries: []topEntries{
-			{
-				"SERVICE": "simple",
-				"#":       "1",
-				"UID":     "root",
-				"PID":     "1",
-				"PPID":    "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:01",
-				"CMD":     "/entrypoint",
-			},
-		},
-		output: trim(`
-			SERVICE  #   UID   PID  PPID  C   STIME  TTY  TIME      CMD
-			simple   1   root  1    1     0   12:00  ?    00:00:01  /entrypoint
-		`),
-	},
-	{
-		name:   "noppid",
-		titles: []string{"UID", "PID", "C", "STIME", "TTY", "TIME", "CMD"},
-		procs:  [][]string{{"root", "1", "0", "12:00", "?", "00:00:02", "/entrypoint"}},
-		header: topHeader{
-			"SERVICE": 0,
-			"#":       1,
-			"UID":     2,
-			"PID":     3,
-			"C":       4,
-			"STIME":   5,
-			"TTY":     6,
-			"TIME":    7,
-			"CMD":     8,
-		},
-		entries: []topEntries{
-			{
-				"SERVICE": "noppid",
-				"#":       "1",
-				"UID":     "root",
-				"PID":     "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:02",
-				"CMD":     "/entrypoint",
-			},
-		},
-		output: trim(`
-			SERVICE  #   UID   PID  C   STIME  TTY  TIME      CMD
-			noppid   1   root  1    0   12:00  ?    00:00:02  /entrypoint
-		`),
-	},
-	{
-		name:   "extra-hdr",
-		titles: []string{"UID", "GID", "PID", "PPID", "C", "STIME", "TTY", "TIME", "CMD"},
-		procs:  [][]string{{"root", "1", "1", "1", "0", "12:00", "?", "00:00:03", "/entrypoint"}},
-		header: topHeader{
-			"SERVICE": 0,
-			"#":       1,
-			"UID":     2,
-			"GID":     3,
-			"PID":     4,
-			"PPID":    5,
-			"C":       6,
-			"STIME":   7,
-			"TTY":     8,
-			"TIME":    9,
-			"CMD":     10,
-		},
-		entries: []topEntries{
-			{
-				"SERVICE": "extra-hdr",
-				"#":       "1",
-				"UID":     "root",
-				"GID":     "1",
-				"PID":     "1",
-				"PPID":    "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:03",
-				"CMD":     "/entrypoint",
-			},
-		},
-		output: trim(`
-			SERVICE    #   UID   GID  PID  PPID  C   STIME  TTY  TIME      CMD
-			extra-hdr  1   root  1    1    1     0   12:00  ?    00:00:03  /entrypoint
-		`),
-	},
-	{
-		name:   "multiple",
-		titles: []string{"UID", "PID", "PPID", "C", "STIME", "TTY", "TIME", "CMD"},
-		procs: [][]string{
-			{"root", "1", "1", "0", "12:00", "?", "00:00:04", "/entrypoint"},
-			{"root", "123", "1", "0", "12:00", "?", "00:00:42", "sleep infinity"},
-		},
-		header: topHeader{
-			"SERVICE": 0,
-			"#":       1,
-			"UID":     2,
-			"PID":     3,
-			"PPID":    4,
-			"C":       5,
-			"STIME":   6,
-			"TTY":     7,
-			"TIME":    8,
-			"CMD":     9,
-		},
-		entries: []topEntries{
-			{
-				"SERVICE": "multiple",
-				"#":       "1",
-				"UID":     "root",
-				"PID":     "1",
-				"PPID":    "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:04",
-				"CMD":     "/entrypoint",
-			},
-			{
-				"SERVICE": "multiple",
-				"#":       "1",
-				"UID":     "root",
-				"PID":     "123",
-				"PPID":    "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:42",
-				"CMD":     "sleep infinity",
-			},
-		},
-		output: trim(`
-			SERVICE   #   UID   PID  PPID  C   STIME  TTY  TIME      CMD
-			multiple  1   root  1    1     0   12:00  ?    00:00:04  /entrypoint
-			multiple  1   root  123  1     0   12:00  ?    00:00:42  sleep infinity
-		`),
-	},
-}
-
-// TestRunTopCore only tests the core functionality of runTop: formatting
-// and printing of the output of (api.Compose).Top().
-func TestRunTopCore(t *testing.T) {
-	t.Parallel()
-
-	all := []api.ContainerProcSummary{}
-
-	for _, tc := range topTestCases {
-		summary := api.ContainerProcSummary{
-			Name:      "not used",
-			Titles:    tc.titles,
-			Processes: tc.procs,
-			Service:   tc.name,
-			Replica:   "1",
-		}
-		all = append(all, summary)
-
-		t.Run(tc.name, func(t *testing.T) {
-			header, entries := collectTop([]api.ContainerProcSummary{summary})
-			assert.Equal(t, tc.header, header)
-			assert.Equal(t, tc.entries, entries)
-
-			var buf bytes.Buffer
-			err := topPrint(&buf, header, entries)
-
-			require.NoError(t, err)
-			assert.Equal(t, tc.output, buf.String())
-		})
-	}
-
-	t.Run("all", func(t *testing.T) {
-		header, entries := collectTop(all)
-		assert.Equal(t, topHeader{
-			"SERVICE": 0,
-			"#":       1,
-			"UID":     2,
-			"PID":     3,
-			"PPID":    4,
-			"C":       5,
-			"STIME":   6,
-			"TTY":     7,
-			"TIME":    8,
-			"GID":     9,
-			"CMD":     10,
-		}, header)
-		assert.Equal(t, []topEntries{
-			{
-				"SERVICE": "simple",
-				"#":       "1",
-				"UID":     "root",
-				"PID":     "1",
-				"PPID":    "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:01",
-				"CMD":     "/entrypoint",
-			}, {
-				"SERVICE": "noppid",
-				"#":       "1",
-				"UID":     "root",
-				"PID":     "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:02",
-				"CMD":     "/entrypoint",
-			}, {
-				"SERVICE": "extra-hdr",
-				"#":       "1",
-				"UID":     "root",
-				"GID":     "1",
-				"PID":     "1",
-				"PPID":    "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:03",
-				"CMD":     "/entrypoint",
-			}, {
-				"SERVICE": "multiple",
-				"#":       "1",
-				"UID":     "root",
-				"PID":     "1",
-				"PPID":    "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:04",
-				"CMD":     "/entrypoint",
-			}, {
-				"SERVICE": "multiple",
-				"#":       "1",
-				"UID":     "root",
-				"PID":     "123",
-				"PPID":    "1",
-				"C":       "0",
-				"STIME":   "12:00",
-				"TTY":     "?",
-				"TIME":    "00:00:42",
-				"CMD":     "sleep infinity",
-			},
-		}, entries)
-
-		var buf bytes.Buffer
-		err := topPrint(&buf, header, entries)
-		require.NoError(t, err)
-		assert.Equal(t, trim(`
-			SERVICE    #   UID   PID  PPID  C   STIME  TTY  TIME      GID  CMD
-			simple     1   root  1    1     0   12:00  ?    00:00:01  -    /entrypoint
-			noppid     1   root  1    -     0   12:00  ?    00:00:02  -    /entrypoint
-			extra-hdr  1   root  1    1     0   12:00  ?    00:00:03  1    /entrypoint
-			multiple   1   root  1    1     0   12:00  ?    00:00:04  -    /entrypoint
-			multiple   1   root  123  1     0   12:00  ?    00:00:42  -    sleep infinity
-		`), buf.String())
-	})
-}
-
-func trim(s string) string {
-	var out bytes.Buffer
-	for _, line := range strings.Split(strings.TrimSpace(s), "\n") {
-		out.WriteString(strings.TrimSpace(line))
-		out.WriteRune('\n')
-	}
-	return out.String()
-}
--- a/cmd/compose/up.go
+++ b/cmd/compose/up.go
@@ -27,9 +27,7 @@ import (
 	"github.com/compose-spec/compose-go/v2/types"
 	"github.com/docker/cli/cli/command"
 	xprogress "github.com/moby/buildkit/util/progress/progressui"
-	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"

 	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/docker/compose/v2/pkg/api"
@@ -109,7 +107,7 @@ func (opts upOptions) OnExit() api.Cascade {
 	}
 }

-func upCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func upCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	up := upOptions{}
 	create := createOptions{}
 	build := buildOptions{ProjectOptions: p}
@@ -165,7 +163,6 @@ func upCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *c
 	flags.BoolVar(&create.recreateDeps, "always-recreate-deps", false, "Recreate dependent containers. Incompatible with --no-recreate.")
 	flags.BoolVarP(&create.noInherit, "renew-anon-volumes", "V", false, "Recreate anonymous volumes instead of retrieving data from the previous containers")
 	flags.BoolVar(&create.quietPull, "quiet-pull", false, "Pull without printing progress information")
-	flags.BoolVar(&build.quiet, "quiet-build", false, "Suppress the build output")
 	flags.StringArrayVar(&up.attach, "attach", []string{}, "Restrict attaching to the specified services. Incompatible with --attach-dependencies.")
 	flags.StringArrayVar(&up.noAttach, "no-attach", []string{}, "Do not attach (stream logs) to the specified services")
 	flags.BoolVar(&up.attachDependencies, "attach-dependencies", false, "Automatically attach to log output of dependent services")
@@ -173,15 +170,7 @@ func upCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *c
 	flags.IntVar(&up.waitTimeout, "wait-timeout", 0, "Maximum duration in seconds to wait for the project to be running|healthy")
 	flags.BoolVarP(&up.watch, "watch", "w", false, "Watch source code and rebuild/refresh containers when files are updated.")
 	flags.BoolVar(&up.navigationMenu, "menu", false, "Enable interactive shortcuts when running attached. Incompatible with --detach. Can also be enable/disable by setting COMPOSE_MENU environment var.")
-	flags.BoolVarP(&create.AssumeYes, "yes", "y", false, `Assume "yes" as answer to all prompts and run non-interactively`)
-	flags.SetNormalizeFunc(func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		// assumeYes was introduced by mistake as `--y`
-		if name == "y" {
-			logrus.Warn("--y is deprecated, please use --yes instead")
-			name = "yes"
-		}
-		return pflag.NormalizedName(name)
-	})
+
 	return upCmd
 }

@@ -203,11 +192,7 @@ func validateFlags(up *upOptions, create *createOptions) error {
 		return fmt.Errorf("--build and --no-build are incompatible")
 	}
 	if up.Detach && (up.attachDependencies || up.cascadeStop || up.cascadeFail || len(up.attach) > 0 || up.watch) {
-		if up.wait {
-			return fmt.Errorf("--wait cannot be combined with --abort-on-container-exit, --abort-on-container-failure, --attach, --attach-dependencies or --watch")
-		} else {
-			return fmt.Errorf("--detach cannot be combined with --abort-on-container-exit, --abort-on-container-failure, --attach, --attach-dependencies or --watch")
-		}
+		return fmt.Errorf("--detach cannot be combined with --abort-on-container-exit, --abort-on-container-failure, --attach, --attach-dependencies or --watch")
 	}
 	if create.noInherit && create.noRecreate {
 		return fmt.Errorf("--no-recreate and --renew-anon-volumes are incompatible")
@@ -224,21 +209,16 @@ func validateFlags(up *upOptions, create *createOptions) error {
 	return nil
 }

-//nolint:gocyclo
 func runUp(
 	ctx context.Context,
 	dockerCli command.Cli,
-	backend api.Compose,
+	backend api.Service,
 	createOptions createOptions,
 	upOptions upOptions,
 	buildOptions buildOptions,
 	project *types.Project,
 	services []string,
 ) error {
-	if err := checksForRemoteStack(ctx, dockerCli, project, buildOptions, createOptions.AssumeYes, []string{}); err != nil {
-		return err
-	}
-
 	err := createOptions.Apply(project)
 	if err != nil {
 		return err
@@ -262,8 +242,6 @@ func runUp(
 		if err != nil {
 			return err
 		}
-		bo.Services = services
-		bo.Deps = !upOptions.noDeps
 		build = &bo
 	}

@@ -277,7 +255,6 @@ func runUp(
 		Inherit:              !createOptions.noInherit,
 		Timeout:              createOptions.GetTimeout(),
 		QuietPull:            createOptions.quietPull,
-		AssumeYes:            createOptions.AssumeYes,
 	}

 	if upOptions.noStart {
@@ -332,7 +309,7 @@ func runUp(
 			WaitTimeout:    timeout,
 			Watch:          upOptions.watch,
 			Services:       services,
-			NavigationMenu: upOptions.navigationMenu && ui.Mode != "plain" && dockerCli.In().IsTerminal(),
+			NavigationMenu: upOptions.navigationMenu && ui.Mode != "plain",
 		},
 	})
 }
--- a/cmd/compose/up_test.go
+++ b/cmd/compose/up_test.go
@@ -47,4 +47,5 @@ func TestApplyScaleOpt(t *testing.T) {
 	assert.NilError(t, err)
 	assert.Equal(t, *bar.Scale, 3)
 	assert.Equal(t, *bar.Deploy.Replicas, 3)
+
 }
--- a/cmd/compose/version_test.go
+++ b/cmd/compose/version_test.go
@@ -1,76 +0,0 @@
-/*
-   Copyright 2025 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 (
-	"bytes"
-	"testing"
-
-	"github.com/docker/cli/cli/streams"
-	"github.com/docker/compose/v2/internal"
-	"github.com/docker/compose/v2/pkg/mocks"
-	"go.uber.org/mock/gomock"
-	"gotest.tools/v3/assert"
-)
-
-func TestVersionCommand(t *testing.T) {
-	originalVersion := internal.Version
-	defer func() {
-		internal.Version = originalVersion
-	}()
-	internal.Version = "v9.9.9-test"
-
-	tests := []struct {
-		name string
-		args []string
-		want string
-	}{
-		{
-			name: "default",
-			args: []string{},
-			want: "Docker Compose version v9.9.9-test\n",
-		},
-		{
-			name: "short flag",
-			args: []string{"--short"},
-			want: "9.9.9-test\n",
-		},
-		{
-			name: "json flag",
-			args: []string{"--format", "json"},
-			want: `{"version":"v9.9.9-test"}` + "\n",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			ctrl := gomock.NewController(t)
-			defer ctrl.Finish()
-
-			buf := new(bytes.Buffer)
-			cli := mocks.NewMockCli(ctrl)
-			cli.EXPECT().Out().Return(streams.NewOut(buf)).AnyTimes()
-
-			cmd := versionCommand(cli)
-			cmd.SetArgs(test.args)
-			err := cmd.Execute()
-			assert.NilError(t, err)
-
-			assert.Equal(t, test.want, buf.String())
-		})
-	}
-}
--- a/cmd/compose/viz.go
+++ b/cmd/compose/viz.go
@@ -35,7 +35,7 @@ type vizOptions struct {
 	indentationStr   string
 }

-func vizCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func vizCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := vizOptions{
 		ProjectOptions: p,
 	}
@@ -63,7 +63,7 @@ func vizCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *
 	return cmd
 }

-func runViz(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts *vizOptions) error {
+func runViz(ctx context.Context, dockerCli command.Cli, backend api.Service, opts *vizOptions) error {
 	_, _ = fmt.Fprintln(os.Stderr, "viz command is EXPERIMENTAL")
 	project, _, err := opts.ToProject(ctx, dockerCli, nil)
 	if err != nil {
--- a/cmd/compose/volumes.go
+++ b/cmd/compose/volumes.go
@@ -1,92 +0,0 @@
-/*
-   Copyright 2020 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 (
-	"context"
-	"fmt"
-	"slices"
-
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/command/formatter"
-	"github.com/docker/cli/cli/flags"
-	"github.com/docker/compose/v2/pkg/api"
-	"github.com/spf13/cobra"
-)
-
-type volumesOptions struct {
-	*ProjectOptions
-	Quiet  bool
-	Format string
-}
-
-func volumesCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
-	options := volumesOptions{
-		ProjectOptions: p,
-	}
-
-	cmd := &cobra.Command{
-		Use:   "volumes [OPTIONS] [SERVICE...]",
-		Short: "List volumes",
-		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runVol(ctx, dockerCli, backend, args, options)
-		}),
-		ValidArgsFunction: completeServiceNames(dockerCli, p),
-	}
-
-	cmd.Flags().BoolVarP(&options.Quiet, "quiet", "q", false, "Only display volume names")
-	cmd.Flags().StringVar(&options.Format, "format", "table", flags.FormatHelp)
-
-	return cmd
-}
-
-func runVol(ctx context.Context, dockerCli command.Cli, backend api.Compose, services []string, options volumesOptions) error {
-	project, name, err := options.projectOrName(ctx, dockerCli, services...)
-	if err != nil {
-		return err
-	}
-
-	if project != nil {
-		names := project.ServiceNames()
-		for _, service := range services {
-			if !slices.Contains(names, service) {
-				return fmt.Errorf("no such service: %s", service)
-			}
-		}
-	}
-
-	volumes, err := backend.Volumes(ctx, name, api.VolumesOptions{
-		Services: services,
-	})
-	if err != nil {
-		return err
-	}
-
-	if options.Quiet {
-		for _, v := range volumes {
-			_, _ = fmt.Fprintln(dockerCli.Out(), v.Name)
-		}
-		return nil
-	}
-
-	volumeCtx := formatter.Context{
-		Output: dockerCli.Out(),
-		Format: formatter.NewVolumeFormat(options.Format, options.Quiet),
-	}
-
-	return formatter.VolumeWrite(volumeCtx, volumes)
-}
--- a/cmd/compose/wait.go
+++ b/cmd/compose/wait.go
@@ -34,7 +34,7 @@ type waitOptions struct {
 	downProject bool
 }

-func waitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func waitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := waitOptions{
 		ProjectOptions: p,
 	}
@@ -60,7 +60,7 @@ func waitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return cmd
 }

-func runWait(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts *waitOptions) (int64, error) {
+func runWait(ctx context.Context, dockerCli command.Cli, backend api.Service, opts *waitOptions) (int64, error) {
 	_, name, err := opts.projectOrName(ctx, dockerCli)
 	if err != nil {
 		return 0, err
--- a/cmd/compose/watch.go
+++ b/cmd/compose/watch.go
@@ -36,7 +36,7 @@ type watchOptions struct {
 	noUp  bool
 }

-func watchCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func watchCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	watchOpts := watchOptions{
 		ProjectOptions: p,
 	}
@@ -59,13 +59,13 @@ func watchCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	}

 	cmd.Flags().BoolVar(&buildOpts.quiet, "quiet", false, "hide build output")
-	cmd.Flags().BoolVar(&watchOpts.prune, "prune", true, "Prune dangling images on rebuild")
+	cmd.Flags().BoolVar(&watchOpts.prune, "prune", false, "Prune dangling images on rebuild")
 	cmd.Flags().BoolVar(&watchOpts.noUp, "no-up", false, "Do not build & start services before watching")
 	return cmd
 }

-func runWatch(ctx context.Context, dockerCli command.Cli, backend api.Compose, watchOpts watchOptions, buildOpts buildOptions, services []string) error {
-	project, _, err := watchOpts.ToProject(ctx, dockerCli, services)
+func runWatch(ctx context.Context, dockerCli command.Cli, backend api.Service, watchOpts watchOptions, buildOpts buildOptions, services []string) error {
+	project, _, err := watchOpts.ToProject(ctx, dockerCli, nil)
 	if err != nil {
 		return err
 	}
@@ -117,10 +117,9 @@ func runWatch(ctx context.Context, dockerCli command.Cli, backend api.Compose, w
 	}

 	consumer := formatter.NewLogConsumer(ctx, dockerCli.Out(), dockerCli.Err(), false, false, false)
-	return backend.Watch(ctx, project, api.WatchOptions{
-		Build:    &build,
-		LogTo:    consumer,
-		Prune:    watchOpts.prune,
-		Services: services,
+	return backend.Watch(ctx, project, services, api.WatchOptions{
+		Build: &build,
+		LogTo: consumer,
+		Prune: watchOpts.prune,
 	})
 }
--- a/cmd/formatter/ansi.go
+++ b/cmd/formatter/ansi.go
@@ -27,71 +27,67 @@ var disableAnsi bool
 func ansi(code string) string {
 	return fmt.Sprintf("\033%s", code)
 }
-
-func saveCursor() {
+func SaveCursor() {
 	if disableAnsi {
 		return
 	}
 	fmt.Print(ansi("7"))
 }
-
-func restoreCursor() {
+func RestoreCursor() {
 	if disableAnsi {
 		return
 	}
 	fmt.Print(ansi("8"))
 }
-
-func showCursor() {
+func HideCursor() {
+	if disableAnsi {
+		return
+	}
+	fmt.Print(ansi("[?25l"))
+}
+func ShowCursor() {
 	if disableAnsi {
 		return
 	}
 	fmt.Print(ansi("[?25h"))
 }
-
-func moveCursor(y, x int) {
+func MoveCursor(y, x int) {
 	if disableAnsi {
 		return
 	}
 	fmt.Print(ansi(fmt.Sprintf("[%d;%dH", y, x)))
 }
-
-func carriageReturn() {
+func MoveCursorX(pos int) {
 	if disableAnsi {
 		return
 	}
-	fmt.Print(ansi(fmt.Sprintf("[%dG", 0)))
+	fmt.Print(ansi(fmt.Sprintf("[%dG", pos)))
 }
-
-func clearLine() {
+func ClearLine() {
 	if disableAnsi {
 		return
 	}
 	// Does not move cursor from its current position
 	fmt.Print(ansi("[2K"))
 }
-
-func moveCursorUp(lines int) {
+func MoveCursorUp(lines int) {
 	if disableAnsi {
 		return
 	}
 	// Does not add new lines
 	fmt.Print(ansi(fmt.Sprintf("[%dA", lines)))
 }
-
-func moveCursorDown(lines int) {
+func MoveCursorDown(lines int) {
 	if disableAnsi {
 		return
 	}
 	// Does not add new lines
 	fmt.Print(ansi(fmt.Sprintf("[%dB", lines)))
 }
-
-func newLine() {
+func NewLine() {
 	// Like \n
 	fmt.Print("\012")
 }
-
 func lenAnsi(s string) int {
 	// len has into consideration ansi codes, if we want
 	// the len of the actual len(string) we need to strip
--- a/cmd/formatter/colors.go
+++ b/cmd/formatter/colors.go
@@ -19,7 +19,6 @@ package formatter
 import (
 	"fmt"
 	"strconv"
-	"strings"
 	"sync"

 	"github.com/docker/cli/cli/command"
@@ -59,9 +58,6 @@ const (
 	Auto = "auto"
 )

-// ansiColorOffset is the offset for basic foreground colors in ANSI escape codes.
-const ansiColorOffset = 30
-
 // SetANSIMode configure formatter for colored output on ANSI-compliant console
 func SetANSIMode(streams command.Streams, ansi string) {
 	if !useAnsi(streams, ansi) {
@@ -95,15 +91,11 @@ func ansiColor(code, s string, formatOpts ...string) string {

 // Everything about ansiColorCode color https://hyperskill.org/learn/step/18193
 func ansiColorCode(code string, formatOpts ...string) string {
-	var sb strings.Builder
-	sb.WriteString("\033[")
+	res := "\033["
 	for _, c := range formatOpts {
-		sb.WriteString(c)
-		sb.WriteString(";")
+		res = fmt.Sprintf("%s%s;", res, c)
 	}
-	sb.WriteString(code)
-	sb.WriteString("m")
-	return sb.String()
+	return fmt.Sprintf("%s%sm", res, code)
 }

 func makeColorFunc(code string) colorFunc {
@@ -112,12 +104,10 @@ func makeColorFunc(code string) colorFunc {
 	}
 }

-var (
-	nextColor    = rainbowColor
-	rainbow      []colorFunc
-	currentIndex = 0
-	mutex        sync.Mutex
-)
+var nextColor = rainbowColor
+var rainbow []colorFunc
+var currentIndex = 0
+var mutex sync.Mutex

 func rainbowColor() colorFunc {
 	mutex.Lock()
@@ -130,8 +120,8 @@ func rainbowColor() colorFunc {
 func init() {
 	colors := map[string]colorFunc{}
 	for i, name := range names {
-		colors[name] = makeColorFunc(strconv.Itoa(ansiColorOffset + i))
-		colors["intense_"+name] = makeColorFunc(strconv.Itoa(ansiColorOffset+i) + ";1")
+		colors[name] = makeColorFunc(strconv.Itoa(30 + i))
+		colors["intense_"+name] = makeColorFunc(strconv.Itoa(30+i) + ";1")
 	}
 	rainbow = []colorFunc{
 		colors["cyan"],
--- a/cmd/formatter/container.go
+++ b/cmd/formatter/container.go
@@ -24,7 +24,7 @@ import (

 	"github.com/docker/cli/cli/command/formatter"
 	"github.com/docker/compose/v2/pkg/api"
-	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
 	"github.com/docker/go-units"
 )
@@ -212,9 +212,9 @@ func (c *ContainerContext) Publishers() api.PortPublishers {
 }

 func (c *ContainerContext) Ports() string {
-	var ports []container.Port
+	var ports []types.Port
 	for _, publisher := range c.c.Publishers {
-		ports = append(ports, container.Port{
+		ports = append(ports, types.Port{
 			IP:          publisher.URL,
 			PrivatePort: uint16(publisher.TargetPort),
 			PublicPort:  uint16(publisher.PublishedPort),
--- a/cmd/formatter/logs.go
+++ b/cmd/formatter/logs.go
@@ -56,6 +56,10 @@ func NewLogConsumer(ctx context.Context, stdout, stderr io.Writer, color, prefix
 	}
 }

+func (l *logConsumer) Register(name string) {
+	l.register(name)
+}
+
 func (l *logConsumer) register(name string) *presenter {
 	var p *presenter
 	root, _, found := strings.Cut(name, " ")
@@ -69,12 +73,9 @@ func (l *logConsumer) register(name string) *presenter {
 	} else {
 		cf := monochrome
 		if l.color {
-			switch name {
-			case "":
-				cf = monochrome
-			case api.WatchLogger:
+			if name == api.WatchLogger {
 				cf = makeColorFunc("92")
-			default:
+			} else {
 				cf = nextColor()
 			}
 		}
@@ -117,15 +118,23 @@ func (l *logConsumer) write(w io.Writer, container, message string) {
 	if l.ctx.Err() != nil {
 		return
 	}
+	if KeyboardManager != nil {
+		KeyboardManager.ClearKeyboardInfo()
+	}
+
 	p := l.getPresenter(container)
 	timestamp := time.Now().Format(jsonmessage.RFC3339NanoFixed)
 	for _, line := range strings.Split(message, "\n") {
 		if l.timestamp {
-			_, _ = fmt.Fprintf(w, "%s%s %s\n", p.prefix, timestamp, line)
+			_, _ = fmt.Fprintf(w, "%s%s%s\n", p.prefix, timestamp, line)
 		} else {
 			_, _ = fmt.Fprintf(w, "%s%s\n", p.prefix, line)
 		}
 	}
+
+	if KeyboardManager != nil {
+		KeyboardManager.PrintKeyboardInfo()
+	}
 }

 func (l *logConsumer) Status(container, msg string) {
@@ -159,27 +168,3 @@ func (p *presenter) setPrefix(width int) {
 	}
 	p.prefix = p.colors(fmt.Sprintf("%-"+strconv.Itoa(width)+"s | ", p.name))
 }
-
-type logDecorator struct {
-	decorated api.LogConsumer
-	Before    func()
-	After     func()
-}
-
-func (l logDecorator) Log(containerName, message string) {
-	l.Before()
-	l.decorated.Log(containerName, message)
-	l.After()
-}
-
-func (l logDecorator) Err(containerName, message string) {
-	l.Before()
-	l.decorated.Err(containerName, message)
-	l.After()
-}
-
-func (l logDecorator) Status(container, msg string) {
-	l.Before()
-	l.decorated.Status(container, msg)
-	l.After()
-}
--- a/cmd/formatter/multierrformat.go
+++ b/cmd/formatter/multierrformat.go
@@ -14,16 +14,25 @@
   limitations under the License.
 */

-package e2e
+package formatter

 import (
-	"testing"
+	"strings"
+
+	"github.com/hashicorp/go-multierror"
 )

-func TestComposeModel(t *testing.T) {
-	t.Skip("waiting for docker-model release")
-	c := NewParallelCLI(t)
-	defer c.cleanupWithDown(t, "model-test")
-
-	c.RunDockerComposeCmd(t, "-f", "./fixtures/model/compose.yaml", "run", "test", "sh", "-c", "curl ${FOO_URL}")
+// SetMultiErrorFormat set cli default format for multi-errors
+func SetMultiErrorFormat(errs *multierror.Error) {
+	if errs != nil {
+		errs.ErrorFormat = formatErrors
+	}
+}
+
+func formatErrors(errs []error) string {
+	messages := make([]string, len(errs))
+	for i, err := range errs {
+		messages[i] = "Error: " + err.Error()
+	}
+	return strings.Join(messages, "\n")
 }
--- a/cmd/formatter/shortcut.go
+++ b/cmd/formatter/shortcut.go
@@ -29,7 +29,9 @@ import (
 	"github.com/compose-spec/compose-go/v2/types"
 	"github.com/docker/compose/v2/internal/tracing"
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/watch"
 	"github.com/eiannone/keyboard"
+	"github.com/hashicorp/go-multierror"
 	"github.com/skratchdot/open-golang/open"
 )

@@ -48,8 +50,8 @@ func (ke *KeyboardError) printError(height int, info string) {
 	if ke.shouldDisplay() {
 		errMessage := ke.err.Error()

-		moveCursor(height-1-extraLines(info)-extraLines(errMessage), 0)
-		clearLine()
+		MoveCursor(height-1-extraLines(info)-extraLines(errMessage), 0)
+		ClearLine()

 		fmt.Print(errMessage)
 	}
@@ -69,14 +71,26 @@ func (ke *KeyboardError) error() string {
 }

 type KeyboardWatch struct {
+	Watcher  watch.Notify
 	Watching bool
-	Watcher  Feature
+	WatchFn  func(ctx context.Context, doneCh chan bool, project *types.Project, services []string, options api.WatchOptions) error
+	Ctx      context.Context
+	Cancel   context.CancelFunc
 }

-// Feature is an compose feature that can be started/stopped by a menu command
-type Feature interface {
-	Start(context.Context) error
-	Stop() error
+func (kw *KeyboardWatch) isWatching() bool {
+	return kw.Watching
+}
+
+func (kw *KeyboardWatch) switchWatching() {
+	kw.Watching = !kw.Watching
+}
+
+func (kw *KeyboardWatch) newContext(ctx context.Context) context.CancelFunc {
+	ctx, cancel := context.WithCancel(ctx)
+	kw.Ctx = ctx
+	kw.Cancel = cancel
+	return cancel
 }

 type KEYBOARD_LOG_LEVEL int
@@ -89,26 +103,40 @@ const (

 type LogKeyboard struct {
 	kError                KeyboardError
-	Watch                 *KeyboardWatch
+	Watch                 KeyboardWatch
 	IsDockerDesktopActive bool
+	IsWatchConfigured     bool
 	logLevel              KEYBOARD_LOG_LEVEL
 	signalChannel         chan<- os.Signal
 }

-func NewKeyboardManager(isDockerDesktopActive bool, sc chan<- os.Signal) *LogKeyboard {
-	return &LogKeyboard{
-		IsDockerDesktopActive: isDockerDesktopActive,
-		logLevel:              INFO,
-		signalChannel:         sc,
-	}
+var KeyboardManager *LogKeyboard
+var eg multierror.Group
+
+func NewKeyboardManager(ctx context.Context, isDockerDesktopActive, isWatchConfigured bool,
+	sc chan<- os.Signal,
+	watchFn func(ctx context.Context,
+		doneCh chan bool,
+		project *types.Project,
+		services []string,
+		options api.WatchOptions,
+	) error,
+) {
+	km := LogKeyboard{}
+	km.IsDockerDesktopActive = isDockerDesktopActive
+	km.IsWatchConfigured = isWatchConfigured
+	km.logLevel = INFO
+
+	km.Watch.Watching = false
+	km.Watch.WatchFn = watchFn
+
+	km.signalChannel = sc
+
+	KeyboardManager = &km
 }

-func (lk *LogKeyboard) Decorate(l api.LogConsumer) api.LogConsumer {
-	return logDecorator{
-		decorated: l,
-		Before:    lk.clearNavigationMenu,
-		After:     lk.PrintKeyboardInfo,
-	}
+func (lk *LogKeyboard) ClearKeyboardInfo() {
+	lk.clearNavigationMenu()
 }

 func (lk *LogKeyboard) PrintKeyboardInfo() {
@@ -133,7 +161,7 @@ func (lk *LogKeyboard) createBuffer(lines int) {

 	if lines > 0 {
 		allocateSpace(lines)
-		moveCursorUp(lines)
+		MoveCursorUp(lines)
 	}
 }

@@ -146,17 +174,17 @@ func (lk *LogKeyboard) printNavigationMenu() {
 		height := goterm.Height()
 		menu := lk.navigationMenu()

-		carriageReturn()
-		saveCursor()
+		MoveCursorX(0)
+		SaveCursor()

 		lk.kError.printError(height, menu)

-		moveCursor(height-extraLines(menu), 0)
-		clearLine()
+		MoveCursor(height-extraLines(menu), 0)
+		ClearLine()
 		fmt.Print(menu)

-		carriageReturn()
-		restoreCursor()
+		MoveCursorX(0)
+		RestoreCursor()
 	}
 }

@@ -178,8 +206,8 @@ func (lk *LogKeyboard) navigationMenu() string {
 	if openDDInfo != "" || openDDUI != "" {
 		watchInfo = navColor("   ")
 	}
-	isEnabled := " Enable"
-	if lk.Watch != nil && lk.Watch.Watching {
+	var isEnabled = " Enable"
+	if lk.Watch.Watching {
 		isEnabled = " Disable"
 	}
 	watchInfo = watchInfo + shortcutKeyColor("w") + navColor(isEnabled+" Watch")
@@ -188,66 +216,62 @@ func (lk *LogKeyboard) navigationMenu() string {

 func (lk *LogKeyboard) clearNavigationMenu() {
 	height := goterm.Height()
-	carriageReturn()
-	saveCursor()
+	MoveCursorX(0)
+	SaveCursor()

-	// clearLine()
+	// ClearLine()
 	for i := 0; i < height; i++ {
-		moveCursorDown(1)
-		clearLine()
+		MoveCursorDown(1)
+		ClearLine()
 	}
-	restoreCursor()
+	RestoreCursor()
 }

 func (lk *LogKeyboard) openDockerDesktop(ctx context.Context, project *types.Project) {
 	if !lk.IsDockerDesktopActive {
 		return
 	}
-	go func() {
-		_ = tracing.EventWrapFuncForErrGroup(ctx, "menu/gui", tracing.SpanOptions{},
-			func(ctx context.Context) error {
-				link := fmt.Sprintf("docker-desktop://dashboard/apps/%s", project.Name)
-				err := open.Run(link)
-				if err != nil {
-					err = fmt.Errorf("could not open Docker Desktop")
-					lk.keyboardError("View", err)
-				}
-				return err
-			})()
-	}()
+	eg.Go(tracing.EventWrapFuncForErrGroup(ctx, "menu/gui", tracing.SpanOptions{},
+		func(ctx context.Context) error {
+			link := fmt.Sprintf("docker-desktop://dashboard/apps/%s", project.Name)
+			err := open.Run(link)
+			if err != nil {
+				err = fmt.Errorf("Could not open Docker Desktop")
+				lk.keyboardError("View", err)
+			}
+			return err
+		}),
+	)
 }

 func (lk *LogKeyboard) openDDComposeUI(ctx context.Context, project *types.Project) {
 	if !lk.IsDockerDesktopActive {
 		return
 	}
-	go func() {
-		_ = tracing.EventWrapFuncForErrGroup(ctx, "menu/gui/composeview", tracing.SpanOptions{},
-			func(ctx context.Context) error {
-				link := fmt.Sprintf("docker-desktop://dashboard/docker-compose/%s", project.Name)
-				err := open.Run(link)
-				if err != nil {
-					err = fmt.Errorf("could not open Docker Desktop Compose UI")
-					lk.keyboardError("View Config", err)
-				}
-				return err
-			})()
-	}()
+	eg.Go(tracing.EventWrapFuncForErrGroup(ctx, "menu/gui/composeview", tracing.SpanOptions{},
+		func(ctx context.Context) error {
+			link := fmt.Sprintf("docker-desktop://dashboard/docker-compose/%s", project.Name)
+			err := open.Run(link)
+			if err != nil {
+				err = fmt.Errorf("Could not open Docker Desktop Compose UI")
+				lk.keyboardError("View Config", err)
+			}
+			return err
+		}),
+	)
 }
-
 func (lk *LogKeyboard) openDDWatchDocs(ctx context.Context, project *types.Project) {
-	go func() {
-		_ = tracing.EventWrapFuncForErrGroup(ctx, "menu/gui/watch", tracing.SpanOptions{},
-			func(ctx context.Context) error {
-				link := fmt.Sprintf("docker-desktop://dashboard/docker-compose/%s/watch", project.Name)
-				err := open.Run(link)
-				if err != nil {
-					err = fmt.Errorf("could not open Docker Desktop Compose UI")
-					lk.keyboardError("Watch Docs", err)
-				}
-				return err
-			})()
-	}()
+	eg.Go(tracing.EventWrapFuncForErrGroup(ctx, "menu/gui/watch", tracing.SpanOptions{},
+		func(ctx context.Context) error {
+			link := fmt.Sprintf("docker-desktop://dashboard/docker-compose/%s/watch", project.Name)
+			err := open.Run(link)
+			if err != nil {
+				err = fmt.Errorf("Could not open Docker Desktop Compose UI")
+				lk.keyboardError("Watch Docs", err)
+			}
+			return err
+		}),
+	)
 }

 func (lk *LogKeyboard) keyboardError(prefix string, err error) {
@@ -261,54 +285,53 @@ func (lk *LogKeyboard) keyboardError(prefix string, err error) {
 	}()
 }

-func (lk *LogKeyboard) ToggleWatch(ctx context.Context, options api.UpOptions) {
-	if lk.Watch == nil {
+func (lk *LogKeyboard) StartWatch(ctx context.Context, doneCh chan bool, project *types.Project, options api.UpOptions) {
+	if !lk.IsWatchConfigured {
 		return
 	}
-	if lk.Watch.Watching {
-		err := lk.Watch.Watcher.Stop()
-		if err != nil {
-			options.Start.Attach.Err(api.WatchLogger, err.Error())
-		} else {
-			lk.Watch.Watching = false
-		}
+	lk.Watch.switchWatching()
+	if !lk.Watch.isWatching() {
+		lk.Watch.Cancel()
 	} else {
-		go func() {
-			_ = tracing.EventWrapFuncForErrGroup(ctx, "menu/watch", tracing.SpanOptions{},
-				func(ctx context.Context) error {
-					err := lk.Watch.Watcher.Start(ctx)
-					if err != nil {
-						options.Start.Attach.Err(api.WatchLogger, err.Error())
-					} else {
-						lk.Watch.Watching = true
-					}
+		eg.Go(tracing.EventWrapFuncForErrGroup(ctx, "menu/watch", tracing.SpanOptions{},
+			func(ctx context.Context) error {
+				if options.Create.Build == nil {
+					err := fmt.Errorf("Cannot run watch mode with flag --no-build")
+					lk.keyboardError("Watch", err)
 					return err
-				})()
-		}()
+				}
+
+				lk.Watch.newContext(ctx)
+				buildOpts := *options.Create.Build
+				buildOpts.Quiet = true
+				return lk.Watch.WatchFn(lk.Watch.Ctx, doneCh, project, options.Start.Services, api.WatchOptions{
+					Build: &buildOpts,
+					LogTo: options.Start.Attach,
+				})
+			}))
 	}
 }

-func (lk *LogKeyboard) HandleKeyEvents(ctx context.Context, event keyboard.KeyEvent, project *types.Project, options api.UpOptions) {
+func (lk *LogKeyboard) HandleKeyEvents(event keyboard.KeyEvent, ctx context.Context, doneCh chan bool, project *types.Project, options api.UpOptions) {
 	switch kRune := event.Rune; kRune {
 	case 'v':
 		lk.openDockerDesktop(ctx, project)
 	case 'w':
-		if lk.Watch == nil {
+		if !lk.IsWatchConfigured {
 			// we try to open watch docs if DD is installed
 			if lk.IsDockerDesktopActive {
 				lk.openDDWatchDocs(ctx, project)
 			}
 			// either way we mark menu/watch as an error
-			go func() {
-				_ = tracing.EventWrapFuncForErrGroup(ctx, "menu/watch", tracing.SpanOptions{},
-					func(ctx context.Context) error {
-						err := fmt.Errorf("watch is not yet configured. Learn more: %s", ansiColor(CYAN, "https://docs.docker.com/compose/file-watch/"))
-						lk.keyboardError("Watch", err)
-						return err
-					})()
-			}()
+			eg.Go(tracing.EventWrapFuncForErrGroup(ctx, "menu/watch", tracing.SpanOptions{},
+				func(ctx context.Context) error {
+					err := fmt.Errorf("watch is not yet configured. Learn more: %s", ansiColor(CYAN, "https://docs.docker.com/compose/file-watch/"))
+					lk.keyboardError("Watch", err)
+					return err
+				}))
+			return
 		}
-		lk.ToggleWatch(ctx, options)
+		lk.StartWatch(ctx, doneCh, project, options)
 	case 'o':
 		lk.openDDComposeUI(ctx, project)
 	}
@@ -316,31 +339,26 @@ func (lk *LogKeyboard) HandleKeyEvents(ctx context.Context, event keyboard.KeyEv
 	case keyboard.KeyCtrlC:
 		_ = keyboard.Close()
 		lk.clearNavigationMenu()
-		showCursor()
+		ShowCursor()

 		lk.logLevel = NONE
+		if lk.Watch.Watching && lk.Watch.Cancel != nil {
+			lk.Watch.Cancel()
+			_ = eg.Wait().ErrorOrNil() // Need to print this ?
+		}
 		// will notify main thread to kill and will handle gracefully
 		lk.signalChannel <- syscall.SIGINT
-	case keyboard.KeyCtrlZ:
-		handleCtrlZ()
 	case keyboard.KeyEnter:
-		newLine()
+		NewLine()
 		lk.printNavigationMenu()
 	}
 }

-func (lk *LogKeyboard) EnableWatch(enabled bool, watcher Feature) {
-	lk.Watch = &KeyboardWatch{
-		Watching: enabled,
-		Watcher:  watcher,
-	}
-}
-
 func allocateSpace(lines int) {
 	for i := 0; i < lines; i++ {
-		clearLine()
-		newLine()
-		carriageReturn()
+		ClearLine()
+		NewLine()
+		MoveCursorX(0)
 	}
 }

--- a/cmd/formatter/shortcut_unix.go
+++ b/cmd/formatter/shortcut_unix.go
@@ -1,25 +0,0 @@
-//go:build !windows
-
-/*
-   Copyright 2024 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 formatter
-
-import "syscall"
-
-func handleCtrlZ() {
-	_ = syscall.Kill(0, syscall.SIGSTOP)
-}
--- a/cmd/formatter/shortcut_windows.go
+++ b/cmd/formatter/shortcut_windows.go
@@ -1,25 +0,0 @@
-//go:build windows
-
-/*
-   Copyright 2024 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 formatter
-
-// handleCtrlZ is a no-op on Windows as SIGSTOP is not supported
-func handleCtrlZ() {
-	// Windows doesn't support SIGSTOP/SIGCONT signals
-	// Ctrl+Z behavior is handled differently by the Windows terminal
-}
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -20,11 +20,11 @@ import (
 	"os"

 	dockercli "github.com/docker/cli/cli"
-	"github.com/docker/cli/cli-plugins/metadata"
+	"github.com/docker/cli/cli-plugins/manager"
 	"github.com/docker/cli/cli-plugins/plugin"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/cmd/cmdtrace"
-	"github.com/docker/compose/v2/cmd/prompt"
+	"github.com/docker/docker/client"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"

@@ -35,43 +35,60 @@ import (
 )

 func pluginMain() {
-	plugin.Run(
-		func(cli command.Cli) *cobra.Command {
-			backend := compose.NewComposeService(cli,
-				compose.WithPrompt(prompt.NewPrompt(cli.In(), cli.Out()).Confirm),
-			)
-			cmd := commands.RootCommand(cli, backend)
-			originalPreRunE := cmd.PersistentPreRunE
-			cmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
-				// initialize the cli instance
-				if err := plugin.PersistentPreRunE(cmd, args); err != nil {
-					return err
-				}
-				if err := cmdtrace.Setup(cmd, cli, os.Args[1:]); err != nil {
-					logrus.Debugf("failed to enable tracing: %v", err)
-				}
+	plugin.Run(func(dockerCli command.Cli) *cobra.Command {
+		// TODO(milas): this cast is safe but we should not need to do this,
+		// 	we should expose the concrete service type so that we do not need
+		// 	to rely on the `api.Service` interface internally
+		backend := compose.NewComposeService(dockerCli).(commands.Backend)
+		cmd := commands.RootCommand(dockerCli, backend)
+		originalPreRunE := cmd.PersistentPreRunE
+		cmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
+			// initialize the dockerCli instance
+			if err := plugin.PersistentPreRunE(cmd, args); err != nil {
+				return err
+			}
+			// compose-specific initialization
+			dockerCliPostInitialize(dockerCli)

-				if originalPreRunE != nil {
-					return originalPreRunE(cmd, args)
-				}
-				return nil
+			if err := cmdtrace.Setup(cmd, dockerCli, os.Args[1:]); err != nil {
+				logrus.Debugf("failed to enable tracing: %v", err)
 			}

-			cmd.SetFlagErrorFunc(func(c *cobra.Command, err error) error {
-				return dockercli.StatusError{
-					StatusCode: 1,
-					Status:     err.Error(),
-				}
-			})
-			return cmd
-		},
-		metadata.Metadata{
+			if originalPreRunE != nil {
+				return originalPreRunE(cmd, args)
+			}
+			return nil
+		}
+
+		cmd.SetFlagErrorFunc(func(c *cobra.Command, err error) error {
+			return dockercli.StatusError{
+				StatusCode: compose.CommandSyntaxFailure.ExitCode,
+				Status:     err.Error(),
+			}
+		})
+		return cmd
+	},
+		manager.Metadata{
 			SchemaVersion: "0.1.0",
 			Vendor:        "Docker Inc.",
 			Version:       internal.Version,
-		},
-		command.WithUserAgent("compose/"+internal.Version),
-	)
+		})
+}
+
+// dockerCliPostInitialize performs Compose-specific configuration for the
+// command.Cli instance provided by the plugin.Run() initialization.
+//
+// NOTE: This must be called AFTER plugin.PersistentPreRunE.
+func dockerCliPostInitialize(dockerCli command.Cli) {
+	// HACK(milas): remove once docker/cli#4574 is merged; for now,
+	// set it in a rather roundabout way by grabbing the underlying
+	// concrete client and manually invoking an option on it
+	_ = dockerCli.Apply(func(cli *command.DockerCli) error {
+		if mobyClient, ok := cli.Client().(*client.Client); ok {
+			_ = client.WithUserAgent("compose/" + internal.Version)(mobyClient)
+		}
+		return nil
+	})
 }

 func main() {
--- a/docs/examples/provider.go
+++ b/docs/examples/provider.go
@@ -1,152 +0,0 @@
-/*
-   Copyright 2020 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 main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"time"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-func main() {
-	cmd := &cobra.Command{
-		Short: "Compose Provider Example",
-		Use:   "demo",
-	}
-	cmd.AddCommand(composeCommand())
-	err := cmd.Execute()
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-type options struct {
-	db   string
-	size int
-}
-
-func composeCommand() *cobra.Command {
-	c := &cobra.Command{
-		Use:              "compose EVENT",
-		TraverseChildren: true,
-	}
-	c.PersistentFlags().String("project-name", "", "compose project name") // unused
-
-	var options options
-	upCmd := &cobra.Command{
-		Use: "up",
-		Run: func(_ *cobra.Command, args []string) {
-			up(options, args)
-		},
-		Args: cobra.ExactArgs(1),
-	}
-
-	upCmd.Flags().StringVar(&options.db, "type", "", "Database type (mysql, postgres, etc.)")
-	_ = upCmd.MarkFlagRequired("type")
-	upCmd.Flags().IntVar(&options.size, "size", 10, "Database size in GB")
-	upCmd.Flags().String("name", "", "Name of the database to be created")
-	_ = upCmd.MarkFlagRequired("name")
-
-	downCmd := &cobra.Command{
-		Use:  "down",
-		Run:  down,
-		Args: cobra.ExactArgs(1),
-	}
-	downCmd.Flags().String("name", "", "Name of the database to be deleted")
-	_ = downCmd.MarkFlagRequired("name")
-
-	c.AddCommand(upCmd, downCmd)
-	c.AddCommand(metadataCommand(upCmd, downCmd))
-	return c
-}
-
-const lineSeparator = "\n"
-
-func up(options options, args []string) {
-	servicename := args[0]
-	fmt.Printf(`{ "type": "debug", "message": "Starting %s" }%s`, servicename, lineSeparator)
-
-	for i := 0; i < options.size; i += 10 {
-		time.Sleep(1 * time.Second)
-		fmt.Printf(`{ "type": "info", "message": "Processing ... %d%%" }%s`, i*100/options.size, lineSeparator)
-	}
-	fmt.Printf(`{ "type": "setenv", "message": "URL=https://magic.cloud/%s" }%s`, servicename, lineSeparator)
-}
-
-func down(_ *cobra.Command, _ []string) {
-	fmt.Printf(`{ "type": "error", "message": "Permission error" }%s`, lineSeparator)
-}
-
-func metadataCommand(upCmd, downCmd *cobra.Command) *cobra.Command {
-	return &cobra.Command{
-		Use: "metadata",
-		Run: func(cmd *cobra.Command, _ []string) {
-			metadata(upCmd, downCmd)
-		},
-		Args: cobra.NoArgs,
-	}
-}
-
-func metadata(upCmd, downCmd *cobra.Command) {
-	metadata := ProviderMetadata{}
-	metadata.Description = "Manage services on AwesomeCloud"
-	metadata.Up = commandParameters(upCmd)
-	metadata.Down = commandParameters(downCmd)
-	jsonMetadata, err := json.Marshal(metadata)
-	if err != nil {
-		panic(err)
-	}
-	fmt.Println(string(jsonMetadata))
-}
-
-func commandParameters(cmd *cobra.Command) CommandMetadata {
-	cmdMetadata := CommandMetadata{}
-	cmd.Flags().VisitAll(func(f *pflag.Flag) {
-		_, isRequired := f.Annotations[cobra.BashCompOneRequiredFlag]
-		cmdMetadata.Parameters = append(cmdMetadata.Parameters, Metadata{
-			Name:        f.Name,
-			Description: f.Usage,
-			Required:    isRequired,
-			Type:        f.Value.Type(),
-			Default:     f.DefValue,
-		})
-	})
-	return cmdMetadata
-}
-
-type ProviderMetadata struct {
-	Description string          `json:"description"`
-	Up          CommandMetadata `json:"up"`
-	Down        CommandMetadata `json:"down"`
-}
-
-type CommandMetadata struct {
-	Parameters []Metadata `json:"parameters"`
-}
-
-type Metadata struct {
-	Name        string `json:"name"`
-	Description string `json:"description"`
-	Required    bool   `json:"required"`
-	Type        string `json:"type"`
-	Default     string `json:"default,omitempty"`
-}
--- a/docs/extension.md
+++ b/docs/extension.md
@@ -1,176 +0,0 @@
-# About
-
-The Compose application model defines `service` as an abstraction for a computing unit managing (a subset of)
-application needs, which can interact with other service by relying on network(s). Docker Compose is designed 
-to use the Docker Engine ("Moby") API to manage services as containers, but the abstraction _could_ also cover 
-many other runtimes, typically cloud services or services natively provided by host.
-
-The Compose extensibility model has been designed to extend the `service` support to runtimes accessible through
-third-party tooling.
-
-# Architecture
-
-Compose extensibility relies on the `provider` attribute to select the actual binary responsible for managing
-the resource(s) needed to run a service.
-
-```yaml
-  database:
-    provider:
-      type: awesomecloud
-      options:
-        type: mysql
-        size: 256
-        name: myAwesomeCloudDB
-```
-
-`provider.type` tells Compose the binary to run, which can be either:
- Another Docker CLI plugin (typically, `model` to run `docker-model`)
- An executable in user's `PATH`
-
-If `provider.type` doesn't resolve into any of those, Compose will report an error and interrupt the `up` command.
-
-To be a valid Compose extension, provider command *MUST* accept a `compose` command (which can be hidden)
-with subcommands `up` and `down`.
-
-## Up lifecycle
-
-To execute an application's `up` lifecycle, Compose executes the provider's `compose up` command, passing 
-the project name, service name, and additional options. The `provider.options` are translated 
-into command line flags. For example:
-```console
-awesomecloud compose --project-name <NAME> up --type=mysql --size=256 "database"
-```
-
-> __Note:__ `project-name` _should_ be used by the provider to tag resources
-> set for project, so that later execution with `down` subcommand releases 
-> all allocated resources set for the project.
-
-## Communication with Compose
-
-Providers can interact with Compose using `stdout` as a channel, sending JSON line delimited messages.
-JSON messages MUST include a `type` and a `message` attribute.
-```json
-{ "type": "info", "message": "preparing mysql ..." }
-```
-
-`type` can be either:
- `info`: Reports status updates to the user. Compose will render message as the service state in the progress UI
- `error`: Let's the user know something went wrong with details about the error. Compose will render the message as the reason for the service failure.
- `setenv`: Let's the plugin tell Compose how dependent services can access the created resource. See next section for further details.
- `debug`: Those messages could help debugging the provider, but are not rendered to the user by default. They are rendered when Compose is started with `--verbose` flag.
-
-```mermaid
-sequenceDiagram
-    Shell->>Compose: docker compose up
-    Compose->>Provider: compose up --project-name=xx --foo=bar "database"
-    Provider--)Compose: json { "info": "pulling 25%" }
-    Compose-)Shell: pulling 25%
-    Provider--)Compose: json { "info": "pulling 50%" }
-    Compose-)Shell: pulling 50%
-    Provider--)Compose: json { "info": "pulling 75%" }
-    Compose-)Shell: pulling 75%
-    Provider--)Compose: json { "setenv": "URL=http://cloud.com/abcd:1234" }
-    Compose-)Compose: set DATABASE_URL
-    Provider-)Compose: EOF (command complete) exit 0
-    Compose-)Shell: service started
-```
-
-## Connection to a service managed by a provider
-
-A service in the Compose application can declare dependency on a service managed by an external provider: 
-
-```yaml
-services:
-  app:
-    image: myapp 
-    depends_on:
-       - database
-
-  database:
-    provider:
-      type: awesomecloud
-```
-
-When the provider command sends a `setenv` JSON message, Compose injects the specified variable into any dependent service,
-automatically prefixing it with the service name. For example, if `awesomecloud compose up` returns:
-```json
-{"type": "setenv", "message": "URL=https://awesomecloud.com/db:1234"}
-```
-Then the `app` service, which depends on the service managed by the provider, will receive a `DATABASE_URL` environment variable injected
-into its runtime environment.
-
-> __Note:__  The `compose up` provider command _MUST_ be idempotent. If resource is already running, the command _MUST_ set
-> the same environment variables to ensure consistent configuration of dependent services.
-
-## Down lifecycle
-
-`down` lifecycle is equivalent to `up` with the `<provider> compose --project-name <NAME> down <SERVICE>` command.
-The provider is responsible for releasing all resources associated with the service.
-
-## Provide metadata about options
-
-Compose extensions *MAY* optionally implement a `metadata` subcommand to provide information about the parameters accepted by the `up` and `down` commands.  
-
-The `metadata` subcommand takes no parameters and returns a JSON structure on the `stdout` channel that describes the parameters accepted by both the `up` and `down` commands, including whether each parameter is mandatory or optional.
-
-```console
-awesomecloud compose metadata
-```
-
-The expected JSON output format is:
-```json
-{
-  "description": "Manage services on AwesomeCloud",
-  "up": {
-    "parameters": [
-      {
-        "name": "type",
-        "description": "Database type (mysql, postgres, etc.)",
-        "required": true,
-        "type": "string"
-      },
-      {
-        "name": "size",
-        "description": "Database size in GB",
-        "required": false,
-        "type": "integer",
-        "default": "10"
-      },
-      {
-        "name": "name",
-        "description": "Name of the database to be created",
-        "required": true,
-        "type": "string"
-      }
-    ]
-  },
-  "down": {
-    "parameters": [
-      {
-        "name": "name",
-        "description": "Name of the database to be removed",
-        "required": true,
-        "type": "string"
-      }
-    ]
-  }
-}
-```
-The top elements are:
- `description`: Human-readable description of the provider
- `up`: Object describing the parameters accepted by the `up` command
- `down`: Object describing the parameters accepted by the `down` command
-
-And for each command parameter, you should include the following properties:
- `name`: The parameter name (without `--` prefix)
- `description`: Human-readable description of the parameter
- `required`: Boolean indicating if the parameter is mandatory
- `type`: Parameter type (`string`, `integer`, `boolean`, etc.)
- `default`: Default value (optional, only for non-required parameters)
- `enum`: List of possible values supported by the parameter separated by `,` (optional, only for parameters with a limited set of values)
-
-This metadata allows Compose and other tools to understand the provider's interface and provide better user experience, such as validation, auto-completion, and documentation generation.
-
-## Examples
-
-See [example](examples/provider.go) for illustration on implementing this API in a command line 
--- a/docs/reference/compose.md
+++ b/docs/reference/compose.md
@@ -12,7 +12,6 @@ Define and run multi-container applications with Docker
 | Name                            | Description                                                                             |
 |:--------------------------------|:----------------------------------------------------------------------------------------|
 | [`attach`](compose_attach.md)   | Attach local standard input, output, and error streams to a service's running container |
-| [`bridge`](compose_bridge.md)   | Convert compose files into another model                                                |
 | [`build`](compose_build.md)     | Build or rebuild services                                                               |
 | [`commit`](compose_commit.md)   | Create a new image from a service container's changes                                   |
 | [`config`](compose_config.md)   | Parse, resolve and render compose file in canonical format                              |
@@ -29,7 +28,6 @@ Define and run multi-container applications with Docker
 | [`pause`](compose_pause.md)     | Pause services                                                                          |
 | [`port`](compose_port.md)       | Print the public port for a port binding                                                |
 | [`ps`](compose_ps.md)           | List containers                                                                         |
-| [`publish`](compose_publish.md) | Publish compose application                                                             |
 | [`pull`](compose_pull.md)       | Pull service images                                                                     |
 | [`push`](compose_push.md)       | Push service images                                                                     |
 | [`restart`](compose_restart.md) | Restart service containers                                                              |
@@ -43,7 +41,6 @@ Define and run multi-container applications with Docker
 | [`unpause`](compose_unpause.md) | Unpause services                                                                        |
 | [`up`](compose_up.md)           | Create and start containers                                                             |
 | [`version`](compose_version.md) | Show the Docker Compose version information                                             |
-| [`volumes`](compose_volumes.md) | List volumes                                                                            |
 | [`wait`](compose_wait.md)       | Block until containers of all (or specified) services stop.                             |
 | [`watch`](compose_watch.md)     | Watch build context for service and rebuild/refresh containers when files are updated   |

@@ -60,7 +57,7 @@ Define and run multi-container applications with Docker
 | `-f`, `--file`         | `stringArray` |         | Compose configuration files                                                                         |
 | `--parallel`           | `int`         | `-1`    | Control max parallelism, -1 for unlimited                                                           |
 | `--profile`            | `stringArray` |         | Specify a profile to enable                                                                         |
-| `--progress`           | `string`      |         | Set type of progress output (auto, tty, plain, json, quiet)                                         |
+| `--progress`           | `string`      | `auto`  | Set type of progress output (auto, tty, plain, json, quiet)                                         |
 | `--project-directory`  | `string`      |         | Specify an alternate working directory<br>(default: the path of the, first specified, Compose file) |
 | `-p`, `--project-name` | `string`      |         | Project name                                                                                        |

@@ -70,7 +67,7 @@ Define and run multi-container applications with Docker
 ## Examples

 ### Use `-f` to specify the name and path of one or more Compose files
-Use the `-f` flag to specify the location of a Compose [configuration file](/reference/compose-file/).
+Use the `-f` flag to specify the location of a Compose configuration file.

 #### Specifying multiple Compose files
 You can supply multiple `-f` configuration files. When you supply multiple files, Compose combines them into a single
@@ -80,10 +77,10 @@ to their predecessors.
 For example, consider this command line:

 ```console
-$ docker compose -f compose.yaml -f compose.admin.yaml run backup_db
+$ docker compose -f docker-compose.yml -f docker-compose.admin.yml run backup_db
 ```

-The `compose.yaml` file might specify a `webapp` service.
+The `docker-compose.yml` file might specify a `webapp` service.

 ```yaml
 services:
@@ -94,7 +91,7 @@ services:
    volumes:
      - "/data"
 ```
-If the `compose.admin.yaml` also specifies this same service, any matching fields override the previous file.
+If the `docker-compose.admin.yml` also specifies this same service, any matching fields override the previous file.
 New values, add to the `webapp` service configuration.

 ```yaml
@@ -209,4 +206,4 @@ $ docker compose --dry-run up --build -d
 From the example above, you can see that the first step is to pull the image defined by `db` service, then build the `backend` service.  
 Next, the containers are created. The `db` service is started, and the `backend` and `proxy` wait until the `db` service is healthy before starting.

-Dry Run mode works with almost all commands. You cannot use Dry Run mode with a command that doesn't change the state of a Compose stack such as `ps`, `ls`, `logs` for example.
+Dry Run mode works with almost all commands. You cannot use Dry Run mode with a command that doesn't change the state of a Compose stack such as `ps`, `ls`, `logs` for example.  
--- a/docs/reference/compose_alpha_publish.md
+++ b/docs/reference/compose_alpha_publish.md
@@ -8,10 +8,8 @@ Publish compose application
 | Name                      | Type     | Default | Description                                                                    |
 |:--------------------------|:---------|:--------|:-------------------------------------------------------------------------------|
 | `--dry-run`               | `bool`   |         | Execute command in dry run mode                                                |
-| `--oci-version`           | `string` |         | OCI image/artifact specification version (automatically determined by default) |
+| `--oci-version`           | `string` |         | OCI Image/Artifact specification version (automatically determined by default) |
 | `--resolve-image-digests` | `bool`   |         | Pin image tags to digests                                                      |
-| `--with-env`              | `bool`   |         | Include environment variables in the published OCI artifact                    |
-| `-y`, `--yes`             | `bool`   |         | Assume "yes" as answer to all prompts                                          |


 <!---MARKER_GEN_END-->
--- a/docs/reference/compose_bridge.md
+++ b/docs/reference/compose_bridge.md
@@ -1,22 +0,0 @@
-# docker compose bridge
-
-<!---MARKER_GEN_START-->
-Convert compose files into another model
-
-### Subcommands
-
-| Name                                                   | Description                                                                  |
-|:-------------------------------------------------------|:-----------------------------------------------------------------------------|
-| [`convert`](compose_bridge_convert.md)                 | Convert compose files to Kubernetes manifests, Helm charts, or another model |
-| [`transformations`](compose_bridge_transformations.md) | Manage transformation images                                                 |
-
-
-### Options
-
-| Name        | Type   | Default | Description                     |
-|:------------|:-------|:--------|:--------------------------------|
-| `--dry-run` | `bool` |         | Execute command in dry run mode |
-
-
-<!---MARKER_GEN_END-->
-
--- a/docs/reference/compose_bridge_convert.md
+++ b/docs/reference/compose_bridge_convert.md
@@ -1,17 +0,0 @@
-# docker compose bridge convert
-
-<!---MARKER_GEN_START-->
-Convert compose files to Kubernetes manifests, Helm charts, or another model
-
-### Options
-
-| Name                     | Type          | Default | Description                                                                          |
-|:-------------------------|:--------------|:--------|:-------------------------------------------------------------------------------------|
-| `--dry-run`              | `bool`        |         | Execute command in dry run mode                                                      |
-| `-o`, `--output`         | `string`      | `out`   | The output directory for the Kubernetes resources                                    |
-| `--templates`            | `string`      |         | Directory containing transformation templates                                        |
-| `-t`, `--transformation` | `stringArray` |         | Transformation to apply to compose model (default: docker/compose-bridge-kubernetes) |
-
-
-<!---MARKER_GEN_END-->
-
--- a/docs/reference/compose_bridge_transformations.md
+++ b/docs/reference/compose_bridge_transformations.md
@@ -1,22 +0,0 @@
-# docker compose bridge transformations
-
-<!---MARKER_GEN_START-->
-Manage transformation images
-
-### Subcommands
-
-| Name                                                 | Description                    |
-|:-----------------------------------------------------|:-------------------------------|
-| [`create`](compose_bridge_transformations_create.md) | Create a new transformation    |
-| [`list`](compose_bridge_transformations_list.md)     | List available transformations |
-
-
-### Options
-
-| Name        | Type   | Default | Description                     |
-|:------------|:-------|:--------|:--------------------------------|
-| `--dry-run` | `bool` |         | Execute command in dry run mode |
-
-
-<!---MARKER_GEN_END-->
-
--- a/docs/reference/compose_bridge_transformations_create.md
+++ b/docs/reference/compose_bridge_transformations_create.md
@@ -1,15 +0,0 @@
-# docker compose bridge transformations create
-
-<!---MARKER_GEN_START-->
-Create a new transformation
-
-### Options
-
-| Name           | Type     | Default | Description                                                                 |
-|:---------------|:---------|:--------|:----------------------------------------------------------------------------|
-| `--dry-run`    | `bool`   |         | Execute command in dry run mode                                             |
-| `-f`, `--from` | `string` |         | Existing transformation to copy (default: docker/compose-bridge-kubernetes) |
-
-
-<!---MARKER_GEN_END-->
-
--- a/docs/reference/compose_bridge_transformations_list.md
+++ b/docs/reference/compose_bridge_transformations_list.md
@@ -1,20 +0,0 @@
-# docker compose bridge transformations list
-
-<!---MARKER_GEN_START-->
-List available transformations
-
-### Aliases
-
-`docker compose bridge transformations list`, `docker compose bridge transformations ls`
-
-### Options
-
-| Name            | Type     | Default | Description                                |
-|:----------------|:---------|:--------|:-------------------------------------------|
-| `--dry-run`     | `bool`   |         | Execute command in dry run mode            |
-| `--format`      | `string` | `table` | Format the output. Values: [table \| json] |
-| `-q`, `--quiet` | `bool`   |         | Only display transformer names             |
-
-
-<!---MARKER_GEN_END-->
-
--- a/docs/reference/compose_build.md
+++ b/docs/reference/compose_build.md
@@ -4,9 +4,9 @@
 Services are built once and then tagged, by default as `project-service`.

 If the Compose file specifies an
-[image](https://github.com/compose-spec/compose-spec/blob/main/spec.md#image) name,
+[image](https://github.com/compose-spec/compose-spec/blob/master/spec.md#image) name,
 the image is tagged with that name, substituting any variables beforehand. See
-[variable interpolation](https://github.com/compose-spec/compose-spec/blob/main/spec.md#interpolation).
+[variable interpolation](https://github.com/compose-spec/compose-spec/blob/master/spec.md#interpolation).

 If you change a service's `Dockerfile` or the contents of its build directory,
 run `docker compose build` to rebuild it.
@@ -17,16 +17,12 @@ run `docker compose build` to rebuild it.
 |:----------------------|:--------------|:--------|:------------------------------------------------------------------------------------------------------------|
 | `--build-arg`         | `stringArray` |         | Set build-time variables for services                                                                       |
 | `--builder`           | `string`      |         | Set builder to use                                                                                          |
-| `--check`             | `bool`        |         | Check build configuration                                                                                   |
 | `--dry-run`           | `bool`        |         | Execute command in dry run mode                                                                             |
 | `-m`, `--memory`      | `bytes`       | `0`     | Set memory limit for the build container. Not supported by BuildKit.                                        |
 | `--no-cache`          | `bool`        |         | Do not use cache when building the image                                                                    |
-| `--print`             | `bool`        |         | Print equivalent bake file                                                                                  |
-| `--provenance`        | `string`      |         | Add a provenance attestation                                                                                |
 | `--pull`              | `bool`        |         | Always attempt to pull a newer version of the image                                                         |
 | `--push`              | `bool`        |         | Push service images                                                                                         |
-| `-q`, `--quiet`       | `bool`        |         | Suppress the build output                                                                                   |
-| `--sbom`              | `string`      |         | Add a SBOM attestation                                                                                      |
+| `-q`, `--quiet`       | `bool`        |         | Don't print anything to STDOUT                                                                              |
 | `--ssh`               | `string`      |         | Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent) |
 | `--with-dependencies` | `bool`        |         | Also build dependencies (transitively)                                                                      |

@@ -38,9 +34,9 @@ run `docker compose build` to rebuild it.
 Services are built once and then tagged, by default as `project-service`.

 If the Compose file specifies an
-[image](https://github.com/compose-spec/compose-spec/blob/main/spec.md#image) name,
+[image](https://github.com/compose-spec/compose-spec/blob/master/spec.md#image) name,
 the image is tagged with that name, substituting any variables beforehand. See
-[variable interpolation](https://github.com/compose-spec/compose-spec/blob/main/spec.md#interpolation).
+[variable interpolation](https://github.com/compose-spec/compose-spec/blob/master/spec.md#interpolation).

 If you change a service's `Dockerfile` or the contents of its build directory,
 run `docker compose build` to rebuild it.
--- a/docs/reference/compose_config.md
+++ b/docs/reference/compose_config.md
@@ -5,20 +5,20 @@
 It merges the Compose files set by `-f` flags, resolves variables in the Compose file, and expands short-notation into
 the canonical format.

+### Aliases
+
+`docker compose config`, `docker compose convert`
+
 ### Options

 | Name                      | Type     | Default | Description                                                                 |
 |:--------------------------|:---------|:--------|:----------------------------------------------------------------------------|
 | `--dry-run`               | `bool`   |         | Execute command in dry run mode                                             |
 | `--environment`           | `bool`   |         | Print environment used for interpolation.                                   |
-| `--format`                | `string` |         | Format the output. Values: [yaml \| json]                                   |
+| `--format`                | `string` | `yaml`  | Format the output. Values: [yaml \| json]                                   |
 | `--hash`                  | `string` |         | Print the service config hash, one per line.                                |
 | `--images`                | `bool`   |         | Print the image names, one per line.                                        |
-| `--lock-image-digests`    | `bool`   |         | Produces an override file with image digests                                |
-| `--models`                | `bool`   |         | Print the model names, one per line.                                        |
-| `--networks`              | `bool`   |         | Print the network names, one per line.                                      |
 | `--no-consistency`        | `bool`   |         | Don't check model consistency - warning: may produce invalid Compose output |
-| `--no-env-resolution`     | `bool`   |         | Don't resolve service env files                                             |
 | `--no-interpolate`        | `bool`   |         | Don't interpolate environment variables                                     |
 | `--no-normalize`          | `bool`   |         | Don't normalize compose model                                               |
 | `--no-path-resolution`    | `bool`   |         | Don't resolve file paths                                                    |
--- a/docs/reference/compose_create.md
+++ b/docs/reference/compose_create.md
@@ -16,7 +16,6 @@ Creates containers for a service
 | `--quiet-pull`     | `bool`        |          | Pull without printing progress information                                                    |
 | `--remove-orphans` | `bool`        |          | Remove containers for services not defined in the Compose file                                |
 | `--scale`          | `stringArray` |          | Scale SERVICE to NUM instances. Overrides the `scale` setting in the Compose file if present. |
-| `-y`, `--yes`      | `bool`        |          | Assume "yes" as answer to all prompts and run non-interactively                               |


 <!---MARKER_GEN_END-->
--- a/docs/reference/compose_events.md
+++ b/docs/reference/compose_events.md
@@ -23,12 +23,10 @@ The events that can be received using this can be seen [here](/reference/cli/doc

 ### Options

-| Name        | Type     | Default | Description                               |
-|:------------|:---------|:--------|:------------------------------------------|
-| `--dry-run` | `bool`   |         | Execute command in dry run mode           |
-| `--json`    | `bool`   |         | Output events as a stream of json objects |
-| `--since`   | `string` |         | Show all events created since timestamp   |
-| `--until`   | `string` |         | Stream events until this timestamp        |
+| Name        | Type   | Default | Description                               |
+|:------------|:-------|:--------|:------------------------------------------|
+| `--dry-run` | `bool` |         | Execute command in dry run mode           |
+| `--json`    | `bool` |         | Output events as a stream of json objects |


 <!---MARKER_GEN_END-->
--- a/docs/reference/compose_exec.md
+++ b/docs/reference/compose_exec.md
@@ -6,12 +6,6 @@ This is the equivalent of `docker exec` targeting a Compose service.
 With this subcommand, you can run arbitrary commands in your services. Commands allocate a TTY by default, so
 you can use a command such as `docker compose exec web sh` to get an interactive prompt.

-By default, Compose will enter container in interactive mode and allocate a TTY, while the equivalent `docker exec`
-command requires passing `--interactive --tty` flags to get the same behavior. Compose also support those two flags
-to offer a smooth migration between commands, whenever they are no-op by default. Still, `interactive` can be used to
-force disabling interactive mode (`--interactive=false`), typically when `docker compose exec` command is used inside
-a script.
-
 ### Options

 | Name              | Type          | Default | Description                                                                      |
@@ -20,7 +14,7 @@ a script.
 | `--dry-run`       | `bool`        |         | Execute command in dry run mode                                                  |
 | `-e`, `--env`     | `stringArray` |         | Set environment variables                                                        |
 | `--index`         | `int`         | `0`     | Index of the container if service has multiple replicas                          |
-| `-T`, `--no-tty`  | `bool`        | `true`  | Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY. |
+| `-T`, `--no-TTY`  | `bool`        | `true`  | Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY. |
 | `--privileged`    | `bool`        |         | Give extended privileges to the process                                          |
 | `-u`, `--user`    | `string`      |         | Run the command as this user                                                     |
 | `-w`, `--workdir` | `string`      |         | Path to workdir directory for this command                                       |
@@ -34,9 +28,3 @@ This is the equivalent of `docker exec` targeting a Compose service.

 With this subcommand, you can run arbitrary commands in your services. Commands allocate a TTY by default, so
 you can use a command such as `docker compose exec web sh` to get an interactive prompt.
-
-By default, Compose will enter container in interactive mode and allocate a TTY, while the equivalent `docker exec` 
-command requires passing `--interactive --tty` flags to get the same behavior. Compose also support those two flags
-to offer a smooth migration between commands, whenever they are no-op by default. Still, `interactive` can be used to 
-force disabling interactive mode (`--interactive=false`), typically when `docker compose exec` command is used inside 
-a script.
--- a/docs/reference/compose_ls.md
+++ b/docs/reference/compose_ls.md
@@ -11,7 +11,7 @@ Lists running Compose projects
 | `--dry-run`     | `bool`   |         | Execute command in dry run mode            |
 | `--filter`      | `filter` |         | Filter output based on conditions provided |
 | `--format`      | `string` | `table` | Format the output. Values: [table \| json] |
-| `-q`, `--quiet` | `bool`   |         | Only display project names                 |
+| `-q`, `--quiet` | `bool`   |         | Only display IDs                           |


 <!---MARKER_GEN_END-->
--- a/docs/reference/compose_publish.md
+++ b/docs/reference/compose_publish.md
@@ -1,19 +0,0 @@
-# docker compose publish
-
-<!---MARKER_GEN_START-->
-Publish compose application
-
-### Options
-
-| Name                      | Type     | Default | Description                                                                    |
-|:--------------------------|:---------|:--------|:-------------------------------------------------------------------------------|
-| `--app`                   | `bool`   |         | Published compose application (includes referenced images)                     |
-| `--dry-run`               | `bool`   |         | Execute command in dry run mode                                                |
-| `--oci-version`           | `string` |         | OCI image/artifact specification version (automatically determined by default) |
-| `--resolve-image-digests` | `bool`   |         | Pin image tags to digests                                                      |
-| `--with-env`              | `bool`   |         | Include environment variables in the published OCI artifact                    |
-| `-y`, `--yes`             | `bool`   |         | Assume "yes" as answer to all prompts                                          |
-
-
-<!---MARKER_GEN_END-->
-
--- a/docs/reference/compose_restart.md
+++ b/docs/reference/compose_restart.md
@@ -9,8 +9,8 @@ after a container is built, but before the container's command is executed) are
 after restarting.

 If you are looking to configure a service's restart policy, refer to
-[restart](https://github.com/compose-spec/compose-spec/blob/main/spec.md#restart)
-or [restart_policy](https://github.com/compose-spec/compose-spec/blob/main/deploy.md#restart_policy).
+[restart](https://github.com/compose-spec/compose-spec/blob/master/spec.md#restart)
+or [restart_policy](https://github.com/compose-spec/compose-spec/blob/master/deploy.md#restart_policy).

 ### Options

@@ -33,5 +33,5 @@ after a container is built, but before the container's command is executed) are
 after restarting.

 If you are looking to configure a service's restart policy, refer to
-[restart](https://github.com/compose-spec/compose-spec/blob/main/spec.md#restart)
-or [restart_policy](https://github.com/compose-spec/compose-spec/blob/main/deploy.md#restart_policy).
+[restart](https://github.com/compose-spec/compose-spec/blob/master/spec.md#restart)
+or [restart_policy](https://github.com/compose-spec/compose-spec/blob/master/deploy.md#restart_policy).
--- a/docs/reference/compose_run.md
+++ b/docs/reference/compose_run.md
@@ -57,33 +57,29 @@ specified in the service configuration.

 ### Options

-| Name                    | Type          | Default  | Description                                                                      |
-|:------------------------|:--------------|:---------|:---------------------------------------------------------------------------------|
-| `--build`               | `bool`        |          | Build image before starting container                                            |
-| `--cap-add`             | `list`        |          | Add Linux capabilities                                                           |
-| `--cap-drop`            | `list`        |          | Drop Linux capabilities                                                          |
-| `-d`, `--detach`        | `bool`        |          | Run container in background and print container ID                               |
-| `--dry-run`             | `bool`        |          | Execute command in dry run mode                                                  |
-| `--entrypoint`          | `string`      |          | Override the entrypoint of the image                                             |
-| `-e`, `--env`           | `stringArray` |          | Set environment variables                                                        |
-| `--env-from-file`       | `stringArray` |          | Set environment variables from file                                              |
-| `-i`, `--interactive`   | `bool`        | `true`   | Keep STDIN open even if not attached                                             |
-| `-l`, `--label`         | `stringArray` |          | Add or override a label                                                          |
-| `--name`                | `string`      |          | Assign a name to the container                                                   |
-| `-T`, `--no-TTY`        | `bool`        | `true`   | Disable pseudo-TTY allocation (default: auto-detected)                           |
-| `--no-deps`             | `bool`        |          | Don't start linked services                                                      |
-| `-p`, `--publish`       | `stringArray` |          | Publish a container's port(s) to the host                                        |
-| `--pull`                | `string`      | `policy` | Pull image before running ("always"\|"missing"\|"never")                         |
-| `-q`, `--quiet`         | `bool`        |          | Don't print anything to STDOUT                                                   |
-| `--quiet-build`         | `bool`        |          | Suppress progress output from the build process                                  |
-| `--quiet-pull`          | `bool`        |          | Pull without printing progress information                                       |
-| `--remove-orphans`      | `bool`        |          | Remove containers for services not defined in the Compose file                   |
-| `--rm`                  | `bool`        |          | Automatically remove the container when it exits                                 |
-| `-P`, `--service-ports` | `bool`        |          | Run command with all service's ports enabled and mapped to the host              |
-| `--use-aliases`         | `bool`        |          | Use the service's network useAliases in the network(s) the container connects to |
-| `-u`, `--user`          | `string`      |          | Run as specified username or uid                                                 |
-| `-v`, `--volume`        | `stringArray` |          | Bind mount a volume                                                              |
-| `-w`, `--workdir`       | `string`      |          | Working directory inside the container                                           |
+| Name                    | Type          | Default | Description                                                                      |
+|:------------------------|:--------------|:--------|:---------------------------------------------------------------------------------|
+| `--build`               | `bool`        |         | Build image before starting container                                            |
+| `--cap-add`             | `list`        |         | Add Linux capabilities                                                           |
+| `--cap-drop`            | `list`        |         | Drop Linux capabilities                                                          |
+| `-d`, `--detach`        | `bool`        |         | Run container in background and print container ID                               |
+| `--dry-run`             | `bool`        |         | Execute command in dry run mode                                                  |
+| `--entrypoint`          | `string`      |         | Override the entrypoint of the image                                             |
+| `-e`, `--env`           | `stringArray` |         | Set environment variables                                                        |
+| `-i`, `--interactive`   | `bool`        | `true`  | Keep STDIN open even if not attached                                             |
+| `-l`, `--label`         | `stringArray` |         | Add or override a label                                                          |
+| `--name`                | `string`      |         | Assign a name to the container                                                   |
+| `-T`, `--no-TTY`        | `bool`        | `true`  | Disable pseudo-TTY allocation (default: auto-detected)                           |
+| `--no-deps`             | `bool`        |         | Don't start linked services                                                      |
+| `-p`, `--publish`       | `stringArray` |         | Publish a container's port(s) to the host                                        |
+| `--quiet-pull`          | `bool`        |         | Pull without printing progress information                                       |
+| `--remove-orphans`      | `bool`        |         | Remove containers for services not defined in the Compose file                   |
+| `--rm`                  | `bool`        |         | Automatically remove the container when it exits                                 |
+| `-P`, `--service-ports` | `bool`        |         | Run command with all service's ports enabled and mapped to the host              |
+| `--use-aliases`         | `bool`        |         | Use the service's network useAliases in the network(s) the container connects to |
+| `-u`, `--user`          | `string`      |         | Run as specified username or uid                                                 |
+| `-v`, `--volume`        | `stringArray` |         | Bind mount a volume                                                              |
+| `-w`, `--workdir`       | `string`      |         | Working directory inside the container                                           |


 <!---MARKER_GEN_END-->
--- a/docs/reference/compose_stats.md
+++ b/docs/reference/compose_stats.md
@@ -5,13 +5,13 @@ Display a live stream of container(s) resource usage statistics

 ### Options

-| Name          | Type     | Default | Description                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-|:--------------|:---------|:--------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `-a`, `--all` | `bool`   |         | Show all containers (default shows just running)                                                                                                                                                                                                                                                                                                                                                                                             |
-| `--dry-run`   | `bool`   |         | Execute command in dry run mode                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `--format`    | `string` |         | Format output using a custom template:<br>'table':            Print output in table format with column headers (default)<br>'table TEMPLATE':   Print output in table format using the given Go template<br>'json':             Print in JSON format<br>'TEMPLATE':         Print output using the given Go template.<br>Refer to https://docs.docker.com/engine/cli/formatting/ for more information about formatting output with templates |
-| `--no-stream` | `bool`   |         | Disable streaming stats and only pull the first result                                                                                                                                                                                                                                                                                                                                                                                       |
-| `--no-trunc`  | `bool`   |         | Do not truncate output                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| Name          | Type     | Default | Description                                                                                                                                                                                                                                                                                                                                                                                                                          |
+|:--------------|:---------|:--------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `-a`, `--all` | `bool`   |         | Show all containers (default shows just running)                                                                                                                                                                                                                                                                                                                                                                                     |
+| `--dry-run`   | `bool`   |         | Execute command in dry run mode                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `--format`    | `string` |         | Format output using a custom template:<br>'table':            Print output in table format with column headers (default)<br>'table TEMPLATE':   Print output in table format using the given Go template<br>'json':             Print in JSON format<br>'TEMPLATE':         Print output using the given Go template.<br>Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates |
+| `--no-stream` | `bool`   |         | Disable streaming stats and only pull the first result                                                                                                                                                                                                                                                                                                                                                                               |
+| `--no-trunc`  | `bool`   |         | Do not truncate output                                                                                                                                                                                                                                                                                                                                                                                                               |


 <!---MARKER_GEN_END-->
--- a/docs/reference/compose_up.md
+++ b/docs/reference/compose_up.md
@@ -44,7 +44,6 @@ If the process is interrupted using `SIGINT` (ctrl + C) or `SIGTERM`, the contai
 | `--no-recreate`                | `bool`        |          | If containers already exist, don't recreate them. Incompatible with --force-recreate.                                                               |
 | `--no-start`                   | `bool`        |          | Don't start the services after creating them                                                                                                        |
 | `--pull`                       | `string`      | `policy` | Pull image before running ("always"\|"missing"\|"never")                                                                                            |
-| `--quiet-build`                | `bool`        |          | Suppress the build output                                                                                                                           |
 | `--quiet-pull`                 | `bool`        |          | Pull without printing progress information                                                                                                          |
 | `--remove-orphans`             | `bool`        |          | Remove containers for services not defined in the Compose file                                                                                      |
 | `-V`, `--renew-anon-volumes`   | `bool`        |          | Recreate anonymous volumes instead of retrieving data from the previous containers                                                                  |
@@ -54,7 +53,6 @@ If the process is interrupted using `SIGINT` (ctrl + C) or `SIGTERM`, the contai
 | `--wait`                       | `bool`        |          | Wait for services to be running\|healthy. Implies detached mode.                                                                                    |
 | `--wait-timeout`               | `int`         | `0`      | Maximum duration in seconds to wait for the project to be running\|healthy                                                                          |
 | `-w`, `--watch`                | `bool`        |          | Watch source code and rebuild/refresh containers when files are updated.                                                                            |
-| `-y`, `--yes`                  | `bool`        |          | Assume "yes" as answer to all prompts and run non-interactively                                                                                     |


 <!---MARKER_GEN_END-->
--- a/docs/reference/compose_volumes.md
+++ b/docs/reference/compose_volumes.md
@@ -1,16 +0,0 @@
-# docker compose volumes
-
-<!---MARKER_GEN_START-->
-List volumes
-
-### Options
-
-| Name            | Type     | Default | Description                                                                                                                                                                                                                                                                                                                                                                                                                          |
-|:----------------|:---------|:--------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `--dry-run`     | `bool`   |         | Execute command in dry run mode                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `--format`      | `string` | `table` | Format output using a custom template:<br>'table':            Print output in table format with column headers (default)<br>'table TEMPLATE':   Print output in table format using the given Go template<br>'json':             Print in JSON format<br>'TEMPLATE':         Print output using the given Go template.<br>Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates |
-| `-q`, `--quiet` | `bool`   |         | Only display volume names                                                                                                                                                                                                                                                                                                                                                                                                            |
-
-
-<!---MARKER_GEN_END-->
-
--- a/docs/reference/compose_watch.md
+++ b/docs/reference/compose_watch.md
@@ -9,7 +9,7 @@ Watch build context for service and rebuild/refresh containers when files are up
 |:------------|:-------|:--------|:----------------------------------------------|
 | `--dry-run` | `bool` |         | Execute command in dry run mode               |
 | `--no-up`   | `bool` |         | Do not build & start services before watching |
-| `--prune`   | `bool` | `true`  | Prune dangling images on rebuild              |
+| `--prune`   | `bool` |         | Prune dangling images on rebuild              |
 | `--quiet`   | `bool` |         | hide build output                             |


--- a/docs/reference/docker_compose.yaml
+++ b/docs/reference/docker_compose.yaml
@@ -6,7 +6,6 @@ pname: docker
 plink: docker.yaml
 cname:
    - docker compose attach
-    - docker compose bridge
    - docker compose build
    - docker compose commit
    - docker compose config
@@ -23,7 +22,6 @@ cname:
    - docker compose pause
    - docker compose port
    - docker compose ps
-    - docker compose publish
    - docker compose pull
    - docker compose push
    - docker compose restart
@@ -37,12 +35,10 @@ cname:
    - docker compose unpause
    - docker compose up
    - docker compose version
-    - docker compose volumes
    - docker compose wait
    - docker compose watch
 clink:
    - docker_compose_attach.yaml
-    - docker_compose_bridge.yaml
    - docker_compose_build.yaml
    - docker_compose_commit.yaml
    - docker_compose_config.yaml
@@ -59,7 +55,6 @@ clink:
    - docker_compose_pause.yaml
    - docker_compose_port.yaml
    - docker_compose_ps.yaml
-    - docker_compose_publish.yaml
    - docker_compose_pull.yaml
    - docker_compose_push.yaml
    - docker_compose_restart.yaml
@@ -73,7 +68,6 @@ clink:
    - docker_compose_unpause.yaml
    - docker_compose_up.yaml
    - docker_compose_version.yaml
-    - docker_compose_volumes.yaml
    - docker_compose_wait.yaml
    - docker_compose_watch.yaml
 options:
@@ -171,6 +165,7 @@ options:
      swarm: false
    - option: progress
      value_type: string
+      default_value: auto
      description: Set type of progress output (auto, tty, plain, json, quiet)
      deprecated: false
      hidden: false
@@ -234,7 +229,7 @@ options:
      swarm: false
 examples: |-
    ### Use `-f` to specify the name and path of one or more Compose files
-    Use the `-f` flag to specify the location of a Compose [configuration file](/reference/compose-file/).
+    Use the `-f` flag to specify the location of a Compose configuration file.

    #### Specifying multiple Compose files
    You can supply multiple `-f` configuration files. When you supply multiple files, Compose combines them into a single
@@ -244,10 +239,10 @@ examples: |-
    For example, consider this command line:

    ```console
-    $ docker compose -f compose.yaml -f compose.admin.yaml run backup_db
+    $ docker compose -f docker-compose.yml -f docker-compose.admin.yml run backup_db
    ```

-    The `compose.yaml` file might specify a `webapp` service.
+    The `docker-compose.yml` file might specify a `webapp` service.

    ```yaml
    services:
@@ -258,7 +253,7 @@ examples: |-
        volumes:
          - "/data"
    ```
-    If the `compose.admin.yaml` also specifies this same service, any matching fields override the previous file.
+    If the `docker-compose.admin.yml` also specifies this same service, any matching fields override the previous file.
    New values, add to the `webapp` service configuration.

    ```yaml
--- a/docs/reference/docker_compose_alpha_generate.yaml
+++ b/docs/reference/docker_compose_alpha_generate.yaml
@@ -45,7 +45,7 @@ inherited_options:
      kubernetes: false
      swarm: false
 deprecated: false
-hidden: true
+hidden: false
 experimental: false
 experimentalcli: true
 kubernetes: false
--- a/docs/reference/docker_compose_alpha_publish.yaml
+++ b/docs/reference/docker_compose_alpha_publish.yaml
@@ -5,20 +5,10 @@ usage: docker compose alpha publish [OPTIONS] REPOSITORY[:TAG]
 pname: docker compose alpha
 plink: docker_compose_alpha.yaml
 options:
-    - option: app
-      value_type: bool
-      default_value: "false"
-      description: Published compose application (includes referenced images)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
    - option: oci-version
      value_type: string
      description: |
-        OCI image/artifact specification version (automatically determined by default)
+        OCI Image/Artifact specification version (automatically determined by default)
      deprecated: false
      hidden: false
      experimental: false
@@ -35,27 +25,6 @@ options:
      experimentalcli: false
      kubernetes: false
      swarm: false
-    - option: with-env
-      value_type: bool
-      default_value: "false"
-      description: Include environment variables in the published OCI artifact
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: "yes"
-      shorthand: "y"
-      value_type: bool
-      default_value: "false"
-      description: Assume "yes" as answer to all prompts
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
 inherited_options:
    - option: dry-run
      value_type: bool
@@ -68,7 +37,7 @@ inherited_options:
      kubernetes: false
      swarm: false
 deprecated: false
-hidden: true
+hidden: false
 experimental: false
 experimentalcli: true
 kubernetes: false
--- a/docs/reference/docker_compose_alpha_viz.yaml
+++ b/docs/reference/docker_compose_alpha_viz.yaml
@@ -69,7 +69,7 @@ inherited_options:
      kubernetes: false
      swarm: false
 deprecated: false
-hidden: true
+hidden: false
 experimental: false
 experimentalcli: true
 kubernetes: false
--- a/docs/reference/docker_compose_bridge.yaml
+++ b/docs/reference/docker_compose_bridge.yaml
@@ -1,29 +0,0 @@
-command: docker compose bridge
-short: Convert compose files into another model
-long: Convert compose files into another model
-pname: docker compose
-plink: docker_compose.yaml
-cname:
-    - docker compose bridge convert
-    - docker compose bridge transformations
-clink:
-    - docker_compose_bridge_convert.yaml
-    - docker_compose_bridge_transformations.yaml
-inherited_options:
-    - option: dry-run
-      value_type: bool
-      default_value: "false"
-      description: Execute command in dry run mode
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-deprecated: false
-hidden: false
-experimental: false
-experimentalcli: false
-kubernetes: false
-swarm: false
-
--- a/docs/reference/docker_compose_bridge_convert.yaml
+++ b/docs/reference/docker_compose_bridge_convert.yaml
@@ -1,59 +0,0 @@
-command: docker compose bridge convert
-short: |
-    Convert compose files to Kubernetes manifests, Helm charts, or another model
-long: |
-    Convert compose files to Kubernetes manifests, Helm charts, or another model
-usage: docker compose bridge convert
-pname: docker compose bridge
-plink: docker_compose_bridge.yaml
-options:
-    - option: output
-      shorthand: o
-      value_type: string
-      default_value: out
-      description: The output directory for the Kubernetes resources
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: templates
-      value_type: string
-      description: Directory containing transformation templates
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: transformation
-      shorthand: t
-      value_type: stringArray
-      default_value: '[]'
-      description: |
-        Transformation to apply to compose model (default: docker/compose-bridge-kubernetes)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-inherited_options:
-    - option: dry-run
-      value_type: bool
-      default_value: "false"
-      description: Execute command in dry run mode
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-deprecated: false
-hidden: false
-experimental: false
-experimentalcli: false
-kubernetes: false
-swarm: false
-
--- a/docs/reference/docker_compose_bridge_transformations.yaml
+++ b/docs/reference/docker_compose_bridge_transformations.yaml
@@ -1,29 +0,0 @@
-command: docker compose bridge transformations
-short: Manage transformation images
-long: Manage transformation images
-pname: docker compose bridge
-plink: docker_compose_bridge.yaml
-cname:
-    - docker compose bridge transformations create
-    - docker compose bridge transformations list
-clink:
-    - docker_compose_bridge_transformations_create.yaml
-    - docker_compose_bridge_transformations_list.yaml
-inherited_options:
-    - option: dry-run
-      value_type: bool
-      default_value: "false"
-      description: Execute command in dry run mode
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-deprecated: false
-hidden: false
-experimental: false
-experimentalcli: false
-kubernetes: false
-swarm: false
-
--- a/docs/reference/docker_compose_bridge_transformations_create.yaml
+++ b/docs/reference/docker_compose_bridge_transformations_create.yaml
@@ -1,36 +0,0 @@
-command: docker compose bridge transformations create
-short: Create a new transformation
-long: Create a new transformation
-usage: docker compose bridge transformations create [OPTION] PATH
-pname: docker compose bridge transformations
-plink: docker_compose_bridge_transformations.yaml
-options:
-    - option: from
-      shorthand: f
-      value_type: string
-      description: |
-        Existing transformation to copy (default: docker/compose-bridge-kubernetes)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-inherited_options:
-    - option: dry-run
-      value_type: bool
-      default_value: "false"
-      description: Execute command in dry run mode
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-deprecated: false
-hidden: false
-experimental: false
-experimentalcli: false
-kubernetes: false
-swarm: false
-
--- a/docs/reference/docker_compose_bridge_transformations_list.yaml
+++ b/docs/reference/docker_compose_bridge_transformations_list.yaml
@@ -1,47 +0,0 @@
-command: docker compose bridge transformations list
-aliases: docker compose bridge transformations list, docker compose bridge transformations ls
-short: List available transformations
-long: List available transformations
-usage: docker compose bridge transformations list
-pname: docker compose bridge transformations
-plink: docker_compose_bridge_transformations.yaml
-options:
-    - option: format
-      value_type: string
-      default_value: table
-      description: 'Format the output. Values: [table | json]'
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: quiet
-      shorthand: q
-      value_type: bool
-      default_value: "false"
-      description: Only display transformer names
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-inherited_options:
-    - option: dry-run
-      value_type: bool
-      default_value: "false"
-      description: Execute command in dry run mode
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-deprecated: false
-hidden: false
-experimental: false
-experimentalcli: false
-kubernetes: false
-swarm: false
-
--- a/Show More
+++ b/Show More