feat: test wildcards

fix: executor and formatter tests
feat: remove entrypoint from the executor
2026-05-18 21:26:37 +02:00 · 2025-08-11 12:00:34 +00:00 · 2025-08-11 12:00:34 +00:00 · 2025-08-11 12:00:34 +00:00 · 2025-08-11 12:00:34 +00:00 · 2025-08-11 12:00:34 +00:00
359 changed files with 22730 additions and 26135 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -8,6 +8,6 @@ charset = utf-8
 trim_trailing_whitespace = true
 indent_style = tab

-[*.{md,mdx,yml,yaml,json,toml,htm,html,js,ts,vue,css,svg,sh,bash,fish}]
+[*.{md,mdx,yml,yaml,json,toml,htm,html,js,ts,css,svg,sh,bash,fish}]
 indent_style = space
 indent_size = 2
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,5 +1,2 @@
 * text=auto
 *.mdx -linguist-detectable
-
-# Keep LF line endings in testdata for consistent checksums across platforms
-testdata/** text eol=lf
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -7,5 +7,3 @@ Please understand that it may take some time to be reviewed.
 Also, make sure to follow the [Contribution Guide](https://taskfile.dev/contributing/).

 -->
-
- [ ] I have read and followed the [Contribution Guide](https://taskfile.dev/contributing/)
--- a/.github/renovate.json
+++ b/.github/renovate.json
@@ -8,17 +8,6 @@
  ],
  "mode": "full",
  "addLabels":["area: dependencies"],
-  "customManagers": [
-    {
-      "customType": "regex",
-      "fileMatch": ["^\\.github/workflows/.*\\.ya?ml$"],
-      "matchStrings": [
-        "uses:\\s*golangci/golangci-lint-action@\\S+\\s+with:\\s+version:\\s*(?<currentValue>v[\\d.]+)"
-      ],
-      "datasourceTemplate": "github-releases",
-      "depNameTemplate": "golangci/golangci-lint"
-    }
-  ],
  "packageRules": [
    {
      "matchManagers": ["github-actions"],
--- a/.github/workflows/issue-awaiting-response.yml
+++ b/.github/workflows/issue-awaiting-response.yml
@@ -4,16 +4,13 @@ on:
  issue_comment:
    types: [created]

-permissions:
-  issues: write
-
 jobs:
  issue-awaiting-response:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            const issue = await github.rest.issues.get({
              owner: context.repo.owner,
--- a/.github/workflows/issue-closed.yml
+++ b/.github/workflows/issue-closed.yml
@@ -4,16 +4,13 @@ on:
  issues:
    types: [closed]

-permissions:
-  issues: write
-
 jobs:
  issue-closed:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            const labels = await github.paginate(
              github.rest.issues.listLabelsOnIssue, {
--- a/.github/workflows/issue-experiment.yml
+++ b/.github/workflows/issue-experiment.yml
@@ -2,19 +2,16 @@ name: issue experiment

 on:
  issues:
-    types: [field_added]
-
-permissions:
-  issues: write
+    types: [labeled]

 jobs:
-  issue-experiment-proposal:
-    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'proposal'
+  issue-experiment-proposed:
+    if: github.event.label.name == format('status{0} proposed', ':')
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
@@ -23,12 +20,12 @@ jobs:
              body: 'This issue has been marked as an experiment proposal! :test_tube: It will now enter a period of consultation during which we encourage the community to provide feedback on the proposed design. Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
            })
  issue-experiment-draft:
-    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'draft'
+    if: github.event.label.name == format('status{0} draft', ':')
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
@@ -37,12 +34,12 @@ jobs:
              body: 'This experiment has been marked as a draft! :sparkles: This means that an initial implementation has been added to the latest release of Task! You can find information about this experiment and how to enable it in our [experiments documentation](https://taskfile.dev/experiments). Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
            })
  issue-experiment-candidate:
-    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'candidate'
+    if: github.event.label.name == format('status{0} candidate', ':')
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
@@ -51,12 +48,12 @@ jobs:
              body: 'This experiment has been marked as a candidate! :fire: This means that the  implementation is nearing completion and we are entering a period for final comments and feedback! You can find information about this experiment and how to enable it in our [experiments documentation](https://taskfile.dev/experiments). Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
            })
  issue-experiment-stable:
-    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'stable'
+    if: github.event.label.name == format('status{0} stable', ':')
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
@@ -65,12 +62,12 @@ jobs:
              body: 'This experiment has been marked as stable! :metal: This means that the  implementation is now final and ready to be released. No more changes will be made and the experiment is safe to use in production! You can find information about this experiment and how to enable it in our [experiments documentation](https://taskfile.dev/experiments). Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
            })
  issue-experiment-released:
-    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'released'
+    if: github.event.label.name == format('status{0} released', ':')
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
@@ -85,12 +82,12 @@ jobs:
              state: 'closed'
            })
  issue-experiment-abandoned:
-    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'abandoned'
+    if: github.event.label.name == format('status{0} abandoned', ':')
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
@@ -105,12 +102,12 @@ jobs:
              state: 'closed'
            })
  issue-experiment-superseded:
-    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'superseded'
+    if: github.event.label.name == format('status{0} superseded', ':')
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
--- a/.github/workflows/issue-needs-triage.yml
+++ b/.github/workflows/issue-needs-triage.yml
@@ -4,16 +4,13 @@ on:
  issues:
    types: [opened]

-permissions:
-  issues: write
-
 jobs:
  issue-needs-triage:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      - uses: actions/github-script@v7
        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
+          github-token: ${{secrets.GH_PAT}}
          script: |
            const labels = await github.paginate(
              github.rest.issues.listLabelsOnIssue, {
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -8,39 +8,67 @@ on:
    branches:
      - main

-permissions:
-  contents: read
-
 jobs:
  lint:
    name: Lint
    strategy:
      matrix:
-        go-version: [1.25.x, 1.26.x]
+        go-version: [1.23.x, 1.24.x]
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{matrix.go-version}}

-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v4

      - name: golangci-lint
-        uses: golangci/golangci-lint-action@1e7e51e771db61008b38414a730f564565cf7c20 # v9.2.0
+        uses: golangci/golangci-lint-action@v8
        with:
-          version: v2.11.4
+          version: v2.1.0

  lint-jsonschema:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+      - uses: actions/setup-python@v5
        with:
-          python-version: 3.14
+          python-version: 3.12

-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@v4

      - name: install check-jsonschema
        run: python -m pip install 'check-jsonschema==0.27.3'

      - name: check-jsonschema (metaschema)
-        run: check-jsonschema --check-metaschema website/src/public/schema.json
+        run: check-jsonschema --check-metaschema website/static/schema.json
+  check_doc:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files in the docs folder
+        id: changed-files-specific
+        uses: tj-actions/changed-files@v46
+        with:
+          files: website/versioned_docs/**
+
+      - uses: actions/github-script@v7
+        if: steps.changed-files-specific.outputs.any_changed == 'true'
+        with:
+          script: |
+            core.setFailed('website/versioned_docs has changed. Instead you need to update the docs in the website/docs folder.')
+  check_schema:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files in the docs folder
+        id: changed-files-specific
+        uses: tj-actions/changed-files@v46
+        with:
+          files: |
+            website/static/schema.json
+            website/static/schema-taskrc.json
+      - uses: actions/github-script@v7
+        if: steps.changed-files-specific.outputs.any_changed == 'true'
+        with:
+          script: |
+            core.setFailed('schema.json or schema-taskrc.json has changed. Instead you need to update next-schema.json or next-schema-taskrc.json.')
--- a/.github/workflows/pr-build.yml
+++ b/.github/workflows/pr-build.yml
@@ -1,69 +0,0 @@
-name: PR Build
-
-on:
-  pull_request_target:
-    types: [labeled, synchronize]
-
-permissions:
-  contents: read
-  pull-requests: write
-
-jobs:
-  build:
-    if: contains(github.event.pull_request.labels.*.name, 'needs-build')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          fetch-depth: 0
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
-        with:
-          go-version: "1.26.x"
-          cache: true
-      - uses: goreleaser/goreleaser-action@ec59f474b9834571250b370d4735c50f8e2d1e29 # v7
-        with:
-          version: "~> v2"
-          args: release --snapshot --clean --config .goreleaser-pr.yml
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: task_linux_amd64
-          path: dist/task_linux_amd64.tar.gz
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: task_linux_arm64
-          path: dist/task_linux_arm64.tar.gz
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: task_darwin_amd64
-          path: dist/task_darwin_amd64.tar.gz
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: task_darwin_arm64
-          path: dist/task_darwin_arm64.tar.gz
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: task_windows_amd64
-          path: dist/task_windows_amd64.zip
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: checksums
-          path: dist/task_checksums.txt
-      - uses: peter-evans/find-comment@b30e6a3c0ed37e7c023ccd3f1db5c6c0b0c23aad # v4.0.0
-        id: find-comment
-        with:
-          token: ${{secrets.GITHUB_TOKEN}}
-          issue-number: ${{ github.event.pull_request.number }}
-          body-includes: "📦 Build artifacts ready!"
-      - uses: peter-evans/create-or-update-comment@e8674b075228eee787fea43ef493e45ece1004c9 # v5.0.0
-        with:
-          token: ${{secrets.GITHUB_TOKEN}}
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          issue-number: ${{ github.event.pull_request.number }}
-          body: |
-            ## 📦 Build artifacts ready!
-
-            Download binaries from [this workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}).
-
-            Available platforms: Linux, macOS, Windows (amd64, arm64)
-          edit-mode: replace
--- a/.github/workflows/release-nightly.yml
+++ b/.github/workflows/release-nightly.yml
@@ -1,34 +1,29 @@
-name: Release nightly
+name: Realease nightly

 on:
  workflow_dispatch:
  schedule:
    - cron: 0 0 * * *
-
-permissions:
-  contents: write
-
 jobs:
  goreleaser:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Set up Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@v5
        with:
-          go-version: 1.26.x
+          go-version: 1.24.x

      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@ec59f474b9834571250b370d4735c50f8e2d1e29 # v7
+        uses: goreleaser/goreleaser-action@v6
        with:
          distribution: goreleaser-pro
          version: latest
          args: release --clean --nightly -f .goreleaser-nightly.yml
        env:
-          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          GITHUB_TOKEN: ${{secrets.GH_PAT}}
          GORELEASER_KEY: ${{secrets.GORELEASER_KEY}}
-          CLOUDSMITH_TOKEN: ${{secrets.CLOUDSMITH_TOKEN}}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -3,57 +3,28 @@ name: goreleaser
 on:
  push:
    tags:
-      - "v*"
-
-permissions:
-  id-token: write # Required for OIDC
-  contents: write
+      - 'v*'

 jobs:
  goreleaser:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Set up Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@v5
        with:
-          go-version: 1.26.x
-
-      - uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
-        with:
-          node-version: "24"
-          registry-url: "https://registry.npmjs.org"
-
-      - name: Update npm
-        run: npm install -g npm@latest
-
-      - name: Install Task
-        uses: go-task/setup-task@3be4020d41929789a01026e0e427a4321ce0ad44 # v2
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v5
-        with:
-          package_json_file: "website/package.json"
-          run_install: "true"
+          go-version: 1.24.x

      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@ec59f474b9834571250b370d4735c50f8e2d1e29 # v7
+        uses: goreleaser/goreleaser-action@v6
        with:
          distribution: goreleaser-pro
          version: latest
          args: release --clean --draft
        env:
-          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          GITHUB_TOKEN: ${{secrets.GH_PAT}}
          GORELEASER_KEY: ${{secrets.GORELEASER_KEY}}
-          CLOUDSMITH_TOKEN: ${{secrets.CLOUDSMITH_TOKEN}}
-
-      - name: Deploy Website
-        shell: bash
-        run: |
-          task website:deploy:prod
-        env:
-          NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
--- a/.github/workflows/security.yml
+++ b/.github/workflows/security.yml
@@ -1,19 +0,0 @@
-name: Security
-
-on:
-  pull_request:
-  push:
-    tags:
-      - v*
-    branches:
-      - main
-
-permissions:
-  contents: read
-
-jobs:
-  govulncheck:
-    name: govulncheck
-    runs-on: ubuntu-latest
-    steps:
-      - uses: golang/govulncheck-action@b625fbe08f3bccbe446d94fbf87fcc875a4f50ee # v1.0.4
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -8,26 +8,31 @@ on:
    branches:
      - main

-permissions:
-  contents: read
-
 jobs:
  test:
    name: Test
    strategy:
-      fail-fast: false
      matrix:
-        go-version: [1.25.x, 1.26.x]
+        go-version: [1.23.x, 1.24.x]
        platform: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{matrix.platform}}
    steps:
-      - name: Check out code
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
      - name: Set up Go ${{matrix.go-version}}
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@v5
        with:
          go-version: ${{matrix.go-version}}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v4
+
+      - name: Download Go modules
+        run: go mod download
+        env:
+          GOPROXY: https://proxy.golang.org
+
+      - name: Build
+        run: go build -o ./bin/task -v ./cmd/task

      - name: Test
-        run: go run ./cmd/task test
+        run: ./bin/task test --output=group --output-group-begin='::group::{{.TASK}}' --output-group-end='::endgroup::'
--- a/.gitignore
+++ b/.gitignore
@@ -35,4 +35,3 @@ tags
 /testdata/vars/v1
 /tmp
 node_modules
-website/.netlify/
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -33,7 +33,6 @@ formatters:
 linters:
  enable:
    - depguard
-    - gosec
    - mirror
    - misspell
    - noctx
@@ -42,9 +41,6 @@ linters:
    - tparallel
    - usetesting
  settings:
-    gosec:
-      excludes:
-        - G306
    depguard:
      rules:
        main:
--- a/.goreleaser-pr.yml
+++ b/.goreleaser-pr.yml
@@ -1,31 +0,0 @@
-# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
-version: 2
-
-builds:
-  - binary: task
-    main: ./cmd/task
-    goos: [windows, darwin, linux]
-    goarch: [amd64, arm64]
-    env:
-      - CGO_ENABLED=0
-    mod_timestamp: '{{ .CommitTimestamp }}'
-    flags:
-      - -trimpath
-    ldflags:
-      - "-s -w"
-
-archives:
-  - name_template: '{{.Binary}}_{{.Os}}_{{.Arch}}'
-    files:
-      - README.md
-      - LICENSE
-      - completion/**/*
-    format_overrides:
-      - goos: windows
-        formats: [zip]
-
-snapshot:
-  version_template: 'pr-{{ .ShortCommit }}'
-
-checksum:
-  name_template: 'task_checksums.txt'
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -22,8 +22,6 @@ builds:
        goarch: '386'
      - goos: darwin
        goarch: riscv64
-      - goos: windows
-        goarch: arm
      - goos: windows
        goarch: riscv64
    env:
@@ -62,7 +60,7 @@ nfpms:
  - vendor: Task
    homepage: https://taskfile.dev
    maintainer: The Task authors <task@taskfile.dev>
-    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+    description: Simple task runner written in Go
    section: golang
    license: MIT
    conflicts:
@@ -70,8 +68,7 @@ nfpms:
    formats:
      - deb
      - rpm
-      - apk
-    file_name_template: '{{.ProjectName}}_{{.Version}}_{{.Os}}_{{.Arch}}'
+    file_name_template: '{{.ProjectName}}_{{.Os}}_{{.Arch}}'
    contents:
      - src: completion/bash/task.bash
        dst: /etc/bash_completion.d/task
@@ -82,14 +79,13 @@ nfpms:

 brews:
  - name: go-task
-    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+    description: Task runner / simpler Make alternative written in Go
    license: MIT
    homepage: https://taskfile.dev
    directory: Formula
    repository:
      owner: go-task
      name: homebrew-tap
-      token: "{{secrets.GH_GORELEASER_TOKEN}}" # So that it runs as the task-bot user
    test: system "#{bin}/task", "--help"
    install: |-
      bin.install "task"
@@ -103,8 +99,8 @@ brews:
 winget:
  - name: Task
    publisher: Task
-    short_description: The modern task runner.
-    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+    short_description: A task runner / simpler Make alternative written in Go
+    description: Task is a task runner / build tool that aims to be simpler and easier to use than, for example, GNU Make.
    license: MIT
    homepage: https://taskfile.dev/
    publisher_url: https://taskfile.dev/
@@ -130,8 +126,7 @@ winget:
    repository:
      owner: go-task
      name: winget-pkgs
-      branch: 'task-{{.Version}}'
-      token: "{{secrets.GH_GORELEASER_TOKEN}}" # So that it runs as the task-bot user
+      branch: 'chore/task-{{.Version}}'
      pull_request:
        enabled: true
        draft: false
@@ -140,37 +135,3 @@ winget:
          owner: microsoft
          name: winget-pkgs
          branch: master
-        body: |
-          /cc @andreynering @pd93 @vmaerten
-
-npms:
-  - name: "@go-task/cli"
-    repository: "git+https://github.com/go-task/task.git"
-    bugs: https://github.com/go-task/task/issues
-    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
-    homepage: https://taskfile.dev
-    license: MIT
-    author: "The Task authors"
-    access: public
-    keywords:
-      - "task"
-      - "taskfile"
-      - "build-tool"
-      - "task-runner"
-
-cloudsmiths:
-  - organization: "task"
-    repository: "{{if not .IsNightly}}task{{end}}"
-    formats:
-      - deb
-      - rpm
-      - apk
-    distributions:
-      deb:
-        - "any-distro/any-version"
-      rpm:
-        - "any-distro/any-version"
-      alpine:
-        - "alpine/any-version"
-    component: main
-    republish: true
--- a/.nvmrc
+++ b/.nvmrc
@@ -0,0 +1 @@
+22.18.0
--- a/.vscode/settings-sample.json
+++ b/.vscode/settings-sample.json
@@ -1,12 +1,15 @@
 {
  "yaml.schemas": {
-    "./website/src/public/schema.json": [
-        "Taskfile.yml",
-        "Taskfile.yaml",
-        "taskfile.yml",
-        "taskfile.yaml"
+    "./website/static/schema.json": [
+      "Taskfile.yml",
+      "tmp/**/*.yml"
    ]
  },
+  "search.exclude": {
+    "**/versioned_docs": true,
+    "**/versioned_sidesbars": true,
+    "**/i18n": true
+  },
  "gopls": {
      "formatting.local": "github.com/go-task"
  },
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,243 +1,5 @@
 # Changelog

-## v3.50.0 - 2026-04-13
-
- Added `enum.ref` support in `requires`: enum constraints can now reference
-  variables or template pipelines (e.g., `ref: .ALLOWED_ENVS`) instead of
-  duplicating static lists. Combined with `sh:` variables, this enables fully
-  dynamic enum validation (#2678 by @vmaerten).
- Fixed Fish completion using hardcoded `task` binary name instead of
-  `$GO_TASK_PROGNAME` for experiments cache (#2730, #2727 by @SergioChan).
- Fixed watch mode ignoring SIGHUP signal, causing the watcher to exit instead
-  of restarting (#2764, #2642).
- Fixed a long time bug where the task wouldn't re-run as it should when using
-  `method: timestamp` and the files listed on `generates:` were deleted.
-  This makes `method: timestamp` behaves the same as `method: checksum`
-  (#1230, #2716 by @drichardson).
-
-## v3.49.1 - 2026-03-08
-
-* Reverted #2632 for now, which caused some regressions. That change will be
-  reworked (#2720, #2722, #2723).
-
-## v3.49.0 - 2026-03-07
-
- Fixed included Taskfiles with `watch: true` not triggering watch mode when
-  called from the root Taskfile (#2686, #1763 by @trulede).
- Fixed Remote Git Taskfiles failing on Windows due to backslashes in URL paths
-  (#2656 by @Trim21).
- Fixed remote Git Taskfiles timing out when resolving includes after accepting
-  the trust prompt (#2669, #2668 by @vmaerten).
- Fixed unclear error message when Taskfile search stops at a directory
-  ownership boundary (#2682, #1683 by @trulede).
- Fixed global variables from imported Taskfiles not resolving `ref:` values
-  correctly (#2632 by @trulede).
- Every `.taskrc.yml` option can now be overridden with a `TASK_`-prefixed
-  environment variable, making CI and container configuration easier (#2607,
-  #1066 by @vmaerten).
-
-## v3.48.0 - 2026-01-26
-
- Fixed `if:` conditions when using to check dynamic variables. Also, skip
-  variable prompt if task would be skipped by `if:` (#2658, #2660 by @vmaerten).
- Fixed `ROOT_TASKFILE` variable pointing to directory instead of the actual
-  Taskfile path when no explicit `-t` flag is provided (#2635, #1706 by
-  @trulede).
- Included Taskfiles with `silent: true` now properly propagate silence to their
-  tasks, while still allowing individual tasks to override with `silent: false`
-  (#2640, #1319 by @trulede).
- Added TLS certificate options for Remote Taskfiles: use `--cacert` for
-  self-signed certificates and `--cert`/`--cert-key` for mTLS authentication
-  (#2537, #2242 by @vmaerten).
-
-## v3.47.0 - 2026-01-24
-
- Fixed remote git Taskfiles: cloning now works without explicit ref, and
-  directory includes are properly resolved (#2602 by @vmaerten).
- For `output: prefixed`, print `prefix:` if set instead of task name (#1566,
-  #2633 by @trulede).
- Ensure no ANSI sequences are printed for `--color=false` (#2560, #2584 by
-  @trulede).
- Task aliases can now contain wildcards and will match accordingly (e.g., `s-*`
-  as alias for `start-*`) (#1900, #2234 by @vmaerten).
- Added conditional execution with the `if` field: skip tasks, commands, or task
-  calls based on shell exit codes or template expressions like
-  `{{ eq .ENV "prod" }}` (#2564, #608 by @vmaerten).
- Task can now interactively prompt for missing required variables when running
-  in a TTY, with support for enum selection menus. Enable with `--interactive`
-  flag or `interactive: true` in `.taskrc.yml` (#2579, #2079 by @vmaerten).
-
-## v3.46.4 - 2025-12-24
-
- Fixed regressions in completion script for Fish (#2591, #2604, #2592 by
-  @WinkelCode).
-
-## v3.46.3 - 2025-12-19
-
- Fixed regression in completion script for zsh (#2593, #2594 by @vmaerten).
-
-## v3.46.2 - 2025-12-18
-
- Fixed a regression on previous release that affected variables passed via
-  command line (#2588, #2589 by @vmaerten).
-
-## v3.46.1 - 2025-12-18
-
-### ✨ Features
-
- A small behavior change was made to dependencies. Task will now wait for all
-  dependencies to finish running before continuing, even if any of them fail. To
-  opt for the previous behavior, set `failfast: true` either on your
-  `.taskrc.yml` or per task, or use the `--failfast` flag, which will also work
-  for `--parallel` (#1246, #2525 by @andreynering).
- The `--summary` flag now displays `vars:` (both global and task-level),
-  `env:`, and `requires:` sections. Dynamic variables show their shell command
-  (e.g., `sh: echo "hello"`) instead of the evaluated value (#2486 ,#2524 by
-  @vmaerten).
- Improved performance of fuzzy task name matching by implementing lazy
-  initialization. Added `--disable-fuzzy` flag and `disable-fuzzy` taskrc option
-  to allow disabling fuzzy matching entirely (#2521, #2523 by @vmaerten).
- Added LLM-optimized documentation via VitePress plugin, generating `llms.txt`
-  and `llms-full.txt` for AI-powered development tools (#2513 by @vmaerten).
- Added `--trusted-hosts` CLI flag and `remote.trusted-hosts` config option to
-  skip confirmation prompts for specified hosts when using Remote Taskfiles
-  (#2491, #2473 by @maciejlech).
- When running in GitHub Actions, Task now automatically emits error annotations
-  on failure, improving visibility in workflow summaries (#2568 by @vmaerten).
- The `--yes` flag is now accessible in templates via the new `CLI_ASSUME_YES`
-  variable (#2577, #2479 by @semihbkgr).
- Improved shell completion scripts (Zsh, Fish, PowerShell) by adding missing
-  flags and dynamic experimental feature detection (#2532 by @vmaerten).
- Remote Taskfiles now accept `application/octet-stream` Content-Type (#2536,
-  #1944 by @vmaerten).
- Shell completion now works when Task is installed or aliased under a different
-  binary name via TASK_EXE environment variable (#2495, #2468 by @vmaerten).
- Some small fixes and improvements were made to `task --init` and to the
-  default Taskfile it generates (#2433 by @andreynering).
- Added `--remote-cache-dir` flag and `remote.cache-dir` taskrc option to
-  customize the cache directory for Remote Taskfiles (#2572 by @vmaerten).
- Zsh completion now supports zstyle verbose option to show or hide task
-  descriptions (#2571 by @vmaerten).
- Task now automatically enables colored output in CI environments (GitHub
-  Actions, GitLab CI, etc.) without requiring FORCE_COLOR=1 (#2569 by
-  @vmaerten).
- Added color taskrc option to explicitly enable or disable colored output
-  globally (#2569 by @vmaerten).
- Improved Git Remote Taskfiles by switching to go-getter: SSH authentication
-  now works out of the box and `applyOf` is properly supported (#2512 by
-  @vmaerten).
-
-### 🐛 Fixes
-
- Fix RPM upload to Cloudsmith by including the version in the filename to
-  ensure unique filenames (#2507 by @vmaerten).
- Fix `run: when_changed` to work properly for Taskfiles included multiple times
-  (#2508, #2511 by @trulede).
- Fixed Zsh and Fish completions to stop suggesting task names after `--`
-  separator, allowing proper CLI_ARGS completion (#1843, #1844 by
-  @boiledfroginthewell).
- Watch mode (`--watch`) now always runs the task, regardless of `run: once` or
-  `run: when_changed` settings (#2566, #1388 by @trulede).
- Fixed global variables (CLI_ARGS, CLI_FORCE, etc.) not being accessible in
-  root-level vars section (#2403, #2397 by @trulede, @vmaerten).
- Fixed a bug where `ignore_error` was ignored when using `task:` to call
-  another task (#2552, #363 by @trulede).
- Fixed Zsh completion not suggesting global tasks when using `-g`/`--global`
-  flag (#1574, #2574 by @vmaerten).
- Fixed Fish completion failing to parse task descriptions containing colons
-  (e.g., URLs or namespaced functions) (#2101, #2573 by @vmaerten).
- Fixed false positive "property 'for' is not allowed" warnings in IntelliJ when
-  using `for` loops in Taskfiles (#2576 by @vmaerten).
-
-## v3.45.5 - 2025-11-11
-
- Fixed bug that made a generic message, instead of an useful one, appear when a
-  Taskfile could not be found (#2431 by @andreynering).
- Fixed a bug that caused an error when including a Remote Git Taskfile (#2438
-  by @twelvelabs).
- Fixed issue where `.taskrc.yml` was not returned if reading it failed, and
-  corrected handling of remote entrypoint Taskfiles (#2460, #2461 by @vmaerten).
- Improved performance of `--list` and `--list-all` by introducing a faster
-  compilation method that skips source globbing and checksum updates (#1322,
-  #2053 by @vmaerten).
- Fixed a concurrency bug with `output: group`. This ensures that begin/end
-  parts won't be mixed up from different tasks (#1208, #2349, #2350 by
-  @trulede).
- Do not re-evaluate variables for `defer:` (#2244, #2418 by @trulede).
- Improve error message when a Taskfile is not found (#2441, #2494 by
-  @vmaerten).
- Fixed generic error message `exit status 1` when a dependency task failed
-  (#2286 by @GrahamDennis).
- Fixed YAML library from the unmaintained `gopkg.in/yaml.v3` to the new fork
-  maintained by the official YAML org (#2171, #2434 by @andreynering).
- On Windows, the built-in version of the `rm` core utils contains a fix related
-  to the `-f` flag (#2426,
-  [u-root/u-root#3464](https://github.com/u-root/u-root/pull/3464),
-  [mvdan/sh#1199](https://github.com/mvdan/sh/pull/1199), #2506 by
-  @andreynering).
-
-## v3.45.4 - 2025-09-17
-
- Fixed a bug where `cache-expiry` could not be defined in `.taskrc.yml` (#2423
-  by @vmaerten).
- Fixed a bug where `.taskrc.yml` files in parent folders were not read
-  correctly (#2424 by @vmaerten).
- Fixed a bug where autocomplete in subfolders did not work with zsh (#2425 by
-  @vmaerten).
-
-## v3.45.3 - 2025-09-15
-
- Task now includes built-in core utilities to greatly improve compatibility on
-  Windows. This means that your commands that uses `cp`, `mv`, `mkdir` or any
-  other common core utility will now work by default on Windows, without extra
-  setup. This is something we wanted to address for many many years, and it's
-  finally being shipped!
-  [Read our blog post this the topic](https://taskfile.dev/blog/windows-core-utils).
-  (#197, #2360 by @andreynering).
- :sparkles: Built and deployed a [brand new website](https://taskfile.dev)
-  using [VitePress](https://vitepress.dev) (#2359, #2369, #2371, #2375, #2378 by
-  @vmaerten, @andreynering, @pd93).
- Began releasing
-  [nightly builds](https://github.com/go-task/task/releases/tag/nightly). This
-  will allow people to test our changes before they are fully released and
-  without having to install Go to build them (#2358 by @vmaerten).
- Added support for global config files in `$XDG_CONFIG_HOME/task/taskrc.yml` or
-  `$HOME/.taskrc.yml`. Check out our new
-  [configuration guide](https://taskfile.dev/docs/reference/config) for more
-  details (#2247, #2380, #2390, #2391 by @vmaerten, @pd93).
- Added experiments to the taskrc schema to clarify the expected keys and values
-  (#2235 by @vmaerten).
- Added support for new properties in `.taskrc.yml`: insecure, verbose,
-  concurrency, remote offline, remote timeout, and remote expiry. :warning:
-  Note: setting offline via environment variable is no longer supported. (#2389
-  by @vmaerten)
- Added a `--nested` flag when outputting tasks using `--list --json`. This will
-  output tasks in a nested structure when tasks are namespaced (#2415 by @pd93).
- Enhanced support for tasks with wildcards: they are now logged correctly, and
-  wildcard parameters are fully considered during fingerprinting (#1808, #1795
-  by @vmaerten).
- Fixed panic when a variable was declared as an empty hash (`{}`) (#2416, #2417
-  by @trulede).
-
-#### Package API
-
- Bumped the minimum version of Go to 1.24 (#2358 by @vmaerten).
-
-#### Other news
-
-We recently released our
-[official GitHub Action](https://github.com/go-task/setup-task). This is based
-on the fantastic work by the Arduino team who created and maintained the
-community version. Now that this is officially adopted, fixes/updates should be
-more timely. We have already merged a couple of longstanding PRs in our
-[first release](https://github.com/go-task/setup-task/releases/tag/v1.0.0) (by
-@pd93, @shrink, @trim21 and all the previous contributors to
-[arduino/setup-task](https://github.com/arduino/setup-task/)).
-
-## v3.45.0-v3.45.2 - 2025-09-15
-
-Failed due to an issue with our release process.
-
 ## v3.44.1 - 2025-07-23

 - Internal tasks will no longer be shown as suggestions since they cannot be
--- a/README.md
+++ b/README.md
@@ -1,16 +1,16 @@
 <div align="center">
  <a href="https://taskfile.dev">
-    <img src="website/src/public/img/logo.svg" width="200px" height="200px" />
+    <img src="website/static/img/logo.svg" width="200px" height="200px" />
  </a>

-  <h1>Task: The Modern Task Runner</h1>
+  <h1>Task</h1>

  <p>
-    A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+    Task is a task runner / build tool that aims to be simpler and easier to use than, for example, <a href="https://www.gnu.org/software/make/">GNU Make<a>.
  </p>

  <p>
-    <a href="https://taskfile.dev/docs/installation">Installation</a> &bullet; <a href="https://taskfile.dev/docs/getting-started">Getting Started</a> &bullet; <a href="https://taskfile.dev/docs/guide">Docs</a> &bullet; <a href="https://twitter.com/taskfiledev">Twitter</a> &bullet; <a href="https://bsky.app/profile/taskfile.dev">Bluesky</a> &bullet; <a href="https://fosstodon.org/@task">Mastodon</a> &bullet; <a href="https://discord.gg/6TY36E39UK">Discord</a>
+    <a href="https://taskfile.dev/installation/">Installation</a> | <a href="https://taskfile.dev/usage/">Documentation</a> | <a href="https://twitter.com/taskfiledev">Twitter</a> | <a href="https://bsky.app/profile/taskfile.dev">Bluesky</a> | <a href="https://fosstodon.org/@task">Mastodon</a> | <a href="https://discord.gg/6TY36E39UK">Discord</a>
  </p>

  <h1>Gold Sponsors</h1>
@@ -19,29 +19,7 @@
    <tr>
      <td align="center" valign="middle">
        <a target="_blank" href="https://devowl.io">
-          <img src="website/src/public/img/devowl.io.svg" height="100px" width="200px" title="devowl.io" />
-        </a>
-      </td>
-      <td align="center" valign="middle">
-        <a target="_blank" href="https://goodx.international/">
-          <img src="website/src/public/img/goodx.svg" height="80px" width="200px" title="GoodX" />
-        </a>
-      </td>
-      <td align="center" valign="middle">
-        <a target="_blank" href="https://magic.dev/">
-          <img src="website/src/public/img/magic.png" height="100px" width="200px" title="Magic" />
-        </a>
-      </td>
-    </tr>
-  </table>
-
-  <h2>Community Sponsors</h2>
-
-  <table>
-    <tr>
-      <td align="center" valign="middle">
-        <a target="_blank" href="https://cloudsmith.com/">
-          <img src="website/src/public/img/cloudsmith.svg" height="100px" width="200px" title="Cloudsmith" />
+          <img src="/website/static/img/devowl.io.svg" height="100px" title="devowl.io" />
        </a>
      </td>
    </tr>
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -8,7 +8,6 @@ includes:

 vars:
  BIN: "{{.ROOT_DIR}}/bin"
-  GOTESTSUM_FORMAT: '{{if .CI}}github-actions{{else}}pkgname{{end}}'

 env:
  CGO_ENABLED: '0'
@@ -29,7 +28,6 @@ tasks:
    aliases: [i]
    sources:
      - './**/*.go'
-      - go.mod
    cmds:
      - go install -v ./cmd/task

@@ -133,37 +131,29 @@ tasks:
  test:
    desc: Runs test suite
    aliases: [t]
-    deps: [gotestsum:install]
    sources:
      - "**/*.go"
      - "testdata/**/*"
    cmds:
-      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' ./...
+      - go test ./...

  test:watch:
    desc: Runs test suite with watch tests included
-    deps: [sleepit:build, gotestsum:install]
+    deps: [sleepit:build]
    cmds:
-      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' ./... -tags 'watch'
+      - go test ./... -tags 'watch'

  test:all:
    desc: Runs test suite with signals and watch tests included
-    deps: [sleepit:build, gotestsum:install]
+    deps: [sleepit:build]
    cmds:
-      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' -tags 'signals watch' ./...
+      - go test -tags 'signals watch' ./...

  goreleaser:test:
    desc: Tests release process without publishing
    cmds:
      - goreleaser --snapshot --clean

-  gotestsum:install:
-    desc: Installs gotestsum
-    status:
-      - command -v gotestsum
-    cmds:
-      - go install gotest.tools/gotestsum@latest
-
  goreleaser:install:
    desc: Installs goreleaser
    cmds:
@@ -213,6 +203,7 @@ tasks:
        Please wait for the CI to finish and then do the following:

        - Copy the changelog for v{{.VERSION}} to the GitHub release
+        - Publish the package to NPM with `task npm:publish`
        - Update and push the snapcraft manifest in https://github.com/go-task/snap/blob/main/snap/snapcraft.yaml
    preconditions:
      - sh: test $(git rev-parse --abbrev-ref HEAD) = "main"
@@ -227,7 +218,12 @@ tasks:
      - "git add --all"
      - "git commit -m v{{.VERSION}}"
      - "git push"
-      - "git tag -a v{{.VERSION}} -m v{{.VERSION}}"
+      - "git tag v{{.VERSION}}"
      - "git push origin tag v{{.VERSION}}"
      - cmd: printf "%s" '{{.COMPLETE_MESSAGE}}'
        silent: true
+
+  npm:publish:
+    desc: Publish release to npm
+    cmds:
+      - npm publish --access=public
--- a/cmd/release/main.go
+++ b/cmd/release/main.go
@@ -3,23 +3,33 @@ package main
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"regexp"
 	"strings"
 	"time"

 	"github.com/Masterminds/semver/v3"
+	"github.com/otiai10/copy"
 	"github.com/spf13/pflag"

 	"github.com/go-task/task/v3/errors"
 )

 const (
-	changelogSource = "CHANGELOG.md"
-	changelogTarget = "website/src/docs/changelog.md"
-	versionFile     = "internal/version/version.txt"
+	changelogSource    = "CHANGELOG.md"
+	changelogTarget    = "website/docs/changelog.mdx"
+	docsSource         = "website/docs"
+	docsTarget         = "website/versioned_docs/version-latest"
+	schemaSource       = "website/static/next-schema.json"
+	schemaTarget       = "website/static/schema.json"
+	schemaTaskrcSource = "website/static/next-schema-taskrc.json"
+	schemaTaskrcTarget = "website/static/schema-taskrc.json"
 )

-var changelogReleaseRegex = regexp.MustCompile(`## Unreleased`)
+var (
+	changelogReleaseRegex = regexp.MustCompile(`## Unreleased`)
+	versionRegex          = regexp.MustCompile(`(?m)^  "version": "\d+\.\d+\.\d+",$`)
+)

 // Flags
 var (
@@ -43,7 +53,7 @@ func release() error {
 		return errors.New("error: expected version number")
 	}

-	version, err := getVersion(versionFile)
+	version, err := getVersion()
 	if err != nil {
 		return err
 	}
@@ -61,18 +71,36 @@ func release() error {
 		return err
 	}

-	if err := setVersionFile(versionFile, version); err != nil {
+	if err := setVersionFile("internal/version/version.txt", version); err != nil {
+		return err
+	}
+
+	if err := setJSONVersion("package.json", version); err != nil {
+		return err
+	}
+
+	if err := setJSONVersion("package-lock.json", version); err != nil {
+		return err
+	}
+
+	if err := docs(); err != nil {
+		return err
+	}
+
+	if err := schema(); err != nil {
 		return err
 	}

 	return nil
 }

-func getVersion(filename string) (*semver.Version, error) {
-	b, err := os.ReadFile(filename)
+func getVersion() (*semver.Version, error) {
+	cmd := exec.Command("git", "describe", "--tags", "--abbrev=0")
+	b, err := cmd.Output()
 	if err != nil {
 		return nil, err
 	}
+
 	return semver.NewVersion(strings.TrimSpace(string(b)))
 }

@@ -117,21 +145,51 @@ func changelog(version *semver.Version) error {
 	changelog = changelogReleaseRegex.ReplaceAllString(changelog, fmt.Sprintf("## v%s - %s", version, date))

 	// Write the changelog to the source file
-	if err := os.WriteFile(changelogSource, []byte(changelog), 0o644); err != nil { //nolint:gosec
+	if err := os.WriteFile(changelogSource, []byte(changelog), 0o644); err != nil {
 		return err
 	}

-	// Wrap the changelog content with v-pre directive for VitePress to prevent
-	// Vue from interpreting template syntax like {{.TASK_VERSION}}
-	changelogWithVPre := strings.Replace(changelog, "# Changelog\n\n", "# Changelog\n\n::: v-pre\n\n", 1) + "\n:::"
-
 	// Add the frontmatter to the changelog
-	changelogWithFrontmatter := fmt.Sprintf("---\n%s\n---\n\n%s", frontmatter, changelogWithVPre)
+	changelog = fmt.Sprintf("---\n%s\n---\n\n%s", frontmatter, changelog)

 	// Write the changelog to the target file
-	return os.WriteFile(changelogTarget, []byte(changelogWithFrontmatter), 0o644) //nolint:gosec
+	return os.WriteFile(changelogTarget, []byte(changelog), 0o644)
 }

 func setVersionFile(fileName string, version *semver.Version) error {
 	return os.WriteFile(fileName, []byte(version.String()+"\n"), 0o644)
 }
+
+func setJSONVersion(fileName string, version *semver.Version) error {
+	// Read the JSON file
+	b, err := os.ReadFile(fileName)
+	if err != nil {
+		return err
+	}
+
+	// Replace the version
+	new := versionRegex.ReplaceAllString(string(b), fmt.Sprintf(`  "version": "%s",`, version.String()))
+
+	// Write the JSON file
+	return os.WriteFile(fileName, []byte(new), 0o644)
+}
+
+func docs() error {
+	if err := os.RemoveAll(docsTarget); err != nil {
+		return err
+	}
+	if err := copy.Copy(docsSource, docsTarget); err != nil {
+		return err
+	}
+	return nil
+}
+
+func schema() error {
+	if err := copy.Copy(schemaSource, schemaTarget); err != nil {
+		return err
+	}
+	if err := copy.Copy(schemaTaskrcSource, schemaTaskrcTarget); err != nil {
+		return err
+	}
+	return nil
+}
--- a/cmd/task/task.go
+++ b/cmd/task/task.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strconv"

 	"github.com/spf13/pflag"

@@ -17,6 +16,7 @@ import (
 	"github.com/go-task/task/v3/internal/flags"
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/version"
+	"github.com/go-task/task/v3/taskfile"
 	"github.com/go-task/task/v3/taskfile/ast"
 )

@@ -29,34 +29,19 @@ func main() {
 			Color:   flags.Color,
 		}
 		if err, ok := err.(*errors.TaskRunError); ok && flags.ExitCode {
-			emitCIErrorAnnotation(err)
 			l.Errf(logger.Red, "%v\n", err)
 			os.Exit(err.TaskExitCode())
 		}
 		if err, ok := err.(errors.TaskError); ok {
-			emitCIErrorAnnotation(err)
 			l.Errf(logger.Red, "%v\n", err)
 			os.Exit(err.Code())
 		}
-		emitCIErrorAnnotation(err)
 		l.Errf(logger.Red, "%v\n", err)
 		os.Exit(errors.CodeUnknown)
 	}
 	os.Exit(errors.CodeOk)
 }

-// emitCIErrorAnnotation emits an error annotation for supported CI providers.
-func emitCIErrorAnnotation(err error) {
-	if isGA, _ := strconv.ParseBool(os.Getenv("GITHUB_ACTIONS")); !isGA {
-		return
-	}
-	if e, ok := err.(*errors.TaskRunError); ok {
-		fmt.Fprintf(os.Stdout, "::error title=Task '%s' failed::%v\n", e.TaskName, e.Err)
-		return
-	}
-	fmt.Fprintf(os.Stdout, "::error title=Task failed::%v\n", err)
-}
-
 func run() error {
 	log := &logger.Logger{
 		Stdout:  os.Stdout,
@@ -126,16 +111,63 @@ func run() error {
 		return nil
 	}

-	e := task.NewExecutor(
-		flags.WithFlags(),
-		task.WithVersionCheck(true),
+	if err := experiments.Validate(); err != nil {
+		log.Warnf("%s\n", err.Error())
+	}
+
+	// Create a new root node for the given entrypoint
+	node, err := taskfile.NewRootNode(
+		flags.Entrypoint,
+		flags.Dir,
+		flags.Insecure,
 	)
-	if err := e.Setup(); err != nil {
+	if err != nil {
 		return err
 	}

+	tempDir, err := task.NewTempDir(node.Dir())
+	if err != nil {
+		return err
+	}
+
+	reader := taskfile.NewReader(
+		flags.WithFlags(),
+		taskfile.WithTempDir(tempDir.Remote),
+		taskfile.WithDebugFunc(func(s string) {
+			log.VerboseOutf(logger.Magenta, s)
+		}),
+		taskfile.WithPromptFunc(func(s string) error {
+			return log.Prompt(logger.Yellow, s, "n", "y", "yes")
+		}),
+	)
+
+	ctx, cf := context.WithTimeout(context.Background(), flags.Timeout)
+	defer cf()
+	graph, err := reader.Read(ctx, node)
+	if err != nil {
+		if errors.Is(err, context.DeadlineExceeded) {
+			return &errors.TaskfileNetworkTimeoutError{URI: node.Location(), Timeout: flags.Timeout}
+		}
+		return err
+	}
+
+	executor, err := task.NewExecutor(graph,
+		flags.WithFlags(),
+		task.WithDir(node.Dir()),
+		task.WithTempDir(tempDir),
+	)
+	if err != nil {
+		return err
+	}
+
+	// If the download flag is specified, we should stop execution as soon as
+	// taskfile is downloaded
+	if flags.Download {
+		return nil
+	}
+
 	if flags.ClearCache {
-		cachePath := filepath.Join(e.TempDir.Remote, "remote")
+		cachePath := filepath.Join(executor.TempDir.Remote, "remote")
 		return os.RemoveAll(cachePath)
 	}

@@ -144,13 +176,12 @@ func run() error {
 		flags.ListAll,
 		flags.ListJson,
 		flags.NoStatus,
-		flags.Nested,
 	)
 	if listOptions.ShouldListTasks() {
 		if flags.Silent {
-			return e.ListTaskNames(flags.ListAll)
+			return executor.ListTaskNames(flags.ListAll)
 		}
-		foundTasks, err := e.ListTasks(listOptions)
+		foundTasks, err := executor.ListTasks(listOptions)
 		if err != nil {
 			return err
 		}
@@ -172,32 +203,27 @@ func run() error {
 		calls = append(calls, &task.Call{Task: "default"})
 	}

-	// Merge CLI variables first (e.g. FOO=bar) so they take priority over Taskfile defaults
-	e.Taskfile.Vars.Merge(globals, nil)
-
-	// Then ReverseMerge special variables so they're available for templating
 	cliArgsPostDashQuoted, err := args.ToQuotedString(cliArgsPostDash)
 	if err != nil {
 		return err
 	}
-	specialVars := ast.NewVars()
-	specialVars.Set("CLI_ARGS", ast.Var{Value: cliArgsPostDashQuoted})
-	specialVars.Set("CLI_ARGS_LIST", ast.Var{Value: cliArgsPostDash})
-	specialVars.Set("CLI_FORCE", ast.Var{Value: flags.Force || flags.ForceAll})
-	specialVars.Set("CLI_SILENT", ast.Var{Value: flags.Silent})
-	specialVars.Set("CLI_VERBOSE", ast.Var{Value: flags.Verbose})
-	specialVars.Set("CLI_OFFLINE", ast.Var{Value: flags.Offline})
-	specialVars.Set("CLI_ASSUME_YES", ast.Var{Value: flags.AssumeYes})
-	e.Taskfile.Vars.ReverseMerge(specialVars, nil)
+	globals.Set("CLI_ARGS", ast.Var{Value: cliArgsPostDashQuoted})
+	globals.Set("CLI_ARGS_LIST", ast.Var{Value: cliArgsPostDash})
+	globals.Set("CLI_FORCE", ast.Var{Value: flags.Force || flags.ForceAll})
+	globals.Set("CLI_SILENT", ast.Var{Value: flags.Silent})
+	globals.Set("CLI_VERBOSE", ast.Var{Value: flags.Verbose})
+	globals.Set("CLI_OFFLINE", ast.Var{Value: flags.Offline})
+	executor.Taskfile.Vars.Merge(globals, nil)
+
 	if !flags.Watch {
-		e.InterceptInterruptSignals()
+		executor.InterceptInterruptSignals()
 	}

-	ctx := context.Background()
+	ctx = context.Background()

 	if flags.Status {
-		return e.Status(ctx, calls...)
+		return executor.Status(ctx, calls...)
 	}

-	return e.Run(ctx, calls...)
+	return executor.Run(ctx, calls...)
 }
--- a/cmd/tmp/main.go
+++ b/cmd/tmp/main.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+func main() {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond)
+	defer cancel()
+	if err := run(ctx); err != nil {
+		fmt.Println(ctx.Err())
+		fmt.Println(err)
+	}
+}
+
+func run(ctx context.Context) error {
+	req, err := http.NewRequest("GET", "https://taskfile.dev/schema.json", nil)
+	if err != nil {
+		fmt.Println(1)
+		return err
+	}
+
+	resp, err := http.DefaultClient.Do(req.WithContext(ctx))
+	if err != nil {
+		if ctx.Err() != nil {
+			fmt.Println(2)
+			return err
+		}
+		fmt.Println(3)
+		return err
+	}
+	defer resp.Body.Close()
+
+	return nil
+}
--- a/compiler.go
+++ b/compiler.go
@@ -51,7 +51,7 @@ func (c *Compiler) getVariables(t *ast.Task, call *Call, evaluateShVars bool) (*
 		return nil, err
 	}
 	for k, v := range specialVars {
-		result.Set(k, ast.Var{Value: v, Secret: false})
+		result.Set(k, ast.Var{Value: v})
 	}

 	getRangeFunc := func(dir string) func(k string, v ast.Var) error {
@@ -61,14 +61,13 @@ func (c *Compiler) getVariables(t *ast.Task, call *Call, evaluateShVars bool) (*
 			newVar := templater.ReplaceVar(v, cache)
 			// If the variable should not be evaluated, but is nil, set it to an empty string
 			// This stops empty interface errors when using the templater to replace values later
-			// Preserve the Sh field so it can be displayed in summary
 			if !evaluateShVars && newVar.Value == nil {
-				result.Set(k, ast.Var{Value: "", Sh: newVar.Sh, Secret: v.Secret})
+				result.Set(k, ast.Var{Value: ""})
 				return nil
 			}
 			// If the variable should not be evaluated and it is set, we can set it and return
 			if !evaluateShVars {
-				result.Set(k, ast.Var{Value: newVar.Value, Sh: newVar.Sh, Secret: v.Secret})
+				result.Set(k, ast.Var{Value: newVar.Value})
 				return nil
 			}
 			// Now we can check for errors since we've handled all the cases when we don't want to evaluate
@@ -77,7 +76,7 @@ func (c *Compiler) getVariables(t *ast.Task, call *Call, evaluateShVars bool) (*
 			}
 			// If the variable is already set, we can set it and return
 			if newVar.Value != nil || newVar.Sh == nil {
-				result.Set(k, ast.Var{Value: newVar.Value, Secret: v.Secret})
+				result.Set(k, ast.Var{Value: newVar.Value})
 				return nil
 			}
 			// If the variable is dynamic, we need to resolve it first
@@ -85,7 +84,7 @@ func (c *Compiler) getVariables(t *ast.Task, call *Call, evaluateShVars bool) (*
 			if err != nil {
 				return err
 			}
-			result.Set(k, ast.Var{Value: static, Secret: v.Secret})
+			result.Set(k, ast.Var{Value: static})
 			return nil
 		}
 	}
@@ -198,21 +197,18 @@ func (c *Compiler) ResetCache() {
 }

 func (c *Compiler) getSpecialVars(t *ast.Task, call *Call) (map[string]string, error) {
-	// Use filepath.ToSlash for all paths to ensure consistent forward slashes
-	// across platforms. This prevents issues with backslashes being interpreted
-	// as escape sequences when paths are used in shell commands on Windows.
 	allVars := map[string]string{
 		"TASK_EXE":         filepath.ToSlash(os.Args[0]),
-		"ROOT_TASKFILE":    filepath.ToSlash(filepathext.SmartJoin(c.Dir, c.Entrypoint)),
-		"ROOT_DIR":         filepath.ToSlash(c.Dir),
-		"USER_WORKING_DIR": filepath.ToSlash(c.UserWorkingDir),
+		"ROOT_TASKFILE":    filepathext.SmartJoin(c.Dir, c.Entrypoint),
+		"ROOT_DIR":         c.Dir,
+		"USER_WORKING_DIR": c.UserWorkingDir,
 		"TASK_VERSION":     version.GetVersion(),
 	}
 	if t != nil {
 		allVars["TASK"] = t.Task
-		allVars["TASK_DIR"] = filepath.ToSlash(filepathext.SmartJoin(c.Dir, t.Dir))
-		allVars["TASKFILE"] = filepath.ToSlash(t.Location.Taskfile)
-		allVars["TASKFILE_DIR"] = filepath.ToSlash(filepath.Dir(t.Location.Taskfile))
+		allVars["TASK_DIR"] = filepathext.SmartJoin(c.Dir, t.Dir)
+		allVars["TASKFILE"] = t.Location.Taskfile
+		allVars["TASKFILE_DIR"] = filepath.Dir(t.Location.Taskfile)
 	} else {
 		allVars["TASK"] = ""
 		allVars["TASK_DIR"] = ""
--- a/completion/bash/task.bash
+++ b/completion/bash/task.bash
@@ -1,7 +1,6 @@
 # vim: set tabstop=2 shiftwidth=2 expandtab:

 _GO_TASK_COMPLETION_LIST_OPTION='--list-all'
-TASK_CMD="${TASK_EXE:-task}"

 function _task()
 {
@@ -22,14 +21,10 @@ function _task()

  # Handle special arguments of options.
  case "$prev" in
-    -d|--dir|--remote-cache-dir)
+    -d|--dir)
      _filedir -d
      return $?
    ;;
-    --cacert|--cert|--cert-key)
-      _filedir
-      return $?
-    ;;
    -t|--taskfile)
      _filedir yaml || return $?
      _filedir yml
@@ -57,4 +52,4 @@ function _task()
  __ltrim_colon_completions "$cur"
 }

-complete -F _task "$TASK_CMD"
+complete -F _task task
--- a/completion/fish/task.fish
+++ b/completion/fish/task.fish
@@ -1,31 +1,4 @@
-set -l GO_TASK_PROGNAME (if set -q GO_TASK_PROGNAME; echo $GO_TASK_PROGNAME; else if set -q TASK_EXE; echo $TASK_EXE; else; echo task; end)
-
-# Cache variables for experiments (global)
-set -g __task_experiments_cache ""
-set -g __task_experiments_cache_time 0
-
-# Helper function to get experiments with 1-second cache
-function __task_get_experiments --inherit-variable GO_TASK_PROGNAME
-    set -l now (date +%s)
-    set -l ttl 1  # Cache for 1 second only
-
-    # Return cached value if still valid
-    if test (math "$now - $__task_experiments_cache_time") -lt $ttl
-        printf '%s\n' $__task_experiments_cache
-        return
-    end
-
-    # Refresh cache
-    set -g __task_experiments_cache ($GO_TASK_PROGNAME --experiments 2>/dev/null)
-    set -g __task_experiments_cache_time $now
-    printf '%s\n' $__task_experiments_cache
-end
-
-# Helper function to check if an experiment is enabled
-function __task_is_experiment_enabled
-    set -l experiment $argv[1]
-    __task_get_experiments | string match -qr "^\* $experiment:.*on"
-end
+set -l GO_TASK_PROGNAME task

 function __task_get_tasks --description "Prints all available tasks with their description" --inherit-variable GO_TASK_PROGNAME
  # Check if the global task is requested
@@ -54,67 +27,28 @@ function __task_get_tasks --description "Prints all available tasks with their d
  end

  # Grab names and descriptions (if any) of the tasks
-  set -l output (echo $rawOutput | sed -e '1d; s/\* \(.*\):[[:space:]]\{2,\}\(.*\)[[:space:]]\{2,\}(\(aliases.*\))/\1\t\2\t\3/' -e 's/\* \(.*\):[[:space:]]\{2,\}\(.*\)/\1\t\2/'| string split0)
+  set -l output (echo $rawOutput | sed -e '1d; s/\* \(.*\):\s*\(.*\)\s*(\(aliases.*\))/\1\t\2\t\3/' -e 's/\* \(.*\):\s*\(.*\)/\1\t\2/'| string split0)
  if test $output
    echo $output
  end
 end

-complete -c $GO_TASK_PROGNAME \
-  -d 'Runs the specified task(s). Falls back to the "default" task if no task name was specified, or lists all tasks if an unknown task name was specified.' \
-  -xa "(__task_get_tasks)" \
-  -n "not __fish_seen_subcommand_from --"
+complete -c $GO_TASK_PROGNAME -d 'Runs the specified task(s). Falls back to the "default" task if no task name was specified, or lists all tasks if an unknown task name was
+specified.' -xa "(__task_get_tasks)"

-# Standard flags
-complete -c $GO_TASK_PROGNAME -s a -l list-all                  -d 'list all tasks'
-complete -c $GO_TASK_PROGNAME -s c -l color                     -d 'colored output (default true)'
-complete -c $GO_TASK_PROGNAME -s C -l concurrency               -d 'limit number of concurrent tasks'
-complete -c $GO_TASK_PROGNAME      -l completion                -d 'generate shell completion script' -xa "bash zsh fish powershell"
-complete -c $GO_TASK_PROGNAME -s d -l dir                       -d 'set directory of execution'
-complete -c $GO_TASK_PROGNAME      -l disable-fuzzy             -d 'disable fuzzy matching for task names'
-complete -c $GO_TASK_PROGNAME -s n -l dry                       -d 'compile and print tasks without executing'
-complete -c $GO_TASK_PROGNAME -s x -l exit-code                 -d 'pass-through exit code of task command'
-complete -c $GO_TASK_PROGNAME      -l experiments               -d 'list available experiments'
-complete -c $GO_TASK_PROGNAME -s F -l failfast                  -d 'when running tasks in parallel, stop all tasks if one fails'
-complete -c $GO_TASK_PROGNAME -s f -l force                     -d 'force execution even when up-to-date'
-complete -c $GO_TASK_PROGNAME -s g -l global                    -d 'run global Taskfile from home directory'
-complete -c $GO_TASK_PROGNAME -s h -l help                      -d 'show help'
-complete -c $GO_TASK_PROGNAME -s i -l init                      -d 'create new Taskfile'
-complete -c $GO_TASK_PROGNAME      -l insecure                  -d 'allow insecure Taskfile downloads'
-complete -c $GO_TASK_PROGNAME -s I -l interval                  -d 'interval to watch for changes'
-complete -c $GO_TASK_PROGNAME -s j -l json                      -d 'format task list as JSON'
-complete -c $GO_TASK_PROGNAME -s l -l list                      -d 'list tasks with descriptions'
-complete -c $GO_TASK_PROGNAME      -l nested                    -d 'nest namespaces when listing as JSON'
-complete -c $GO_TASK_PROGNAME      -l no-status                 -d 'ignore status when listing as JSON'
-complete -c $GO_TASK_PROGNAME      -l interactive               -d 'prompt for missing required variables'
-complete -c $GO_TASK_PROGNAME -s o -l output                    -d 'set output style' -xa "interleaved group prefixed"
-complete -c $GO_TASK_PROGNAME      -l output-group-begin        -d 'message template before grouped output'
-complete -c $GO_TASK_PROGNAME      -l output-group-end          -d 'message template after grouped output'
-complete -c $GO_TASK_PROGNAME      -l output-group-error-only   -d 'hide output from successful tasks'
-complete -c $GO_TASK_PROGNAME -s p -l parallel                  -d 'execute tasks in parallel'
-complete -c $GO_TASK_PROGNAME -s s -l silent                    -d 'disable echoing'
-complete -c $GO_TASK_PROGNAME      -l sort                      -d 'set task sorting order' -xa "default alphanumeric none"
-complete -c $GO_TASK_PROGNAME      -l status                    -d 'exit non-zero if tasks not up-to-date'
-complete -c $GO_TASK_PROGNAME      -l summary                   -d 'show task summary'
-complete -c $GO_TASK_PROGNAME -s t -l taskfile                  -d 'choose Taskfile to run'
-complete -c $GO_TASK_PROGNAME -s v -l verbose                   -d 'verbose output'
-complete -c $GO_TASK_PROGNAME      -l version                   -d 'show version'
-complete -c $GO_TASK_PROGNAME -s w -l watch                     -d 'watch mode, re-run on changes'
-complete -c $GO_TASK_PROGNAME -s y -l yes                       -d 'assume yes to all prompts'
-
-# Experimental flags (dynamically checked at completion time via -n condition)
-# GentleForce experiment
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled GENTLE_FORCE" -l force-all -d 'force execution of task and all dependencies'
-
-# RemoteTaskfiles experiment - Options
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l offline          -d 'use only local or cached Taskfiles'
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l timeout          -d 'timeout for remote Taskfile downloads'
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l expiry           -d 'cache expiry duration'
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l remote-cache-dir -d 'directory to cache remote Taskfiles' -xa "(__fish_complete_directories)"
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l cacert           -d 'custom CA certificate for TLS' -r
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l cert             -d 'client certificate for mTLS' -r
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l cert-key         -d 'client certificate private key' -r
-
-# RemoteTaskfiles experiment - Operations
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l download    -d 'download remote Taskfile'
-complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l clear-cache -d 'clear remote Taskfile cache'
+complete -c $GO_TASK_PROGNAME -s c -l color     -d 'colored output (default true)'
+complete -c $GO_TASK_PROGNAME -s d -l dir       -d 'sets directory of execution'
+complete -c $GO_TASK_PROGNAME      -l dry       -d 'compiles and prints tasks in the order that they would be run, without executing them'
+complete -c $GO_TASK_PROGNAME -s f -l force     -d 'forces execution even when the task is up-to-date'
+complete -c $GO_TASK_PROGNAME -s h -l help      -d 'shows Task usage'
+complete -c $GO_TASK_PROGNAME -s i -l init      -d 'creates a new Taskfile.yml in the current folder'
+complete -c $GO_TASK_PROGNAME -s l -l list      -d 'lists tasks with description of current Taskfile'
+complete -c $GO_TASK_PROGNAME -s o -l output    -d 'sets output style: [interleaved|group|prefixed]' -xa "interleaved group prefixed"
+complete -c $GO_TASK_PROGNAME -s p -l parallel  -d 'executes tasks provided on command line in parallel'
+complete -c $GO_TASK_PROGNAME -s s -l silent    -d 'disables echoing'
+complete -c $GO_TASK_PROGNAME      -l status    -d 'exits with non-zero exit code if any of the given tasks is not up-to-date'
+complete -c $GO_TASK_PROGNAME      -l summary   -d 'show summary about a task'
+complete -c $GO_TASK_PROGNAME -s t -l taskfile  -d 'choose which Taskfile to run. Defaults to "Taskfile.yml"'
+complete -c $GO_TASK_PROGNAME -s v -l verbose   -d 'enables verbose mode'
+complete -c $GO_TASK_PROGNAME      -l version   -d 'show Task version'
+complete -c $GO_TASK_PROGNAME -s w -l watch     -d 'enables watch of the given task'
--- a/completion/ps/task.ps1
+++ b/completion/ps/task.ps1
@@ -5,86 +5,22 @@ Register-ArgumentCompleter -CommandName task -ScriptBlock {

 	if ($commandName.StartsWith('-')) {
 		$completions = @(
-			# Standard flags (alphabetical order)
-			[CompletionResult]::new('-a', '-a', [CompletionResultType]::ParameterName, 'list all tasks'),
-			[CompletionResult]::new('--list-all', '--list-all', [CompletionResultType]::ParameterName, 'list all tasks'),
-			[CompletionResult]::new('-c', '-c', [CompletionResultType]::ParameterName, 'colored output'),
-			[CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'colored output'),
-			[CompletionResult]::new('-C', '-C', [CompletionResultType]::ParameterName, 'limit concurrent tasks'),
-			[CompletionResult]::new('--concurrency', '--concurrency', [CompletionResultType]::ParameterName, 'limit concurrent tasks'),
-			[CompletionResult]::new('--completion', '--completion', [CompletionResultType]::ParameterName, 'generate shell completion'),
-			[CompletionResult]::new('-d', '-d', [CompletionResultType]::ParameterName, 'set directory'),
-			[CompletionResult]::new('--dir', '--dir', [CompletionResultType]::ParameterName, 'set directory'),
-			[CompletionResult]::new('--disable-fuzzy', '--disable-fuzzy', [CompletionResultType]::ParameterName, 'disable fuzzy matching'),
-			[CompletionResult]::new('-n', '-n', [CompletionResultType]::ParameterName, 'dry run'),
-			[CompletionResult]::new('--dry', '--dry', [CompletionResultType]::ParameterName, 'dry run'),
-			[CompletionResult]::new('-x', '-x', [CompletionResultType]::ParameterName, 'pass-through exit code'),
-			[CompletionResult]::new('--exit-code', '--exit-code', [CompletionResultType]::ParameterName, 'pass-through exit code'),
-			[CompletionResult]::new('--experiments', '--experiments', [CompletionResultType]::ParameterName, 'list experiments'),
-			[CompletionResult]::new('-F', '-F', [CompletionResultType]::ParameterName, 'fail fast on pallalel tasks'),
-			[CompletionResult]::new('--failfast', '--failfast', [CompletionResultType]::ParameterName, 'force execution'),
-			[CompletionResult]::new('-f', '-f', [CompletionResultType]::ParameterName, 'force execution'),
-			[CompletionResult]::new('--force', '--force', [CompletionResultType]::ParameterName, 'force execution'),
-			[CompletionResult]::new('-g', '-g', [CompletionResultType]::ParameterName, 'run global Taskfile'),
-			[CompletionResult]::new('--global', '--global', [CompletionResultType]::ParameterName, 'run global Taskfile'),
-			[CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'show help'),
-			[CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'show help'),
-			[CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'create new Taskfile'),
-			[CompletionResult]::new('--init', '--init', [CompletionResultType]::ParameterName, 'create new Taskfile'),
-			[CompletionResult]::new('--insecure', '--insecure', [CompletionResultType]::ParameterName, 'allow insecure downloads'),
-			[CompletionResult]::new('-I', '-I', [CompletionResultType]::ParameterName, 'watch interval'),
-			[CompletionResult]::new('--interval', '--interval', [CompletionResultType]::ParameterName, 'watch interval'),
-			[CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'format as JSON'),
-			[CompletionResult]::new('--json', '--json', [CompletionResultType]::ParameterName, 'format as JSON'),
-			[CompletionResult]::new('-l', '-l', [CompletionResultType]::ParameterName, 'list tasks'),
-			[CompletionResult]::new('--list', '--list', [CompletionResultType]::ParameterName, 'list tasks'),
-			[CompletionResult]::new('--nested', '--nested', [CompletionResultType]::ParameterName, 'nest namespaces in JSON'),
-			[CompletionResult]::new('--no-status', '--no-status', [CompletionResultType]::ParameterName, 'ignore status in JSON'),
-			[CompletionResult]::new('--interactive', '--interactive', [CompletionResultType]::ParameterName, 'prompt for missing required variables'),
-			[CompletionResult]::new('-o', '-o', [CompletionResultType]::ParameterName, 'set output style'),
-			[CompletionResult]::new('--output', '--output', [CompletionResultType]::ParameterName, 'set output style'),
-			[CompletionResult]::new('--output-group-begin', '--output-group-begin', [CompletionResultType]::ParameterName, 'template before group'),
-			[CompletionResult]::new('--output-group-end', '--output-group-end', [CompletionResultType]::ParameterName, 'template after group'),
-			[CompletionResult]::new('--output-group-error-only', '--output-group-error-only', [CompletionResultType]::ParameterName, 'hide successful output'),
-			[CompletionResult]::new('-p', '-p', [CompletionResultType]::ParameterName, 'execute in parallel'),
-			[CompletionResult]::new('--parallel', '--parallel', [CompletionResultType]::ParameterName, 'execute in parallel'),
-			[CompletionResult]::new('-s', '-s', [CompletionResultType]::ParameterName, 'silent mode'),
-			[CompletionResult]::new('--silent', '--silent', [CompletionResultType]::ParameterName, 'silent mode'),
-			[CompletionResult]::new('--sort', '--sort', [CompletionResultType]::ParameterName, 'task sorting order'),
-			[CompletionResult]::new('--status', '--status', [CompletionResultType]::ParameterName, 'check task status'),
-			[CompletionResult]::new('--summary', '--summary', [CompletionResultType]::ParameterName, 'show task summary'),
-			[CompletionResult]::new('-t', '-t', [CompletionResultType]::ParameterName, 'choose Taskfile'),
-			[CompletionResult]::new('--taskfile', '--taskfile', [CompletionResultType]::ParameterName, 'choose Taskfile'),
-			[CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'verbose output'),
-			[CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'verbose output'),
-			[CompletionResult]::new('--version', '--version', [CompletionResultType]::ParameterName, 'show version'),
-			[CompletionResult]::new('-w', '-w', [CompletionResultType]::ParameterName, 'watch mode'),
-			[CompletionResult]::new('--watch', '--watch', [CompletionResultType]::ParameterName, 'watch mode'),
-			[CompletionResult]::new('-y', '-y', [CompletionResultType]::ParameterName, 'assume yes'),
-			[CompletionResult]::new('--yes', '--yes', [CompletionResultType]::ParameterName, 'assume yes')
+			[CompletionResult]::new('--list-all ', '--list-all ', [CompletionResultType]::ParameterName, 'list all tasks'),
+			[CompletionResult]::new('--color ', '--color', [CompletionResultType]::ParameterName, '--color'),
+			[CompletionResult]::new('--concurrency=', '--concurrency=', [CompletionResultType]::ParameterName, 'concurrency'),
+			[CompletionResult]::new('--interval=', '--interval=', [CompletionResultType]::ParameterName, 'interval'),
+			[CompletionResult]::new('--output=interleaved ', '--output=interleaved', [CompletionResultType]::ParameterName, '--output='),
+			[CompletionResult]::new('--output=group ', '--output=group', [CompletionResultType]::ParameterName, '--output='),
+			[CompletionResult]::new('--output=prefixed ', '--output=prefixed', [CompletionResultType]::ParameterName, '--output='),
+			[CompletionResult]::new('--dry ', '--dry', [CompletionResultType]::ParameterName, '--dry'),
+			[CompletionResult]::new('--force ', '--force', [CompletionResultType]::ParameterName, '--force'),
+			[CompletionResult]::new('--parallel ', '--parallel', [CompletionResultType]::ParameterName, '--parallel'),
+			[CompletionResult]::new('--silent ', '--silent', [CompletionResultType]::ParameterName, '--silent'),
+			[CompletionResult]::new('--status ', '--status', [CompletionResultType]::ParameterName, '--status'),
+			[CompletionResult]::new('--verbose ', '--verbose', [CompletionResultType]::ParameterName, '--verbose'),
+			[CompletionResult]::new('--watch ', '--watch', [CompletionResultType]::ParameterName, '--watch')
 		)

-		# Experimental flags (dynamically added based on enabled experiments)
-		$experiments = & task --experiments 2>$null | Out-String
-
-		if ($experiments -match '\* GENTLE_FORCE:.*on') {
-			$completions += [CompletionResult]::new('--force-all', '--force-all', [CompletionResultType]::ParameterName, 'force all dependencies')
-		}
-
-		if ($experiments -match '\* REMOTE_TASKFILES:.*on') {
-			# Options
-			$completions += [CompletionResult]::new('--offline', '--offline', [CompletionResultType]::ParameterName, 'use cached Taskfiles')
-			$completions += [CompletionResult]::new('--timeout', '--timeout', [CompletionResultType]::ParameterName, 'download timeout')
-			$completions += [CompletionResult]::new('--expiry', '--expiry', [CompletionResultType]::ParameterName, 'cache expiry')
-			$completions += [CompletionResult]::new('--remote-cache-dir', '--remote-cache-dir', [CompletionResultType]::ParameterName, 'cache directory')
-			$completions += [CompletionResult]::new('--cacert', '--cacert', [CompletionResultType]::ParameterName, 'custom CA certificate')
-			$completions += [CompletionResult]::new('--cert', '--cert', [CompletionResultType]::ParameterName, 'client certificate')
-			$completions += [CompletionResult]::new('--cert-key', '--cert-key', [CompletionResultType]::ParameterName, 'client private key')
-			# Operations
-			$completions += [CompletionResult]::new('--download', '--download', [CompletionResultType]::ParameterName, 'download remote Taskfile')
-			$completions += [CompletionResult]::new('--clear-cache', '--clear-cache', [CompletionResultType]::ParameterName, 'clear cache')
-		}
-
 		return $completions.Where{ $_.CompletionText.StartsWith($commandName) }
 	}

--- a/completion/zsh/_task
+++ b/completion/zsh/_task
@@ -1,151 +1,67 @@
 #compdef task
+compdef _task task
 typeset -A opt_args
-TASK_CMD="${TASK_EXE:-task}"
-compdef _task "$TASK_CMD"

 _GO_TASK_COMPLETION_LIST_OPTION="${GO_TASK_COMPLETION_LIST_OPTION:---list-all}"

-# Check if an experiment is enabled
-function __task_is_experiment_enabled() {
-    local experiment=$1
-    task --experiments 2>/dev/null | grep -q "^\* ${experiment}:.*on"
-}
-
 # Listing commands from Taskfile.yml
 function __task_list() {
    local -a scripts cmd
    local -i enabled=0
    local taskfile item task desc

-    cmd=($TASK_CMD)
+    cmd=(task)
    taskfile=${(Qv)opt_args[(i)-t|--taskfile]}
    taskfile=${taskfile//\~/$HOME}

-    for arg in "${words[@]:0:$CURRENT}"; do
-        if [[ "$arg" = "--" ]]; then
-            # Use default completion for words after `--` as they are CLI_ARGS.
-            _default
-            return 0
-        fi
-    done

    if [[ -n "$taskfile" && -f "$taskfile" ]]; then
-        cmd+=(--taskfile "$taskfile")
-    fi
-
-    # Check if global flag is set
-    if (( ${+opt_args[-g]} || ${+opt_args[--global]} )); then
-        cmd+=(--global)
-    fi
-
-    if output=$("${cmd[@]}" $_GO_TASK_COMPLETION_LIST_OPTION 2>/dev/null); then
        enabled=1
+        cmd+=(--taskfile "$taskfile")
+    else
+        for taskfile in {T,t}askfile{,.dist}.{yaml,yml}; do
+            if [[ -f "$taskfile" ]]; then
+                enabled=1
+                break
+            fi
+        done
    fi

    (( enabled )) || return 0

    scripts=()
-
-    # Read zstyle verbose option (default = true via -T)
-    local show_desc
-    zstyle -T ":completion:${curcontext}:" verbose && show_desc=true || show_desc=false
-
-    for item in "${(@)${(f)output}[2,-1]#\* }"; do
+    for item in "${(@)${(f)$("${cmd[@]}" $_GO_TASK_COMPLETION_LIST_OPTION)}[2,-1]#\* }"; do
        task="${item%%:[[:space:]]*}"
-
-        if [[ "$show_desc" == "true" ]]; then
-            local desc="${item##[^[:space:]]##[[:space:]]##}"
-            scripts+=( "${task//:/\\:}:$desc" )
-        else
-            scripts+=( "$task" )
-        fi
+        desc="${item##[^[:space:]]##[[:space:]]##}"
+        scripts+=( "${task//:/\\:}:$desc" )
    done
-
-    if [[ "$show_desc" == "true" ]]; then
-        _describe 'Task to run' scripts
-    else
-        compadd -Q -a scripts
-    fi
+    _describe 'Task to run' scripts
 }

 _task() {
-    local -a standard_args operation_args
-
-    standard_args=(
-        '(-C --concurrency)'{-C,--concurrency}'[limit number of concurrent tasks]: '
-        '(-p --parallel)'{-p,--parallel}'[run command-line tasks in parallel]'
-        '(-F --failfast)'{-F,--failfast}'[when running tasks in parallel, stop all tasks if one fails]'
-        '(-f --force)'{-f,--force}'[run even if task is up-to-date]'
-        '(-c --color)'{-c,--color}'[colored output]'
-        '(--completion)--completion[generate shell completion script]:shell:(bash zsh fish powershell)'
-        '(-d --dir)'{-d,--dir}'[dir to run in]:execution dir:_dirs'
-        '(--disable-fuzzy)--disable-fuzzy[disable fuzzy matching for task names]'
-        '(-n --dry)'{-n,--dry}'[compiles and prints tasks without executing]'
-        '(--dry)--dry[dry-run mode, compile and print tasks only]'
-        '(-x --exit-code)'{-x,--exit-code}'[pass-through exit code of task command]'
-        '(--experiments)--experiments[list available experiments]'
-        '(-g --global)'{-g,--global}'[run global Taskfile from home directory]'
-        '(--insecure)--insecure[allow insecure Taskfile downloads]'
-        '(-I --interval)'{-I,--interval}'[interval to watch for changes]:duration: '
-        '(-j --json)'{-j,--json}'[format task list as JSON]'
-        '(--nested)--nested[nest namespaces when listing as JSON]'
-        '(--no-status)--no-status[ignore status when listing as JSON]'
-        '(--interactive)--interactive[prompt for missing required variables]'
-        '(-o --output)'{-o,--output}'[set output style]:style:(interleaved group prefixed)'
-        '(--output-group-begin)--output-group-begin[message template before grouped output]:template text: '
-        '(--output-group-end)--output-group-end[message template after grouped output]:template text: '
-        '(--output-group-error-only)--output-group-error-only[hide output from successful tasks]'
-        '(-s --silent)'{-s,--silent}'[disable echoing]'
-        '(--sort)--sort[set task sorting order]:order:(default alphanumeric none)'
-        '(--status)--status[exit non-zero if supplied tasks not up-to-date]'
-        '(--summary)--summary[show summary\: field from tasks instead of running them]'
-        '(-t --taskfile)'{-t,--taskfile}'[specify a different taskfile]:taskfile:_files'
-        '(-v --verbose)'{-v,--verbose}'[verbose mode]'
-        '(-w --watch)'{-w,--watch}'[watch-mode for given tasks, re-run when inputs change]'
-        '(-y --yes)'{-y,--yes}'[assume yes to all prompts]'
-    )
-
-    # Experimental flags (dynamically added based on enabled experiments)
-    # Options (modify behavior)
-    if __task_is_experiment_enabled "GENTLE_FORCE"; then
-        standard_args+=('(--force-all)--force-all[force execution of task and all dependencies]')
-    fi
-
-    if __task_is_experiment_enabled "REMOTE_TASKFILES"; then
-        standard_args+=(
-            '(--offline --download)--offline[use only local or cached Taskfiles]'
-            '(--timeout)--timeout[timeout for remote Taskfile downloads]:duration: '
-            '(--expiry)--expiry[cache expiry duration]:duration: '
-            '(--remote-cache-dir)--remote-cache-dir[directory to cache remote Taskfiles]:cache dir:_dirs'
-            '(--cacert)--cacert[custom CA certificate for TLS]:file:_files'
-            '(--cert)--cert[client certificate for mTLS]:file:_files'
-            '(--cert-key)--cert-key[client certificate private key]:file:_files'
-        )
-    fi
-
-    operation_args=(
-        # Task names completion (can be specified multiple times)
-        '(operation)*: :__task_list'
-        # Operational args completion (mutually exclusive)
-        + '(operation)'
-            '(*)'{-l,--list}'[list describable tasks]'
-            '(*)'{-a,--list-all}'[list all tasks]'
-            '(*)'{-i,--init}'[create new Taskfile.yml]'
-            '(- *)'{-h,--help}'[show help]'
-            '(- *)--version[show version and exit]'
-    )
-
-    # Experimental operations (dynamically added based on enabled experiments)
-    if __task_is_experiment_enabled "REMOTE_TASKFILES"; then
-        standard_args+=(
-            '(--offline --clear-cache)--download[download remote Taskfile]'
-        )
-        operation_args+=(
-            '(* --download)--clear-cache[clear remote Taskfile cache]'
-        )
-    fi
-
-    _arguments -S $standard_args $operation_args
+    _arguments \
+        '(-C --concurrency)'{-C,--concurrency}'[limit number of concurrent tasks]: ' \
+        '(-p --parallel)'{-p,--parallel}'[run command-line tasks in parallel]' \
+        '(-f --force)'{-f,--force}'[run even if task is up-to-date]' \
+        '(-c --color)'{-c,--color}'[colored output]' \
+        '(-d --dir)'{-d,--dir}'[dir to run in]:execution dir:_dirs' \
+        '(--dry)--dry[dry-run mode, compile and print tasks only]' \
+        '(-o --output)'{-o,--output}'[set output style]:style:(interleaved group prefixed)' \
+        '(--output-group-begin)--output-group-begin[message template before grouped output]:template text: ' \
+        '(--output-group-end)--output-group-end[message template after grouped output]:template text: ' \
+        '(-s --silent)'{-s,--silent}'[disable echoing]' \
+        '(--status)--status[exit non-zero if supplied tasks not up-to-date]' \
+        '(--summary)--summary[show summary\: field from tasks instead of running them]' \
+        '(-t --taskfile)'{-t,--taskfile}'[specify a different taskfile]:taskfile:_files' \
+        '(-v --verbose)'{-v,--verbose}'[verbose mode]' \
+        '(-w --watch)'{-w,--watch}'[watch-mode for given tasks, re-run when inputs change]' \
+        + '(operation)' \
+            {-l,--list}'[list describable tasks]' \
+            {-a,--list-all}'[list all tasks]' \
+            {-i,--init}'[create new Taskfile.yml]' \
+            '(-*)'{-h,--help}'[show help]' \
+            '(-*)--version[show version and exit]' \
+            '*: :__task_list'
 }

 # don't run the completion function when being source-ed or eval-ed
--- a/errors/error_taskfile_decode.go
+++ b/errors/error_taskfile_decode.go
@@ -5,12 +5,15 @@ import (
 	"cmp"
 	"errors"
 	"fmt"
+	"regexp"
 	"strings"

 	"github.com/fatih/color"
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"
 )

+var typeErrorRegex = regexp.MustCompile(`line \d+: (.*)`)
+
 type (
 	TaskfileDecodeError struct {
 		Message  string
@@ -50,10 +53,10 @@ func (err *TaskfileDecodeError) Error() string {
 			if len(te.Errors) > 1 {
 				fmt.Fprintln(buf, color.RedString("errs:"))
 				for _, message := range te.Errors {
-					fmt.Fprintln(buf, color.RedString("- %s", message))
+					fmt.Fprintln(buf, color.RedString("- %s", extractTypeErrorMessage(message)))
 				}
 			} else {
-				fmt.Fprintln(buf, color.RedString("err:  %s", te.Errors[0]))
+				fmt.Fprintln(buf, color.RedString("err:  %s", extractTypeErrorMessage(te.Errors[0])))
 			}
 		} else {
 			// Otherwise print the error message normally
@@ -125,3 +128,11 @@ func (err *TaskfileDecodeError) WithFileInfo(location string, snippet string) *T
 	err.Snippet = snippet
 	return err
 }
+
+func extractTypeErrorMessage(message string) string {
+	matches := typeErrorRegex.FindStringSubmatch(message)
+	if len(matches) == 2 {
+		return matches[1]
+	}
+	return message
+}
--- a/errors/errors_task.go
+++ b/errors/errors_task.go
@@ -54,10 +54,6 @@ func (err *TaskRunError) TaskExitCode() int {
 	return err.Code()
 }

-func (err *TaskRunError) Unwrap() error {
-	return err.Err
-}
-
 // TaskInternalError when the user attempts to invoke a task that is internal.
 type TaskInternalError struct {
 	TaskName string
@@ -166,7 +162,7 @@ func (v MissingVar) String() string {
 }

 func (err *TaskMissingRequiredVarsError) Error() string {
-	vars := make([]string, 0, len(err.MissingVars))
+	var vars []string
 	for _, v := range err.MissingVars {
 		vars = append(vars, v.String())
 	}
@@ -195,9 +191,9 @@ type TaskNotAllowedVarsError struct {
 func (err *TaskNotAllowedVarsError) Error() string {
 	var builder strings.Builder

-	builder.WriteString(fmt.Sprintf("task: Task %q cancelled because it is missing required variables:\n", err.TaskName)) //nolint:staticcheck
+	builder.WriteString(fmt.Sprintf("task: Task %q cancelled because it is missing required variables:\n", err.TaskName))
 	for _, s := range err.NotAllowedVars {
-		builder.WriteString(fmt.Sprintf("  - %s has an invalid value : '%s' (allowed values : %v)\n", s.Name, s.Value, s.Enum)) //nolint:staticcheck
+		builder.WriteString(fmt.Sprintf("  - %s has an invalid value : '%s' (allowed values : %v)\n", s.Name, s.Value, s.Enum))
 	}

 	return builder.String()
--- a/errors/errors_taskfile.go
+++ b/errors/errors_taskfile.go
@@ -3,7 +3,6 @@ package errors
 import (
 	"fmt"
 	"net/http"
-	"path/filepath"
 	"time"

 	"github.com/Masterminds/semver/v3"
@@ -12,23 +11,16 @@ import (
 // TaskfileNotFoundError is returned when no appropriate Taskfile is found when
 // searching the filesystem.
 type TaskfileNotFoundError struct {
-	URI         string
-	Walk        bool
-	AskInit     bool
-	OwnerChange bool
+	URI  string
+	Walk bool
 }

 func (err TaskfileNotFoundError) Error() string {
 	var walkText string
-	if err.OwnerChange {
-		walkText = " (or any of the parent directories until ownership changed)."
-	} else if err.Walk {
-		walkText = " (or any of the parent directories)."
+	if err.Walk {
+		walkText = " (or any of the parent directories)"
 	}
-	if err.AskInit {
-		walkText += " Run `task --init` to create a new Taskfile."
-	}
-	return fmt.Sprintf(`task: No Taskfile found at %q%s`, filepath.ToSlash(err.URI), walkText)
+	return fmt.Sprintf(`task: No Taskfile found at %q%s`, err.URI, walkText)
 }

 func (err TaskfileNotFoundError) Code() int {
@@ -55,7 +47,7 @@ type TaskfileInvalidError struct {
 }

 func (err TaskfileInvalidError) Error() string {
-	return fmt.Sprintf("task: Failed to parse %s:\n%v", filepath.ToSlash(err.URI), err.Err)
+	return fmt.Sprintf("task: Failed to parse %s:\n%v", err.URI, err.Err)
 }

 func (err TaskfileInvalidError) Code() int {
@@ -74,7 +66,7 @@ func (err TaskfileFetchFailedError) Error() string {
 	if err.HTTPStatusCode != 0 {
 		statusText = fmt.Sprintf(" with status code %d (%s)", err.HTTPStatusCode, http.StatusText(err.HTTPStatusCode))
 	}
-	return fmt.Sprintf(`task: Download of %q failed%s`, filepath.ToSlash(err.URI), statusText)
+	return fmt.Sprintf(`task: Download of %q failed%s`, err.URI, statusText)
 }

 func (err TaskfileFetchFailedError) Code() int {
@@ -90,7 +82,7 @@ type TaskfileNotTrustedError struct {
 func (err *TaskfileNotTrustedError) Error() string {
 	return fmt.Sprintf(
 		`task: Taskfile %q not trusted by user`,
-		filepath.ToSlash(err.URI),
+		err.URI,
 	)
 }

@@ -107,7 +99,7 @@ type TaskfileNotSecureError struct {
 func (err *TaskfileNotSecureError) Error() string {
 	return fmt.Sprintf(
 		`task: Taskfile %q cannot be downloaded over an insecure connection. You can override this by using the --insecure flag`,
-		filepath.ToSlash(err.URI),
+		err.URI,
 	)
 }

@@ -124,7 +116,7 @@ type TaskfileCacheNotFoundError struct {
 func (err *TaskfileCacheNotFoundError) Error() string {
 	return fmt.Sprintf(
 		`task: Taskfile %q was not found in the cache. Remove the --offline flag to use a remote copy or download it using the --download flag`,
-		filepath.ToSlash(err.URI),
+		err.URI,
 	)
 }

@@ -145,12 +137,12 @@ func (err *TaskfileVersionCheckError) Error() string {
 	if err.SchemaVersion == nil {
 		return fmt.Sprintf(
 			`task: Missing schema version in Taskfile %q`,
-			filepath.ToSlash(err.URI),
+			err.URI,
 		)
 	}
 	return fmt.Sprintf(
 		"task: Invalid schema version in Taskfile %q:\nSchema version (%s) %s",
-		filepath.ToSlash(err.URI),
+		err.URI,
 		err.SchemaVersion.String(),
 		err.Message,
 	)
@@ -170,7 +162,7 @@ type TaskfileNetworkTimeoutError struct {
 func (err *TaskfileNetworkTimeoutError) Error() string {
 	return fmt.Sprintf(
 		`task: Network connection timed out after %s while attempting to download Taskfile %q`,
-		err.Timeout, filepath.ToSlash(err.URI),
+		err.Timeout, err.URI,
 	)
 }

@@ -187,8 +179,8 @@ type TaskfileCycleError struct {

 func (err TaskfileCycleError) Error() string {
 	return fmt.Sprintf("task: include cycle detected between %s <--> %s",
-		filepath.ToSlash(err.Source),
-		filepath.ToSlash(err.Destination),
+		err.Source,
+		err.Destination,
 	)
 }

@@ -207,7 +199,7 @@ type TaskfileDoesNotMatchChecksum struct {
 func (err *TaskfileDoesNotMatchChecksum) Error() string {
 	return fmt.Sprintf(
 		"task: The checksum of the Taskfile at %q does not match!\ngot: %q\nwant: %q",
-		filepath.ToSlash(err.URI),
+		err.URI,
 		err.ActualChecksum,
 		err.ExpectedChecksum,
 	)
--- a/executor.go
+++ b/executor.go
@@ -4,10 +4,11 @@ import (
 	"context"
 	"io"
 	"os"
+	"path/filepath"
 	"sync"
 	"time"

-	"github.com/puzpuzpuz/xsync/v4"
+	"github.com/puzpuzpuz/xsync/v3"
 	"github.com/sajari/fuzzy"

 	"github.com/go-task/task/v3/internal/logger"
@@ -26,35 +27,21 @@ type (
 	// within them.
 	Executor struct {
 		// Flags
-		Dir                 string
-		Entrypoint          string
-		TempDir             TempDir
-		Force               bool
-		ForceAll            bool
-		Insecure            bool
-		Download            bool
-		Offline             bool
-		TrustedHosts        []string
-		Timeout             time.Duration
-		CacheExpiryDuration time.Duration
-		RemoteCacheDir      string
-		CACert              string
-		Cert                string
-		CertKey             string
-		Watch               bool
-		Verbose             bool
-		Silent              bool
-		DisableFuzzy        bool
-		AssumeYes           bool
-		AssumeTerm          bool // Used for testing
-		Interactive         bool
-		Dry                 bool
-		Summary             bool
-		Parallel            bool
-		Color               bool
-		Concurrency         int
-		Interval            time.Duration
-		Failfast            bool
+		Dir         string
+		TempDir     *TempDir
+		Force       bool
+		ForceAll    bool
+		Watch       bool
+		Verbose     bool
+		Silent      bool
+		AssumeYes   bool
+		AssumeTerm  bool // Used for testing
+		Dry         bool
+		Summary     bool
+		Parallel    bool
+		Color       bool
+		Concurrency int
+		Interval    time.Duration

 		// I/O
 		Stdin  io.Reader
@@ -71,28 +58,26 @@ type (
 		UserWorkingDir     string
 		EnableVersionCheck bool

-		fuzzyModel     *fuzzy.Model
-		fuzzyModelOnce sync.Once
+		fuzzyModel *fuzzy.Model

-		promptedVars         *ast.Vars // vars collected via interactive prompts
 		concurrencySemaphore chan struct{}
 		taskCallCount        map[string]*int32
 		mkdirMutexMap        map[string]*sync.Mutex
 		executionHashes      map[string]context.Context
 		executionHashesMutex sync.Mutex
-		watchedDirs          *xsync.Map[string, bool]
-	}
-	TempDir struct {
-		Remote      string
-		Fingerprint string
+		watchedDirs          *xsync.MapOf[string, bool]
 	}
 )

 // NewExecutor creates a new [Executor] and applies the given functional options
 // to it.
-func NewExecutor(opts ...ExecutorOption) *Executor {
+func NewExecutor(graph *ast.TaskfileGraph, opts ...ExecutorOption) (*Executor, error) {
+	tf, err := graph.Merge()
+	if err != nil {
+		return nil, err
+	}
 	e := &Executor{
-		Timeout:              time.Second * 10,
+		Taskfile:             tf,
 		Stdin:                os.Stdin,
 		Stdout:               os.Stdout,
 		Stderr:               os.Stderr,
@@ -110,7 +95,10 @@ func NewExecutor(opts ...ExecutorOption) *Executor {
 		executionHashesMutex: sync.Mutex{},
 	}
 	e.Options(opts...)
-	return e
+	if err := e.setup(); err != nil {
+		return nil, err
+	}
+	return e, nil
 }

 // Options loops through the given [ExecutorOption] functions and applies them
@@ -132,33 +120,23 @@ type dirOption struct {
 }

 func (o *dirOption) ApplyToExecutor(e *Executor) {
-	e.Dir = o.dir
-}
-
-// WithEntrypoint sets the entrypoint (main Taskfile) of the [Executor]. By
-// default, Task will search for one of the default Taskfiles in the given
-// directory.
-func WithEntrypoint(entrypoint string) ExecutorOption {
-	return &entrypointOption{entrypoint}
-}
-
-type entrypointOption struct {
-	entrypoint string
-}
-
-func (o *entrypointOption) ApplyToExecutor(e *Executor) {
-	e.Entrypoint = o.entrypoint
+	absDir, err := filepath.Abs(o.dir)
+	if err != nil {
+		e.Dir = o.dir
+		return
+	}
+	e.Dir = absDir
 }

 // WithTempDir sets the temporary directory that will be used by [Executor] for
 // storing temporary files like checksums and cached remote files. By default,
 // the temporary directory is set to the user's temporary directory.
-func WithTempDir(tempDir TempDir) ExecutorOption {
+func WithTempDir(tempDir *TempDir) ExecutorOption {
 	return &tempDirOption{tempDir}
 }

 type tempDirOption struct {
-	tempDir TempDir
+	tempDir *TempDir
 }

 func (o *tempDirOption) ApplyToExecutor(e *Executor) {
@@ -193,142 +171,6 @@ func (o *forceAllOption) ApplyToExecutor(e *Executor) {
 	e.ForceAll = o.forceAll
 }

-// WithInsecure allows the [Executor] to make insecure connections when reading
-// remote taskfiles. By default, insecure connections are rejected.
-func WithInsecure(insecure bool) ExecutorOption {
-	return &insecureOption{insecure}
-}
-
-type insecureOption struct {
-	insecure bool
-}
-
-func (o *insecureOption) ApplyToExecutor(e *Executor) {
-	e.Insecure = o.insecure
-}
-
-// WithDownload forces the [Executor] to download a fresh copy of the taskfile
-// from the remote source.
-func WithDownload(download bool) ExecutorOption {
-	return &downloadOption{download}
-}
-
-type downloadOption struct {
-	download bool
-}
-
-func (o *downloadOption) ApplyToExecutor(e *Executor) {
-	e.Download = o.download
-}
-
-// WithOffline stops the [Executor] from being able to make network connections.
-// It will still be able to read local files and cached copies of remote files.
-func WithOffline(offline bool) ExecutorOption {
-	return &offlineOption{offline}
-}
-
-type offlineOption struct {
-	offline bool
-}
-
-func (o *offlineOption) ApplyToExecutor(e *Executor) {
-	e.Offline = o.offline
-}
-
-// WithTrustedHosts configures the [Executor] with a list of trusted hosts for remote
-// Taskfiles. Hosts in this list will not prompt for user confirmation.
-func WithTrustedHosts(trustedHosts []string) ExecutorOption {
-	return &trustedHostsOption{trustedHosts}
-}
-
-type trustedHostsOption struct {
-	trustedHosts []string
-}
-
-func (o *trustedHostsOption) ApplyToExecutor(e *Executor) {
-	e.TrustedHosts = o.trustedHosts
-}
-
-// WithTimeout sets the [Executor]'s timeout for fetching remote taskfiles. By
-// default, the timeout is set to 10 seconds.
-func WithTimeout(timeout time.Duration) ExecutorOption {
-	return &timeoutOption{timeout}
-}
-
-type timeoutOption struct {
-	timeout time.Duration
-}
-
-func (o *timeoutOption) ApplyToExecutor(e *Executor) {
-	e.Timeout = o.timeout
-}
-
-// WithCacheExpiryDuration sets the duration after which the cache is considered
-// expired. By default, the cache is 0 (disabled).
-func WithCacheExpiryDuration(duration time.Duration) ExecutorOption {
-	return &cacheExpiryDurationOption{duration: duration}
-}
-
-type cacheExpiryDurationOption struct {
-	duration time.Duration
-}
-
-func (o *cacheExpiryDurationOption) ApplyToExecutor(r *Executor) {
-	r.CacheExpiryDuration = o.duration
-}
-
-// WithRemoteCacheDir sets the directory where remote taskfiles are cached.
-func WithRemoteCacheDir(dir string) ExecutorOption {
-	return &remoteCacheDirOption{dir: dir}
-}
-
-type remoteCacheDirOption struct {
-	dir string
-}
-
-func (o *remoteCacheDirOption) ApplyToExecutor(e *Executor) {
-	e.RemoteCacheDir = o.dir
-}
-
-// WithCACert sets the path to a custom CA certificate for TLS connections.
-func WithCACert(caCert string) ExecutorOption {
-	return &caCertOption{caCert: caCert}
-}
-
-type caCertOption struct {
-	caCert string
-}
-
-func (o *caCertOption) ApplyToExecutor(e *Executor) {
-	e.CACert = o.caCert
-}
-
-// WithCert sets the path to a client certificate for TLS connections.
-func WithCert(cert string) ExecutorOption {
-	return &certOption{cert: cert}
-}
-
-type certOption struct {
-	cert string
-}
-
-func (o *certOption) ApplyToExecutor(e *Executor) {
-	e.Cert = o.cert
-}
-
-// WithCertKey sets the path to a client certificate key for TLS connections.
-func WithCertKey(certKey string) ExecutorOption {
-	return &certKeyOption{certKey: certKey}
-}
-
-type certKeyOption struct {
-	certKey string
-}
-
-func (o *certKeyOption) ApplyToExecutor(e *Executor) {
-	e.CertKey = o.certKey
-}
-
 // WithWatch tells the [Executor] to keep running in the background and watch
 // for changes to the fingerprint of the tasks that are run. When changes are
 // detected, a new task run is triggered.
@@ -372,19 +214,6 @@ func (o *silentOption) ApplyToExecutor(e *Executor) {
 	e.Silent = o.silent
 }

-// WithDisableFuzzy tells the [Executor] to disable fuzzy matching for task names.
-func WithDisableFuzzy(disableFuzzy bool) ExecutorOption {
-	return &disableFuzzyOption{disableFuzzy}
-}
-
-type disableFuzzyOption struct {
-	disableFuzzy bool
-}
-
-func (o *disableFuzzyOption) ApplyToExecutor(e *Executor) {
-	e.DisableFuzzy = o.disableFuzzy
-}
-
 // WithAssumeYes tells the [Executor] to assume "yes" for all prompts.
 func WithAssumeYes(assumeYes bool) ExecutorOption {
 	return &assumeYesOption{assumeYes}
@@ -411,19 +240,6 @@ func (o *assumeTermOption) ApplyToExecutor(e *Executor) {
 	e.AssumeTerm = o.assumeTerm
 }

-// WithInteractive tells the [Executor] to prompt for missing required variables.
-func WithInteractive(interactive bool) ExecutorOption {
-	return &interactiveOption{interactive}
-}
-
-type interactiveOption struct {
-	interactive bool
-}
-
-func (o *interactiveOption) ApplyToExecutor(e *Executor) {
-	e.Interactive = o.interactive
-}
-
 // WithDry tells the [Executor] to output the commands that would be run without
 // actually running them.
 func WithDry(dry bool) ExecutorOption {
@@ -604,16 +420,3 @@ type versionCheckOption struct {
 func (o *versionCheckOption) ApplyToExecutor(e *Executor) {
 	e.EnableVersionCheck = o.enableVersionCheck
 }
-
-// WithFailfast tells the [Executor] whether or not to check the version of
-func WithFailfast(failfast bool) ExecutorOption {
-	return &failfastOption{failfast}
-}
-
-type failfastOption struct {
-	failfast bool
-}
-
-func (o *failfastOption) ApplyToExecutor(e *Executor) {
-	e.Failfast = o.failfast
-}
--- a/executor_setup.go
+++ b/executor_setup.go
@@ -4,18 +4,13 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"path/filepath"
 	"slices"
-	"strings"
 	"sync"

 	"github.com/Masterminds/semver/v3"
 	"github.com/sajari/fuzzy"

 	"github.com/go-task/task/v3/errors"
-	"github.com/go-task/task/v3/internal/env"
-	"github.com/go-task/task/v3/internal/execext"
-	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/output"
 	"github.com/go-task/task/v3/internal/version"
@@ -23,18 +18,9 @@ import (
 	"github.com/go-task/task/v3/taskfile/ast"
 )

-func (e *Executor) Setup() error {
+func (e *Executor) setup() error {
 	e.setupLogger()
-	node, err := e.getRootNode()
-	if err != nil {
-		return err
-	}
-	if err := e.setupTempDir(); err != nil {
-		return err
-	}
-	if err := e.readTaskfile(node); err != nil {
-		return err
-	}
+	e.setupFuzzyModel()
 	e.setupStdFiles()
 	if err := e.setupOutput(); err != nil {
 		return err
@@ -53,60 +39,6 @@ func (e *Executor) Setup() error {
 	return nil
 }

-func (e *Executor) getRootNode() (taskfile.Node, error) {
-	node, err := taskfile.NewRootNode(e.Entrypoint, e.Dir, e.Insecure, e.Timeout,
-		taskfile.WithCACert(e.CACert),
-		taskfile.WithCert(e.Cert),
-		taskfile.WithCertKey(e.CertKey),
-	)
-	var taskNotFoundError errors.TaskfileNotFoundError
-	if errors.As(err, &taskNotFoundError) {
-		taskNotFoundError.AskInit = true
-		return nil, taskNotFoundError
-	}
-	if err != nil {
-		return nil, err
-	}
-	e.Dir = node.Dir()
-	e.Entrypoint = node.Location()
-	return node, err
-}
-
-func (e *Executor) readTaskfile(node taskfile.Node) error {
-	ctx, cf := context.WithTimeout(context.Background(), e.Timeout)
-	defer cf()
-	debugFunc := func(s string) {
-		e.Logger.VerboseOutf(logger.Magenta, s)
-	}
-	promptFunc := func(s string) error {
-		return e.Logger.Prompt(logger.Yellow, s, "n", "y", "yes")
-	}
-	reader := taskfile.NewReader(
-		taskfile.WithInsecure(e.Insecure),
-		taskfile.WithDownload(e.Download),
-		taskfile.WithOffline(e.Offline),
-		taskfile.WithTrustedHosts(e.TrustedHosts),
-		taskfile.WithTempDir(e.TempDir.Remote),
-		taskfile.WithCacheExpiryDuration(e.CacheExpiryDuration),
-		taskfile.WithReaderCACert(e.CACert),
-		taskfile.WithReaderCert(e.Cert),
-		taskfile.WithReaderCertKey(e.CertKey),
-		taskfile.WithDebugFunc(debugFunc),
-		taskfile.WithPromptFunc(promptFunc),
-	)
-	graph, err := reader.Read(ctx, node)
-	if err != nil {
-		if errors.Is(err, context.DeadlineExceeded) {
-			return &errors.TaskfileNetworkTimeoutError{URI: node.Location(), Timeout: e.Timeout}
-		}
-		return err
-	}
-	if e.Taskfile, err = graph.Merge(); err != nil {
-		return err
-	}
-	return nil
-}
-
 func (e *Executor) setupFuzzyModel() {
 	if e.Taskfile == nil {
 		return
@@ -128,52 +60,6 @@ func (e *Executor) setupFuzzyModel() {
 	e.fuzzyModel = model
 }

-func (e *Executor) setupTempDir() error {
-	if e.TempDir != (TempDir{}) {
-		return nil
-	}
-
-	tempDir := env.GetTaskEnv("TEMP_DIR")
-	if tempDir == "" {
-		e.TempDir = TempDir{
-			Remote:      filepathext.SmartJoin(e.Dir, ".task"),
-			Fingerprint: filepathext.SmartJoin(e.Dir, ".task"),
-		}
-	} else if filepath.IsAbs(tempDir) || strings.HasPrefix(tempDir, "~") {
-		tempDir, err := execext.ExpandLiteral(tempDir)
-		if err != nil {
-			return err
-		}
-		projectDir, _ := filepath.Abs(e.Dir)
-		projectName := filepath.Base(projectDir)
-		e.TempDir = TempDir{
-			Remote:      tempDir,
-			Fingerprint: filepathext.SmartJoin(tempDir, projectName),
-		}
-
-	} else {
-		e.TempDir = TempDir{
-			Remote:      filepathext.SmartJoin(e.Dir, tempDir),
-			Fingerprint: filepathext.SmartJoin(e.Dir, tempDir),
-		}
-	}
-
-	// RemoteCacheDir from taskrc/env can override the remote cache directory
-	if e.RemoteCacheDir != "" {
-		if filepath.IsAbs(e.RemoteCacheDir) || strings.HasPrefix(e.RemoteCacheDir, "~") {
-			remoteCacheDir, err := execext.ExpandLiteral(e.RemoteCacheDir)
-			if err != nil {
-				return err
-			}
-			e.TempDir.Remote = remoteCacheDir
-		} else {
-			e.TempDir.Remote = filepathext.SmartJoin(e.Dir, e.RemoteCacheDir)
-		}
-	}
-
-	return nil
-}
-
 func (e *Executor) setupStdFiles() {
 	if e.Stdin == nil {
 		e.Stdin = os.Stdin
@@ -219,7 +105,7 @@ func (e *Executor) setupCompiler() error {

 	e.Compiler = &Compiler{
 		Dir:            e.Dir,
-		Entrypoint:     e.Entrypoint,
+		Entrypoint:     e.Taskfile.Location,
 		UserWorkingDir: e.UserWorkingDir,
 		TaskfileEnv:    e.Taskfile.Env,
 		TaskfileVars:   e.Taskfile.Vars,
--- a/executor_test.go
+++ b/executor_test.go
@@ -3,9 +3,11 @@ package task_test
 import (
 	"bytes"
 	"cmp"
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
+	"slices"
 	"testing"

 	"github.com/sebdah/goldie/v2"
@@ -14,6 +16,7 @@ import (
 	"github.com/go-task/task/v3"
 	"github.com/go-task/task/v3/experiments"
 	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/taskfile"
 	"github.com/go-task/task/v3/taskfile/ast"
 )

@@ -33,7 +36,12 @@ type (
 		task            string
 		vars            map[string]any
 		input           string
+		nodeDir         string
+		nodeEntrypoint  string
+		nodeInsecure    bool
+		readerOpts      []taskfile.ReaderOption
 		executorOpts    []task.ExecutorOption
+		wantReaderError bool
 		wantSetupError  bool
 		wantRunError    bool
 		wantStatusError bool
@@ -46,8 +54,9 @@ type (
 func NewExecutorTest(t *testing.T, opts ...ExecutorTestOption) {
 	t.Helper()
 	tt := &ExecutorTest{
-		task: "default",
-		vars: map[string]any{},
+		task:    "default",
+		vars:    map[string]any{},
+		nodeDir: ".",
 		TaskTest: TaskTest{
 			experiments:         map[*experiments.Experiment]int{},
 			fixtureTemplateData: map[string]any{},
@@ -143,12 +152,53 @@ func (tt *ExecutorTest) run(t *testing.T) {
 	t.Helper()
 	f := func(t *testing.T) {
 		t.Helper()
-		var buffer SyncBuffer
+		var buf bytes.Buffer
+		ctx := context.Background()

-		opts := append(
+		// Create a new root node for the given entrypoint
+		node, err := taskfile.NewRootNode(
+			tt.nodeEntrypoint,
+			tt.nodeDir,
+			tt.nodeInsecure,
+		)
+		require.NoError(t, err)
+
+		// Create a golden fixture file for the output
+		g := goldie.New(t,
+			goldie.WithFixtureDir(filepath.Join(node.Dir(), "testdata")),
+		)
+
+		// Set up a temporary directory for the taskfile reader and task executor
+		tempDir, err := task.NewTempDir(node.Dir())
+		require.NoError(t, err)
+		tt.readerOpts = append(tt.readerOpts, taskfile.WithTempDir(tempDir.Remote))
+
+		// Set up the taskfile reader
+		reader := taskfile.NewReader(tt.readerOpts...)
+		graph, err := reader.Read(ctx, node)
+		if tt.wantReaderError {
+			require.Error(t, err)
+			tt.writeFixtureErrReader(t, g, err)
+			tt.writeFixtureBuffer(t, g, buf)
+			return
+		} else {
+			require.NoError(t, err)
+		}
+
+		executorOpts := slices.Concat(
+			// Apply the node directory and temp directory to the executor options
+			// by default, but allow them to by overridden by the test options
+			[]task.ExecutorOption{
+				task.WithDir(node.Dir()),
+				task.WithTempDir(tempDir),
+			},
+			// Apply the executor options from the test
 			tt.executorOpts,
-			task.WithStdout(&buffer),
-			task.WithStderr(&buffer),
+			// Force the input/output streams to be set to the test buffer
+			[]task.ExecutorOption{
+				task.WithStdout(&buf),
+				task.WithStderr(&buf),
+			},
 		)

 		// If the test has input, create a reader for it and add it to the
@@ -156,23 +206,15 @@ func (tt *ExecutorTest) run(t *testing.T) {
 		if tt.input != "" {
 			var reader bytes.Buffer
 			reader.WriteString(tt.input)
-			opts = append(opts, task.WithStdin(&reader))
+			executorOpts = append(executorOpts, task.WithStdin(&reader))
 		}

 		// Set up the task executor
-		e := task.NewExecutor(opts...)
-
-		// Create a golden fixture file for the output
-		g := goldie.New(t,
-			goldie.WithFixtureDir(filepath.Join(e.Dir, "testdata")),
-			goldie.WithEqualFn(NormalizedEqual),
-		)
-
-		// Call setup and check for errors
-		if err := e.Setup(); tt.wantSetupError {
+		executor, err := task.NewExecutor(graph, executorOpts...)
+		if tt.wantSetupError {
 			require.Error(t, err)
 			tt.writeFixtureErrSetup(t, g, err)
-			tt.writeFixtureBuffer(t, g, buffer.buf)
+			tt.writeFixtureBuffer(t, g, buf)
 			return
 		} else {
 			require.NoError(t, err)
@@ -189,11 +231,10 @@ func (tt *ExecutorTest) run(t *testing.T) {
 		}

 		// Run the task and check for errors
-		ctx := t.Context()
-		if err := e.Run(ctx, call); tt.wantRunError {
+		if err := executor.Run(ctx, call); tt.wantRunError {
 			require.Error(t, err)
 			tt.writeFixtureErrRun(t, g, err)
-			tt.writeFixtureBuffer(t, g, buffer.buf)
+			tt.writeFixtureBuffer(t, g, buf)
 			return
 		} else {
 			require.NoError(t, err)
@@ -201,12 +242,12 @@ func (tt *ExecutorTest) run(t *testing.T) {

 		// If the status flag is set, run the status check
 		if tt.wantStatusError {
-			if err := e.Status(ctx, call); err != nil {
+			if err := executor.Status(ctx, call); err != nil {
 				tt.writeFixtureStatus(t, g, err.Error())
 			}
 		}

-		tt.writeFixtureBuffer(t, g, buffer.buf)
+		tt.writeFixtureBuffer(t, g, buf)
 	}

 	// Run the test (with a name if it has one)
@@ -220,19 +261,16 @@ func (tt *ExecutorTest) run(t *testing.T) {
 func TestEmptyTask(t *testing.T) {
 	t.Parallel()
 	NewExecutorTest(t,
-		WithExecutorOptions(
-			task.WithDir("testdata/empty_task"),
-		),
+		WithNodeDir("testdata/empty_task"),
+		WithExecutorOptions(),
 	)
 }

 func TestEmptyTaskfile(t *testing.T) {
 	t.Parallel()
 	NewExecutorTest(t,
-		WithExecutorOptions(
-			task.WithDir("testdata/empty_taskfile"),
-		),
-		WithSetupError(),
+		WithNodeDir("testdata/empty_taskfile"),
+		WithReaderError(),
 		WithFixtureTemplating(),
 	)
 }
@@ -241,15 +279,15 @@ func TestEnv(t *testing.T) {
 	t.Setenv("QUX", "from_os")
 	NewExecutorTest(t,
 		WithName("env precedence disabled"),
+		WithNodeDir("testdata/env"),
 		WithExecutorOptions(
-			task.WithDir("testdata/env"),
 			task.WithSilent(true),
 		),
 	)
 	NewExecutorTest(t,
 		WithName("env precedence enabled"),
+		WithNodeDir("testdata/env"),
 		WithExecutorOptions(
-			task.WithDir("testdata/env"),
 			task.WithSilent(true),
 		),
 		WithExperiment(&experiments.EnvPrecedence, 1),
@@ -259,92 +297,30 @@ func TestEnv(t *testing.T) {
 func TestVars(t *testing.T) {
 	t.Parallel()
 	NewExecutorTest(t,
+		WithNodeDir("testdata/vars"),
 		WithExecutorOptions(
-			task.WithDir("testdata/vars"),
 			task.WithSilent(true),
 		),
 	)
-	NewExecutorTest(t,
-		WithName("cli-var-priority-default"),
-		WithExecutorOptions(
-			task.WithDir("testdata/vars"),
-			task.WithSilent(true),
-		),
-		WithTask("cli-var-priority"),
-	)
-	NewExecutorTest(t,
-		WithName("cli-var-priority-override"),
-		WithExecutorOptions(
-			task.WithDir("testdata/vars"),
-			task.WithSilent(true),
-		),
-		WithTask("cli-var-priority"),
-		WithVar("CLI_VAR", "from_cli"),
-	)
-}
-
-func TestSecretVars(t *testing.T) {
-	t.Parallel()
-	NewExecutorTest(t,
-		WithName("secret vars are masked in logs"),
-		WithExecutorOptions(
-			task.WithDir("testdata/secrets"),
-		),
-		WithTask("test-secret-masking"),
-	)
-	NewExecutorTest(t,
-		WithName("multiple secrets masked"),
-		WithExecutorOptions(
-			task.WithDir("testdata/secrets"),
-		),
-		WithTask("test-multiple-secrets"),
-	)
-	NewExecutorTest(t,
-		WithName("mixed secret and public vars"),
-		WithExecutorOptions(
-			task.WithDir("testdata/secrets"),
-		),
-		WithTask("test-mixed"),
-	)
-	NewExecutorTest(t,
-		WithName("deferred command with secrets"),
-		WithExecutorOptions(
-			task.WithDir("testdata/secrets"),
-		),
-		WithTask("test-deferred-secret"),
-	)
-	NewExecutorTest(t,
-		WithName("env secret limitation"),
-		WithExecutorOptions(
-			task.WithDir("testdata/secrets"),
-		),
-		WithTask("test-env-secret-limitation"),
-	)
 }

 func TestRequires(t *testing.T) {
 	t.Parallel()
 	NewExecutorTest(t,
 		WithName("required var missing"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
+		WithNodeDir("testdata/requires"),
 		WithTask("missing-var"),
 		WithRunError(),
 	)
 	NewExecutorTest(t,
 		WithName("required var ok"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
+		WithNodeDir("testdata/requires"),
 		WithTask("missing-var"),
 		WithVar("FOO", "bar"),
 	)
 	NewExecutorTest(t,
 		WithName("fails validation"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
+		WithNodeDir("testdata/requires"),
 		WithTask("validation-var"),
 		WithVar("ENV", "dev"),
 		WithVar("FOO", "bar"),
@@ -352,83 +328,37 @@ func TestRequires(t *testing.T) {
 	)
 	NewExecutorTest(t,
 		WithName("passes validation"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
+		WithNodeDir("testdata/requires"),
 		WithTask("validation-var"),
 		WithVar("FOO", "one"),
 		WithVar("ENV", "dev"),
 	)
 	NewExecutorTest(t,
 		WithName("required var missing + fails validation"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
+		WithNodeDir("testdata/requires"),
 		WithTask("validation-var"),
 		WithRunError(),
 	)
 	NewExecutorTest(t,
 		WithName("required var missing + fails validation"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
+		WithNodeDir("testdata/requires"),
 		WithTask("validation-var-dynamic"),
 		WithVar("FOO", "one"),
 		WithVar("ENV", "dev"),
 	)
 	NewExecutorTest(t,
 		WithName("require before compile"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
+		WithNodeDir("testdata/requires"),
 		WithTask("require-before-compile"),
 		WithRunError(),
 	)
 	NewExecutorTest(t,
 		WithName("var defined in task"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
+		WithNodeDir("testdata/requires"),
 		WithTask("var-defined-in-task"),
 	)
-	NewExecutorTest(t,
-		WithName("enum ref - passes validation"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
-		WithTask("validation-var-ref"),
-		WithVar("ENV", "dev"),
-	)
-	NewExecutorTest(t,
-		WithName("enum ref - fails validation"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
-		WithTask("validation-var-ref"),
-		WithVar("ENV", "invalid"),
-		WithRunError(),
-	)
-	NewExecutorTest(t,
-		WithName("enum ref - ref to non-list"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
-		WithTask("validation-var-ref-invalid"),
-		WithVar("VALUE", "test"),
-		WithRunError(),
-	)
-	NewExecutorTest(t,
-		WithName("enum ref - ref to nonexistent var"),
-		WithExecutorOptions(
-			task.WithDir("testdata/requires"),
-		),
-		WithTask("validation-var-ref-nonexistent"),
-		WithVar("ENV", "dev"),
-		WithRunError(),
-	)
 }

-// TODO: mock fs
 func TestSpecialVars(t *testing.T) {
 	t.Parallel()

@@ -439,7 +369,6 @@ func TestSpecialVars(t *testing.T) {
 		// Root
 		"print-task",
 		"print-root-dir",
-		"print-root-taskfile",
 		"print-taskfile",
 		"print-taskfile-dir",
 		"print-task-dir",
@@ -450,12 +379,13 @@ func TestSpecialVars(t *testing.T) {
 		"included:print-taskfile-dir",
 	}

-	for _, dir := range []string{dir, subdir} {
+	for _, executorDir := range []string{dir, subdir} {
 		for _, test := range tests {
+			name := fmt.Sprintf("%s-%s", executorDir, test)
 			NewExecutorTest(t,
-				WithName(fmt.Sprintf("%s-%s", dir, test)),
+				WithName(name),
+				WithNodeDir(executorDir),
 				WithExecutorOptions(
-					task.WithDir(dir),
 					task.WithSilent(true),
 					task.WithVersionCheck(true),
 				),
@@ -469,8 +399,8 @@ func TestSpecialVars(t *testing.T) {
 func TestConcurrency(t *testing.T) {
 	t.Parallel()
 	NewExecutorTest(t,
+		WithNodeDir("testdata/concurrency"),
 		WithExecutorOptions(
-			task.WithDir("testdata/concurrency"),
 			task.WithConcurrency(1),
 		),
 		WithPostProcessFn(PPSortedLines),
@@ -480,8 +410,8 @@ func TestConcurrency(t *testing.T) {
 func TestParams(t *testing.T) {
 	t.Parallel()
 	NewExecutorTest(t,
+		WithNodeDir("testdata/params"),
 		WithExecutorOptions(
-			task.WithDir("testdata/params"),
 			task.WithSilent(true),
 		),
 		WithPostProcessFn(PPSortedLines),
@@ -491,15 +421,14 @@ func TestParams(t *testing.T) {
 func TestDeps(t *testing.T) {
 	t.Parallel()
 	NewExecutorTest(t,
+		WithNodeDir("testdata/deps"),
 		WithExecutorOptions(
-			task.WithDir("testdata/deps"),
 			task.WithSilent(true),
 		),
 		WithPostProcessFn(PPSortedLines),
 	)
 }

-// TODO: mock fs
 func TestStatus(t *testing.T) {
 	t.Parallel()

@@ -522,8 +451,8 @@ func TestStatus(t *testing.T) {
 	// gen-foo creates foo.txt, and will always fail it's status check.
 	NewExecutorTest(t,
 		WithName("run gen-foo 1 silent"),
+		WithNodeDir(dir),
 		WithExecutorOptions(
-			task.WithDir(dir),
 			task.WithSilent(true),
 		),
 		WithTask("gen-foo"),
@@ -534,8 +463,8 @@ func TestStatus(t *testing.T) {
 	// only exists after the first run.
 	NewExecutorTest(t,
 		WithName("run gen-bar 1 silent"),
+		WithNodeDir(dir),
 		WithExecutorOptions(
-			task.WithDir(dir),
 			task.WithSilent(true),
 		),
 		WithTask("gen-bar"),
@@ -544,8 +473,8 @@ func TestStatus(t *testing.T) {
 	// if e.Verbose is set to true.
 	NewExecutorTest(t,
 		WithName("run gen-baz silent"),
+		WithNodeDir(dir),
 		WithExecutorOptions(
-			task.WithDir(dir),
 			task.WithSilent(true),
 		),
 		WithTask("gen-silent-baz"),
@@ -560,8 +489,8 @@ func TestStatus(t *testing.T) {
 	// Run gen-bar a second time to produce a checksum file that matches bar.txt
 	NewExecutorTest(t,
 		WithName("run gen-bar 2 silent"),
+		WithNodeDir(dir),
 		WithExecutorOptions(
-			task.WithDir(dir),
 			task.WithSilent(true),
 		),
 		WithTask("gen-bar"),
@@ -569,8 +498,8 @@ func TestStatus(t *testing.T) {
 	// Run gen-bar a third time, to make sure we've triggered the status check.
 	NewExecutorTest(t,
 		WithName("run gen-bar 3 silent"),
+		WithNodeDir(dir),
 		WithExecutorOptions(
-			task.WithDir(dir),
 			task.WithSilent(true),
 		),
 		WithTask("gen-bar"),
@@ -582,8 +511,8 @@ func TestStatus(t *testing.T) {
 	require.NoError(t, err)
 	NewExecutorTest(t,
 		WithName("run gen-bar 4 silent"),
+		WithNodeDir(dir),
 		WithExecutorOptions(
-			task.WithDir(dir),
 			task.WithSilent(true),
 		),
 		WithTask("gen-bar"),
@@ -591,56 +520,44 @@ func TestStatus(t *testing.T) {
 	// all: not up-to-date
 	NewExecutorTest(t,
 		WithName("run gen-foo 2"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("gen-foo"),
 	)
 	// status: not up-to-date
 	NewExecutorTest(t,
 		WithName("run gen-foo 3"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("gen-foo"),
 	)
 	// sources: not up-to-date
 	NewExecutorTest(t,
 		WithName("run gen-bar 5"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("gen-bar"),
 	)
 	// all: up-to-date
 	NewExecutorTest(t,
 		WithName("run gen-bar 6"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("gen-bar"),
 	)
 	// sources: not up-to-date, no output produced.
 	NewExecutorTest(t,
 		WithName("run gen-baz 2"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("gen-silent-baz"),
 	)
 	// up-to-date, no output produced
 	NewExecutorTest(t,
 		WithName("run gen-baz 3"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("gen-silent-baz"),
 	)
 	// up-to-date, output produced due to Verbose mode.
 	NewExecutorTest(t,
 		WithName("run gen-baz 4 verbose"),
+		WithNodeDir(dir),
 		WithExecutorOptions(
-			task.WithDir(dir),
 			task.WithVerbose(true),
 		),
 		WithTask("gen-silent-baz"),
@@ -653,32 +570,24 @@ func TestPrecondition(t *testing.T) {
 	const dir = "testdata/precondition"
 	NewExecutorTest(t,
 		WithName("a precondition has been met"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("foo"),
 	)
 	NewExecutorTest(t,
 		WithName("a precondition was not met"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("impossible"),
 		WithRunError(),
 	)
 	NewExecutorTest(t,
 		WithName("precondition in dependency fails the task"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("depends_on_impossible"),
 		WithRunError(),
 	)
 	NewExecutorTest(t,
 		WithName("precondition in cmd fails the task"),
-		WithExecutorOptions(
-			task.WithDir(dir),
-		),
+		WithNodeDir(dir),
 		WithTask("executes_failing_task_as_cmd"),
 		WithRunError(),
 	)
@@ -689,70 +598,40 @@ func TestAlias(t *testing.T) {

 	NewExecutorTest(t,
 		WithName("alias"),
-		WithExecutorOptions(
-			task.WithDir("testdata/alias"),
-		),
+		WithNodeDir("testdata/alias"),
 		WithTask("f"),
 	)

 	NewExecutorTest(t,
 		WithName("duplicate alias"),
-		WithExecutorOptions(
-			task.WithDir("testdata/alias"),
-		),
+		WithNodeDir("testdata/alias"),
 		WithTask("x"),
 		WithRunError(),
 	)

 	NewExecutorTest(t,
 		WithName("alias summary"),
+		WithNodeDir("testdata/alias"),
 		WithExecutorOptions(
-			task.WithDir("testdata/alias"),
 			task.WithSummary(true),
 		),
 		WithTask("f"),
 	)
 }

-func TestSummaryWithVarsAndRequires(t *testing.T) {
-	t.Parallel()
-
-	// Test basic case from prompt.md - vars and requires
-	NewExecutorTest(t,
-		WithName("vars-and-requires"),
-		WithExecutorOptions(
-			task.WithDir("testdata/summary-vars-requires"),
-			task.WithSummary(true),
-		),
-		WithTask("mytask"),
-	)
-
-	// Test with shell variables
-	NewExecutorTest(t,
-		WithName("shell-vars"),
-		WithExecutorOptions(
-			task.WithDir("testdata/summary-vars-requires"),
-			task.WithSummary(true),
-		),
-		WithTask("with-sh-var"),
-	)
-}
-
 func TestLabel(t *testing.T) {
 	t.Parallel()

 	NewExecutorTest(t,
 		WithName("up to date"),
-		WithExecutorOptions(
-			task.WithDir("testdata/label_uptodate"),
-		),
+		WithNodeDir("testdata/label_uptodate"),
 		WithTask("foo"),
 	)

 	NewExecutorTest(t,
 		WithName("summary"),
+		WithNodeDir("testdata/label_summary"),
 		WithExecutorOptions(
-			task.WithDir("testdata/label_summary"),
 			task.WithSummary(true),
 		),
 		WithTask("foo"),
@@ -760,56 +639,20 @@ func TestLabel(t *testing.T) {

 	NewExecutorTest(t,
 		WithName("status"),
-		WithExecutorOptions(
-			task.WithDir("testdata/label_status"),
-		),
+		WithNodeDir("testdata/label_status"),
 		WithTask("foo"),
 		WithStatusError(),
 	)

 	NewExecutorTest(t,
 		WithName("var"),
-		WithExecutorOptions(
-			task.WithDir("testdata/label_var"),
-		),
+		WithNodeDir("testdata/label_var"),
 		WithTask("foo"),
 	)

 	NewExecutorTest(t,
 		WithName("label in summary"),
-		WithExecutorOptions(
-			task.WithDir("testdata/label_summary"),
-		),
-		WithTask("foo"),
-	)
-
-	NewExecutorTest(t,
-		WithName("label in error"),
-		WithExecutorOptions(
-			task.WithDir("testdata/label_error"),
-		),
-		WithTask("foo"),
-		WithRunError(),
-	)
-}
-
-func TestPrefix(t *testing.T) {
-	t.Parallel()
-
-	NewExecutorTest(t,
-		WithName("up to date"),
-		WithExecutorOptions(
-			task.WithDir("testdata/prefix_uptodate"),
-			task.WithOutputStyle(ast.Output{Name: "prefixed"}),
-		),
-		WithTask("foo"),
-	)
-
-	NewExecutorTest(t,
-		WithName("up to dat with no output style"),
-		WithExecutorOptions(
-			task.WithDir("testdata/prefix_uptodate"),
-		),
+		WithNodeDir("testdata/label_summary"),
 		WithTask("foo"),
 	)
 }
@@ -836,8 +679,8 @@ func TestPromptInSummary(t *testing.T) {

 			opts := []ExecutorTestOption{
 				WithName(test.name),
+				WithNodeDir("testdata/prompt"),
 				WithExecutorOptions(
-					task.WithDir("testdata/prompt"),
 					task.WithAssumeTerm(true),
 				),
 				WithTask("foo"),
@@ -855,8 +698,8 @@ func TestPromptWithIndirectTask(t *testing.T) {
 	t.Parallel()

 	NewExecutorTest(t,
+		WithNodeDir("testdata/prompt"),
 		WithExecutorOptions(
-			task.WithDir("testdata/prompt"),
 			task.WithAssumeTerm(true),
 		),
 		WithTask("bar"),
@@ -869,8 +712,8 @@ func TestPromptAssumeYes(t *testing.T) {

 	NewExecutorTest(t,
 		WithName("--yes flag should skip prompt"),
+		WithNodeDir("testdata/prompt"),
 		WithExecutorOptions(
-			task.WithDir("testdata/prompt"),
 			task.WithAssumeTerm(true),
 			task.WithAssumeYes(true),
 		),
@@ -880,8 +723,8 @@ func TestPromptAssumeYes(t *testing.T) {

 	NewExecutorTest(t,
 		WithName("task should raise errors.TaskCancelledError"),
+		WithNodeDir("testdata/prompt"),
 		WithExecutorOptions(
-			task.WithDir("testdata/prompt"),
 			task.WithAssumeTerm(true),
 		),
 		WithTask("foo"),
@@ -918,8 +761,8 @@ func TestForCmds(t *testing.T) {
 	for _, test := range tests {
 		opts := []ExecutorTestOption{
 			WithName(test.name),
+			WithNodeDir("testdata/for/cmds"),
 			WithExecutorOptions(
-				task.WithDir("testdata/for/cmds"),
 				task.WithSilent(true),
 				task.WithForce(true),
 			),
@@ -961,8 +804,8 @@ func TestForDeps(t *testing.T) {
 	for _, test := range tests {
 		opts := []ExecutorTestOption{
 			WithName(test.name),
+			WithNodeDir("testdata/for/deps"),
 			WithExecutorOptions(
-				task.WithDir("testdata/for/deps"),
 				task.WithSilent(true),
 				task.WithForce(true),
 				// Force output of each dep to be grouped together to prevent interleaving
@@ -1007,8 +850,8 @@ func TestReference(t *testing.T) {
 	for _, test := range tests {
 		NewExecutorTest(t,
 			WithName(test.name),
+			WithNodeDir("testdata/var_references"),
 			WithExecutorOptions(
-				task.WithDir("testdata/var_references"),
 				task.WithSilent(true),
 				task.WithForce(true),
 			),
@@ -1075,8 +918,8 @@ func TestVarInheritance(t *testing.T) {
 	for _, test := range tests {
 		NewExecutorTest(t,
 			WithName(test.name),
+			WithNodeDir(fmt.Sprintf("testdata/var_inheritance/v3/%s", test.name)),
 			WithExecutorOptions(
-				task.WithDir(fmt.Sprintf("testdata/var_inheritance/v3/%s", test.name)),
 				task.WithSilent(true),
 				task.WithForce(true),
 			),
@@ -1090,26 +933,20 @@ func TestFuzzyModel(t *testing.T) {

 	NewExecutorTest(t,
 		WithName("fuzzy"),
-		WithExecutorOptions(
-			task.WithDir("testdata/fuzzy"),
-		),
+		WithNodeDir("testdata/fuzzy"),
 		WithTask("instal"),
 		WithRunError(),
 	)

 	NewExecutorTest(t,
 		WithName("not-fuzzy"),
-		WithExecutorOptions(
-			task.WithDir("testdata/fuzzy"),
-		),
+		WithNodeDir("testdata/fuzzy"),
 		WithTask("install"),
 	)

 	NewExecutorTest(t,
 		WithName("intern"),
-		WithExecutorOptions(
-			task.WithDir("testdata/fuzzy"),
-		),
+		WithNodeDir("testdata/fuzzy"),
 		WithTask("intern"),
 		WithRunError(),
 	)
@@ -1120,141 +957,64 @@ func TestIncludeChecksum(t *testing.T) {

 	NewExecutorTest(t,
 		WithName("correct"),
-		WithExecutorOptions(
-			task.WithDir("testdata/includes_checksum/correct"),
-		),
+		WithNodeDir("testdata/includes_checksum/correct"),
 	)

 	NewExecutorTest(t,
 		WithName("incorrect"),
-		WithExecutorOptions(
-			task.WithDir("testdata/includes_checksum/incorrect"),
-		),
-		WithSetupError(),
+		WithNodeDir("testdata/includes_checksum/incorrect"),
+		WithReaderError(),
 		WithFixtureTemplating(),
 	)
 }

-func TestIncludeSilent(t *testing.T) {
-	t.Parallel()
-
-	NewExecutorTest(t,
-		WithName("include-taskfile-silent"),
-		WithExecutorOptions(
-			task.WithDir("testdata/includes_silent"),
-		),
-		WithTask("default"),
-	)
-}
-
-func TestFailfast(t *testing.T) {
-	t.Parallel()
-
-	t.Run("Default", func(t *testing.T) {
-		t.Parallel()
-
-		NewExecutorTest(t,
-			WithName("default"),
-			WithExecutorOptions(
-				task.WithDir("testdata/failfast/default"),
-				task.WithSilent(true),
-			),
-			WithPostProcessFn(PPSortedLines),
-			WithRunError(),
-		)
-	})
-
-	t.Run("Option", func(t *testing.T) {
-		t.Parallel()
-
-		NewExecutorTest(t,
-			WithName("default"),
-			WithExecutorOptions(
-				task.WithDir("testdata/failfast/default"),
-				task.WithSilent(true),
-				task.WithFailfast(true),
-			),
-			WithPostProcessFn(PPSortedLines),
-			WithRunError(),
-		)
-	})
-
-	t.Run("Task", func(t *testing.T) {
-		t.Parallel()
-
-		NewExecutorTest(t,
-			WithName("task"),
-			WithExecutorOptions(
-				task.WithDir("testdata/failfast/task"),
-				task.WithSilent(true),
-			),
-			WithPostProcessFn(PPSortedLines),
-			WithRunError(),
-		)
-	})
-}
-
-func TestIf(t *testing.T) {
+func TestWildcard(t *testing.T) {
 	t.Parallel()

 	tests := []struct {
 		name    string
-		task    string
-		vars    map[string]any
-		verbose bool
+		call    string
+		wantErr bool
 	}{
-		// Basic command-level if
-		{name: "cmd-if-true", task: "cmd-if-true"},
-		{name: "cmd-if-false", task: "cmd-if-false"},
-
-		// Task-level if
-		{name: "task-if-true", task: "task-if-true"},
-		{name: "task-if-false", task: "task-if-false", verbose: true},
-
-		// Task call with if
-		{name: "task-call-if-true", task: "task-call-if-true"},
-		{name: "task-call-if-false", task: "task-call-if-false", verbose: true},
-
-		// Go template conditions
-		{name: "template-eq-true", task: "template-eq-true"},
-		{name: "template-eq-false", task: "template-eq-false", verbose: true},
-		{name: "template-ne", task: "template-ne"},
-		{name: "template-bool-true", task: "template-bool-true"},
-		{name: "template-bool-false", task: "template-bool-false"},
-		{name: "template-direct-true", task: "template-direct-true"},
-		{name: "template-direct-false", task: "template-direct-false"},
-		{name: "template-and", task: "template-and"},
-		{name: "template-or", task: "template-or"},
-
-		// CLI variable override
-		{name: "template-cli-var", task: "template-cli-var", vars: map[string]any{"MY_VAR": "yes"}},
-
-		// Task-level if with template
-		{name: "task-level-template", task: "task-level-template"},
-		{name: "task-level-template-false", task: "task-level-template-false", verbose: true},
-
-		// For loop with if
-		{name: "if-in-for-loop", task: "if-in-for-loop", verbose: true},
-
-		// Task-level if with dynamic variable
-		{name: "task-if-dynamic-true", task: "task-if-dynamic-true"},
-		{name: "task-if-dynamic-false", task: "task-if-dynamic-false", verbose: true},
+		{
+			name: "basic wildcard",
+			call: "wildcard-foo",
+		},
+		{
+			name: "double wildcard",
+			call: "foo-wildcard-bar",
+		},
+		{
+			name: "store wildcard",
+			call: "start-foo",
+		},
+		{
+			name: "matches exactly",
+			call: "matches-exactly-*",
+		},
+		{
+			name:    "no matches",
+			call:    "no-match",
+			wantErr: true,
+		},
+		{
+			name: "multiple matches",
+			call: "wildcard-foo-bar",
+		},
 	}

 	for _, test := range tests {
 		opts := []ExecutorTestOption{
 			WithName(test.name),
+			WithNodeDir("testdata/wildcards"),
 			WithExecutorOptions(
-				task.WithDir("testdata/if"),
 				task.WithSilent(true),
-				task.WithVerbose(test.verbose),
+				task.WithForce(true),
 			),
-			WithTask(test.task),
+			WithTask(test.call),
 		}
-		if test.vars != nil {
-			for k, v := range test.vars {
-				opts = append(opts, WithVar(k, v))
-			}
+		if test.wantErr {
+			opts = append(opts, WithRunError())
 		}
 		NewExecutorTest(t, opts...)
 	}
--- a/experiments/experiments.go
+++ b/experiments/experiments.go
@@ -9,7 +9,6 @@ import (
 	"github.com/joho/godotenv"

 	"github.com/go-task/task/v3/taskrc"
-	"github.com/go-task/task/v3/taskrc/ast"
 )

 const envPrefix = "TASK_X_"
@@ -32,13 +31,16 @@ var (
 var xList []Experiment

 func Parse(dir string) {
-	config, _ := taskrc.GetConfig(dir)
-	ParseWithConfig(dir, config)
-}
-
-func ParseWithConfig(dir string, config *ast.TaskRC) {
 	// Read any .env files
 	readDotEnv(dir)
+
+	// Create a node for the Task config reader
+	node, _ := taskrc.NewNode("", dir)
+
+	// Read the Task config file
+	reader := taskrc.NewReader()
+	config, _ := reader.Read(node)
+
 	// Initialize the experiments
 	GentleForce = New("GENTLE_FORCE", config, 1)
 	RemoteTaskfiles = New("REMOTE_TASKFILES", config, 1)
--- a/formatter_test.go
+++ b/formatter_test.go
@@ -2,7 +2,9 @@ package task_test

 import (
 	"bytes"
+	"context"
 	"path/filepath"
+	"slices"
 	"testing"

 	"github.com/sebdah/goldie/v2"
@@ -10,6 +12,7 @@ import (

 	"github.com/go-task/task/v3"
 	"github.com/go-task/task/v3/experiments"
+	"github.com/go-task/task/v3/taskfile"
 	"github.com/go-task/task/v3/taskfile/ast"
 )

@@ -26,12 +29,17 @@ type (
 	// running `task gen:fixtures`.
 	FormatterTest struct {
 		TaskTest
-		task           string
-		vars           map[string]any
-		executorOpts   []task.ExecutorOption
-		listOptions    task.ListOptions
-		wantSetupError bool
-		wantListError  bool
+		task            string
+		vars            map[string]any
+		nodeDir         string
+		nodeEntrypoint  string
+		nodeInsecure    bool
+		readerOpts      []taskfile.ReaderOption
+		executorOpts    []task.ExecutorOption
+		listOptions     task.ListOptions
+		wantReaderError bool
+		wantSetupError  bool
+		wantListError   bool
 	}
 )

@@ -41,8 +49,9 @@ type (
 func NewFormatterTest(t *testing.T, opts ...FormatterTestOption) {
 	t.Helper()
 	tt := &FormatterTest{
-		task: "default",
-		vars: map[string]any{},
+		task:    "default",
+		vars:    map[string]any{},
+		nodeDir: ".",
 		TaskTest: TaskTest{
 			experiments:         map[*experiments.Experiment]int{},
 			fixtureTemplateData: map[string]any{},
@@ -114,24 +123,57 @@ func (tt *FormatterTest) run(t *testing.T) {
 	f := func(t *testing.T) {
 		t.Helper()
 		var buf bytes.Buffer
+		ctx := context.Background()

-		opts := append(
-			tt.executorOpts,
-			task.WithStdout(&buf),
-			task.WithStderr(&buf),
+		// Create a new root node for the given entrypoint
+		node, err := taskfile.NewRootNode(
+			tt.nodeEntrypoint,
+			tt.nodeDir,
+			tt.nodeInsecure,
 		)
-
-		// Set up the task executor
-		e := task.NewExecutor(opts...)
+		require.NoError(t, err)

 		// Create a golden fixture file for the output
 		g := goldie.New(t,
-			goldie.WithFixtureDir(filepath.Join(e.Dir, "testdata")),
-			goldie.WithEqualFn(NormalizedEqual),
+			goldie.WithFixtureDir(filepath.Join(node.Dir(), "testdata")),
 		)

-		// Call setup and check for errors
-		if err := e.Setup(); tt.wantSetupError {
+		// Set up a temporary directory for the taskfile reader and task executor
+		tempDir, err := task.NewTempDir(node.Dir())
+		require.NoError(t, err)
+		tt.readerOpts = append(tt.readerOpts, taskfile.WithTempDir(tempDir.Remote))
+
+		// Set up the taskfile reader
+		reader := taskfile.NewReader(tt.readerOpts...)
+		graph, err := reader.Read(ctx, node)
+		if tt.wantReaderError {
+			require.Error(t, err)
+			tt.writeFixtureErrReader(t, g, err)
+			tt.writeFixtureBuffer(t, g, buf)
+			return
+		} else {
+			require.NoError(t, err)
+		}
+
+		executorOpts := slices.Concat(
+			// Apply the node directory and temp directory to the executor options
+			// by default, but allow them to by overridden by the test options
+			[]task.ExecutorOption{
+				task.WithDir(node.Dir()),
+				task.WithTempDir(tempDir),
+			},
+			// Apply the executor options from the test
+			tt.executorOpts,
+			// Force the input/output streams to be set to the test buffer
+			[]task.ExecutorOption{
+				task.WithStdout(&buf),
+				task.WithStderr(&buf),
+			},
+		)
+
+		// Set up the task executor
+		executor, err := task.NewExecutor(graph, executorOpts...)
+		if tt.wantSetupError {
 			require.Error(t, err)
 			tt.writeFixtureErrSetup(t, g, err)
 			tt.writeFixtureBuffer(t, g, buf)
@@ -147,7 +189,7 @@ func (tt *FormatterTest) run(t *testing.T) {
 		}

 		// Run the formatter and check for errors
-		if _, err := e.ListTasks(tt.listOptions); tt.wantListError {
+		if _, err := executor.ListTasks(tt.listOptions); tt.wantListError {
 			require.Error(t, err)
 			tt.writeFixtureErrList(t, g, err)
 			tt.writeFixtureBuffer(t, g, buf)
@@ -171,9 +213,7 @@ func TestNoLabelInList(t *testing.T) {
 	t.Parallel()

 	NewFormatterTest(t,
-		WithExecutorOptions(
-			task.WithDir("testdata/label_list"),
-		),
+		WithNodeDir("testdata/label_list"),
 		WithListOptions(task.ListOptions{
 			ListOnlyTasksWithDescriptions: true,
 		}),
@@ -185,9 +225,7 @@ func TestListAllShowsNoDesc(t *testing.T) {
 	t.Parallel()

 	NewFormatterTest(t,
-		WithExecutorOptions(
-			task.WithDir("testdata/list_mixed_desc"),
-		),
+		WithNodeDir("testdata/list_mixed_desc"),
 		WithListOptions(task.ListOptions{
 			ListAllTasks: true,
 		}),
@@ -199,9 +237,7 @@ func TestListCanListDescOnly(t *testing.T) {
 	t.Parallel()

 	NewFormatterTest(t,
-		WithExecutorOptions(
-			task.WithDir("testdata/list_mixed_desc"),
-		),
+		WithNodeDir("testdata/list_mixed_desc"),
 		WithListOptions(task.ListOptions{
 			ListOnlyTasksWithDescriptions: true,
 		}),
@@ -212,9 +248,7 @@ func TestListDescInterpolation(t *testing.T) {
 	t.Parallel()

 	NewFormatterTest(t,
-		WithExecutorOptions(
-			task.WithDir("testdata/list_desc_interpolation"),
-		),
+		WithNodeDir("testdata/list_desc_interpolation"),
 		WithListOptions(task.ListOptions{
 			ListOnlyTasksWithDescriptions: true,
 		}),
@@ -225,9 +259,7 @@ func TestJsonListFormat(t *testing.T) {
 	t.Parallel()

 	NewFormatterTest(t,
-		WithExecutorOptions(
-			task.WithDir("testdata/json_list_format"),
-		),
+		WithNodeDir("testdata/json_list_format"),
 		WithListOptions(task.ListOptions{
 			FormatTaskListAsJSON: true,
 		}),
--- a/go.mod
+++ b/go.mod
@@ -1,136 +1,61 @@
 module github.com/go-task/task/v3

-go 1.25.8
+go 1.23.0

 require (
-	charm.land/bubbles/v2 v2.1.0
-	charm.land/bubbletea/v2 v2.0.2
-	charm.land/lipgloss/v2 v2.0.2
 	github.com/Ladicle/tabwriter v1.0.0
 	github.com/Masterminds/semver/v3 v3.4.0
-	github.com/alecthomas/chroma/v2 v2.23.1
+	github.com/alecthomas/chroma/v2 v2.20.0
 	github.com/chainguard-dev/git-urls v1.0.2
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
+	github.com/davecgh/go-spew v1.1.1
 	github.com/dominikbraun/graph v0.23.0
 	github.com/elliotchance/orderedmap/v3 v3.1.0
-	github.com/fatih/color v1.19.0
+	github.com/fatih/color v1.18.0
 	github.com/fsnotify/fsnotify v1.9.0
+	github.com/go-git/go-billy/v5 v5.6.2
+	github.com/go-git/go-git/v5 v5.16.2
 	github.com/go-task/slim-sprig/v3 v3.0.0
 	github.com/go-task/template v0.2.0
 	github.com/google/uuid v1.6.0
-	github.com/hashicorp/go-getter v1.8.6
 	github.com/joho/godotenv v1.5.1
 	github.com/mitchellh/hashstructure/v2 v2.0.2
-	github.com/puzpuzpuz/xsync/v4 v4.4.0
+	github.com/otiai10/copy v1.14.1
+	github.com/puzpuzpuz/xsync/v3 v3.5.1
 	github.com/sajari/fuzzy v1.0.0
-	github.com/sebdah/goldie/v2 v2.8.0
-	github.com/spf13/pflag v1.0.10
-	github.com/stretchr/testify v1.11.1
-	github.com/zeebo/xxh3 v1.1.0
-	go.yaml.in/yaml/v3 v3.0.4
-	golang.org/x/sync v0.20.0
-	golang.org/x/term v0.42.0
-	mvdan.cc/sh/moreinterp v0.0.0-20260120230322-19def062a997
-	mvdan.cc/sh/v3 v3.13.1
+	github.com/sebdah/goldie/v2 v2.7.1
+	github.com/spf13/pflag v1.0.7
+	github.com/stretchr/testify v1.10.0
+	github.com/zeebo/xxh3 v1.0.2
+	golang.org/x/sync v0.16.0
+	golang.org/x/term v0.33.0
+	gopkg.in/yaml.v3 v3.0.1
+	mvdan.cc/sh/v3 v3.12.0
 )

 require (
-	cel.dev/expr v0.25.1 // indirect
-	cloud.google.com/go v0.123.0 // indirect
-	cloud.google.com/go/auth v0.18.2 // indirect
-	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
-	cloud.google.com/go/compute/metadata v0.9.0 // indirect
-	cloud.google.com/go/iam v1.5.3 // indirect
-	cloud.google.com/go/monitoring v1.24.3 // indirect
-	cloud.google.com/go/storage v1.61.3 // indirect
-	github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0 // indirect
-	github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.55.0 // indirect
-	github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.55.0 // indirect
-	github.com/atotto/clipboard v0.1.4 // indirect
-	github.com/aws/aws-sdk-go-v2 v1.41.5 // indirect
-	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8 // indirect
-	github.com/aws/aws-sdk-go-v2/config v1.32.12 // indirect
-	github.com/aws/aws-sdk-go-v2/credentials v1.19.12 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.22 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.13 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.21 // indirect
-	github.com/aws/aws-sdk-go-v2/service/s3 v1.97.3 // indirect
-	github.com/aws/aws-sdk-go-v2/service/signin v1.0.8 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sso v1.30.13 // indirect
-	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sts v1.41.9 // indirect
-	github.com/aws/smithy-go v1.24.2 // indirect
-	github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/charmbracelet/colorprofile v0.4.2 // indirect
-	github.com/charmbracelet/ultraviolet v0.0.0-20260205113103-524a6607adb8 // indirect
-	github.com/charmbracelet/x/ansi v0.11.6 // indirect
-	github.com/charmbracelet/x/term v0.2.2 // indirect
-	github.com/charmbracelet/x/termios v0.1.1 // indirect
-	github.com/charmbracelet/x/windows v0.2.2 // indirect
-	github.com/clipperhouse/displaywidth v0.11.0 // indirect
-	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
-	github.com/cncf/xds/go v0.0.0-20251210132809-ee656c7534f5 // indirect
+	dario.cat/mergo v1.0.0 // indirect
+	github.com/Microsoft/go-winio v0.6.2 // indirect
+	github.com/ProtonMail/go-crypto v1.1.6 // indirect
+	github.com/cloudflare/circl v1.6.1 // indirect
+	github.com/cyphar/filepath-securejoin v0.4.1 // indirect
 	github.com/dlclark/regexp2 v1.11.5 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/envoyproxy/go-control-plane/envoy v1.36.0 // indirect
-	github.com/envoyproxy/protoc-gen-validate v1.3.0 // indirect
-	github.com/felixge/httpsnoop v1.0.4 // indirect
-	github.com/go-jose/go-jose/v4 v4.1.4 // indirect
-	github.com/go-logr/logr v1.4.3 // indirect
-	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/google/s2a-go v0.1.9 // indirect
-	github.com/googleapis/enterprise-certificate-proxy v0.3.14 // indirect
-	github.com/googleapis/gax-go/v2 v2.17.0 // indirect
-	github.com/hashicorp/aws-sdk-go-base/v2 v2.0.0-beta.72 // indirect
-	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
-	github.com/hashicorp/go-version v1.8.0 // indirect
-	github.com/klauspost/compress v1.18.5 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/klauspost/pgzip v1.2.6 // indirect
-	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
+	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
+	github.com/kevinburke/ssh_config v1.2.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.21 // indirect
-	github.com/mitchellh/go-homedir v1.1.0 // indirect
-	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/pierrec/lz4/v4 v4.1.22 // indirect
-	github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/otiai10/mint v1.6.3 // indirect
+	github.com/pjbgf/sha1cd v0.3.2 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
-	github.com/spiffe/go-spiffe/v2 v2.6.0 // indirect
+	github.com/skeema/knownhosts v1.3.1 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
-	github.com/u-root/u-root v0.15.1-0.20251208185023-2f8c7e763cf8 // indirect
-	github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 // indirect
-	github.com/ulikunitz/xz v0.5.15 // indirect
-	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
-	go.opentelemetry.io/contrib/detectors/gcp v1.39.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0 // indirect
-	go.opentelemetry.io/otel v1.43.0 // indirect
-	go.opentelemetry.io/otel/metric v1.43.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.43.0 // indirect
-	go.opentelemetry.io/otel/sdk/metric v1.43.0 // indirect
-	go.opentelemetry.io/otel/trace v1.43.0 // indirect
-	golang.org/x/crypto v0.49.0 // indirect
-	golang.org/x/net v0.52.0 // indirect
-	golang.org/x/oauth2 v0.36.0 // indirect
-	golang.org/x/sys v0.43.0 // indirect
-	golang.org/x/text v0.35.0 // indirect
-	golang.org/x/time v0.15.0 // indirect
-	google.golang.org/api v0.271.0 // indirect
-	google.golang.org/genproto v0.0.0-20260128011058-8636f8732409 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20260203192932-546029d2fa20 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171 // indirect
-	google.golang.org/grpc v1.79.3 // indirect
-	google.golang.org/protobuf v1.36.11 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	github.com/xanzy/ssh-agent v0.3.3 // indirect
+	golang.org/x/crypto v0.37.0 // indirect
+	golang.org/x/net v0.39.0 // indirect
+	golang.org/x/sys v0.34.0 // indirect
+	gopkg.in/warnings.v0 v0.1.2 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -1,190 +1,83 @@
-cel.dev/expr v0.25.1 h1:1KrZg61W6TWSxuNZ37Xy49ps13NUovb66QLprthtwi4=
-cel.dev/expr v0.25.1/go.mod h1:hrXvqGP6G6gyx8UAHSHJ5RGk//1Oj5nXQ2NI02Nrsg4=
-charm.land/bubbles/v2 v2.1.0 h1:YSnNh5cPYlYjPxRrzs5VEn3vwhtEn3jVGRBT3M7/I0g=
-charm.land/bubbles/v2 v2.1.0/go.mod h1:l97h4hym2hvWBVfmJDtrEHHCtkIKeTEb3TTJ4ZOB3wY=
-charm.land/bubbletea/v2 v2.0.2 h1:4CRtRnuZOdFDTWSff9r8QFt/9+z6Emubz3aDMnf/dx0=
-charm.land/bubbletea/v2 v2.0.2/go.mod h1:3LRff2U4WIYXy7MTxfbAQ+AdfM3D8Xuvz2wbsOD9OHQ=
-charm.land/lipgloss/v2 v2.0.2 h1:xFolbF8JdpNkM2cEPTfXEcW1p6NRzOWTSamRfYEw8cs=
-charm.land/lipgloss/v2 v2.0.2/go.mod h1:KjPle2Qd3YmvP1KL5OMHiHysGcNwq6u83MUjYkFvEkM=
-cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE=
-cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU=
-cloud.google.com/go/auth v0.18.2 h1:+Nbt5Ev0xEqxlNjd6c+yYUeosQ5TtEUaNcN/3FozlaM=
-cloud.google.com/go/auth v0.18.2/go.mod h1:xD+oY7gcahcu7G2SG2DsBerfFxgPAJz17zz2joOFF3M=
-cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc=
-cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c=
-cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs=
-cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10=
-cloud.google.com/go/iam v1.5.3 h1:+vMINPiDF2ognBJ97ABAYYwRgsaqxPbQDlMnbHMjolc=
-cloud.google.com/go/iam v1.5.3/go.mod h1:MR3v9oLkZCTlaqljW6Eb2d3HGDGK5/bDv93jhfISFvU=
-cloud.google.com/go/logging v1.13.1 h1:O7LvmO0kGLaHY/gq8cV7T0dyp6zJhYAOtZPX4TF3QtY=
-cloud.google.com/go/logging v1.13.1/go.mod h1:XAQkfkMBxQRjQek96WLPNze7vsOmay9H5PqfsNYDqvw=
-cloud.google.com/go/longrunning v0.8.0 h1:LiKK77J3bx5gDLi4SMViHixjD2ohlkwBi+mKA7EhfW8=
-cloud.google.com/go/longrunning v0.8.0/go.mod h1:UmErU2Onzi+fKDg2gR7dusz11Pe26aknR4kHmJJqIfk=
-cloud.google.com/go/monitoring v1.24.3 h1:dde+gMNc0UhPZD1Azu6at2e79bfdztVDS5lvhOdsgaE=
-cloud.google.com/go/monitoring v1.24.3/go.mod h1:nYP6W0tm3N9H/bOw8am7t62YTzZY+zUeQ+Bi6+2eonI=
-cloud.google.com/go/storage v1.61.3 h1:VS//ZfBuPGDvakfD9xyPW1RGF1Vy3BWUoVZXgW1KMOg=
-cloud.google.com/go/storage v1.61.3/go.mod h1:JtqK8BBB7TWv0HVGHubtUdzYYrakOQIsMLffZ2Z/HWk=
-cloud.google.com/go/trace v1.11.7 h1:kDNDX8JkaAG3R2nq1lIdkb7FCSi1rCmsEtKVsty7p+U=
-cloud.google.com/go/trace v1.11.7/go.mod h1:TNn9d5V3fQVf6s4SCveVMIBS2LJUqo73GACmq/Tky0s=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0 h1:sBEjpZlNHzK1voKq9695PJSX2o5NEXl7/OL3coiIY0c=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0/go.mod h1:P4WPRUkOhJC13W//jWpyfJNDAIpvRbAUIYLX/4jtlE0=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.55.0 h1:UnDZ/zFfG1JhH/DqxIZYU/1CUAlTUScoXD/LcM2Ykk8=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.55.0/go.mod h1:IA1C1U7jO/ENqm/vhi7V9YYpBsp+IMyqNrEN94N7tVc=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.55.0 h1:7t/qx5Ost0s0wbA/VDrByOooURhp+ikYwv20i9Y07TQ=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.55.0/go.mod h1:vB2GH9GAYYJTO3mEn8oYwzEdhlayZIdQz6zdzgUIRvA=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.55.0 h1:0s6TxfCu2KHkkZPnBfsQ2y5qia0jl3MMrmBhu3nCOYk=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.55.0/go.mod h1:Mf6O40IAyB9zR/1J8nGDDPirZQQPbYJni8Yisy7NTMc=
+dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
+dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
 github.com/Ladicle/tabwriter v1.0.0 h1:DZQqPvMumBDwVNElso13afjYLNp0Z7pHqHnu0r4t9Dg=
 github.com/Ladicle/tabwriter v1.0.0/go.mod h1:c4MdCjxQyTbGuQO/gvqJ+IA/89UEwrsD6hUCW98dyp4=
 github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
 github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw=
+github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
 github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
 github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
-github.com/alecthomas/chroma/v2 v2.23.1 h1:nv2AVZdTyClGbVQkIzlDm/rnhk1E9bU9nXwmZ/Vk/iY=
-github.com/alecthomas/chroma/v2 v2.23.1/go.mod h1:NqVhfBR0lte5Ouh3DcthuUCTUpDC9cxBOfyMbMQPs3o=
-github.com/alecthomas/repr v0.5.2 h1:SU73FTI9D1P5UNtvseffFSGmdNci/O6RsqzeXJtP0Qs=
-github.com/alecthomas/repr v0.5.2/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
-github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
-github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
-github.com/aws/aws-sdk-go-v2 v1.41.5 h1:dj5kopbwUsVUVFgO4Fi5BIT3t4WyqIDjGKCangnV/yY=
-github.com/aws/aws-sdk-go-v2 v1.41.5/go.mod h1:mwsPRE8ceUUpiTgF7QmQIJ7lgsKUPQOUl3o72QBrE1o=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8 h1:eBMB84YGghSocM7PsjmmPffTa+1FBUeNvGvFou6V/4o=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8/go.mod h1:lyw7GFp3qENLh7kwzf7iMzAxDn+NzjXEAGjKS2UOKqI=
-github.com/aws/aws-sdk-go-v2/config v1.32.12 h1:O3csC7HUGn2895eNrLytOJQdoL2xyJy0iYXhoZ1OmP0=
-github.com/aws/aws-sdk-go-v2/config v1.32.12/go.mod h1:96zTvoOFR4FURjI+/5wY1vc1ABceROO4lWgWJuxgy0g=
-github.com/aws/aws-sdk-go-v2/credentials v1.19.12 h1:oqtA6v+y5fZg//tcTWahyN9PEn5eDU/Wpvc2+kJ4aY8=
-github.com/aws/aws-sdk-go-v2/credentials v1.19.12/go.mod h1:U3R1RtSHx6NB0DvEQFGyf/0sbrpJrluENHdPy1j/3TE=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20 h1:zOgq3uezl5nznfoK3ODuqbhVg1JzAGDUhXOsU0IDCAo=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20/go.mod h1:z/MVwUARehy6GAg/yQ1GO2IMl0k++cu1ohP9zo887wE=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21 h1:Rgg6wvjjtX8bNHcvi9OnXWwcE0a2vGpbwmtICOsvcf4=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21/go.mod h1:A/kJFst/nm//cyqonihbdpQZwiUhhzpqTsdbhDdRF9c=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21 h1:PEgGVtPoB6NTpPrBgqSE5hE/o47Ij9qk/SEZFbUOe9A=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21/go.mod h1:p+hz+PRAYlY3zcpJhPwXlLC4C+kqn70WIHwnzAfs6ps=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6 h1:qYQ4pzQ2Oz6WpQ8T3HvGHnZydA72MnLuFK9tJwmrbHw=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6/go.mod h1:O3h0IK87yXci+kg6flUKzJnWeziQUKciKrLjcatSNcY=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.22 h1:rWyie/PxDRIdhNf4DzRk0lvjVOqFJuNnO8WwaIRVxzQ=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.22/go.mod h1:zd/JsJ4P7oGfUhXn1VyLqaRZwPmZwg44Jf2dS84Dm3Y=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7 h1:5EniKhLZe4xzL7a+fU3C2tfUN4nWIqlLesfrjkuPFTY=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7/go.mod h1:x0nZssQ3qZSnIcePWLvcoFisRXJzcTVvYpAAdYX8+GI=
-github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.13 h1:JRaIgADQS/U6uXDqlPiefP32yXTda7Kqfx+LgspooZM=
-github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.13/go.mod h1:CEuVn5WqOMilYl+tbccq8+N2ieCy0gVn3OtRb0vBNNM=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21 h1:c31//R3xgIJMSC8S6hEVq+38DcvUlgFY0FM6mSI5oto=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21/go.mod h1:r6+pf23ouCB718FUxaqzZdbpYFyDtehyZcmP5KL9FkA=
-github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.21 h1:ZlvrNcHSFFWURB8avufQq9gFsheUgjVD9536obIknfM=
-github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.21/go.mod h1:cv3TNhVrssKR0O/xxLJVRfd2oazSnZnkUeTf6ctUwfQ=
-github.com/aws/aws-sdk-go-v2/service/s3 v1.97.3 h1:HwxWTbTrIHm5qY+CAEur0s/figc3qwvLWsNkF4RPToo=
-github.com/aws/aws-sdk-go-v2/service/s3 v1.97.3/go.mod h1:uoA43SdFwacedBfSgfFSjjCvYe8aYBS7EnU5GZ/YKMM=
-github.com/aws/aws-sdk-go-v2/service/signin v1.0.8 h1:0GFOLzEbOyZABS3PhYfBIx2rNBACYcKty+XGkTgw1ow=
-github.com/aws/aws-sdk-go-v2/service/signin v1.0.8/go.mod h1:LXypKvk85AROkKhOG6/YEcHFPoX+prKTowKnVdcaIxE=
-github.com/aws/aws-sdk-go-v2/service/sso v1.30.13 h1:kiIDLZ005EcKomYYITtfsjn7dtOwHDOFy7IbPXKek2o=
-github.com/aws/aws-sdk-go-v2/service/sso v1.30.13/go.mod h1:2h/xGEowcW/g38g06g3KpRWDlT+OTfxxI0o1KqayAB8=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17 h1:jzKAXIlhZhJbnYwHbvUQZEB8KfgAEuG0dc08Bkda7NU=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17/go.mod h1:Al9fFsXjv4KfbzQHGe6V4NZSZQXecFcvaIF4e70FoRA=
-github.com/aws/aws-sdk-go-v2/service/sts v1.41.9 h1:Cng+OOwCHmFljXIxpEVXAGMnBia8MSU6Ch5i9PgBkcU=
-github.com/aws/aws-sdk-go-v2/service/sts v1.41.9/go.mod h1:LrlIndBDdjA/EeXeyNBle+gyCwTlizzW5ycgWnvIxkk=
-github.com/aws/smithy-go v1.24.2 h1:FzA3bu/nt/vDvmnkg+R8Xl46gmzEDam6mZ1hzmwXFng=
-github.com/aws/smithy-go v1.24.2/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
-github.com/aymanbagabas/go-udiff v0.4.1 h1:OEIrQ8maEeDBXQDoGCbbTTXYJMYRCRO1fnodZ12Gv5o=
-github.com/aymanbagabas/go-udiff v0.4.1/go.mod h1:0L9PGwj20lrtmEMeyw4WKJ/TMyDtvAoK9bf2u/mNo3w=
-github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
-github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/alecthomas/chroma/v2 v2.19.0 h1:Im+SLRgT8maArxv81mULDWN8oKxkzboH07CHesxElq4=
+github.com/alecthomas/chroma/v2 v2.19.0/go.mod h1:RVX6AvYm4VfYe/zsk7mjHueLDZor3aWCNE14TFlepBk=
+github.com/alecthomas/chroma/v2 v2.20.0 h1:sfIHpxPyR07/Oylvmcai3X/exDlE8+FA820NTz+9sGw=
+github.com/alecthomas/chroma/v2 v2.20.0/go.mod h1:e7tViK0xh/Nf4BYHl00ycY6rV7b8iXBksI9E359yNmA=
+github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
+github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
+github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
+github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/chainguard-dev/git-urls v1.0.2 h1:pSpT7ifrpc5X55n4aTTm7FFUE+ZQHKiqpiwNkJrVcKQ=
 github.com/chainguard-dev/git-urls v1.0.2/go.mod h1:rbGgj10OS7UgZlbzdUQIQpT0k/D4+An04HJY7Ol+Y/o=
-github.com/charmbracelet/colorprofile v0.4.2 h1:BdSNuMjRbotnxHSfxy+PCSa4xAmz7szw70ktAtWRYrY=
-github.com/charmbracelet/colorprofile v0.4.2/go.mod h1:0rTi81QpwDElInthtrQ6Ni7cG0sDtwAd4C4le060fT8=
-github.com/charmbracelet/ultraviolet v0.0.0-20260205113103-524a6607adb8 h1:eyFRbAmexyt43hVfeyBofiGSEmJ7krjLOYt/9CF5NKA=
-github.com/charmbracelet/ultraviolet v0.0.0-20260205113103-524a6607adb8/go.mod h1:SQpCTRNBtzJkwku5ye4S3HEuthAlGy2n9VXZnWkEW98=
-github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8=
-github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ=
-github.com/charmbracelet/x/exp/golden v0.0.0-20250806222409-83e3a29d542f h1:pk6gmGpCE7F3FcjaOEKYriCvpmIN4+6OS/RD0vm4uIA=
-github.com/charmbracelet/x/exp/golden v0.0.0-20250806222409-83e3a29d542f/go.mod h1:IfZAMTHB6XkZSeXUqriemErjAWCCzT0LwjKFYCZyw0I=
-github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
-github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=
-github.com/charmbracelet/x/termios v0.1.1 h1:o3Q2bT8eqzGnGPOYheoYS8eEleT5ZVNYNy8JawjaNZY=
-github.com/charmbracelet/x/termios v0.1.1/go.mod h1:rB7fnv1TgOPOyyKRJ9o+AsTU/vK5WHJ2ivHeut/Pcwo=
-github.com/charmbracelet/x/windows v0.2.2 h1:IofanmuvaxnKHuV04sC0eBy/smG6kIKrWG2/jYn2GuM=
-github.com/charmbracelet/x/windows v0.2.2/go.mod h1:/8XtdKZzedat74NQFn0NGlGL4soHB0YQZrETF96h75k=
-github.com/clipperhouse/displaywidth v0.11.0 h1:lBc6kY44VFw+TDx4I8opi/EtL9m20WSEFgwIwO+UVM8=
-github.com/clipperhouse/displaywidth v0.11.0/go.mod h1:bkrFNkf81G8HyVqmKGxsPufD3JhNl3dSqnGhOoSD/o0=
-github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk=
-github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
-github.com/cncf/xds/go v0.0.0-20251210132809-ee656c7534f5 h1:6xNmx7iTtyBRev0+D/Tv1FZd4SCg8axKApyNyRsAt/w=
-github.com/cncf/xds/go v0.0.0-20251210132809-ee656c7534f5/go.mod h1:KdCmV+x/BuvyMxRnYBlmVaq4OLiKW6iRQfvC62cvdkI=
+github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0=
+github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
 github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s=
 github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
+github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s=
+github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
-github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
 github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dominikbraun/graph v0.23.0 h1:TdZB4pPqCLFxYhdyMFb1TBdFxp8XLcJfTTBQucVPgCo=
 github.com/dominikbraun/graph v0.23.0/go.mod h1:yOjYyogZLY1LSG9E33JWZJiq5k83Qy2C6POAuiViluc=
-github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
-github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o=
+github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE=
 github.com/elliotchance/orderedmap/v3 v3.1.0 h1:j4DJ5ObEmMBt/lcwIecKcoRxIQUEnw0L804lXYDt/pg=
 github.com/elliotchance/orderedmap/v3 v3.1.0/go.mod h1:G+Hc2RwaZvJMcS4JpGCOyViCnGeKf0bTYCGTO4uhjSo=
-github.com/envoyproxy/go-control-plane v0.14.0 h1:hbG2kr4RuFj222B6+7T83thSPqLjwBIfQawTkC++2HA=
-github.com/envoyproxy/go-control-plane v0.14.0/go.mod h1:NcS5X47pLl/hfqxU70yPwL9ZMkUlwlKxtAohpi2wBEU=
-github.com/envoyproxy/go-control-plane/envoy v1.36.0 h1:yg/JjO5E7ubRyKX3m07GF3reDNEnfOboJ0QySbH736g=
-github.com/envoyproxy/go-control-plane/envoy v1.36.0/go.mod h1:ty89S1YCCVruQAm9OtKeEkQLTb+Lkz0k8v9W0Oxsv98=
-github.com/envoyproxy/go-control-plane/ratelimit v0.1.0 h1:/G9QYbddjL25KvtKTv3an9lx6VBE2cnb8wp1vEGNYGI=
-github.com/envoyproxy/go-control-plane/ratelimit v0.1.0/go.mod h1:Wk+tMFAFbCXaJPzVVHnPgRKdUdwW/KdbRt94AzgRee4=
-github.com/envoyproxy/protoc-gen-validate v1.3.0 h1:TvGH1wof4H33rezVKWSpqKz5NXWg5VPuZ0uONDT6eb4=
-github.com/envoyproxy/protoc-gen-validate v1.3.0/go.mod h1:HvYl7zwPa5mffgyeTUHA9zHIH36nmrm7oCbo4YKoSWA=
-github.com/fatih/color v1.19.0 h1:Zp3PiM21/9Ld6FzSKyL5c/BULoe/ONr9KlbYVOfG8+w=
-github.com/fatih/color v1.19.0/go.mod h1:zNk67I0ZUT1bEGsSGyCZYZNrHuTkJJB+r6Q9VuMi0LE=
-github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
-github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
+github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
 github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
-github.com/go-jose/go-jose/v4 v4.1.4 h1:moDMcTHmvE6Groj34emNPLs/qtYXRVcd6S7NHbHz3kA=
-github.com/go-jose/go-jose/v4 v4.1.4/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08=
-github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
-github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
-github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
+github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
+github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
+github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
+github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=
+github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=
+github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
+github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
+github.com/go-git/go-git/v5 v5.16.2 h1:fT6ZIOjE5iEnkzKyxTHK1W4HGAsPhqEqiSAssSO77hM=
+github.com/go-git/go-git/v5 v5.16.2/go.mod h1:4Ge4alE/5gPs30F2H1esi2gPd69R0C39lolkucHBOp8=
 github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
 github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
 github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
 github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
 github.com/go-task/template v0.2.0 h1:xW7ek0o65FUSTbKcSNeg2Vyf/I7wYXFgLUznptvviBE=
 github.com/go-task/template v0.2.0/go.mod h1:dbdoUb6qKnHQi1y6o+IdIrs0J4o/SEhSTA6bbzZmdtc=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/martian/v3 v3.3.3 h1:DIhPTQrbPkgs2yJYdXU/eNACCG5DVQjySNRNlflZ9Fc=
-github.com/google/martian/v3 v3.3.3/go.mod h1:iEPrYcgCF7jA9OtScMFQyAlZZ4YXTKEtJ1E6RWzmBA0=
-github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0=
-github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/enterprise-certificate-proxy v0.3.14 h1:yh8ncqsbUY4shRD5dA6RlzjJaT4hi3kII+zYw8wmLb8=
-github.com/googleapis/enterprise-certificate-proxy v0.3.14/go.mod h1:vqVt9yG9480NtzREnTlmGSBmFrA+bzb0yl0TxoBQXOg=
-github.com/googleapis/gax-go/v2 v2.17.0 h1:RksgfBpxqff0EZkDWYuz9q/uWsTVz+kf43LsZ1J6SMc=
-github.com/googleapis/gax-go/v2 v2.17.0/go.mod h1:mzaqghpQp4JDh3HvADwrat+6M3MOIDp5YKHhb9PAgDY=
-github.com/hashicorp/aws-sdk-go-base/v2 v2.0.0-beta.72 h1:vTCWu1wbdYo7PEZFem/rlr01+Un+wwVmI7wiegFdRLk=
-github.com/hashicorp/aws-sdk-go-base/v2 v2.0.0-beta.72/go.mod h1:Vn+BBgKQHVQYdVQ4NZDICE1Brb+JfaONyDHr3q07oQc=
-github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
-github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
-github.com/hashicorp/go-getter v1.8.6 h1:9sQboWULaydVphxc4S64oAI4YqpuCk7nPmvbk131ebY=
-github.com/hashicorp/go-getter v1.8.6/go.mod h1:nVH12eOV2P58dIiL3rsU6Fh3wLeJEKBOJzhMmzlSWoo=
-github.com/hashicorp/go-version v1.8.0 h1:KAkNb1HAiZd1ukkxDFGmokVZe1Xy9HG6NUp+bPle2i4=
-github.com/hashicorp/go-version v1.8.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
+github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
+github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/klauspost/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE=
-github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
-github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
-github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
-github.com/klauspost/pgzip v1.2.6 h1:8RXeL5crjEUFnR2/Sn6GJNWtSQ3Dk8pq4CL3jvdDyjU=
-github.com/klauspost/pgzip v1.2.6/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
+github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
+github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
@@ -192,132 +85,93 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
-github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.21 h1:jJKAZiQH+2mIinzCJIaIG9Be1+0NR+5sz/lYEEjdM8w=
-github.com/mattn/go-runewidth v0.0.21/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
-github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
-github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=
 github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=
-github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
-github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
-github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU=
-github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
+github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
+github.com/otiai10/copy v1.14.1 h1:5/7E6qsUMBaH5AnQ0sSLzzTg1oTECmcCmT6lvF45Na8=
+github.com/otiai10/copy v1.14.1/go.mod h1:oQwrEDDOci3IM8dJF0d8+jnbfPDllW6vUjNc3DoZm9I=
+github.com/otiai10/mint v1.6.3 h1:87qsV/aw1F5as1eH1zS/yqHY85ANKVMgkDrf9rcxbQs=
+github.com/otiai10/mint v1.6.3/go.mod h1:MJm72SBthJjz8qhefc4z1PYEieWmy8Bku7CjcAqyUSM=
+github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
+github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo=
-github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
-github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/puzpuzpuz/xsync/v4 v4.4.0 h1:vlSN6/CkEY0pY8KaB0yqo/pCLZvp9nhdbBdjipT4gWo=
-github.com/puzpuzpuz/xsync/v4 v4.4.0/go.mod h1:VJDmTCJMBt8igNxnkQd86r+8KUeN1quSfNKu5bLYFQo=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg=
+github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/sajari/fuzzy v1.0.0 h1:+FmwVvJErsd0d0hAPlj4CxqxUtQY/fOoY0DwX4ykpRY=
 github.com/sajari/fuzzy v1.0.0/go.mod h1:OjYR6KxoWOe9+dOlXeiCJd4dIbED4Oo8wpS89o0pwOo=
-github.com/sebdah/goldie/v2 v2.8.0 h1:dZb9wR8q5++oplmEiJT+U/5KyotVD+HNGCAc5gNr8rc=
-github.com/sebdah/goldie/v2 v2.8.0/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI=
+github.com/sebdah/goldie/v2 v2.7.1 h1:PkBHymaYdtvEkZV7TmyqKxdmn5/Vcj+8TpATWZjnG5E=
+github.com/sebdah/goldie/v2 v2.7.1/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
-github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
-github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spiffe/go-spiffe/v2 v2.6.0 h1:l+DolpxNWYgruGQVV0xsfeya3CsC7m8iBzDnMpsbLuo=
-github.com/spiffe/go-spiffe/v2 v2.6.0/go.mod h1:gm2SeUoMZEtpnzPNs2Csc0D/gX33k1xIx7lEzqblHEs=
+github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=
+github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=
+github.com/spf13/pflag v1.0.7 h1:vN6T9TfwStFPFM5XzjsvmzZkLuaLX+HS+0SeFLRgU6M=
+github.com/spf13/pflag v1.0.7/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/u-root/u-root v0.15.1-0.20251208185023-2f8c7e763cf8 h1:cq+DjLAjz3ZPwh0+G571O/jMH0c0DzReDPLjQGL2/BA=
-github.com/u-root/u-root v0.15.1-0.20251208185023-2f8c7e763cf8/go.mod h1:JNauIV2zopCBv/6o+umxcT3bKe8YUqYJaTZQYSYpKss=
-github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 h1:pyC9PaHYZFgEKFdlp3G8RaCKgVpHZnecvArXvPXcFkM=
-github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701/go.mod h1:P3a5rG4X7tI17Nn3aOIAYr5HbIMukwXG0urG0WuL8OA=
-github.com/ulikunitz/xz v0.5.15 h1:9DNdB5s+SgV3bQ2ApL10xRc35ck0DuIX/isZvIk+ubY=
-github.com/ulikunitz/xz v0.5.15/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
+github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
 github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
 github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
-github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
-github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
-go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
-go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
-go.opentelemetry.io/contrib/detectors/gcp v1.39.0 h1:kWRNZMsfBHZ+uHjiH4y7Etn2FK26LAGkNFw7RHv1DhE=
-go.opentelemetry.io/contrib/detectors/gcp v1.39.0/go.mod h1:t/OGqzHBa5v6RHZwrDBJ2OirWc+4q/w2fTbLZwAKjTk=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0 h1:YH4g8lQroajqUwWbq/tr2QX1JFmEXaDLgG+ew9bLMWo=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0/go.mod h1:fvPi2qXDqFs8M4B4fmJhE92TyQs9Ydjlg3RvfUp+NbQ=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0 h1:F7Jx+6hwnZ41NSFTO5q4LYDtJRXBf2PD0rNBkeB/lus=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0/go.mod h1:UHB22Z8QsdRDrnAtX4PntOl36ajSxcdUMt1sF7Y6E7Q=
-go.opentelemetry.io/otel v1.43.0 h1:mYIM03dnh5zfN7HautFE4ieIig9amkNANT+xcVxAj9I=
-go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0=
-go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.40.0 h1:ZrPRak/kS4xI3AVXy8F7pipuDXmDsrO8Lg+yQjBLjw0=
-go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.40.0/go.mod h1:3y6kQCWztq6hyW8Z9YxQDDm0Je9AJoFar2G0yDcmhRk=
-go.opentelemetry.io/otel/metric v1.43.0 h1:d7638QeInOnuwOONPp4JAOGfbCEpYb+K6DVWvdxGzgM=
-go.opentelemetry.io/otel/metric v1.43.0/go.mod h1:RDnPtIxvqlgO8GRW18W6Z/4P462ldprJtfxHxyKd2PY=
-go.opentelemetry.io/otel/sdk v1.43.0 h1:pi5mE86i5rTeLXqoF/hhiBtUNcrAGHLKQdhg4h4V9Dg=
-go.opentelemetry.io/otel/sdk v1.43.0/go.mod h1:P+IkVU3iWukmiit/Yf9AWvpyRDlUeBaRg6Y+C58QHzg=
-go.opentelemetry.io/otel/sdk/metric v1.43.0 h1:S88dyqXjJkuBNLeMcVPRFXpRw2fuwdvfCGLEo89fDkw=
-go.opentelemetry.io/otel/sdk/metric v1.43.0/go.mod h1:C/RJtwSEJ5hzTiUz5pXF1kILHStzb9zFlIEe85bhj6A=
-go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09nk+3A=
-go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
-go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
-golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
-golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 h1:nDVHiLt8aIbd/VzvPWN6kSOPE7+F/fNFDSXLVYkE/Iw=
-golang.org/x/exp v0.0.0-20250305212735-054e65f0b394/go.mod h1:sIifuuw/Yco/y6yb6+bDNfyeQ/MdPUy/hKEMYQV17cM=
-golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
-golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
-golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
-golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
-golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
+github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
+golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
+golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
+golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
-golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU=
-golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A=
-golang.org/x/term v0.42.0 h1:UiKe+zDFmJobeJ5ggPwOshJIVt6/Ft0rcfrXZDLWAWY=
-golang.org/x/term v0.42.0/go.mod h1:Dq/D+snpsbazcBG5+F9Q1n2rXV8Ma+71xEjTRufARgY=
-golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
-golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
-golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
-golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
-gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
-gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/api v0.271.0 h1:cIPN4qcUc61jlh7oXu6pwOQqbJW2GqYh5PS6rB2C/JY=
-google.golang.org/api v0.271.0/go.mod h1:CGT29bhwkbF+i11qkRUJb2KMKqcJ1hdFceEIRd9u64Q=
-google.golang.org/genproto v0.0.0-20260128011058-8636f8732409 h1:VQZ/yAbAtjkHgH80teYd2em3xtIkkHd7ZhqfH2N9CsM=
-google.golang.org/genproto v0.0.0-20260128011058-8636f8732409/go.mod h1:rxKD3IEILWEu3P44seeNOAwZN4SaoKaQ/2eTg4mM6EM=
-google.golang.org/genproto/googleapis/api v0.0.0-20260203192932-546029d2fa20 h1:7ei4lp52gK1uSejlA8AZl5AJjeLUOHBQscRQZUgAcu0=
-google.golang.org/genproto/googleapis/api v0.0.0-20260203192932-546029d2fa20/go.mod h1:ZdbssH/1SOVnjnDlXzxDHK2MCidiqXtbYccJNzNYPEE=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171 h1:ggcbiqK8WWh6l1dnltU4BgWGIGo+EVYxCaAPih/zQXQ=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
-google.golang.org/grpc v1.79.3 h1:sybAEdRIEtvcD68Gx7dmnwjZKlyfuc61Dyo9pGXXkKE=
-google.golang.org/grpc v1.79.3/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ=
-google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
-google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
+golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.33.0 h1:NuFncQrRcaRvVmgRkvM3j/F00gWIAlcmlB8ACEKmGIg=
+golang.org/x/term v0.33.0/go.mod h1:s18+ql9tYWp1IfpV9DmCtQDDSRBUjKaw9M1eAv5UeF0=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
+golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-mvdan.cc/sh/moreinterp v0.0.0-20260120230322-19def062a997 h1:3bbJwtPFh98dJ6lxRdR3eLHTH1CmR3BcU6TriIMiXjE=
-mvdan.cc/sh/moreinterp v0.0.0-20260120230322-19def062a997/go.mod h1:Qy/zdaMDxq9sT72Gi43K3gsV+TtTohyDO3f1cyBVwuo=
-mvdan.cc/sh/v3 v3.13.1 h1:DP3TfgZhDkT7lerUdnp6PTGKyxxzz6T+cOlY/xEvfWk=
-mvdan.cc/sh/v3 v3.13.1/go.mod h1:lXJ8SexMvEVcHCoDvAGLZgFJ9Wsm2sulmoNEXGhYZD0=
+mvdan.cc/sh/v3 v3.12.0 h1:ejKUR7ONP5bb+UGHGEG/k9V5+pRVIyD+LsZz7o8KHrI=
+mvdan.cc/sh/v3 v3.12.0/go.mod h1:Se6Cj17eYSn+sNooLZiEUnNNmNxg0imoYlTu4CyaGyg=
--- a/help.go
+++ b/help.go
@@ -24,17 +24,15 @@ type ListOptions struct {
 	ListAllTasks                  bool
 	FormatTaskListAsJSON          bool
 	NoStatus                      bool
-	Nested                        bool
 }

 // NewListOptions creates a new ListOptions instance
-func NewListOptions(list, listAll, listAsJson, noStatus, nested bool) ListOptions {
+func NewListOptions(list, listAll, listAsJson, noStatus bool) ListOptions {
 	return ListOptions{
 		ListOnlyTasksWithDescriptions: list,
 		ListAllTasks:                  listAll,
 		FormatTaskListAsJSON:          listAsJson,
 		NoStatus:                      noStatus,
-		Nested:                        nested,
 	}
 }

@@ -65,7 +63,7 @@ func (e *Executor) ListTasks(o ListOptions) (bool, error) {
 		return false, err
 	}
 	if o.FormatTaskListAsJSON {
-		output, err := e.ToEditorOutput(tasks, o.NoStatus, o.Nested)
+		output, err := e.ToEditorOutput(tasks, o.NoStatus)
 		if err != nil {
 			return false, err
 		}
@@ -137,17 +135,33 @@ func (e *Executor) ListTaskNames(allTasks bool) error {
 	return nil
 }

-func (e *Executor) ToEditorOutput(tasks []*ast.Task, noStatus bool, nested bool) (*editors.Namespace, error) {
+func (e *Executor) ToEditorOutput(tasks []*ast.Task, noStatus bool) (*editors.Taskfile, error) {
+	o := &editors.Taskfile{
+		Tasks:    make([]editors.Task, len(tasks)),
+		Location: e.Taskfile.Location,
+	}
 	var g errgroup.Group
-	editorTasks := make([]editors.Task, len(tasks))
-
-	// Look over each task in parallel and turn it into an editor task
 	for i := range tasks {
+		aliases := []string{}
+		if len(tasks[i].Aliases) > 0 {
+			aliases = tasks[i].Aliases
+		}
 		g.Go(func() error {
-			editorTask := editors.NewTask(tasks[i])
+			o.Tasks[i] = editors.Task{
+				Name:     tasks[i].Name(),
+				Task:     tasks[i].Task,
+				Desc:     tasks[i].Desc,
+				Summary:  tasks[i].Summary,
+				Aliases:  aliases,
+				UpToDate: false,
+				Location: &editors.Location{
+					Line:     tasks[i].Location.Line,
+					Column:   tasks[i].Location.Column,
+					Taskfile: tasks[i].Location.Taskfile,
+				},
+			}

 			if noStatus {
-				editorTasks[i] = editorTask
 				return nil
 			}

@@ -166,35 +180,10 @@ func (e *Executor) ToEditorOutput(tasks []*ast.Task, noStatus bool, nested bool)
 				return err
 			}

-			editorTask.UpToDate = &upToDate
-			editorTasks[i] = editorTask
+			o.Tasks[i].UpToDate = upToDate
+
 			return nil
 		})
 	}
-	if err := g.Wait(); err != nil {
-		return nil, err
-	}
-
-	// Create the root namespace
-	var tasksLen int
-	if !nested {
-		tasksLen = len(editorTasks)
-	}
-	rootNamespace := &editors.Namespace{
-		Tasks:    make([]editors.Task, tasksLen),
-		Location: e.Taskfile.Location,
-	}
-
-	// Recursively add namespaces to the root namespace or if nesting is
-	// disabled add them all to the root namespace
-	for i, task := range editorTasks {
-		taskNamespacePath := strings.Split(task.Task, ast.NamespaceSeparator)
-		if nested {
-			rootNamespace.AddNamespace(taskNamespacePath, task)
-		} else {
-			rootNamespace.Tasks[i] = task
-		}
-	}
-
-	return rootNamespace, g.Wait()
+	return o, g.Wait()
 }
--- a/init.go
+++ b/init.go
@@ -6,10 +6,9 @@ import (

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/taskfile"
 )

-const defaultFilename = "Taskfile.yml"
+const defaultTaskFilename = "Taskfile.yml"

 //go:embed taskfile/templates/default.yml
 var DefaultTaskfile string
@@ -21,30 +20,22 @@ var DefaultTaskfile string
 //
 // The final file path is always returned and may be different from the input path.
 func InitTaskfile(path string) (string, error) {
-	info, err := os.Stat(path)
-	if err == nil && !info.IsDir() {
+	fi, err := os.Stat(path)
+	if err == nil && !fi.IsDir() {
 		return path, errors.TaskfileAlreadyExistsError{}
 	}

-	if info != nil && info.IsDir() {
-		// path was a directory, check if there is a Taskfile already
-		if hasDefaultTaskfile(path) {
+	if fi != nil && fi.IsDir() {
+		path = filepathext.SmartJoin(path, defaultTaskFilename)
+		// path was a directory, so check if Taskfile.yml exists in it
+		if _, err := os.Stat(path); err == nil {
 			return path, errors.TaskfileAlreadyExistsError{}
 		}
-		path = filepathext.SmartJoin(path, defaultFilename)
 	}

 	if err := os.WriteFile(path, []byte(DefaultTaskfile), 0o644); err != nil {
 		return path, err
 	}
+
 	return path, nil
 }
-
-func hasDefaultTaskfile(dir string) bool {
-	for _, name := range taskfile.DefaultTaskfiles {
-		if _, err := os.Stat(filepathext.SmartJoin(dir, name)); err == nil {
-			return true
-		}
-	}
-	return false
-}
--- a/internal/deepcopy/deepcopy.go
+++ b/internal/deepcopy/deepcopy.go
@@ -10,15 +10,6 @@ type Copier[T any] interface {
 	DeepCopy() T
 }

-func Scalar[T any](orig *T) *T {
-	if orig == nil {
-		return nil
-	} else {
-		v := *orig
-		return &v
-	}
-}
-
 func Slice[T any](orig []T) []T {
 	if orig == nil {
 		return nil
--- a/internal/editors/output.go
+++ b/internal/editors/output.go
@@ -1,15 +1,10 @@
 package editors

-import (
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
 type (
-	// Namespace wraps task list output for use in editor integrations (e.g. VSCode, etc)
-	Namespace struct {
-		Tasks      []Task                `json:"tasks"`
-		Namespaces map[string]*Namespace `json:"namespaces,omitempty"`
-		Location   string                `json:"location,omitempty"`
+	// Taskfile wraps task list output for use in editor integrations (e.g. VSCode, etc)
+	Taskfile struct {
+		Tasks    []Task `json:"tasks"`
+		Location string `json:"location"`
 	}
 	// Task describes a single task
 	Task struct {
@@ -18,7 +13,7 @@ type (
 		Desc     string    `json:"desc"`
 		Summary  string    `json:"summary"`
 		Aliases  []string  `json:"aliases"`
-		UpToDate *bool     `json:"up_to_date,omitempty"`
+		UpToDate bool      `json:"up_to_date"`
 		Location *Location `json:"location"`
 	}
 	// Location describes a task's location in a taskfile
@@ -28,59 +23,3 @@ type (
 		Taskfile string `json:"taskfile"`
 	}
 )
-
-func NewTask(task *ast.Task) Task {
-	aliases := []string{}
-	if len(task.Aliases) > 0 {
-		aliases = task.Aliases
-	}
-	return Task{
-		Name:    task.Name(),
-		Task:    task.Task,
-		Desc:    task.Desc,
-		Summary: task.Summary,
-		Aliases: aliases,
-		Location: &Location{
-			Line:     task.Location.Line,
-			Column:   task.Location.Column,
-			Taskfile: task.Location.Taskfile,
-		},
-	}
-}
-
-func (parent *Namespace) AddNamespace(namespacePath []string, task Task) {
-	if len(namespacePath) == 0 {
-		return
-	}
-
-	// If there are no child namespaces, then we have found a task and we can
-	// simply add it to the current namespace
-	if len(namespacePath) == 1 {
-		parent.Tasks = append(parent.Tasks, task)
-		return
-	}
-
-	// Get the key of the current namespace in the path
-	namespaceKey := namespacePath[0]
-
-	// Add the namespace to the parent namespaces map using the namespace key
-	if parent.Namespaces == nil {
-		parent.Namespaces = make(map[string]*Namespace, 0)
-	}
-
-	// Search for the current namespace in the parent namespaces map
-	// If it doesn't exist, create it
-	namespace, ok := parent.Namespaces[namespaceKey]
-	if !ok {
-		namespace = &Namespace{}
-		parent.Namespaces[namespaceKey] = namespace
-	}
-
-	// Remove the current namespace key from the namespace path.
-	childNamespacePath := namespacePath[1:]
-
-	// If there are no child namespaces in the task name, then we have found the
-	// namespace of the task and we can add it to the current namespace.
-	// Otherwise, we need to go deeper
-	namespace.AddNamespace(childNamespacePath, task)
-}
--- a/internal/env/env.go
+++ b/internal/env/env.go
@@ -3,9 +3,7 @@ package env
 import (
 	"fmt"
 	"os"
-	"strconv"
 	"strings"
-	"time"

 	"github.com/go-task/task/v3/experiments"
 	"github.com/go-task/task/v3/taskfile/ast"
@@ -63,63 +61,3 @@ func isTypeAllowed(v any) bool {
 func GetTaskEnv(key string) string {
 	return os.Getenv(taskVarPrefix + key)
 }
-
-// GetTaskEnvBool returns the boolean value of a TASK_ prefixed env var.
-// Returns the value and true if set and valid, or false and false if not set or invalid.
-func GetTaskEnvBool(key string) (bool, bool) {
-	v := GetTaskEnv(key)
-	if v == "" {
-		return false, false
-	}
-	b, err := strconv.ParseBool(v)
-	return b, err == nil
-}
-
-// GetTaskEnvInt returns the integer value of a TASK_ prefixed env var.
-// Returns the value and true if set and valid, or 0 and false if not set or invalid.
-func GetTaskEnvInt(key string) (int, bool) {
-	v := GetTaskEnv(key)
-	if v == "" {
-		return 0, false
-	}
-	i, err := strconv.Atoi(v)
-	return i, err == nil
-}
-
-// GetTaskEnvDuration returns the duration value of a TASK_ prefixed env var.
-// Returns the value and true if set and valid, or 0 and false if not set or invalid.
-func GetTaskEnvDuration(key string) (time.Duration, bool) {
-	v := GetTaskEnv(key)
-	if v == "" {
-		return 0, false
-	}
-	d, err := time.ParseDuration(v)
-	return d, err == nil
-}
-
-// GetTaskEnvString returns the string value of a TASK_ prefixed env var.
-// Returns the value and true if set (non-empty), or empty string and false if not set.
-func GetTaskEnvString(key string) (string, bool) {
-	v := GetTaskEnv(key)
-	return v, v != ""
-}
-
-// GetTaskEnvStringSlice returns a comma-separated list from a TASK_ prefixed env var.
-// Returns the slice and true if set (non-empty), or nil and false if not set.
-func GetTaskEnvStringSlice(key string) ([]string, bool) {
-	v := GetTaskEnv(key)
-	if v == "" {
-		return nil, false
-	}
-	parts := strings.Split(v, ",")
-	result := make([]string, 0, len(parts))
-	for _, p := range parts {
-		if trimmed := strings.TrimSpace(p); trimmed != "" {
-			result = append(result, trimmed)
-		}
-	}
-	if len(result) == 0 {
-		return nil, false
-	}
-	return result, true
-}
--- a/internal/execext/coreutils.go
+++ b/internal/execext/coreutils.go
@@ -1,20 +0,0 @@
-package execext
-
-import (
-	"runtime"
-	"strconv"
-
-	"github.com/go-task/task/v3/internal/env"
-)
-
-var useGoCoreUtils bool
-
-func init() {
-	// If TASK_CORE_UTILS is set to either true or false, respect that.
-	// By default, enable on Windows only.
-	if v, err := strconv.ParseBool(env.GetTaskEnv("CORE_UTILS")); err == nil {
-		useGoCoreUtils = v
-	} else {
-		useGoCoreUtils = runtime.GOOS == "windows"
-	}
-}
--- a/internal/execext/exec.go
+++ b/internal/execext/exec.go
@@ -7,8 +7,8 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"time"

-	"mvdan.cc/sh/moreinterp/coreutils"
 	"mvdan.cc/sh/v3/expand"
 	"mvdan.cc/sh/v3/interp"
 	"mvdan.cc/sh/v3/syntax"
@@ -59,7 +59,7 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 	r, err := interp.New(
 		interp.Params(params...),
 		interp.Env(expand.ListEnviron(environ...)),
-		interp.ExecHandlers(execHandlers()...),
+		interp.ExecHandlers(execHandler),
 		interp.OpenHandler(openHandler),
 		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
 		dirOption(opts.Dir),
@@ -127,8 +127,12 @@ func ExpandFields(s string) ([]string, error) {
 	s = escape(s)
 	p := syntax.NewParser()
 	var words []*syntax.Word
-	for w := range p.WordsSeq(strings.NewReader(s)) {
+	err := p.Words(strings.NewReader(s), func(w *syntax.Word) bool {
 		words = append(words, w)
+		return true
+	})
+	if err != nil {
+		return nil, err
 	}
 	cfg := &expand.Config{
 		Env:      expand.FuncEnviron(os.Getenv),
@@ -139,11 +143,8 @@ func ExpandFields(s string) ([]string, error) {
 	return expand.Fields(cfg, words...)
 }

-func execHandlers() (handlers []func(next interp.ExecHandlerFunc) interp.ExecHandlerFunc) {
-	if useGoCoreUtils {
-		handlers = append(handlers, coreutils.ExecHandler)
-	}
-	return handlers
+func execHandler(next interp.ExecHandlerFunc) interp.ExecHandlerFunc {
+	return interp.DefaultExecHandler(15 * time.Second)
 }

 func openHandler(ctx context.Context, path string, flag int, perm os.FileMode) (io.ReadWriteCloser, error) {
--- a/internal/fingerprint/glob.go
+++ b/internal/fingerprint/glob.go
@@ -2,7 +2,6 @@ package fingerprint

 import (
 	"os"
-	"path/filepath"
 	"sort"

 	"github.com/go-task/task/v3/internal/execext"
@@ -51,8 +50,7 @@ func collectKeys(m map[string]bool) []string {
 	keys := make([]string, 0, len(m))
 	for k, v := range m {
 		if v {
-			// Normalize path separators for consistent sorting across platforms
-			keys = append(keys, filepath.ToSlash(k))
+			keys = append(keys, k)
 		}
 	}
 	sort.Strings(keys)
--- a/internal/fingerprint/sources_checksum.go
+++ b/internal/fingerprint/sources_checksum.go
@@ -53,7 +53,6 @@ func (checker *ChecksumChecker) IsUpToDate(t *ast.Task) (bool, error) {
 	if len(t.Generates) > 0 {
 		// For each specified 'generates' field, check whether the files actually exist
 		for _, g := range t.Generates {
-			// Exclusion patterns don't represent output files; skip them.
 			if g.Negate {
 				continue
 			}
--- a/internal/fingerprint/sources_timestamp.go
+++ b/internal/fingerprint/sources_timestamp.go
@@ -32,28 +32,6 @@ func (checker *TimestampChecker) IsUpToDate(t *ast.Task) (bool, error) {
 	if err != nil {
 		return false, nil
 	}
-
-	// If generates are declared, ensure they all exist. A missing generated
-	// file means the task must run regardless of timestamps.
-	if len(t.Generates) > 0 {
-		for _, g := range t.Generates {
-			// Exclusion patterns don't represent output files; skip them.
-			if g.Negate {
-				continue
-			}
-			files, err := glob(t.Dir, g.Glob)
-			if os.IsNotExist(err) {
-				return false, nil
-			}
-			if err != nil {
-				return false, err
-			}
-			if len(files) == 0 {
-				return false, nil
-			}
-		}
-	}
-
 	generates, err := Globs(t.Dir, t.Generates)
 	if err != nil {
 		return false, nil
--- a/internal/fingerprint/task_test.go
+++ b/internal/fingerprint/task_test.go
@@ -1,6 +1,7 @@
 package fingerprint

 import (
+	"context"
 	"testing"

 	"github.com/stretchr/testify/assert"
@@ -163,7 +164,7 @@ func TestIsTaskUpToDate(t *testing.T) {
 			}

 			result, err := IsTaskUpToDate(
-				t.Context(),
+				context.Background(),
 				tt.task,
 				WithStatusChecker(mockStatusChecker),
 				WithSourcesChecker(mockSourcesChecker),
--- a/internal/flags/flags.go
+++ b/internal/flags/flags.go
@@ -8,7 +8,6 @@ import (
 	"strconv"
 	"time"

-	"github.com/fatih/color"
 	"github.com/spf13/pflag"

 	"github.com/go-task/task/v3"
@@ -16,9 +15,8 @@ import (
 	"github.com/go-task/task/v3/experiments"
 	"github.com/go-task/task/v3/internal/env"
 	"github.com/go-task/task/v3/internal/sort"
+	"github.com/go-task/task/v3/taskfile"
 	"github.com/go-task/task/v3/taskfile/ast"
-	"github.com/go-task/task/v3/taskrc"
-	taskrcast "github.com/go-task/task/v3/taskrc/ast"
 )

 const usage = `Usage: task [flags...] [task...]
@@ -54,14 +52,12 @@ var (
 	TaskSort            string
 	Status              bool
 	NoStatus            bool
-	Nested              bool
 	Insecure            bool
 	Force               bool
 	ForceAll            bool
 	Watch               bool
 	Verbose             bool
 	Silent              bool
-	DisableFuzzy        bool
 	AssumeYes           bool
 	Dry                 bool
 	Summary             bool
@@ -73,20 +69,13 @@ var (
 	Output              ast.Output
 	Color               bool
 	Interval            time.Duration
-	Failfast            bool
 	Global              bool
 	Experiments         bool
 	Download            bool
 	Offline             bool
-	TrustedHosts        []string
 	ClearCache          bool
 	Timeout             time.Duration
 	CacheExpiryDuration time.Duration
-	RemoteCacheDir      string
-	CACert              string
-	Cert                string
-	CertKey             string
-	Interactive         bool
 )

 func init() {
@@ -107,9 +96,7 @@ func init() {

 	// Parse the experiments
 	dir = cmp.Or(dir, filepath.Dir(entrypoint))
-
-	config, _ := taskrc.GetConfig(dir)
-	experiments.ParseWithConfig(dir, config)
+	experiments.Parse(dir)

 	// Parse the rest of the flags
 	log.SetFlags(0)
@@ -118,7 +105,10 @@ func init() {
 		log.Print(usage)
 		pflag.PrintDefaults()
 	}
-
+	offline, err := strconv.ParseBool(cmp.Or(env.GetTaskEnv("OFFLINE"), "false"))
+	if err != nil {
+		offline = false
+	}
 	pflag.BoolVar(&Version, "version", false, "Show Task version.")
 	pflag.BoolVarP(&Help, "help", "h", false, "Shows Task usage.")
 	pflag.BoolVarP(&Init, "init", "i", false, "Creates a new Taskfile.yml in the current folder.")
@@ -129,16 +119,13 @@ func init() {
 	pflag.StringVar(&TaskSort, "sort", "", "Changes the order of the tasks when listed. [default|alphanumeric|none].")
 	pflag.BoolVar(&Status, "status", false, "Exits with non-zero exit code if any of the given tasks is not up-to-date.")
 	pflag.BoolVar(&NoStatus, "no-status", false, "Ignore status when listing tasks as JSON")
-	pflag.BoolVar(&Nested, "nested", false, "Nest namespaces when listing tasks as JSON")
-	pflag.BoolVar(&Insecure, "insecure", getConfig(config, "REMOTE_INSECURE", func() *bool { return config.Remote.Insecure }, false), "Forces Task to download Taskfiles over insecure connections.")
+	pflag.BoolVar(&Insecure, "insecure", false, "Forces Task to download Taskfiles over insecure connections.")
 	pflag.BoolVarP(&Watch, "watch", "w", false, "Enables watch of the given task.")
-	pflag.BoolVarP(&Verbose, "verbose", "v", getConfig(config, "VERBOSE", func() *bool { return config.Verbose }, false), "Enables verbose mode.")
-	pflag.BoolVarP(&Silent, "silent", "s", getConfig(config, "SILENT", func() *bool { return config.Silent }, false), "Disables echoing.")
-	pflag.BoolVar(&DisableFuzzy, "disable-fuzzy", getConfig(config, "DISABLE_FUZZY", func() *bool { return config.DisableFuzzy }, false), "Disables fuzzy matching for task names.")
-	pflag.BoolVarP(&AssumeYes, "yes", "y", getConfig(config, "ASSUME_YES", func() *bool { return nil }, false), "Assume \"yes\" as answer to all prompts.")
-	pflag.BoolVar(&Interactive, "interactive", getConfig(config, "INTERACTIVE", func() *bool { return config.Interactive }, false), "Prompt for missing required variables.")
+	pflag.BoolVarP(&Verbose, "verbose", "v", false, "Enables verbose mode.")
+	pflag.BoolVarP(&Silent, "silent", "s", false, "Disables echoing.")
+	pflag.BoolVarP(&AssumeYes, "yes", "y", false, "Assume \"yes\" as answer to all prompts.")
 	pflag.BoolVarP(&Parallel, "parallel", "p", false, "Executes tasks provided on command line in parallel.")
-	pflag.BoolVarP(&Dry, "dry", "n", getConfig(config, "DRY", func() *bool { return nil }, false), "Compiles and prints tasks in the order that they would be run, without executing them.")
+	pflag.BoolVarP(&Dry, "dry", "n", false, "Compiles and prints tasks in the order that they would be run, without executing them.")
 	pflag.BoolVar(&Summary, "summary", false, "Show summary about a task.")
 	pflag.BoolVarP(&ExitCode, "exit-code", "x", false, "Pass-through the exit code of the task command.")
 	pflag.StringVarP(&Dir, "dir", "d", "", "Sets the directory in which Task will execute and look for a Taskfile.")
@@ -147,10 +134,9 @@ func init() {
 	pflag.StringVar(&Output.Group.Begin, "output-group-begin", "", "Message template to print before a task's grouped output.")
 	pflag.StringVar(&Output.Group.End, "output-group-end", "", "Message template to print after a task's grouped output.")
 	pflag.BoolVar(&Output.Group.ErrorOnly, "output-group-error-only", false, "Swallow output from successful tasks.")
-	pflag.BoolVarP(&Color, "color", "c", getConfig(config, "COLOR", func() *bool { return config.Color }, true), "Colored output. Enabled by default. Set flag to false or use NO_COLOR=1 to disable.")
-	pflag.IntVarP(&Concurrency, "concurrency", "C", getConfig(config, "CONCURRENCY", func() *int { return config.Concurrency }, 0), "Limit number of tasks to run concurrently.")
+	pflag.BoolVarP(&Color, "color", "c", true, "Colored output. Enabled by default. Set flag to false or use NO_COLOR=1 to disable.")
+	pflag.IntVarP(&Concurrency, "concurrency", "C", 0, "Limit number of tasks to run concurrently.")
 	pflag.DurationVarP(&Interval, "interval", "I", 0, "Interval to watch for changes.")
-	pflag.BoolVarP(&Failfast, "failfast", "F", getConfig(config, "FAILFAST", func() *bool { return &config.Failfast }, false), "When running tasks in parallel, stop all tasks if one fails.")
 	pflag.BoolVarP(&Global, "global", "g", false, "Runs global Taskfile, from $HOME/{T,t}askfile.{yml,yaml}.")
 	pflag.BoolVar(&Experiments, "experiments", false, "Lists all the available experiments and whether or not they are enabled.")

@@ -165,40 +151,13 @@ func init() {
 	// Remote Taskfiles experiment will adds the "download" and "offline" flags
 	if experiments.RemoteTaskfiles.Enabled() {
 		pflag.BoolVar(&Download, "download", false, "Downloads a cached version of a remote Taskfile.")
-		pflag.BoolVar(&Offline, "offline", getConfig(config, "REMOTE_OFFLINE", func() *bool { return config.Remote.Offline }, false), "Forces Task to only use local or cached Taskfiles.")
-		pflag.StringSliceVar(&TrustedHosts, "trusted-hosts", getConfig(config, "REMOTE_TRUSTED_HOSTS", func() *[]string { return &config.Remote.TrustedHosts }, nil), "List of trusted hosts for remote Taskfiles (comma-separated).")
-		pflag.DurationVar(&Timeout, "timeout", getConfig(config, "REMOTE_TIMEOUT", func() *time.Duration { return config.Remote.Timeout }, time.Second*10), "Timeout for downloading remote Taskfiles.")
+		pflag.BoolVar(&Offline, "offline", offline, "Forces Task to only use local or cached Taskfiles.")
+		pflag.DurationVar(&Timeout, "timeout", time.Second*10, "Timeout for downloading remote Taskfiles.")
 		pflag.BoolVar(&ClearCache, "clear-cache", false, "Clear the remote cache.")
-		pflag.DurationVar(&CacheExpiryDuration, "expiry", getConfig(config, "REMOTE_CACHE_EXPIRY", func() *time.Duration { return config.Remote.CacheExpiry }, 0), "Expiry duration for cached remote Taskfiles.")
-		pflag.StringVar(&RemoteCacheDir, "remote-cache-dir", getConfig(config, "REMOTE_CACHE_DIR", func() *string { return config.Remote.CacheDir }, env.GetTaskEnv("REMOTE_DIR")), "Directory to cache remote Taskfiles.")
-		pflag.StringVar(&CACert, "cacert", getConfig(config, "REMOTE_CACERT", func() *string { return config.Remote.CACert }, ""), "Path to a custom CA certificate for HTTPS connections.")
-		pflag.StringVar(&Cert, "cert", getConfig(config, "REMOTE_CERT", func() *string { return config.Remote.Cert }, ""), "Path to a client certificate for HTTPS connections.")
-		pflag.StringVar(&CertKey, "cert-key", getConfig(config, "REMOTE_CERT_KEY", func() *string { return config.Remote.CertKey }, ""), "Path to a client certificate key for HTTPS connections.")
+		pflag.DurationVar(&CacheExpiryDuration, "expiry", 0, "Expiry duration for cached remote Taskfiles.")
 	}
+
 	pflag.Parse()
-
-	// Auto-detect color based on environment when not explicitly configured
-	// Priority: CLI flag > TASK_COLOR env > taskrc config > NO_COLOR > FORCE_COLOR/CI > default
-	colorExplicitlySet := pflag.Lookup("color").Changed || env.GetTaskEnv("COLOR") != "" || (config != nil && config.Color != nil)
-	if !colorExplicitlySet {
-		if os.Getenv("NO_COLOR") != "" {
-			Color = false
-			color.NoColor = true
-		} else if os.Getenv("FORCE_COLOR") != "" || isCI() {
-			Color = true
-			color.NoColor = false // Force colors even without TTY
-		}
-		// Otherwise, let fatih/color auto-detect TTY
-	} else {
-		// Explicit config: sync with fatih/color
-		color.NoColor = !Color
-	}
-}
-
-// isCI returns true if running in a CI environment
-func isCI() bool {
-	ci, _ := strconv.ParseBool(os.Getenv("CI"))
-	return ci
 }

 func Validate() error {
@@ -238,21 +197,12 @@ func Validate() error {
 		return errors.New("task: --no-status only applies to --json with --list or --list-all")
 	}

-	if Nested && !ListJson {
-		return errors.New("task: --nested only applies to --json with --list or --list-all")
-	}
-
-	// Validate certificate flags
-	if (Cert != "" && CertKey == "") || (Cert == "" && CertKey != "") {
-		return errors.New("task: --cert and --cert-key must be provided together")
-	}
-
 	return nil
 }

 // WithFlags is a special internal functional option that is used to pass flags
 // from the CLI into any constructor that accepts functional options.
-func WithFlags() task.ExecutorOption {
+func WithFlags() *flagsOption {
 	return &flagsOption{}
 }

@@ -279,25 +229,12 @@ func (o *flagsOption) ApplyToExecutor(e *task.Executor) {

 	e.Options(
 		task.WithDir(dir),
-		task.WithEntrypoint(Entrypoint),
 		task.WithForce(Force),
 		task.WithForceAll(ForceAll),
-		task.WithInsecure(Insecure),
-		task.WithDownload(Download),
-		task.WithOffline(Offline),
-		task.WithTrustedHosts(TrustedHosts),
-		task.WithTimeout(Timeout),
-		task.WithCacheExpiryDuration(CacheExpiryDuration),
-		task.WithRemoteCacheDir(RemoteCacheDir),
-		task.WithCACert(CACert),
-		task.WithCert(Cert),
-		task.WithCertKey(CertKey),
 		task.WithWatch(Watch),
 		task.WithVerbose(Verbose),
 		task.WithSilent(Silent),
-		task.WithDisableFuzzy(DisableFuzzy),
 		task.WithAssumeYes(AssumeYes),
-		task.WithInteractive(Interactive),
 		task.WithDry(Dry || Status),
 		task.WithSummary(Summary),
 		task.WithParallel(Parallel),
@@ -307,49 +244,14 @@ func (o *flagsOption) ApplyToExecutor(e *task.Executor) {
 		task.WithOutputStyle(Output),
 		task.WithTaskSorter(sorter),
 		task.WithVersionCheck(true),
-		task.WithFailfast(Failfast),
 	)
 }

-// getConfig extracts a config value with priority: env var > taskrc config > fallback
-func getConfig[T any](config *taskrcast.TaskRC, envKey string, fieldFunc func() *T, fallback T) T {
-	if envKey != "" {
-		if val, ok := getEnvAs[T](envKey); ok {
-			return val
-		}
-	}
-	if config != nil {
-		if field := fieldFunc(); field != nil {
-			return *field
-		}
-	}
-	return fallback
-}
-
-// getEnvAs parses a TASK_ prefixed env var as type T
-func getEnvAs[T any](envKey string) (T, bool) {
-	var zero T
-	switch any(zero).(type) {
-	case bool:
-		if val, ok := env.GetTaskEnvBool(envKey); ok {
-			return any(val).(T), true
-		}
-	case int:
-		if val, ok := env.GetTaskEnvInt(envKey); ok {
-			return any(val).(T), true
-		}
-	case time.Duration:
-		if val, ok := env.GetTaskEnvDuration(envKey); ok {
-			return any(val).(T), true
-		}
-	case string:
-		if val, ok := env.GetTaskEnvString(envKey); ok {
-			return any(val).(T), true
-		}
-	case []string:
-		if val, ok := env.GetTaskEnvStringSlice(envKey); ok {
-			return any(val).(T), true
-		}
-	}
-	return zero, false
+func (o *flagsOption) ApplyToReader(r *taskfile.Reader) {
+	r.Options(
+		taskfile.WithInsecure(Insecure),
+		taskfile.WithDownload(Download),
+		taskfile.WithOffline(Offline),
+		taskfile.WithCacheExpiryDuration(CacheExpiryDuration),
+	)
 }
--- a/internal/fsext/fs.go
+++ b/internal/fsext/fs.go
@@ -37,87 +37,51 @@ func DefaultDir(entrypoint, dir string) string {
 	return ""
 }

-// ResolveDir returns an absolute path to the directory that the task should be
-// run in. If the entrypoint and dir are BOTH set, then the Taskfile will not
-// sit inside the directory specified by dir and we should ensure that the dir
-// is absolute. Otherwise, the dir will always be the parent directory of the
-// resolved entrypoint, so we should return that parent directory.
-func ResolveDir(entrypoint, resolvedEntrypoint, dir string) (string, error) {
-	if entrypoint != "" && dir != "" {
-		return filepath.Abs(dir)
-	}
-	return filepath.Dir(resolvedEntrypoint), nil
-}
-
-// Search looks for files with the given possible filenames using the given
-// entrypoint and directory. If the entrypoint is set, it checks if the
+// Search will look for files with the given possible filenames using the given
+// entrypoint and directory. If the entrypoint is set, it will check if the
 // entrypoint matches a file or if it matches a directory containing one of the
-// possible filenames. Otherwise, it walks up the file tree starting at the
-// given directory and performs a search in each directory for the possible
+// possible filenames. Otherwise, it will walk up the file tree starting at the
+// given directory and perform a search in each directory for the possible
 // filenames until it finds a match or reaches the root directory. If the
-// entrypoint and directory are both empty, it defaults the directory to the
-// current working directory and performs a recursive search starting there. If
-// a match is found, the absolute path to the file is returned with its
-// directory. If no match is found, an error is returned.
-func Search(entrypoint, dir string, possibleFilenames []string) (string, error) {
+// entrypoint and directory are both empty, it will default the directory to the
+// current working directory and perform a recursive search starting there. If a
+// match is found, the absolute path to the file will be returned with its
+// directory. If no match is found, an error will be returned.
+func Search(entrypoint, dir string, possibleFilenames []string) (string, string, error) {
 	var err error
 	if entrypoint != "" {
 		entrypoint, err = SearchPath(entrypoint, possibleFilenames)
 		if err != nil {
-			return "", err
+			return "", "", err
 		}
-		return entrypoint, nil
+		if dir == "" {
+			dir = filepath.Dir(entrypoint)
+		} else {
+			dir, err = filepath.Abs(dir)
+			if err != nil {
+				return "", "", err
+			}
+		}
+		return entrypoint, dir, nil
 	}
 	if dir == "" {
 		dir, err = os.Getwd()
 		if err != nil {
-			return "", err
+			return "", "", err
 		}
 	}
 	entrypoint, err = SearchPathRecursively(dir, possibleFilenames)
 	if err != nil {
-		return "", err
+		return "", "", err
 	}
-	return entrypoint, nil
+	dir = filepath.Dir(entrypoint)
+	return entrypoint, dir, nil
 }

-// SearchAll looks for files with the given possible filenames using the given
-// entrypoint and directory. If the entrypoint is set, it checks if the
-// entrypoint matches a file or if it matches a directory containing one of the
-// possible filenames and add it to a list of matches. It then walks up the file
-// tree starting at the given directory and performs a search in each directory
-// for the possible filenames until it finds a match or reaches the root
-// directory. If the entrypoint and directory are both empty, it defaults the
-// directory to the current working directory and performs a recursive search
-// starting there. If matches are found, the absolute path to each file is added
-// to the list and returned.
-func SearchAll(entrypoint, dir string, possibleFilenames []string) ([]string, error) {
-	var err error
-	var entrypoints []string
-	if entrypoint != "" {
-		entrypoint, err = SearchPath(entrypoint, possibleFilenames)
-		if err != nil {
-			return nil, err
-		}
-		entrypoints = append(entrypoints, entrypoint)
-	}
-	if dir == "" {
-		dir, err = os.Getwd()
-		if err != nil {
-			return nil, err
-		}
-	}
-	paths, err := SearchNPathRecursively(dir, possibleFilenames, -1)
-	// The call to SearchNPathRecursively is ambiguous and may return
-	// os.ErrPermission if its search ends, however it may have still
-	// returned valid paths. Caller may choose to ignore that error.
-	return append(entrypoints, paths...), err
-}
-
-// SearchPath will check if a file at the given path exists or not. If it does,
-// it will return the path to it. If it does not, it will search for any files
-// at the given path with any of the given possible names. If any of these match
-// a file, the first matching path will be returned. If no files are found, an
+// Search will check if a file at the given path exists or not. If it does, it
+// will return the path to it. If it does not, it will search for any files at
+// the given path with any of the given possible names. If any of these match a
+// file, the first matching path will be returned. If no files are found, an
 // error will be returned.
 func SearchPath(path string, possibleFilenames []string) (string, error) {
 	// Get file info about the path
@@ -147,62 +111,36 @@ func SearchPath(path string, possibleFilenames []string) (string, error) {
 	return "", os.ErrNotExist
 }

-// SearchPathRecursively walks up the directory tree starting at the given
-// path, calling the Search function in each directory until it finds a matching
-// file or reaches the root directory. On supported operating systems, it will
-// also check if the user ID of the directory changes and abort if it does.
+// SearchRecursively will check if a file at the given path exists by calling
+// the exists function. If a file is not found, it will walk up the directory
+// tree calling the Search function until it finds a file or reaches the root
+// directory. On supported operating systems, it will also check if the user ID
+// of the directory changes and abort if it does.
 func SearchPathRecursively(path string, possibleFilenames []string) (string, error) {
-	paths, err := SearchNPathRecursively(path, possibleFilenames, 1)
-	if len(paths) > 0 {
-		// Regardless of the error, return the first possible filename.
-		return paths[0], nil
-	} else {
-		if err != nil {
-			return "", err
-		} else {
-			return "", os.ErrNotExist
-		}
-	}
-}
-
-// SearchNPathRecursively walks up the directory tree starting at the given
-// path, calling the Search function in each directory and adding each matching
-// file that it finds to a list until it reaches the root directory or the
-// length of the list exceeds n. On supported operating systems, it will also
-// check if the user ID of the directory changes and abort if it does.
-func SearchNPathRecursively(path string, possibleFilenames []string, n int) ([]string, error) {
-	var paths []string
-
 	owner, err := sysinfo.Owner(path)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
-
-	for n == -1 || len(paths) < n {
+	for {
 		fpath, err := SearchPath(path, possibleFilenames)
 		if err == nil {
-			paths = append(paths, fpath)
+			return fpath, nil
 		}

 		// Get the parent path/user id
 		parentPath := filepath.Dir(path)
 		parentOwner, err := sysinfo.Owner(parentPath)
 		if err != nil {
-			return nil, err
+			return "", err
 		}

-		// If the user id of the directory changes indicate a permission error, otherwise
-		// the calling code will infer an error condition based on the accumulated
-		// contents of paths.
-		if path == parentPath {
-			return paths, nil
-		} else if parentOwner != owner {
-			return paths, os.ErrPermission
+		// Error if we reached the root directory and still haven't found a file
+		// OR if the user id of the directory changes
+		if path == parentPath || (parentOwner != owner) {
+			return "", os.ErrNotExist
 		}

 		owner = parentOwner
 		path = parentPath
 	}
-
-	return paths, nil
 }
--- a/internal/fsext/fs_test.go
+++ b/internal/fsext/fs_test.go
@@ -71,30 +71,35 @@ func TestSearch(t *testing.T) {
 		dir                string
 		possibleFilenames  []string
 		expectedEntrypoint string
+		expectedDir        string
 	}{
 		{
 			name:               "find foo.txt using relative entrypoint",
 			entrypoint:         "./testdata/foo.txt",
 			possibleFilenames:  []string{"foo.txt"},
 			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+			expectedDir:        filepath.Join(wd, "testdata"),
 		},
 		{
 			name:               "find foo.txt using absolute entrypoint",
 			entrypoint:         filepath.Join(wd, "testdata", "foo.txt"),
 			possibleFilenames:  []string{"foo.txt"},
 			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+			expectedDir:        filepath.Join(wd, "testdata"),
 		},
 		{
 			name:               "find foo.txt using relative dir",
 			dir:                "./testdata",
 			possibleFilenames:  []string{"foo.txt"},
 			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+			expectedDir:        filepath.Join(wd, "testdata"),
 		},
 		{
 			name:               "find foo.txt using absolute dir",
 			dir:                filepath.Join(wd, "testdata"),
 			possibleFilenames:  []string{"foo.txt"},
 			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+			expectedDir:        filepath.Join(wd, "testdata"),
 		},
 		{
 			name:               "find foo.txt using relative dir and relative entrypoint",
@@ -102,6 +107,7 @@ func TestSearch(t *testing.T) {
 			dir:                "./testdata/some/other/dir",
 			possibleFilenames:  []string{"foo.txt"},
 			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+			expectedDir:        filepath.Join(wd, "testdata", "some", "other", "dir"),
 		},
 		{
 			name:               "find fs.go using no entrypoint or dir",
@@ -109,6 +115,7 @@ func TestSearch(t *testing.T) {
 			dir:                "",
 			possibleFilenames:  []string{"fs.go"},
 			expectedEntrypoint: filepath.Join(wd, "fs.go"),
+			expectedDir:        wd,
 		},
 		{
 			name:               "find ../../Taskfile.yml using no entrypoint or dir by walking",
@@ -116,109 +123,30 @@ func TestSearch(t *testing.T) {
 			dir:                "",
 			possibleFilenames:  []string{"Taskfile.yml"},
 			expectedEntrypoint: filepath.Join(wd, "..", "..", "Taskfile.yml"),
+			expectedDir:        filepath.Join(wd, "..", ".."),
 		},
 		{
 			name:               "find foo.txt first if listed first in possible filenames",
 			entrypoint:         "./testdata",
 			possibleFilenames:  []string{"foo.txt", "bar.txt"},
 			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+			expectedDir:        filepath.Join(wd, "testdata"),
 		},
 		{
 			name:               "find bar.txt first if listed first in possible filenames",
 			entrypoint:         "./testdata",
 			possibleFilenames:  []string{"bar.txt", "foo.txt"},
 			expectedEntrypoint: filepath.Join(wd, "testdata", "bar.txt"),
+			expectedDir:        filepath.Join(wd, "testdata"),
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			entrypoint, err := Search(tt.entrypoint, tt.dir, tt.possibleFilenames)
+			entrypoint, dir, err := Search(tt.entrypoint, tt.dir, tt.possibleFilenames)
 			require.NoError(t, err)
 			require.Equal(t, tt.expectedEntrypoint, entrypoint)
-			require.NoError(t, err)
-		})
-	}
-}
-
-func TestResolveDir(t *testing.T) {
-	t.Parallel()
-
-	wd, err := os.Getwd()
-	require.NoError(t, err)
-
-	tests := []struct {
-		name               string
-		entrypoint         string
-		resolvedEntrypoint string
-		dir                string
-		expectedDir        string
-	}{
-		{
-			name:               "find foo.txt using relative entrypoint",
-			entrypoint:         "./testdata/foo.txt",
-			resolvedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
-			expectedDir:        filepath.Join(wd, "testdata"),
-		},
-		{
-			name:               "find foo.txt using absolute entrypoint",
-			entrypoint:         filepath.Join(wd, "testdata", "foo.txt"),
-			resolvedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
-			expectedDir:        filepath.Join(wd, "testdata"),
-		},
-		{
-			name:               "find foo.txt using relative dir",
-			resolvedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
-			dir:                "./testdata",
-			expectedDir:        filepath.Join(wd, "testdata"),
-		},
-		{
-			name:               "find foo.txt using absolute dir",
-			resolvedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
-			dir:                filepath.Join(wd, "testdata"),
-			expectedDir:        filepath.Join(wd, "testdata"),
-		},
-		{
-			name:               "find foo.txt using relative dir and relative entrypoint",
-			entrypoint:         "./testdata/foo.txt",
-			resolvedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
-			dir:                "./testdata/some/other/dir",
-			expectedDir:        filepath.Join(wd, "testdata", "some", "other", "dir"),
-		},
-		{
-			name:               "find fs.go using no entrypoint or dir",
-			entrypoint:         "",
-			resolvedEntrypoint: filepath.Join(wd, "fs.go"),
-			dir:                "",
-			expectedDir:        wd,
-		},
-		{
-			name:               "find ../../Taskfile.yml using no entrypoint or dir by walking",
-			entrypoint:         "",
-			resolvedEntrypoint: filepath.Join(wd, "..", "..", "Taskfile.yml"),
-			dir:                "",
-			expectedDir:        filepath.Join(wd, "..", ".."),
-		},
-		{
-			name:               "find foo.txt first if listed first in possible filenames",
-			entrypoint:         "./testdata",
-			resolvedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
-			expectedDir:        filepath.Join(wd, "testdata"),
-		},
-		{
-			name:               "find bar.txt first if listed first in possible filenames",
-			entrypoint:         "./testdata",
-			resolvedEntrypoint: filepath.Join(wd, "testdata", "bar.txt"),
-			expectedDir:        filepath.Join(wd, "testdata"),
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			dir, err := ResolveDir(tt.entrypoint, tt.resolvedEntrypoint, tt.dir)
-			require.NoError(t, err)
 			require.Equal(t, tt.expectedDir, dir)
-			require.NoError(t, err)
 		})
 	}
 }
--- a/internal/hash/hash.go
+++ b/internal/hash/hash.go
@@ -20,5 +20,5 @@ func Name(t *ast.Task) (string, error) {

 func Hash(t *ast.Task) (string, error) {
 	h, err := hashstructure.Hash(t, hashstructure.FormatV2, nil)
-	return fmt.Sprintf("%s:%s:%d", t.Location.Taskfile, t.LocalName(), h), err
+	return fmt.Sprintf("%s:%d", t.Task, h), err
 }
--- a/internal/input/input.go
+++ b/internal/input/input.go
@@ -1,211 +0,0 @@
-package input
-
-import (
-	"fmt"
-	"io"
-	"strings"
-
-	"charm.land/bubbles/v2/textinput"
-	tea "charm.land/bubbletea/v2"
-	"charm.land/lipgloss/v2"
-
-	"github.com/go-task/task/v3/errors"
-)
-
-var ErrCancelled = errors.New("prompt cancelled")
-
-var (
-	promptStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("6")).Bold(true) // cyan bold
-	cursorStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("6")).Bold(true) // cyan bold
-	selectedStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("2")).Bold(true) // green bold
-	dimStyle      = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))            // gray
-)
-
-// Prompter handles interactive variable prompting
-type Prompter struct {
-	Stdin  io.Reader
-	Stdout io.Writer
-	Stderr io.Writer
-}
-
-// Text prompts the user for a text value
-func (p *Prompter) Text(varName string) (string, error) {
-	m := newTextModel(varName)
-
-	prog := tea.NewProgram(m,
-		tea.WithInput(p.Stdin),
-		tea.WithOutput(p.Stderr),
-	)
-
-	result, err := prog.Run()
-	if err != nil {
-		return "", err
-	}
-
-	model := result.(textModel)
-	if model.cancelled {
-		return "", ErrCancelled
-	}
-
-	return model.value, nil
-}
-
-// Select prompts the user to select from a list of options
-func (p *Prompter) Select(varName string, options []string) (string, error) {
-	if len(options) == 0 {
-		return "", errors.New("no options provided")
-	}
-
-	m := newSelectModel(varName, options)
-
-	prog := tea.NewProgram(m,
-		tea.WithInput(p.Stdin),
-		tea.WithOutput(p.Stderr),
-	)
-
-	result, err := prog.Run()
-	if err != nil {
-		return "", err
-	}
-
-	model := result.(selectModel)
-	if model.cancelled {
-		return "", ErrCancelled
-	}
-
-	return model.options[model.cursor], nil
-}
-
-// Prompt prompts for a variable value, using Select if enum is provided, Text otherwise
-func (p *Prompter) Prompt(varName string, enum []string) (string, error) {
-	if len(enum) > 0 {
-		return p.Select(varName, enum)
-	}
-	return p.Text(varName)
-}
-
-// textModel is the Bubble Tea model for text input
-type textModel struct {
-	varName   string
-	textInput textinput.Model
-	value     string
-	cancelled bool
-	done      bool
-}
-
-func newTextModel(varName string) textModel {
-	ti := textinput.New()
-	ti.Placeholder = ""
-	ti.CharLimit = 256
-	ti.SetWidth(40)
-	ti.Focus()
-
-	return textModel{
-		varName:   varName,
-		textInput: ti,
-	}
-}
-
-func (m textModel) Init() tea.Cmd {
-	return tea.Batch(m.textInput.Focus(), textinput.Blink)
-}
-
-func (m textModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.KeyPressMsg:
-		switch msg.Keystroke() {
-		case "ctrl+c", "escape":
-			m.cancelled = true
-			m.done = true
-			return m, tea.Quit
-		case "enter":
-			m.value = m.textInput.Value()
-			m.done = true
-			return m, tea.Quit
-		}
-	}
-
-	var cmd tea.Cmd
-	m.textInput, cmd = m.textInput.Update(msg)
-	return m, cmd
-}
-
-func (m textModel) View() tea.View {
-	if m.done {
-		return tea.NewView("")
-	}
-
-	prompt := promptStyle.Render(fmt.Sprintf("? Enter value for %s: ", m.varName))
-	return tea.NewView(prompt + m.textInput.View() + "\n")
-}
-
-// selectModel is the Bubble Tea model for selection
-type selectModel struct {
-	varName   string
-	options   []string
-	cursor    int
-	cancelled bool
-	done      bool
-}
-
-func newSelectModel(varName string, options []string) selectModel {
-	return selectModel{
-		varName: varName,
-		options: options,
-		cursor:  0,
-	}
-}
-
-func (m selectModel) Init() tea.Cmd {
-	return nil
-}
-
-func (m selectModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.KeyPressMsg:
-		switch msg.Keystroke() {
-		case "ctrl+c", "escape":
-			m.cancelled = true
-			m.done = true
-			return m, tea.Quit
-		case "up", "shift+tab", "k":
-			if m.cursor > 0 {
-				m.cursor--
-			}
-		case "down", "tab", "j":
-			if m.cursor < len(m.options)-1 {
-				m.cursor++
-			}
-		case "enter":
-			m.done = true
-			return m, tea.Quit
-		}
-	}
-
-	return m, nil
-}
-
-func (m selectModel) View() tea.View {
-	if m.done {
-		return tea.NewView("")
-	}
-
-	var b strings.Builder
-
-	b.WriteString(promptStyle.Render(fmt.Sprintf("? Select value for %s:", m.varName)))
-	b.WriteString("\n")
-
-	for i, opt := range m.options {
-		if i == m.cursor {
-			b.WriteString(cursorStyle.Render("❯ "))
-			b.WriteString(selectedStyle.Render(opt))
-		} else {
-			b.WriteString("  " + opt)
-		}
-		b.WriteString("\n")
-	}
-
-	b.WriteString(dimStyle.Render("  (↑/↓ to move, enter to select, esc to cancel)"))
-
-	return tea.NewView(b.String())
-}
--- a/internal/logger/logger.go
+++ b/internal/logger/logger.go
@@ -3,6 +3,7 @@ package logger
 import (
 	"bufio"
 	"io"
+	"os"
 	"slices"
 	"strconv"
 	"strings"
@@ -42,12 +43,6 @@ type (
 	PrintFunc func(io.Writer, string, ...any)
 )

-func None() PrintFunc {
-	c := color.New()
-	c.DisableColor()
-	return c.FprintfFunc()
-}
-
 func Default() PrintFunc {
 	return color.New(attrsReset...).FprintfFunc()
 }
@@ -101,6 +96,10 @@ func BrightRed() PrintFunc {
 }

 func envColor(name string, defaultColor color.Attribute) []color.Attribute {
+	if os.Getenv("FORCE_COLOR") != "" {
+		color.NoColor = false
+	}
+
 	// Fetch the environment variable
 	override := env.GetTaskEnv(name)

@@ -150,7 +149,7 @@ func (l *Logger) FOutf(w io.Writer, color Color, s string, args ...any) {
 		s, args = "%s", []any{s}
 	}
 	if !l.Color {
-		color = None
+		color = Default
 	}
 	print := color()
 	print(w, s, args...)
@@ -169,7 +168,7 @@ func (l *Logger) Errf(color Color, s string, args ...any) {
 		s, args = "%s", []any{s}
 	}
 	if !l.Color {
-		color = None
+		color = Default
 	}
 	print := color()
 	print(l.Stderr, s, args...)
--- a/internal/output/group.go
+++ b/internal/output/group.go
@@ -24,6 +24,7 @@ func (g Group) WrapWriter(stdOut, _ io.Writer, _ string, cache *templater.Cache)
 		if g.ErrorOnly && err == nil {
 			return nil
 		}
+
 		return gw.close()
 	}
 }
@@ -39,22 +40,14 @@ func (gw *groupWriter) Write(p []byte) (int, error) {
 }

 func (gw *groupWriter) close() error {
-	switch {
-	case gw.buff.Len() == 0:
+	if gw.buff.Len() == 0 {
+		// don't print begin/end messages if there's no buffered entries
 		return nil
-	case gw.begin == "" && gw.end == "":
-		_, err := io.Copy(gw.writer, &gw.buff)
-		return err
-	default:
-		_, err := io.Copy(gw.writer, gw.combinedBuff())
+	}
+	if _, err := io.WriteString(gw.writer, gw.begin); err != nil {
 		return err
 	}
-}
-
-func (gw *groupWriter) combinedBuff() io.Reader {
-	var b bytes.Buffer
-	_, _ = b.WriteString(gw.begin)
-	_, _ = io.Copy(&b, &gw.buff)
-	_, _ = b.WriteString(gw.end)
-	return &b
+	gw.buff.WriteString(gw.end)
+	_, err := io.Copy(gw.writer, &gw.buff)
+	return err
 }
--- a/internal/summary/summary.go
+++ b/internal/summary/summary.go
@@ -1,8 +1,6 @@
 package summary

 import (
-	"fmt"
-	"os"
 	"strings"

 	"github.com/go-task/task/v3/internal/logger"
@@ -31,9 +29,6 @@ func PrintSpaceBetweenSummaries(l *logger.Logger, i int) {
 func PrintTask(l *logger.Logger, t *ast.Task) {
 	printTaskName(l, t)
 	printTaskDescribingText(t, l)
-	printTaskVars(l, t)
-	printTaskEnv(l, t)
-	printTaskRequires(l, t)
 	printTaskDependencies(l, t)
 	printTaskAliases(l, t)
 	printTaskCommands(l, t)
@@ -123,170 +118,3 @@ func printTaskCommands(l *logger.Logger, t *ast.Task) {
 		}
 	}
 }
-
-func printTaskVars(l *logger.Logger, t *ast.Task) {
-	if t.Vars == nil || t.Vars.Len() == 0 {
-		return
-	}
-
-	osEnvVars := getEnvVarNames()
-
-	taskfileEnvVars := make(map[string]bool)
-	if t.Env != nil {
-		for key := range t.Env.All() {
-			taskfileEnvVars[key] = true
-		}
-	}
-
-	hasNonEnvVars := false
-	for key := range t.Vars.All() {
-		if !isEnvVar(key, osEnvVars) && !taskfileEnvVars[key] {
-			hasNonEnvVars = true
-			break
-		}
-	}
-
-	if !hasNonEnvVars {
-		return
-	}
-
-	l.Outf(logger.Default, "\n")
-	l.Outf(logger.Default, "vars:\n")
-
-	for key, value := range t.Vars.All() {
-		// Only display variables that are not from OS environment or Taskfile env
-		if !isEnvVar(key, osEnvVars) && !taskfileEnvVars[key] {
-			formattedValue := formatVarValue(value)
-			l.Outf(logger.Yellow, "  %s: %s\n", key, formattedValue)
-		}
-	}
-}
-
-func printTaskEnv(l *logger.Logger, t *ast.Task) {
-	if t.Env == nil || t.Env.Len() == 0 {
-		return
-	}
-
-	envVars := getEnvVarNames()
-
-	hasNonEnvVars := false
-	for key := range t.Env.All() {
-		if !isEnvVar(key, envVars) {
-			hasNonEnvVars = true
-			break
-		}
-	}
-
-	if !hasNonEnvVars {
-		return
-	}
-
-	l.Outf(logger.Default, "\n")
-	l.Outf(logger.Default, "env:\n")
-
-	for key, value := range t.Env.All() {
-		// Only display variables that are not from OS environment
-		if !isEnvVar(key, envVars) {
-			formattedValue := formatVarValue(value)
-			l.Outf(logger.Yellow, "  %s: %s\n", key, formattedValue)
-		}
-	}
-}
-
-// formatVarValue formats a variable value based on its type.
-// Handles static values, shell commands (sh:), references (ref:), and maps.
-func formatVarValue(v ast.Var) string {
-	// Shell command - check this first before Value
-	// because dynamic vars may have both Sh and an empty Value
-	if v.Sh != nil {
-		return fmt.Sprintf("sh: %s", *v.Sh)
-	}
-
-	// Reference
-	if v.Ref != "" {
-		return fmt.Sprintf("ref: %s", v.Ref)
-	}
-
-	// Static value
-	if v.Value != nil {
-		// Check if it's a map or complex type
-		if m, ok := v.Value.(map[string]any); ok {
-			return formatMap(m, 4)
-		}
-		// Simple string value
-		return fmt.Sprintf(`"%v"`, v.Value)
-	}
-
-	return `""`
-}
-
-// formatMap formats a map value with proper indentation for YAML.
-func formatMap(m map[string]any, indent int) string {
-	if len(m) == 0 {
-		return "{}"
-	}
-
-	var result strings.Builder
-	result.WriteString("\n")
-	spaces := strings.Repeat(" ", indent)
-
-	for k, v := range m {
-		result.WriteString(fmt.Sprintf("%s%s: %v\n", spaces, k, v)) //nolint:staticcheck
-	}
-
-	return result.String()
-}
-
-func printTaskRequires(l *logger.Logger, t *ast.Task) {
-	if t.Requires == nil || len(t.Requires.Vars) == 0 {
-		return
-	}
-
-	l.Outf(logger.Default, "\n")
-	l.Outf(logger.Default, "requires:\n")
-	l.Outf(logger.Default, "  vars:\n")
-
-	for _, v := range t.Requires.Vars {
-		if v.Enum != nil && len(v.Enum.Value) > 0 {
-			l.Outf(logger.Yellow, "    - %s:\n", v.Name)
-			l.Outf(logger.Yellow, "        enum:\n")
-			for _, enumValue := range v.Enum.Value {
-				l.Outf(logger.Yellow, "          - %s\n", enumValue)
-			}
-		} else if v.Enum != nil && v.Enum.Ref != "" {
-			l.Outf(logger.Yellow, "    - %s:\n", v.Name)
-			l.Outf(logger.Yellow, "        enum:\n")
-			l.Outf(logger.Yellow, "          ref: %s\n", v.Enum.Ref)
-		} else {
-			l.Outf(logger.Yellow, "    - %s\n", v.Name)
-		}
-	}
-}
-
-func getEnvVarNames() map[string]bool {
-	envMap := make(map[string]bool)
-	for _, e := range os.Environ() {
-		parts := strings.SplitN(e, "=", 2)
-		if len(parts) > 0 {
-			envMap[parts[0]] = true
-		}
-	}
-	return envMap
-}
-
-// isEnvVar checks if a variable is from OS environment or auto-generated by Task.
-func isEnvVar(key string, envVars map[string]bool) bool {
-	// Filter out auto-generated Task variables
-	if strings.HasPrefix(key, "TASK_") ||
-		strings.HasPrefix(key, "CLI_") ||
-		strings.HasPrefix(key, "ROOT_") ||
-		key == "TASK" ||
-		key == "TASKFILE" ||
-		key == "TASKFILE_DIR" ||
-		key == "USER_WORKING_DIR" ||
-		key == "ALIAS" ||
-		key == "MATCH" {
-		return true
-	}
-	return envVars[key]
-}
--- a/internal/templater/funcs.go
+++ b/internal/templater/funcs.go
@@ -9,7 +9,7 @@ import (

 	"github.com/davecgh/go-spew/spew"
 	"github.com/google/uuid"
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"
 	"mvdan.cc/sh/v3/shell"
 	"mvdan.cc/sh/v3/syntax"

--- a/internal/templater/secrets.go
+++ b/internal/templater/secrets.go
@@ -1,70 +0,0 @@
-package templater
-
-import (
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-// MaskSecrets replaces template placeholders with their values, masking secrets.
-// This function uses the Go templater to resolve all variables ({{.VAR}}) while
-// masking secret ones as "*****".
-func MaskSecrets(cmdTemplate string, vars *ast.Vars) string {
-	if vars == nil || vars.Len() == 0 {
-		return cmdTemplate
-	}
-
-	// Create a cache map with secrets masked
-	maskedVars := vars.DeepCopy()
-	for name, v := range maskedVars.All() {
-		if v.Secret {
-			// Replace secret value with mask
-			maskedVars.Set(name, ast.Var{
-				Value:  "*****",
-				Secret: true,
-			})
-		}
-	}
-
-	// Use the templater to resolve the template with masked secrets
-	cache := &Cache{Vars: maskedVars}
-	result := Replace(cmdTemplate, cache)
-
-	// If there was an error, return the original template
-	if cache.Err() != nil {
-		return cmdTemplate
-	}
-
-	return result
-}
-
-// MaskSecretsWithExtra is like MaskSecrets but also resolves extra variables (e.g., loop vars).
-func MaskSecretsWithExtra(cmdTemplate string, vars *ast.Vars, extra map[string]any) string {
-	if vars == nil || vars.Len() == 0 {
-		// Still need to resolve extra vars even if no vars
-		cache := &Cache{Vars: ast.NewVars()}
-		result := ReplaceWithExtra(cmdTemplate, cache, extra)
-		if cache.Err() != nil {
-			return cmdTemplate
-		}
-		return result
-	}
-
-	// Create a cache map with secrets masked
-	maskedVars := vars.DeepCopy()
-	for name, v := range maskedVars.All() {
-		if v.Secret {
-			maskedVars.Set(name, ast.Var{
-				Value:  "*****",
-				Secret: true,
-			})
-		}
-	}
-
-	cache := &Cache{Vars: maskedVars}
-	result := ReplaceWithExtra(cmdTemplate, cache, extra)
-
-	if cache.Err() != nil {
-		return cmdTemplate
-	}
-
-	return result
-}
--- a/internal/templater/templater.go
+++ b/internal/templater/templater.go
@@ -121,15 +121,14 @@ func ReplaceVar(v ast.Var, cache *Cache) ast.Var {

 func ReplaceVarWithExtra(v ast.Var, cache *Cache, extra map[string]any) ast.Var {
 	if v.Ref != "" {
-		return ast.Var{Value: ResolveRef(v.Ref, cache), Secret: v.Secret}
+		return ast.Var{Value: ResolveRef(v.Ref, cache)}
 	}
 	return ast.Var{
-		Value:  ReplaceWithExtra(v.Value, cache, extra),
-		Sh:     ReplaceWithExtra(v.Sh, cache, extra),
-		Live:   v.Live,
-		Ref:    v.Ref,
-		Dir:    v.Dir,
-		Secret: v.Secret,
+		Value: ReplaceWithExtra(v.Value, cache, extra),
+		Sh:    ReplaceWithExtra(v.Sh, cache, extra),
+		Live:  v.Live,
+		Ref:   v.Ref,
+		Dir:   v.Dir,
 	}
 }

--- a/internal/term/term.go
+++ b/internal/term/term.go
@@ -7,5 +7,5 @@ import (
 )

 func IsTerminal() bool {
-	return term.IsTerminal(int(os.Stdin.Fd())) && term.IsTerminal(int(os.Stdout.Fd())) //nolint:gosec
+	return term.IsTerminal(int(os.Stdin.Fd())) && term.IsTerminal(int(os.Stdout.Fd()))
 }
--- a/internal/version/version.txt
+++ b/internal/version/version.txt
@@ -1 +1 @@
-3.50.0
+3.44.1
--- a/package-lock.json
+++ b/package-lock.json
@@ -0,0 +1,32 @@
+{
+  "name": "@go-task/cli",
+  "version": "3.44.1",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@go-task/cli",
+      "version": "3.26.0",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "@go-task/go-npm": "^0.2.0"
+      }
+    },
+    "node_modules/@go-task/go-npm": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/@go-task/go-npm/-/go-npm-0.2.0.tgz",
+      "integrity": "sha512-vQbdtBvesHm8EUFHX8QKg4rbBodmu9VsAXH1ozpbiN5jdTMOYHTCMM31EurAYmY+rNNtxJQ4JGy6t383RPlqbw==",
+      "bin": {
+        "go-npm": "bin/index.js"
+      }
+    }
+  },
+  "dependencies": {
+    "@go-task/go-npm": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/@go-task/go-npm/-/go-npm-0.2.0.tgz",
+      "integrity": "sha512-vQbdtBvesHm8EUFHX8QKg4rbBodmu9VsAXH1ozpbiN5jdTMOYHTCMM31EurAYmY+rNNtxJQ4JGy6t383RPlqbw=="
+    }
+  }
+}
--- a/package.json
+++ b/package.json
@@ -0,0 +1,34 @@
+{
+  "name": "@go-task/cli",
+  "version": "3.44.1",
+  "description": "A task runner / simpler Make alternative written in Go",
+  "scripts": {
+    "postinstall": "go-npm install",
+    "preuninstall": "go-npm uninstall"
+  },
+  "goBinary": {
+    "name": "task",
+    "path": "./bin",
+    "url": "https://github.com/go-task/task/releases/download/v{{version}}/task_{{platform}}_{{arch}}{{archive_ext}}"
+  },
+  "files": [],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/go-task/task.git"
+  },
+  "keywords": [
+    "task",
+    "taskfile",
+    "build-tool",
+    "task-runner"
+  ],
+  "author": "The Task authors",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/go-task/task/issues"
+  },
+  "homepage": "https://taskfile.dev",
+  "dependencies": {
+    "@go-task/go-npm": "^0.2.0"
+  }
+}
--- a/requires.go
+++ b/requires.go
@@ -4,180 +4,35 @@ import (
 	"slices"

 	"github.com/go-task/task/v3/errors"
-	"github.com/go-task/task/v3/internal/input"
-	"github.com/go-task/task/v3/internal/term"
 	"github.com/go-task/task/v3/taskfile/ast"
 )

-func (e *Executor) canPrompt() bool {
-	return e.Interactive && (e.AssumeTerm || term.IsTerminal())
-}
-
-func (e *Executor) newPrompter() *input.Prompter {
-	return &input.Prompter{
-		Stdin:  e.Stdin,
-		Stdout: e.Stdout,
-		Stderr: e.Stderr,
-	}
-}
-
-// promptDepsVars traverses the dependency tree, collects all missing required
-// variables, and prompts for them upfront. This is used for deps which execute
-// in parallel, so all prompts must happen before execution to avoid interleaving.
-// Prompted values are stored in e.promptedVars for injection into task calls.
-func (e *Executor) promptDepsVars(calls []*Call) error {
-	if !e.canPrompt() {
+func (e *Executor) areTaskRequiredVarsSet(t *ast.Task) error {
+	if t.Requires == nil || len(t.Requires.Vars) == 0 {
 		return nil
 	}

-	// Collect all missing vars from the dependency tree
-	visited := make(map[string]bool)
-	varsMap := make(map[string]*ast.VarsWithValidation)
-
-	var collect func(call *Call) error
-	collect = func(call *Call) error {
-		compiledTask, err := e.FastCompiledTask(call)
-		if err != nil {
-			return err
-		}
-
-		for _, v := range getMissingRequiredVars(compiledTask) {
-			if _, exists := varsMap[v.Name]; !exists {
-				varsMap[v.Name] = v
-			}
-		}
-
-		// Check visited AFTER collecting vars to handle duplicate task calls with different vars
-		if visited[call.Task] {
-			return nil
-		}
-		visited[call.Task] = true
-
-		for _, dep := range compiledTask.Deps {
-			depCall := &Call{
-				Task:   dep.Task,
-				Vars:   dep.Vars,
-				Silent: dep.Silent,
-			}
-			if err := collect(depCall); err != nil {
-				return err
-			}
-		}
-
-		return nil
-	}
-
-	for _, call := range calls {
-		if err := collect(call); err != nil {
-			return err
+	var missingVars []errors.MissingVar
+	for _, requiredVar := range t.Requires.Vars {
+		_, ok := t.Vars.Get(requiredVar.Name)
+		if !ok {
+			missingVars = append(missingVars, errors.MissingVar{
+				Name:          requiredVar.Name,
+				AllowedValues: requiredVar.Enum,
+			})
 		}
 	}

-	if len(varsMap) == 0 {
-		return nil
-	}
-
-	prompter := e.newPrompter()
-	e.promptedVars = ast.NewVars()
-
-	for _, v := range varsMap {
-		value, err := prompter.Prompt(v.Name, getEnumValues(v.Enum))
-		if err != nil {
-			if errors.Is(err, input.ErrCancelled) {
-				return &errors.TaskCancelledByUserError{TaskName: "interactive prompt"}
-			}
-			return err
+	if len(missingVars) > 0 {
+		return &errors.TaskMissingRequiredVarsError{
+			TaskName:    t.Name(),
+			MissingVars: missingVars,
 		}
-		e.promptedVars.Set(v.Name, ast.Var{Value: value})
 	}

 	return nil
 }

-// promptTaskVars prompts for any missing required vars from a single task.
-// Used for sequential task calls (cmds) where we can prompt just-in-time.
-// Returns true if any vars were prompted (caller should recompile the task).
-func (e *Executor) promptTaskVars(t *ast.Task, call *Call) (bool, error) {
-	if !e.canPrompt() || t.Requires == nil || len(t.Requires.Vars) == 0 {
-		return false, nil
-	}
-
-	// Find missing vars, excluding already prompted ones
-	var missing []*ast.VarsWithValidation
-	for _, v := range getMissingRequiredVars(t) {
-		if e.promptedVars != nil {
-			if _, ok := e.promptedVars.Get(v.Name); ok {
-				continue
-			}
-		}
-		missing = append(missing, v)
-	}
-
-	if len(missing) == 0 {
-		return false, nil
-	}
-
-	prompter := e.newPrompter()
-
-	for _, v := range missing {
-		value, err := prompter.Prompt(v.Name, getEnumValues(v.Enum))
-		if err != nil {
-			if errors.Is(err, input.ErrCancelled) {
-				return false, &errors.TaskCancelledByUserError{TaskName: t.Name()}
-			}
-			return false, err
-		}
-
-		// Add to call.Vars for recompilation
-		if call.Vars == nil {
-			call.Vars = ast.NewVars()
-		}
-		call.Vars.Set(v.Name, ast.Var{Value: value})
-
-		// Cache for reuse by other tasks
-		if e.promptedVars == nil {
-			e.promptedVars = ast.NewVars()
-		}
-		e.promptedVars.Set(v.Name, ast.Var{Value: value})
-	}
-
-	return true, nil
-}
-
-// getMissingRequiredVars returns required vars that are not set in the task's vars.
-func getMissingRequiredVars(t *ast.Task) []*ast.VarsWithValidation {
-	if t.Requires == nil {
-		return nil
-	}
-	var missing []*ast.VarsWithValidation
-	for _, v := range t.Requires.Vars {
-		if _, ok := t.Vars.Get(v.Name); !ok {
-			missing = append(missing, v)
-		}
-	}
-	return missing
-}
-
-func (e *Executor) areTaskRequiredVarsSet(t *ast.Task) error {
-	missing := getMissingRequiredVars(t)
-	if len(missing) == 0 {
-		return nil
-	}
-
-	missingVars := make([]errors.MissingVar, len(missing))
-	for i, v := range missing {
-		missingVars[i] = errors.MissingVar{
-			Name:          v.Name,
-			AllowedValues: getEnumValues(v.Enum),
-		}
-	}
-
-	return &errors.TaskMissingRequiredVarsError{
-		TaskName:    t.Name(),
-		MissingVars: missingVars,
-	}
-}
-
 func (e *Executor) areTaskRequiredVarsAllowedValuesSet(t *ast.Task) error {
 	if t.Requires == nil || len(t.Requires.Vars) == 0 {
 		return nil
@@ -187,15 +42,15 @@ func (e *Executor) areTaskRequiredVarsAllowedValuesSet(t *ast.Task) error {
 	for _, requiredVar := range t.Requires.Vars {
 		varValue, _ := t.Vars.Get(requiredVar.Name)

-		enumValues := getEnumValues(requiredVar.Enum)
 		value, isString := varValue.Value.(string)
-		if isString && len(enumValues) > 0 && !slices.Contains(enumValues, value) {
+		if isString && requiredVar.Enum != nil && !slices.Contains(requiredVar.Enum, value) {
 			notAllowedValuesVars = append(notAllowedValuesVars, errors.NotAllowedVar{
 				Value: value,
-				Enum:  enumValues,
+				Enum:  requiredVar.Enum,
 				Name:  requiredVar.Name,
 			})
 		}
+
 	}

 	if len(notAllowedValuesVars) > 0 {
@@ -207,10 +62,3 @@ func (e *Executor) areTaskRequiredVarsAllowedValuesSet(t *ast.Task) error {

 	return nil
 }
-
-func getEnumValues(e *ast.Enum) []string {
-	if e == nil {
-		return nil
-	}
-	return e.Value
-}
--- a/signals.go
+++ b/signals.go
@@ -15,7 +15,7 @@ const maxInterruptSignals = 3
 // time to do cleanup work.
 func (e *Executor) InterceptInterruptSignals() {
 	ch := make(chan os.Signal, maxInterruptSignals)
-	signal.Notify(ch, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP)
+	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)

 	go func() {
 		for i := range maxInterruptSignals {
--- a/task.go
+++ b/task.go
@@ -6,7 +6,6 @@ import (
 	"os"
 	"runtime"
 	"slices"
-	"strings"
 	"sync/atomic"

 	"golang.org/x/sync/errgroup"
@@ -74,21 +73,14 @@ func (e *Executor) Run(ctx context.Context, calls ...*Call) error {
 		return nil
 	}

-	// Prompt for all required vars from deps upfront (parallel execution)
-	if err := e.promptDepsVars(calls); err != nil {
-		return err
-	}
-
 	regularCalls, watchCalls, err := e.splitRegularAndWatchCalls(calls...)
 	if err != nil {
 		return err
 	}

-	g := &errgroup.Group{}
-	if e.Failfast {
-		g, ctx = errgroup.WithContext(ctx)
-	}
+	g, ctx := errgroup.WithContext(ctx)
 	for _, c := range regularCalls {
+		c := c
 		if e.Parallel {
 			g.Go(func() error { return e.RunTask(ctx, c) })
 		} else {
@@ -121,24 +113,11 @@ func (e *Executor) splitRegularAndWatchCalls(calls ...*Call) (regularCalls []*Ca
 			regularCalls = append(regularCalls, c)
 		}
 	}
-	return regularCalls, watchCalls, err
+	return
 }

 // RunTask runs a task by its name
 func (e *Executor) RunTask(ctx context.Context, call *Call) error {
-	// Inject prompted vars into call if available
-	if e.promptedVars != nil {
-		if call.Vars == nil {
-			call.Vars = ast.NewVars()
-		}
-		for name, v := range e.promptedVars.All() {
-			// Only inject if not already set in call
-			if _, ok := call.Vars.Get(name); !ok {
-				call.Vars.Set(name, v)
-			}
-		}
-	}
-
 	t, err := e.FastCompiledTask(call)
 	if err != nil {
 		return err
@@ -148,12 +127,8 @@ func (e *Executor) RunTask(ctx context.Context, call *Call) error {
 		return nil
 	}

-	// Check required vars early (before template compilation) if we can't prompt.
-	// This gives a clear "missing required variables" error instead of a template error.
-	if !e.canPrompt() {
-		if err := e.areTaskRequiredVarsSet(t); err != nil {
-			return err
-		}
+	if err := e.areTaskRequiredVarsSet(t); err != nil {
+		return err
 	}

 	t, err = e.CompiledTask(call)
@@ -161,35 +136,6 @@ func (e *Executor) RunTask(ctx context.Context, call *Call) error {
 		return err
 	}

-	// Check if condition after CompiledTask so dynamic variables are resolved
-	if strings.TrimSpace(t.If) != "" {
-		if err := execext.RunCommand(ctx, &execext.RunCommandOptions{
-			Command: t.If,
-			Dir:     t.Dir,
-			Env:     env.Get(t),
-		}); err != nil {
-			e.Logger.VerboseOutf(logger.Yellow, "task: if condition not met - skipped: %q\n", call.Task)
-			return nil
-		}
-	}
-
-	// Prompt for missing required vars after if check (avoid prompting if task won't run)
-	prompted, err := e.promptTaskVars(t, call)
-	if err != nil {
-		return err
-	}
-	if prompted {
-		// Recompile with the new vars
-		t, err = e.FastCompiledTask(call)
-		if err != nil {
-			return err
-		}
-	}
-
-	if err := e.areTaskRequiredVarsSet(t); err != nil {
-		return err
-	}
-
 	if err := e.areTaskRequiredVarsAllowedValuesSet(t); err != nil {
 		return err
 	}
@@ -204,7 +150,7 @@ func (e *Executor) RunTask(ctx context.Context, call *Call) error {
 	release := e.acquireConcurrencyLimit()
 	defer release()

-	if err = e.startExecution(ctx, t, func(ctx context.Context) error {
+	return e.startExecution(ctx, t, func(ctx context.Context) error {
 		e.Logger.VerboseErrf(logger.Magenta, "task: %q started\n", call.Task)
 		if err := e.runDeps(ctx, t); err != nil {
 			return err
@@ -226,6 +172,7 @@ func (e *Executor) RunTask(ctx context.Context, call *Call) error {
 			if t.Method != "" {
 				method = t.Method
 			}
+
 			upToDate, err := fingerprint.IsTaskUpToDate(ctx, t,
 				fingerprint.WithMethod(method),
 				fingerprint.WithTempDir(e.TempDir.Fingerprint),
@@ -237,12 +184,8 @@ func (e *Executor) RunTask(ctx context.Context, call *Call) error {
 			}

 			if upToDate && preCondMet {
-				if e.Verbose || (!call.Silent && !t.IsSilent() && !e.Taskfile.Silent && !e.Silent) {
-					name := t.Name()
-					if e.OutputStyle.Name == "prefixed" {
-						name = t.Prefix
-					}
-					e.Logger.Errf(logger.Magenta, "task: Task %q is up to date\n", name)
+				if e.Verbose || (!call.Silent && !t.Silent && !e.Taskfile.Silent && !e.Silent) {
+					e.Logger.Errf(logger.Magenta, "task: Task %q is up to date\n", t.Name())
 				}
 				return nil
 			}
@@ -268,7 +211,7 @@ func (e *Executor) RunTask(ctx context.Context, call *Call) error {

 		for i := range t.Cmds {
 			if t.Cmds[i].Defer {
-				defer e.runDeferred(t, call, i, t.Vars, &deferredExitCode)
+				defer e.runDeferred(t, call, i, &deferredExitCode)
 				continue
 			}

@@ -286,16 +229,16 @@ func (e *Executor) RunTask(ctx context.Context, call *Call) error {
 					deferredExitCode = uint8(exitCode)
 				}

-				return err
+				if call.Indirect {
+					return err
+				}
+
+				return &errors.TaskRunError{TaskName: t.Task, Err: err}
 			}
 		}
 		e.Logger.VerboseErrf(logger.Magenta, "task: %q finished\n", call.Task)
 		return nil
-	}); err != nil {
-		return &errors.TaskRunError{TaskName: t.Name(), Err: err}
-	}
-
-	return nil
+	})
 }

 func (e *Executor) mkdir(t *ast.Task) error {
@@ -316,15 +259,13 @@ func (e *Executor) mkdir(t *ast.Task) error {
 }

 func (e *Executor) runDeps(ctx context.Context, t *ast.Task) error {
-	g := &errgroup.Group{}
-	if e.Failfast || t.Failfast {
-		g, ctx = errgroup.WithContext(ctx)
-	}
+	g, ctx := errgroup.WithContext(ctx)

 	reacquire := e.releaseConcurrencyLimit()
 	defer reacquire()

 	for _, d := range t.Deps {
+		d := d
 		g.Go(func() error {
 			err := e.RunTask(ctx, &Call{Task: d.Task, Vars: d.Vars, Silent: d.Silent, Indirect: true})
 			if err != nil {
@@ -337,11 +278,17 @@ func (e *Executor) runDeps(ctx context.Context, t *ast.Task) error {
 	return g.Wait()
 }

-func (e *Executor) runDeferred(t *ast.Task, call *Call, i int, vars *ast.Vars, deferredExitCode *uint8) {
+func (e *Executor) runDeferred(t *ast.Task, call *Call, i int, deferredExitCode *uint8) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()

+	origTask, err := e.GetTask(call)
+	if err != nil {
+		return
+	}
+
 	cmd := t.Cmds[i]
+	vars, _ := e.Compiler.GetVariables(origTask, call)
 	cache := &templater.Cache{Vars: vars}
 	extra := map[string]any{}

@@ -349,11 +296,8 @@ func (e *Executor) runDeferred(t *ast.Task, call *Call, i int, vars *ast.Vars, d
 		extra["EXIT_CODE"] = fmt.Sprintf("%d", *deferredExitCode)
 	}

-	// Resolve template with secrets masked for logging
-	cmd.LogCmd = templater.MaskSecretsWithExtra(cmd.Cmd, vars, extra)
 	cmd.Cmd = templater.ReplaceWithExtra(cmd.Cmd, cache, extra)
 	cmd.Task = templater.ReplaceWithExtra(cmd.Task, cache, extra)
-	cmd.If = templater.ReplaceWithExtra(cmd.If, cache, extra)
 	cmd.Vars = templater.ReplaceVarsWithExtra(cmd.Vars, cache, extra)

 	if err := e.runCommand(ctx, t, call, i); err != nil {
@@ -364,38 +308,24 @@ func (e *Executor) runDeferred(t *ast.Task, call *Call, i int, vars *ast.Vars, d
 func (e *Executor) runCommand(ctx context.Context, t *ast.Task, call *Call, i int) error {
 	cmd := t.Cmds[i]

-	// Check if condition for any command type
-	if strings.TrimSpace(cmd.If) != "" {
-		if err := execext.RunCommand(ctx, &execext.RunCommandOptions{
-			Command: cmd.If,
-			Dir:     t.Dir,
-			Env:     env.Get(t),
-		}); err != nil {
-			e.Logger.VerboseOutf(logger.Yellow, "task: [%s] if condition not met - skipped\n", t.Name())
-			return nil
-		}
-	}
-
 	switch {
 	case cmd.Task != "":
 		reacquire := e.releaseConcurrencyLimit()
 		defer reacquire()

 		err := e.RunTask(ctx, &Call{Task: cmd.Task, Vars: cmd.Vars, Silent: cmd.Silent, Indirect: true})
-		var exitCode interp.ExitStatus
-		if errors.As(err, &exitCode) && cmd.IgnoreError {
-			e.Logger.VerboseErrf(logger.Yellow, "task: [%s] task error ignored: %v\n", t.Name(), err)
-			return nil
+		if err != nil {
+			return err
 		}
-		return err
+		return nil
 	case cmd.Cmd != "":
 		if !shouldRunOnCurrentPlatform(cmd.Platforms) {
 			e.Logger.VerboseOutf(logger.Yellow, "task: [%s] %s not for current platform - ignored\n", t.Name(), cmd.Cmd)
 			return nil
 		}

-		if e.Verbose || (!call.Silent && !cmd.Silent && !t.IsSilent() && !e.Taskfile.Silent && !e.Silent) {
-			e.Logger.Errf(logger.Green, "task: [%s] %s\n", t.Name(), cmd.LogCmd)
+		if e.Verbose || (!call.Silent && !cmd.Silent && !t.Silent && !e.Taskfile.Silent && !e.Silent) {
+			e.Logger.Errf(logger.Green, "task: [%s] %s\n", t.Name(), cmd.Cmd)
 		}

 		if e.Dry {
@@ -443,7 +373,7 @@ func (e *Executor) startExecution(ctx context.Context, t *ast.Task, execute func
 		return err
 	}

-	if h == "" || t.Watch {
+	if h == "" {
 		return execute(ctx)
 	}

@@ -471,40 +401,19 @@ func (e *Executor) startExecution(ctx context.Context, t *ast.Task, execute func
 }

 // FindMatchingTasks returns a list of tasks that match the given call. A task
-// matches a call if its name is equal to the call's task name, or one of aliases, or if it matches
+// matches a call if its name is equal to the call's task name or if it matches
 // a wildcard pattern. The function returns a list of MatchingTask structs, each
 // containing a task and a list of wildcards that were matched.
-// If multiple tasks match due to aliases, a TaskNameConflictError is returned.
-func (e *Executor) FindMatchingTasks(call *Call) ([]*MatchingTask, error) {
+func (e *Executor) FindMatchingTasks(call *Call) []*MatchingTask {
 	if call == nil {
-		return nil, nil
+		return nil
 	}
 	var matchingTasks []*MatchingTask
 	// If there is a direct match, return it
 	if task, ok := e.Taskfile.Tasks.Get(call.Task); ok {
 		matchingTasks = append(matchingTasks, &MatchingTask{Task: task, Wildcards: nil})
-		return matchingTasks, nil
+		return matchingTasks
 	}
-	var aliasedTasks []string
-	for task := range e.Taskfile.Tasks.Values(nil) {
-		if slices.Contains(task.Aliases, call.Task) {
-			aliasedTasks = append(aliasedTasks, task.Task)
-			matchingTasks = append(matchingTasks, &MatchingTask{Task: task, Wildcards: nil})
-		}
-	}
-
-	if len(aliasedTasks) == 1 {
-		return matchingTasks, nil
-	}
-
-	// If we found multiple tasks
-	if len(aliasedTasks) > 1 {
-		return nil, &errors.TaskNameConflictError{
-			Call:      call.Task,
-			TaskNames: aliasedTasks,
-		}
-	}
-
 	// Attempt a wildcard match
 	for _, value := range e.Taskfile.Tasks.All(nil) {
 		if match, wildcards := value.WildcardMatch(call.Task); match {
@@ -514,7 +423,7 @@ func (e *Executor) FindMatchingTasks(call *Call) ([]*MatchingTask, error) {
 			})
 		}
 	}
-	return matchingTasks, nil
+	return matchingTasks
 }

 // GetTask will return the task with the name matching the given call from the taskfile.
@@ -522,11 +431,7 @@ func (e *Executor) FindMatchingTasks(call *Call) ([]*MatchingTask, error) {
 // If multiple tasks contain the same alias or no matches are found an error is returned.
 func (e *Executor) GetTask(call *Call) (*ast.Task, error) {
 	// Search for a matching task
-	matchingTasks, err := e.FindMatchingTasks(call)
-	if err != nil {
-		return nil, err
-	}
-
+	matchingTasks := e.FindMatchingTasks(call)
 	if len(matchingTasks) > 0 {
 		if call.Vars == nil {
 			call.Vars = ast.NewVars()
@@ -535,18 +440,35 @@ func (e *Executor) GetTask(call *Call) (*ast.Task, error) {
 		return matchingTasks[0].Task, nil
 	}

+	// If didn't find one, search for a task with a matching alias
+	var matchingTask *ast.Task
+	var aliasedTasks []string
+	for task := range e.Taskfile.Tasks.Values(nil) {
+		if slices.Contains(task.Aliases, call.Task) {
+			aliasedTasks = append(aliasedTasks, task.Task)
+			matchingTask = task
+		}
+	}
+	// If we found multiple tasks
+	if len(aliasedTasks) > 1 {
+		return nil, &errors.TaskNameConflictError{
+			Call:      call.Task,
+			TaskNames: aliasedTasks,
+		}
+	}
 	// If we found no tasks
-	didYouMean := ""
-	if !e.DisableFuzzy {
-		e.fuzzyModelOnce.Do(e.setupFuzzyModel)
+	if len(aliasedTasks) == 0 {
+		didYouMean := ""
 		if e.fuzzyModel != nil {
 			didYouMean = e.fuzzyModel.SpellCheck(call.Task)
 		}
+		return nil, &errors.TaskNotFoundError{
+			TaskName:   call.Task,
+			DidYouMean: didYouMean,
+		}
 	}
-	return nil, &errors.TaskNotFoundError{
-		TaskName:   call.Task,
-		DidYouMean: didYouMean,
-	}
+
+	return matchingTask, nil
 }

 type FilterFunc func(task *ast.Task) bool
@@ -578,7 +500,7 @@ func (e *Executor) GetTaskList(filters ...FilterFunc) ([]*ast.Task, error) {
 	// Compile the list of tasks
 	for i := range tasks {
 		g.Go(func() error {
-			compiledTask, err := e.CompiledTaskForTaskList(&Call{Task: tasks[i].Task})
+			compiledTask, err := e.FastCompiledTask(&Call{Task: tasks[i].Task})
 			if err != nil {
 				return err
 			}
--- a/task_test.go
+++ b/task_test.go
--- a/taskfile/ast/cmd.go
+++ b/taskfile/ast/cmd.go
@@ -1,7 +1,7 @@
 package ast

 import (
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/deepcopy"
@@ -9,11 +9,9 @@ import (

 // Cmd is a task command
 type Cmd struct {
-	Cmd         string // Resolved command (used for execution and fingerprinting)
-	LogCmd      string // Command with secrets masked (used for logging)
+	Cmd         string
 	Task        string
 	For         *For
-	If          string
 	Silent      bool
 	Set         []string
 	Shopt       []string
@@ -29,10 +27,8 @@ func (c *Cmd) DeepCopy() *Cmd {
 	}
 	return &Cmd{
 		Cmd:         c.Cmd,
-		LogCmd:      c.LogCmd,
 		Task:        c.Task,
 		For:         c.For.DeepCopy(),
-		If:          c.If,
 		Silent:      c.Silent,
 		Set:         deepcopy.Slice(c.Set),
 		Shopt:       deepcopy.Slice(c.Shopt),
@@ -59,7 +55,6 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 			Cmd         string
 			Task        string
 			For         *For
-			If          string
 			Silent      bool
 			Set         []string
 			Shopt       []string
@@ -97,9 +92,7 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 			c.Task = cmdStruct.Task
 			c.Vars = cmdStruct.Vars
 			c.For = cmdStruct.For
-			c.If = cmdStruct.If
 			c.Silent = cmdStruct.Silent
-			c.IgnoreError = cmdStruct.IgnoreError
 			return nil
 		}

@@ -107,7 +100,6 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 		if cmdStruct.Cmd != "" {
 			c.Cmd = cmdStruct.Cmd
 			c.For = cmdStruct.For
-			c.If = cmdStruct.If
 			c.Silent = cmdStruct.Silent
 			c.Set = cmdStruct.Set
 			c.Shopt = cmdStruct.Shopt
--- a/taskfile/ast/defer.go
+++ b/taskfile/ast/defer.go
@@ -1,7 +1,7 @@
 package ast

 import (
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 )
--- a/taskfile/ast/dep.go
+++ b/taskfile/ast/dep.go
@@ -1,7 +1,7 @@
 package ast

 import (
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 )
--- a/taskfile/ast/for.go
+++ b/taskfile/ast/for.go
@@ -1,7 +1,7 @@
 package ast

 import (
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/deepcopy"
--- a/taskfile/ast/glob.go
+++ b/taskfile/ast/glob.go
@@ -1,7 +1,7 @@
 package ast

 import (
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 )
--- a/taskfile/ast/include.go
+++ b/taskfile/ast/include.go
@@ -5,7 +5,7 @@ import (
 	"sync"

 	"github.com/elliotchance/orderedmap/v3"
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/deepcopy"
--- a/taskfile/ast/matrix.go
+++ b/taskfile/ast/matrix.go
@@ -4,7 +4,7 @@ import (
 	"iter"

 	"github.com/elliotchance/orderedmap/v3"
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/deepcopy"
--- a/taskfile/ast/output.go
+++ b/taskfile/ast/output.go
@@ -1,7 +1,7 @@
 package ast

 import (
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 )
--- a/taskfile/ast/platforms.go
+++ b/taskfile/ast/platforms.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"strings"

-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/goext"
--- a/taskfile/ast/precondition.go
+++ b/taskfile/ast/precondition.go
@@ -3,7 +3,7 @@ package ast
 import (
 	"fmt"

-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 )
--- a/taskfile/ast/precondition_test.go
+++ b/taskfile/ast/precondition_test.go
@@ -5,7 +5,7 @@ import (

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/taskfile/ast"
 )
--- a/taskfile/ast/prompt.go
+++ b/taskfile/ast/prompt.go
@@ -1,7 +1,7 @@
 package ast

 import (
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 )
--- a/taskfile/ast/requires.go
+++ b/taskfile/ast/requires.go
@@ -1,7 +1,7 @@
 package ast

 import (
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/deepcopy"
@@ -22,56 +22,9 @@ func (r *Requires) DeepCopy() *Requires {
 	}
 }

-// Enum represents an enum constraint for a required variable.
-// It can either be a static list of values or a reference to another variable.
-type Enum struct {
-	Ref   string
-	Value []string
-}
-
-func (e *Enum) DeepCopy() *Enum {
-	if e == nil {
-		return nil
-	}
-	return &Enum{
-		Ref:   e.Ref,
-		Value: deepcopy.Slice(e.Value),
-	}
-}
-
-// UnmarshalYAML implements yaml.Unmarshaler interface.
-func (e *Enum) UnmarshalYAML(node *yaml.Node) error {
-	switch node.Kind {
-	case yaml.SequenceNode:
-		// Static list of values: enum: ["a", "b"]
-		var values []string
-		if err := node.Decode(&values); err != nil {
-			return errors.NewTaskfileDecodeError(err, node)
-		}
-		e.Value = values
-		return nil
-
-	case yaml.MappingNode:
-		// Reference to another variable: enum: { ref: .VAR }
-		var refStruct struct {
-			Ref string
-		}
-		if err := node.Decode(&refStruct); err != nil {
-			return errors.NewTaskfileDecodeError(err, node)
-		}
-		if refStruct.Ref == "" {
-			return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("enum")
-		}
-		e.Ref = refStruct.Ref
-		return nil
-	}
-
-	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("enum")
-}
-
 type VarsWithValidation struct {
 	Name string
-	Enum *Enum
+	Enum []string
 }

 func (v *VarsWithValidation) DeepCopy() *VarsWithValidation {
@@ -80,7 +33,7 @@ func (v *VarsWithValidation) DeepCopy() *VarsWithValidation {
 	}
 	return &VarsWithValidation{
 		Name: v.Name,
-		Enum: v.Enum.DeepCopy(),
+		Enum: v.Enum,
 	}
 }

@@ -100,7 +53,7 @@ func (v *VarsWithValidation) UnmarshalYAML(node *yaml.Node) error {
 	case yaml.MappingNode:
 		var vv struct {
 			Name string
-			Enum *Enum
+			Enum []string
 		}
 		if err := node.Decode(&vv); err != nil {
 			return errors.NewTaskfileDecodeError(err, node)
--- a/taskfile/ast/task.go
+++ b/taskfile/ast/task.go
@@ -5,7 +5,7 @@ import (
 	"regexp"
 	"strings"

-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/deepcopy"
@@ -13,7 +13,7 @@ import (

 // Task represents a task
 type Task struct {
-	Task          string `hash:"ignore"`
+	Task          string
 	Cmds          []*Cmd
 	Deps          []*Dep
 	Label         string
@@ -32,74 +32,58 @@ type Task struct {
 	Vars          *Vars
 	Env           *Vars
 	Dotenv        []string
-	Silent        *bool
+	Silent        bool
 	Interactive   bool
 	Internal      bool
 	Method        string
-	Prefix        string `hash:"ignore"`
+	Prefix        string
 	IgnoreError   bool
 	Run           string
 	Platforms     []*Platform
-	If            string
 	Watch         bool
 	Location      *Location
-	Failfast      bool
 	// Populated during merging
-	Namespace            string `hash:"ignore"`
+	Namespace            string
 	IncludeVars          *Vars
 	IncludedTaskfileVars *Vars
-
-	FullName string `hash:"ignore"`
 }

 func (t *Task) Name() string {
 	if t.Label != "" {
 		return t.Label
 	}
-	if t.FullName != "" {
-		return t.FullName
-	}
 	return t.Task
 }

 func (t *Task) LocalName() string {
-	name := t.FullName
+	name := t.Task
 	name = strings.TrimPrefix(name, t.Namespace)
 	name = strings.TrimPrefix(name, ":")
 	return name
 }

-// IsSilent returns true if the task has silent mode explicitly enabled.
-// Returns false if Silent is nil (not set) or explicitly set to false.
-func (t *Task) IsSilent() bool {
-	return t.Silent != nil && *t.Silent
-}
-
 // WildcardMatch will check if the given string matches the name of the Task and returns any wildcard values.
 func (t *Task) WildcardMatch(name string) (bool, []string) {
-	names := append([]string{t.Task}, t.Aliases...)
+	// Convert the name into a regex string
+	regexStr := fmt.Sprintf("^%s$", strings.ReplaceAll(t.Task, "*", "(.*)"))
+	regex := regexp.MustCompile(regexStr)
+	wildcards := regex.FindStringSubmatch(name)
+	wildcardCount := strings.Count(t.Task, "*")

-	for _, taskName := range names {
-		regexStr := fmt.Sprintf("^%s$", strings.ReplaceAll(taskName, "*", "(.*)"))
-		regex := regexp.MustCompile(regexStr)
-		wildcards := regex.FindStringSubmatch(name)
-
-		if len(wildcards) == 0 {
-			continue
-		}
-
-		// Remove the first match, which is the full string
-		wildcards = wildcards[1:]
-		wildcardCount := strings.Count(taskName, "*")
-
-		if len(wildcards) != wildcardCount {
-			continue
-		}
-
-		return true, wildcards
+	// If there are no wildcards, return false
+	if len(wildcards) == 0 {
+		return false, nil
 	}

-	return false, nil
+	// Remove the first match, which is the full string
+	wildcards = wildcards[1:]
+
+	// If there are more/less wildcards than matches, return false
+	if len(wildcards) != wildcardCount {
+		return false, wildcards
+	}
+
+	return true, wildcards
 }

 func (t *Task) UnmarshalYAML(node *yaml.Node) error {
@@ -144,7 +128,7 @@ func (t *Task) UnmarshalYAML(node *yaml.Node) error {
 			Vars          *Vars
 			Env           *Vars
 			Dotenv        []string
-			Silent        *bool `yaml:"silent,omitempty"`
+			Silent        bool
 			Interactive   bool
 			Internal      bool
 			Method        string
@@ -152,10 +136,8 @@ func (t *Task) UnmarshalYAML(node *yaml.Node) error {
 			IgnoreError   bool `yaml:"ignore_error"`
 			Run           string
 			Platforms     []*Platform
-			If            string
 			Requires      *Requires
 			Watch         bool
-			Failfast      bool
 		}
 		if err := node.Decode(&task); err != nil {
 			return errors.NewTaskfileDecodeError(err, node)
@@ -184,7 +166,7 @@ func (t *Task) UnmarshalYAML(node *yaml.Node) error {
 		t.Vars = task.Vars
 		t.Env = task.Env
 		t.Dotenv = task.Dotenv
-		t.Silent = deepcopy.Scalar(task.Silent)
+		t.Silent = task.Silent
 		t.Interactive = task.Interactive
 		t.Internal = task.Internal
 		t.Method = task.Method
@@ -192,10 +174,8 @@ func (t *Task) UnmarshalYAML(node *yaml.Node) error {
 		t.IgnoreError = task.IgnoreError
 		t.Run = task.Run
 		t.Platforms = task.Platforms
-		t.If = task.If
 		t.Requires = task.Requires
 		t.Watch = task.Watch
-		t.Failfast = task.Failfast
 		return nil
 	}

@@ -227,7 +207,7 @@ func (t *Task) DeepCopy() *Task {
 		Vars:                 t.Vars.DeepCopy(),
 		Env:                  t.Env.DeepCopy(),
 		Dotenv:               deepcopy.Slice(t.Dotenv),
-		Silent:               deepcopy.Scalar(t.Silent),
+		Silent:               t.Silent,
 		Interactive:          t.Interactive,
 		Internal:             t.Internal,
 		Method:               t.Method,
@@ -237,13 +217,9 @@ func (t *Task) DeepCopy() *Task {
 		IncludeVars:          t.IncludeVars.DeepCopy(),
 		IncludedTaskfileVars: t.IncludedTaskfileVars.DeepCopy(),
 		Platforms:            deepcopy.Slice(t.Platforms),
-		If:                   t.If,
 		Location:             t.Location.DeepCopy(),
 		Requires:             t.Requires.DeepCopy(),
 		Namespace:            t.Namespace,
-		FullName:             t.FullName,
-		Watch:                t.Watch,
-		Failfast:             t.Failfast,
 	}
 	return c
 }
--- a/taskfile/ast/taskfile.go
+++ b/taskfile/ast/taskfile.go
@@ -5,7 +5,7 @@ import (
 	"time"

 	"github.com/Masterminds/semver/v3"
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 )
@@ -59,14 +59,6 @@ func (t1 *Taskfile) Merge(t2 *Taskfile, include *Include) error {
 	if t1.Tasks == nil {
 		t1.Tasks = NewTasks()
 	}
-	if t2.Silent {
-		for _, t := range t2.Tasks.All(nil) {
-			if t.Silent == nil {
-				v := true
-				t.Silent = &v
-			}
-		}
-	}
 	t1.Vars.Merge(t2.Vars, include)
 	t1.Env.Merge(t2.Env, include)
 	return t1.Tasks.Merge(t2.Tasks, include, t1.Vars)
--- a/taskfile/ast/taskfile_test.go
+++ b/taskfile/ast/taskfile_test.go
@@ -5,7 +5,7 @@ import (

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/taskfile/ast"
 )
--- a/taskfile/ast/tasks.go
+++ b/taskfile/ast/tasks.go
@@ -8,7 +8,7 @@ import (
 	"sync"

 	"github.com/elliotchance/orderedmap/v3"
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/filepathext"
@@ -244,8 +244,8 @@ func (t *Tasks) UnmarshalYAML(node *yaml.Node) error {
 }

 func taskNameWithNamespace(taskName string, namespace string) string {
-	if after, ok := strings.CutPrefix(taskName, NamespaceSeparator); ok {
-		return after
+	if strings.HasPrefix(taskName, NamespaceSeparator) {
+		return strings.TrimPrefix(taskName, NamespaceSeparator)
 	}
 	return fmt.Sprintf("%s%s%s", namespace, NamespaceSeparator, taskName)
 }
--- a/taskfile/ast/var.go
+++ b/taskfile/ast/var.go
@@ -1,52 +1,40 @@
 package ast

 import (
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 )

 // Var represents either a static or dynamic variable.
 type Var struct {
-	Value  any
-	Live   any
-	Sh     *string
-	Ref    string
-	Dir    string
-	Secret bool
+	Value any
+	Live  any
+	Sh    *string
+	Ref   string
+	Dir   string
 }

 func (v *Var) UnmarshalYAML(node *yaml.Node) error {
 	switch node.Kind {
 	case yaml.MappingNode:
-		key := "<none>"
-		if len(node.Content) > 0 {
-			key = node.Content[0].Value
-		}
+		key := node.Content[0].Value
 		switch key {
-		case "sh", "ref", "map", "value":
+		case "sh", "ref", "map":
 			var m struct {
-				Sh     *string
-				Ref    string
-				Map    any
-				Value  any
-				Secret bool
+				Sh  *string
+				Ref string
+				Map any
 			}
 			if err := node.Decode(&m); err != nil {
 				return errors.NewTaskfileDecodeError(err, node)
 			}
 			v.Sh = m.Sh
 			v.Ref = m.Ref
-			v.Secret = m.Secret
-			// Handle both "map" and "value" keys
-			if m.Map != nil {
-				v.Value = m.Map
-			} else if m.Value != nil {
-				v.Value = m.Value
-			}
+			v.Value = m.Map
 			return nil
 		default:
-			return errors.NewTaskfileDecodeError(nil, node).WithMessage(`%q is not a valid variable type. Try "sh", "ref", "map", "value" or using a scalar value`, key)
+			return errors.NewTaskfileDecodeError(nil, node).WithMessage(`%q is not a valid variable type. Try "sh", "ref", "map" or using a scalar value`, key)
 		}
 	default:
 		var value any
--- a/taskfile/ast/vars.go
+++ b/taskfile/ast/vars.go
@@ -5,7 +5,7 @@ import (
 	"sync"

 	"github.com/elliotchance/orderedmap/v3"
-	"go.yaml.in/yaml/v3"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/deepcopy"
@@ -113,12 +113,12 @@ func (vars *Vars) ToCacheMap() (m map[string]any) {
 			m[k] = v.Value
 		}
 	}
-	return m
+	return
 }

 // Merge loops over other and merges it values with the variables in vars. If
 // the include parameter is not nil and its it is an advanced import, the
-// directory is set to the value of the include parameter.
+// directory is set set to the value of the include parameter.
 func (vars *Vars) Merge(other *Vars, include *Include) {
 	if vars == nil || vars.om == nil || other == nil {
 		return
@@ -133,35 +133,6 @@ func (vars *Vars) Merge(other *Vars, include *Include) {
 	}
 }

-// ReverseMerge merges other variables with the existing variables in vars, but
-// keeps the other variables first in order. If the include parameter is not
-// nil and it is an advanced import, the directory is set to the value of the
-// include parameter.
-func (vars *Vars) ReverseMerge(other *Vars, include *Include) {
-	if vars == nil || vars.om == nil || other == nil || other.om == nil {
-		return
-	}
-
-	newOM := orderedmap.NewOrderedMap[string, Var]()
-
-	other.mutex.RLock()
-	for pair := other.om.Front(); pair != nil; pair = pair.Next() {
-		val := pair.Value
-		if include != nil && include.AdvancedImport {
-			val.Dir = include.Dir
-		}
-		newOM.Set(pair.Key, val)
-	}
-	other.mutex.RUnlock()
-
-	vars.mutex.Lock()
-	for pair := vars.om.Front(); pair != nil; pair = pair.Next() {
-		newOM.Set(pair.Key, pair.Value)
-	}
-	vars.om = newOM
-	vars.mutex.Unlock()
-}
-
 func (vs *Vars) DeepCopy() *Vars {
 	if vs == nil {
 		return nil
--- a/taskfile/node.go
+++ b/taskfile/node.go
@@ -3,7 +3,6 @@ package taskfile
 import (
 	"context"
 	"strings"
-	"time"

 	giturls "github.com/chainguard-dev/git-urls"

@@ -33,15 +32,13 @@ func NewRootNode(
 	entrypoint string,
 	dir string,
 	insecure bool,
-	timeout time.Duration,
-	opts ...NodeOption,
 ) (Node, error) {
 	dir = fsext.DefaultDir(entrypoint, dir)
 	// If the entrypoint is "-", we read from stdin
 	if entrypoint == "-" {
 		return NewStdinNode(dir)
 	}
-	return NewNode(entrypoint, dir, insecure, opts...)
+	return NewNode(entrypoint, dir, insecure)
 }

 func NewNode(
@@ -73,16 +70,6 @@ func NewNode(
 	return node, err
 }

-func isRemoteEntrypoint(entrypoint string) bool {
-	scheme, _ := getScheme(entrypoint)
-	switch scheme {
-	case "git", "http", "https":
-		return true
-	default:
-		return false
-	}
-}
-
 func getScheme(uri string) (string, error) {
 	u, err := giturls.Parse(uri)
 	if u == nil {
--- a/taskfile/node_base.go
+++ b/taskfile/node_base.go
@@ -10,9 +10,6 @@ type (
 		parent   Node
 		dir      string
 		checksum string
-		caCert   string
-		cert     string
-		certKey  string
 	}
 )

@@ -57,21 +54,3 @@ func (node *baseNode) Checksum() string {
 func (node *baseNode) Verify(checksum string) bool {
 	return node.checksum == "" || node.checksum == checksum
 }
-
-func WithCACert(caCert string) NodeOption {
-	return func(node *baseNode) {
-		node.caCert = caCert
-	}
-}
-
-func WithCert(cert string) NodeOption {
-	return func(node *baseNode) {
-		node.cert = cert
-	}
-}
-
-func WithCertKey(certKey string) NodeOption {
-	return func(node *baseNode) {
-		node.certKey = certKey
-	}
-}
--- a/taskfile/node_file.go
+++ b/taskfile/node_file.go
@@ -4,8 +4,8 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strings"

-	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/internal/fsext"
@@ -18,30 +18,15 @@ type FileNode struct {
 }

 func NewFileNode(entrypoint, dir string, opts ...NodeOption) (*FileNode, error) {
-	// Find the entrypoint file
-	resolvedEntrypoint, err := fsext.Search(entrypoint, dir, DefaultTaskfiles)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			if entrypoint == "" {
-				return nil, errors.TaskfileNotFoundError{URI: entrypoint, Walk: true}
-			} else {
-				return nil, errors.TaskfileNotFoundError{URI: entrypoint, Walk: false}
-			}
-		} else if errors.Is(err, os.ErrPermission) {
-			return nil, errors.TaskfileNotFoundError{URI: entrypoint, Walk: true, OwnerChange: true}
-		}
-		return nil, err
-	}
-
-	// Resolve the directory
-	resolvedDir, err := fsext.ResolveDir(entrypoint, resolvedEntrypoint, dir)
+	var err error
+	base := NewBaseNode(dir, opts...)
+	entrypoint, base.dir, err = fsext.Search(entrypoint, base.dir, defaultTaskfiles)
 	if err != nil {
 		return nil, err
 	}
-
 	return &FileNode{
-		baseNode:   NewBaseNode(resolvedDir, opts...),
-		entrypoint: resolvedEntrypoint,
+		baseNode:   base,
+		entrypoint: entrypoint,
 	}, nil
 }

@@ -60,7 +45,10 @@ func (node *FileNode) Read() ([]byte, error) {

 func (node *FileNode) ResolveEntrypoint(entrypoint string) (string, error) {
 	// If the file is remote, we don't need to resolve the path
-	if isRemoteEntrypoint(entrypoint) {
+	if strings.Contains(entrypoint, "://") {
+		return entrypoint, nil
+	}
+	if strings.HasPrefix(entrypoint, "git") {
 		return entrypoint, nil
 	}

--- a/taskfile/node_git.go
+++ b/taskfile/node_git.go
@@ -3,20 +3,20 @@ package taskfile
 import (
 	"context"
 	"fmt"
+	"io"
 	"net/url"
-	"os"
-	"path"
 	"path/filepath"
 	"strings"
-	"sync"

 	giturls "github.com/chainguard-dev/git-urls"
-	"github.com/hashicorp/go-getter"
+	"github.com/go-git/go-billy/v5/memfs"
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/storage/memory"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/internal/fsext"
 )

 // An GitNode is a node that reads a Taskfile from a remote location via Git.
@@ -28,36 +28,6 @@ type GitNode struct {
 	path   string
 }

-type gitRepoCache struct {
-	mu    sync.Mutex             // Protects the locks map
-	locks map[string]*sync.Mutex // One mutex per repo cache key
-}
-
-func (c *gitRepoCache) getLockForRepo(cacheKey string) *sync.Mutex {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if _, exists := c.locks[cacheKey]; !exists {
-		c.locks[cacheKey] = &sync.Mutex{}
-	}
-
-	return c.locks[cacheKey]
-}
-
-var globalGitRepoCache = &gitRepoCache{
-	locks: make(map[string]*sync.Mutex),
-}
-
-func CleanGitCache() error {
-	// Clear the in-memory locks map to prevent memory leak
-	globalGitRepoCache.mu.Lock()
-	globalGitRepoCache.locks = make(map[string]*sync.Mutex)
-	globalGitRepoCache.mu.Unlock()
-
-	cacheDir := filepath.Join(os.TempDir(), "task-git-repos")
-	return os.RemoveAll(cacheDir)
-}
-
 func NewGitNode(
 	entrypoint string,
 	dir string,
@@ -102,83 +72,24 @@ func (node *GitNode) Read() ([]byte, error) {
 	return node.ReadContext(context.Background())
 }

-func (node *GitNode) buildURL() string {
-	// Get the base URL
-	baseURL := node.url.String()
-
-	// Always use git:: prefix for git URLs (following Terraform's pattern)
-	// This forces go-getter to use git protocol
-	if node.ref != "" {
-		return fmt.Sprintf("git::%s?ref=%s&depth=1", baseURL, node.ref)
-	}
-	// When no ref is specified, omit it entirely to let git clone the default branch
-	return fmt.Sprintf("git::%s?depth=1", baseURL)
-}
-
-// getOrCloneRepo returns the path to a cached git repository.
-// If the repository is not cached, it clones it first.
-// This function is thread-safe: multiple goroutines cloning the same repo+ref
-// will synchronize, and only one clone operation will occur.
-//
-// The cache directory is /tmp/task-git-repos/{cache_key}/
-func (node *GitNode) getOrCloneRepo(ctx context.Context) (string, error) {
-	cacheKey := node.repoCacheKey()
-
-	repoMutex := globalGitRepoCache.getLockForRepo(cacheKey)
-	repoMutex.Lock()
-	defer repoMutex.Unlock()
-
-	cacheDir := filepath.Join(os.TempDir(), "task-git-repos", cacheKey)
-
-	// Check cache FIRST - if already cloned, no network needed, timeout irrelevant
-	gitDir := filepath.Join(cacheDir, ".git")
-	if _, err := os.Stat(gitDir); err == nil {
-		return cacheDir, nil
-	}
-
-	// Only check context if we need to clone (requires network)
-	if err := ctx.Err(); err != nil {
-		return "", fmt.Errorf("context cancelled while waiting for repository lock: %w", err)
-	}
-
-	getterURL := node.buildURL()
-
-	client := &getter.Client{
-		Ctx:  ctx,
-		Src:  getterURL,
-		Dst:  cacheDir,
-		Mode: getter.ClientModeDir,
-	}
-
-	if err := client.Get(); err != nil {
-		_ = os.RemoveAll(cacheDir)
-		return "", fmt.Errorf("failed to clone repository: %w", err)
-	}
-
-	return cacheDir, nil
-}
-
-func (node *GitNode) ReadContext(ctx context.Context) ([]byte, error) {
-	// Get or clone the repository into cache
-	repoDir, err := node.getOrCloneRepo(ctx)
+func (node *GitNode) ReadContext(_ context.Context) ([]byte, error) {
+	fs := memfs.New()
+	storer := memory.NewStorage()
+	_, err := git.Clone(storer, fs, &git.CloneOptions{
+		URL:           node.url.String(),
+		ReferenceName: plumbing.ReferenceName(node.ref),
+		SingleBranch:  true,
+		Depth:         1,
+	})
 	if err != nil {
 		return nil, err
 	}
-
-	// Build path to Taskfile in the cached repo
-	// If node.path is empty, search in repo root; otherwise search in the specified path
-	// fsext.SearchPath handles both files and directories (searching for DefaultTaskfiles)
-	searchPath := repoDir
-	if node.path != "" {
-		searchPath = filepath.Join(repoDir, node.path)
-	}
-	filePath, err := fsext.SearchPath(searchPath, DefaultTaskfiles)
+	file, err := fs.Open(node.path)
 	if err != nil {
 		return nil, err
 	}
-
-	// Read file from cached repo
-	b, err := os.ReadFile(filePath)
+	// Read the entire response body
+	b, err := io.ReadAll(file)
 	if err != nil {
 		return nil, err
 	}
@@ -187,13 +98,8 @@ func (node *GitNode) ReadContext(ctx context.Context) ([]byte, error) {
 }

 func (node *GitNode) ResolveEntrypoint(entrypoint string) (string, error) {
-	// If the file is remote, we don't need to resolve the path
-	if isRemoteEntrypoint(entrypoint) {
-		return entrypoint, nil
-	}
-
-	dir, _ := path.Split(node.path)
-	resolvedEntrypoint := fmt.Sprintf("%s//%s", node.url, path.Join(dir, entrypoint))
+	dir, _ := filepath.Split(node.path)
+	resolvedEntrypoint := fmt.Sprintf("%s//%s", node.url, filepath.Join(dir, entrypoint))
 	if node.ref != "" {
 		return fmt.Sprintf("%s?ref=%s", resolvedEntrypoint, node.ref), nil
 	}
@@ -227,22 +133,6 @@ func (node *GitNode) CacheKey() string {
 	return fmt.Sprintf("git.%s.%s.%s", node.url.Host, prefix, checksum)
 }

-// repoCacheKey generates a unique cache key for the repository+ref combination.
-// Unlike CacheKey() which includes the file path, this identifies the repository itself.
-// Two GitNodes with the same repo+ref but different file paths will share the same cache.
-//
-// Returns a path like: github.com/user/repo.git/main
-func (node *GitNode) repoCacheKey() string {
-	repoPath := strings.Trim(node.url.Path, "/")
-
-	ref := node.ref
-	if ref == "" {
-		ref = "_default_" // Placeholder for the remote's default branch
-	}
-
-	return filepath.Join(node.url.Host, repoPath, ref)
-}
-
 func splitURLOnDoubleSlash(u *url.URL) (string, string) {
 	x := strings.Split(u.Path, "//")
 	switch len(x) {
--- a/taskfile/node_git_test.go
+++ b/taskfile/node_git_test.go
@@ -21,17 +21,6 @@ func TestGitNode_ssh(t *testing.T) {
 	assert.Equal(t, "ssh://git@github.com/foo/bar.git//common.yml?ref=main", entrypoint)
 }

-func TestGitNode_sshWithAltRepo(t *testing.T) {
-	t.Parallel()
-
-	node, err := NewGitNode("git@github.com:foo/bar.git//Taskfile.yml?ref=main", "", false)
-	assert.NoError(t, err)
-
-	entrypoint, err := node.ResolveEntrypoint("git@github.com:foo/other.git//Taskfile.yml?ref=dev")
-	assert.NoError(t, err)
-	assert.Equal(t, "git@github.com:foo/other.git//Taskfile.yml?ref=dev", entrypoint)
-}
-
 func TestGitNode_sshWithDir(t *testing.T) {
 	t.Parallel()

@@ -102,146 +91,3 @@ func TestGitNode_CacheKey(t *testing.T) {
 		assert.Equal(t, tt.expectedKey, key)
 	}
 }
-
-func TestGitNode_buildURL(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		entrypoint  string
-		expectedURL string
-	}{
-		{
-			name:        "HTTPS with ref",
-			entrypoint:  "https://github.com/foo/bar.git//Taskfile.yml?ref=main",
-			expectedURL: "git::https://github.com/foo/bar.git?ref=main&depth=1",
-		},
-		{
-			name:        "SSH with ref",
-			entrypoint:  "git@github.com:foo/bar.git//Taskfile.yml?ref=main",
-			expectedURL: "git::ssh://git@github.com/foo/bar.git?ref=main&depth=1",
-		},
-		{
-			name:        "HTTPS with tag ref",
-			entrypoint:  "https://github.com/foo/bar.git//Taskfile.yml?ref=v1.0.0",
-			expectedURL: "git::https://github.com/foo/bar.git?ref=v1.0.0&depth=1",
-		},
-		{
-			name:        "HTTPS without ref (uses remote default branch)",
-			entrypoint:  "https://github.com/foo/bar.git//Taskfile.yml",
-			expectedURL: "git::https://github.com/foo/bar.git?depth=1",
-		},
-		{
-			name:        "SSH with directory path",
-			entrypoint:  "git@github.com:foo/bar.git//directory/Taskfile.yml?ref=dev",
-			expectedURL: "git::ssh://git@github.com/foo/bar.git?ref=dev&depth=1",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			node, err := NewGitNode(tt.entrypoint, "", false)
-			require.NoError(t, err)
-			gotURL := node.buildURL()
-			assert.Equal(t, tt.expectedURL, gotURL)
-		})
-	}
-}
-
-func TestRepoCacheKey_SameRepoSameRef(t *testing.T) {
-	t.Parallel()
-
-	// Same repo, same ref, different files should have SAME cache key
-	node1, err := NewGitNode("https://github.com/foo/bar.git//file1.yml?ref=main", "", false)
-	require.NoError(t, err)
-
-	node2, err := NewGitNode("https://github.com/foo/bar.git//dir/file2.yml?ref=main", "", false)
-	require.NoError(t, err)
-
-	key1 := node1.repoCacheKey()
-	key2 := node2.repoCacheKey()
-
-	assert.Equal(t, key1, key2, "Same repo+ref should generate same cache key regardless of file path")
-}
-
-func TestRepoCacheKey_SameRepoDifferentRef(t *testing.T) {
-	t.Parallel()
-
-	// Same repo, different ref should have DIFFERENT cache keys
-	node1, err := NewGitNode("https://github.com/foo/bar.git//file.yml?ref=main", "", false)
-	require.NoError(t, err)
-
-	node2, err := NewGitNode("https://github.com/foo/bar.git//file.yml?ref=dev", "", false)
-	require.NoError(t, err)
-
-	key1 := node1.repoCacheKey()
-	key2 := node2.repoCacheKey()
-
-	assert.NotEqual(t, key1, key2, "Different refs should generate different cache keys")
-}
-
-func TestRepoCacheKey_DifferentRepos(t *testing.T) {
-	t.Parallel()
-
-	// Different repos should have DIFFERENT cache keys
-	node1, err := NewGitNode("https://github.com/foo/bar.git//file.yml?ref=main", "", false)
-	require.NoError(t, err)
-
-	node2, err := NewGitNode("https://github.com/foo/other.git//file.yml?ref=main", "", false)
-	require.NoError(t, err)
-
-	key1 := node1.repoCacheKey()
-	key2 := node2.repoCacheKey()
-
-	assert.NotEqual(t, key1, key2, "Different repos should generate different cache keys")
-}
-
-func TestRepoCacheKey_NoRefVsExplicitRef(t *testing.T) {
-	t.Parallel()
-
-	// No ref (uses default branch) vs explicit ref should have DIFFERENT cache keys
-	node1, err := NewGitNode("https://github.com/foo/bar.git//file.yml", "", false)
-	require.NoError(t, err)
-
-	node2, err := NewGitNode("https://github.com/foo/bar.git//file.yml?ref=main", "", false)
-	require.NoError(t, err)
-
-	key1 := node1.repoCacheKey()
-	key2 := node2.repoCacheKey()
-
-	assert.NotEqual(t, key1, key2, "No ref and explicit ref should generate different cache keys")
-}
-
-func TestRepoCacheKey_SSHvsHTTPS(t *testing.T) {
-	t.Parallel()
-
-	// SSH vs HTTPS pointing to same repo should have SAME cache key
-	// They clone the same repo, so we want to share the cache
-	node1, err := NewGitNode("git@github.com:foo/bar.git//file.yml?ref=main", "", false)
-	require.NoError(t, err)
-
-	node2, err := NewGitNode("https://github.com/foo/bar.git//file.yml?ref=main", "", false)
-	require.NoError(t, err)
-
-	key1 := node1.repoCacheKey()
-	key2 := node2.repoCacheKey()
-
-	assert.Equal(t, key1, key2, "SSH and HTTPS for same repo should share cache")
-}
-
-func TestRepoCacheKey_Consistency(t *testing.T) {
-	t.Parallel()
-
-	// Calling repoCacheKey multiple times on same node should return same key
-	node, err := NewGitNode("https://github.com/foo/bar.git//file.yml?ref=main", "", false)
-	require.NoError(t, err)
-
-	key1 := node.repoCacheKey()
-	key2 := node.repoCacheKey()
-	key3 := node.repoCacheKey()
-
-	assert.Equal(t, key1, key2)
-	assert.Equal(t, key2, key3)
-}
--- a/taskfile/node_http.go
+++ b/taskfile/node_http.go
@@ -2,13 +2,10 @@ package taskfile

 import (
 	"context"
-	"crypto/tls"
-	"crypto/x509"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
-	"os"
 	"path/filepath"
 	"strings"

@@ -20,54 +17,7 @@ import (
 // An HTTPNode is a node that reads a Taskfile from a remote location via HTTP.
 type HTTPNode struct {
 	*baseNode
-	url    *url.URL     // stores url pointing actual remote file. (e.g. with Taskfile.yml)
-	client *http.Client // HTTP client with optional TLS configuration
-}
-
-// buildHTTPClient creates an HTTP client with optional TLS configuration.
-// If no certificate options are provided, it returns http.DefaultClient.
-func buildHTTPClient(insecure bool, caCert, cert, certKey string) (*http.Client, error) {
-	// Validate that cert and certKey are provided together
-	if (cert != "" && certKey == "") || (cert == "" && certKey != "") {
-		return nil, fmt.Errorf("both --cert and --cert-key must be provided together")
-	}
-
-	// If no TLS customization is needed, return the default client
-	if !insecure && caCert == "" && cert == "" {
-		return http.DefaultClient, nil
-	}
-
-	tlsConfig := &tls.Config{
-		InsecureSkipVerify: insecure, //nolint:gosec
-	}
-
-	// Load custom CA certificate if provided
-	if caCert != "" {
-		caCertData, err := os.ReadFile(caCert)
-		if err != nil {
-			return nil, fmt.Errorf("failed to read CA certificate: %w", err)
-		}
-		caCertPool := x509.NewCertPool()
-		if !caCertPool.AppendCertsFromPEM(caCertData) {
-			return nil, fmt.Errorf("failed to parse CA certificate")
-		}
-		tlsConfig.RootCAs = caCertPool
-	}
-
-	// Load client certificate and key if provided
-	if cert != "" && certKey != "" {
-		clientCert, err := tls.LoadX509KeyPair(cert, certKey)
-		if err != nil {
-			return nil, fmt.Errorf("failed to load client certificate: %w", err)
-		}
-		tlsConfig.Certificates = []tls.Certificate{clientCert}
-	}
-
-	return &http.Client{
-		Transport: &http.Transport{
-			TLSClientConfig: tlsConfig,
-		},
-	}, nil
+	url *url.URL // stores url pointing actual remote file. (e.g. with Taskfile.yml)
 }

 func NewHTTPNode(
@@ -84,16 +34,9 @@ func NewHTTPNode(
 	if url.Scheme == "http" && !insecure {
 		return nil, &errors.TaskfileNotSecureError{URI: url.Redacted()}
 	}
-
-	client, err := buildHTTPClient(insecure, base.caCert, base.cert, base.certKey)
-	if err != nil {
-		return nil, err
-	}
-
 	return &HTTPNode{
 		baseNode: base,
 		url:      url,
-		client:   client,
 	}, nil
 }

@@ -106,16 +49,16 @@ func (node *HTTPNode) Read() ([]byte, error) {
 }

 func (node *HTTPNode) ReadContext(ctx context.Context) ([]byte, error) {
-	url, err := RemoteExists(ctx, *node.url, node.client)
+	url, err := RemoteExists(ctx, *node.url)
 	if err != nil {
 		return nil, err
 	}
-	req, err := http.NewRequestWithContext(ctx, "GET", url.String(), nil)
+	req, err := http.NewRequest("GET", url.String(), nil)
 	if err != nil {
 		return nil, errors.TaskfileFetchFailedError{URI: node.Location()}
 	}

-	resp, err := node.client.Do(req.WithContext(ctx))
+	resp, err := http.DefaultClient.Do(req.WithContext(ctx))
 	if err != nil {
 		if ctx.Err() != nil {
 			return nil, err
--- a/taskfile/node_http_test.go
+++ b/taskfile/node_http_test.go
@@ -1,18 +1,7 @@
 package taskfile

 import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"math/big"
-	"net/http"
-	"os"
-	"path/filepath"
 	"testing"
-	"time"

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -58,227 +47,3 @@ func TestHTTPNode_CacheKey(t *testing.T) {
 		assert.Equal(t, tt.expectedKey, key)
 	}
 }
-
-func TestBuildHTTPClient_Default(t *testing.T) {
-	t.Parallel()
-
-	// When no TLS customization is needed, should return http.DefaultClient
-	client, err := buildHTTPClient(false, "", "", "")
-	require.NoError(t, err)
-	assert.Equal(t, http.DefaultClient, client)
-}
-
-func TestBuildHTTPClient_Insecure(t *testing.T) {
-	t.Parallel()
-
-	client, err := buildHTTPClient(true, "", "", "")
-	require.NoError(t, err)
-	require.NotNil(t, client)
-	assert.NotEqual(t, http.DefaultClient, client)
-
-	// Check that InsecureSkipVerify is set
-	transport, ok := client.Transport.(*http.Transport)
-	require.True(t, ok)
-	require.NotNil(t, transport.TLSClientConfig)
-	assert.True(t, transport.TLSClientConfig.InsecureSkipVerify)
-}
-
-func TestBuildHTTPClient_CACert(t *testing.T) {
-	t.Parallel()
-
-	// Create a temporary CA cert file
-	tempDir := t.TempDir()
-	caCertPath := filepath.Join(tempDir, "ca.crt")
-
-	// Generate a valid CA certificate
-	caCertPEM := generateTestCACert(t)
-	err := os.WriteFile(caCertPath, caCertPEM, 0o600)
-	require.NoError(t, err)
-
-	client, err := buildHTTPClient(false, caCertPath, "", "")
-	require.NoError(t, err)
-	require.NotNil(t, client)
-	assert.NotEqual(t, http.DefaultClient, client)
-
-	// Check that custom RootCAs is set
-	transport, ok := client.Transport.(*http.Transport)
-	require.True(t, ok)
-	require.NotNil(t, transport.TLSClientConfig)
-	assert.NotNil(t, transport.TLSClientConfig.RootCAs)
-}
-
-func TestBuildHTTPClient_CACertNotFound(t *testing.T) {
-	t.Parallel()
-
-	client, err := buildHTTPClient(false, "/nonexistent/ca.crt", "", "")
-	assert.Error(t, err)
-	assert.Nil(t, client)
-	assert.Contains(t, err.Error(), "failed to read CA certificate")
-}
-
-func TestBuildHTTPClient_CACertInvalid(t *testing.T) {
-	t.Parallel()
-
-	// Create a temporary file with invalid content
-	tempDir := t.TempDir()
-	caCertPath := filepath.Join(tempDir, "invalid.crt")
-	err := os.WriteFile(caCertPath, []byte("not a valid certificate"), 0o600)
-	require.NoError(t, err)
-
-	client, err := buildHTTPClient(false, caCertPath, "", "")
-	assert.Error(t, err)
-	assert.Nil(t, client)
-	assert.Contains(t, err.Error(), "failed to parse CA certificate")
-}
-
-func TestBuildHTTPClient_CertWithoutKey(t *testing.T) {
-	t.Parallel()
-
-	client, err := buildHTTPClient(false, "", "/path/to/cert.crt", "")
-	assert.Error(t, err)
-	assert.Nil(t, client)
-	assert.Contains(t, err.Error(), "both --cert and --cert-key must be provided together")
-}
-
-func TestBuildHTTPClient_KeyWithoutCert(t *testing.T) {
-	t.Parallel()
-
-	client, err := buildHTTPClient(false, "", "", "/path/to/key.pem")
-	assert.Error(t, err)
-	assert.Nil(t, client)
-	assert.Contains(t, err.Error(), "both --cert and --cert-key must be provided together")
-}
-
-func TestBuildHTTPClient_CertAndKey(t *testing.T) {
-	t.Parallel()
-
-	// Create temporary cert and key files
-	tempDir := t.TempDir()
-	certPath := filepath.Join(tempDir, "client.crt")
-	keyPath := filepath.Join(tempDir, "client.key")
-
-	// Generate a self-signed certificate and key for testing
-	cert, key := generateTestCertAndKey(t)
-	err := os.WriteFile(certPath, cert, 0o600)
-	require.NoError(t, err)
-	err = os.WriteFile(keyPath, key, 0o600)
-	require.NoError(t, err)
-
-	client, err := buildHTTPClient(false, "", certPath, keyPath)
-	require.NoError(t, err)
-	require.NotNil(t, client)
-	assert.NotEqual(t, http.DefaultClient, client)
-
-	// Check that client certificate is set
-	transport, ok := client.Transport.(*http.Transport)
-	require.True(t, ok)
-	require.NotNil(t, transport.TLSClientConfig)
-	assert.Len(t, transport.TLSClientConfig.Certificates, 1)
-}
-
-func TestBuildHTTPClient_CertNotFound(t *testing.T) {
-	t.Parallel()
-
-	client, err := buildHTTPClient(false, "", "/nonexistent/cert.crt", "/nonexistent/key.pem")
-	assert.Error(t, err)
-	assert.Nil(t, client)
-	assert.Contains(t, err.Error(), "failed to load client certificate")
-}
-
-func TestBuildHTTPClient_InsecureWithCACert(t *testing.T) {
-	t.Parallel()
-
-	// Create a temporary CA cert file
-	tempDir := t.TempDir()
-	caCertPath := filepath.Join(tempDir, "ca.crt")
-
-	// Generate a valid CA certificate
-	caCertPEM := generateTestCACert(t)
-	err := os.WriteFile(caCertPath, caCertPEM, 0o600)
-	require.NoError(t, err)
-
-	// Both insecure and CA cert can be set together
-	client, err := buildHTTPClient(true, caCertPath, "", "")
-	require.NoError(t, err)
-	require.NotNil(t, client)
-
-	transport, ok := client.Transport.(*http.Transport)
-	require.True(t, ok)
-	require.NotNil(t, transport.TLSClientConfig)
-	assert.True(t, transport.TLSClientConfig.InsecureSkipVerify)
-	assert.NotNil(t, transport.TLSClientConfig.RootCAs)
-}
-
-// generateTestCertAndKey generates a self-signed certificate and key for testing
-func generateTestCertAndKey(t *testing.T) (certPEM, keyPEM []byte) {
-	t.Helper()
-
-	// Generate a new ECDSA private key
-	privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	require.NoError(t, err)
-
-	// Create a certificate template
-	template := x509.Certificate{
-		SerialNumber: big.NewInt(1),
-		Subject: pkix.Name{
-			Organization: []string{"Task Org"},
-		},
-		NotBefore:             time.Now(),
-		NotAfter:              time.Now().Add(time.Hour),
-		KeyUsage:              x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
-		BasicConstraintsValid: true,
-	}
-
-	// Create the certificate
-	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &privateKey.PublicKey, privateKey)
-	require.NoError(t, err)
-
-	// Encode certificate to PEM
-	certPEM = pem.EncodeToMemory(&pem.Block{
-		Type:  "CERTIFICATE",
-		Bytes: certDER,
-	})
-
-	// Encode private key to PEM
-	keyDER, err := x509.MarshalECPrivateKey(privateKey)
-	require.NoError(t, err)
-	keyPEM = pem.EncodeToMemory(&pem.Block{
-		Type:  "EC PRIVATE KEY",
-		Bytes: keyDER,
-	})
-
-	return certPEM, keyPEM
-}
-
-// generateTestCACert generates a self-signed CA certificate for testing
-func generateTestCACert(t *testing.T) []byte {
-	t.Helper()
-
-	// Generate a new ECDSA private key
-	privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	require.NoError(t, err)
-
-	// Create a CA certificate template
-	template := x509.Certificate{
-		SerialNumber: big.NewInt(1),
-		Subject: pkix.Name{
-			Organization: []string{"Test CA"},
-		},
-		NotBefore:             time.Now(),
-		NotAfter:              time.Now().Add(time.Hour),
-		KeyUsage:              x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
-		IsCA:                  true,
-		BasicConstraintsValid: true,
-	}
-
-	// Create the certificate
-	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &privateKey.PublicKey, privateKey)
-	require.NoError(t, err)
-
-	// Encode certificate to PEM
-	return pem.EncodeToMemory(&pem.Block{
-		Type:  "CERTIFICATE",
-		Bytes: certDER,
-	})
-}
--- a/taskfile/node_stdin.go
+++ b/taskfile/node_stdin.go
@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"fmt"
 	"os"
+	"strings"

 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
@@ -42,7 +43,7 @@ func (node *StdinNode) Read() ([]byte, error) {

 func (node *StdinNode) ResolveEntrypoint(entrypoint string) (string, error) {
 	// If the file is remote, we don't need to resolve the path
-	if isRemoteEntrypoint(entrypoint) {
+	if strings.Contains(entrypoint, "://") {
 		return entrypoint, nil
 	}

--- a/taskfile/reader.go
+++ b/taskfile/reader.go
@@ -3,14 +3,13 @@ package taskfile
 import (
 	"context"
 	"fmt"
-	"net/url"
 	"os"
 	"sync"
 	"time"

 	"github.com/dominikbraun/graph"
-	"go.yaml.in/yaml/v3"
 	"golang.org/x/sync/errgroup"
+	"gopkg.in/yaml.v3"

 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/env"
@@ -44,12 +43,8 @@ type (
 		insecure            bool
 		download            bool
 		offline             bool
-		trustedHosts        []string
 		tempDir             string
 		cacheExpiryDuration time.Duration
-		caCert              string
-		cert                string
-		certKey             string
 		debugFunc           DebugFunc
 		promptFunc          PromptFunc
 		promptMutex         sync.Mutex
@@ -64,7 +59,6 @@ func NewReader(opts ...ReaderOption) *Reader {
 		insecure:            false,
 		download:            false,
 		offline:             false,
-		trustedHosts:        nil,
 		tempDir:             os.TempDir(),
 		cacheExpiryDuration: 0,
 		debugFunc:           nil,
@@ -125,20 +119,6 @@ func (o *offlineOption) ApplyToReader(r *Reader) {
 	r.offline = o.offline
 }

-// WithTrustedHosts configures the [Reader] with a list of trusted hosts for remote
-// Taskfiles. Hosts in this list will not prompt for user confirmation.
-func WithTrustedHosts(trustedHosts []string) ReaderOption {
-	return &trustedHostsOption{trustedHosts: trustedHosts}
-}
-
-type trustedHostsOption struct {
-	trustedHosts []string
-}
-
-func (o *trustedHostsOption) ApplyToReader(r *Reader) {
-	r.trustedHosts = o.trustedHosts
-}
-
 // WithTempDir sets the temporary directory that will be used by the [Reader].
 // By default, the reader uses [os.TempDir].
 func WithTempDir(tempDir string) ReaderOption {
@@ -202,59 +182,14 @@ func (o *promptFuncOption) ApplyToReader(r *Reader) {
 	r.promptFunc = o.promptFunc
 }

-// WithReaderCACert sets the path to a custom CA certificate for TLS connections.
-func WithReaderCACert(caCert string) ReaderOption {
-	return &readerCACertOption{caCert: caCert}
-}
-
-type readerCACertOption struct {
-	caCert string
-}
-
-func (o *readerCACertOption) ApplyToReader(r *Reader) {
-	r.caCert = o.caCert
-}
-
-// WithReaderCert sets the path to a client certificate for TLS connections.
-func WithReaderCert(cert string) ReaderOption {
-	return &readerCertOption{cert: cert}
-}
-
-type readerCertOption struct {
-	cert string
-}
-
-func (o *readerCertOption) ApplyToReader(r *Reader) {
-	r.cert = o.cert
-}
-
-// WithReaderCertKey sets the path to a client certificate key for TLS connections.
-func WithReaderCertKey(certKey string) ReaderOption {
-	return &readerCertKeyOption{certKey: certKey}
-}
-
-type readerCertKeyOption struct {
-	certKey string
-}
-
-func (o *readerCertKeyOption) ApplyToReader(r *Reader) {
-	r.certKey = o.certKey
-}
-
 // Read will read the Taskfile defined by the [Reader]'s [Node] and recurse
 // through any [ast.Includes] it finds, reading each included Taskfile and
 // building an [ast.TaskfileGraph] as it goes. If any errors occur, they will be
 // returned immediately.
 func (r *Reader) Read(ctx context.Context, node Node) (*ast.TaskfileGraph, error) {
-	// Clean up git cache after reading all taskfiles
-	defer func() {
-		_ = CleanGitCache()
-	}()
-
 	if err := r.include(ctx, node); err != nil {
 		return nil, err
 	}
-
 	return r.graph, nil
 }

@@ -271,28 +206,6 @@ func (r *Reader) promptf(format string, a ...any) error {
 	return nil
 }

-// isTrusted checks if a URI's host matches any of the trusted hosts patterns.
-func (r *Reader) isTrusted(uri string) bool {
-	if len(r.trustedHosts) == 0 {
-		return false
-	}
-
-	// Parse the URI to extract the host
-	parsedURL, err := url.Parse(uri)
-	if err != nil {
-		return false
-	}
-	host := parsedURL.Host
-
-	// Check against each trusted pattern (exact match including port if provided)
-	for _, pattern := range r.trustedHosts {
-		if host == pattern {
-			return true
-		}
-	}
-	return false
-}
-
 func (r *Reader) include(ctx context.Context, node Node) error {
 	// Create a new vertex for the Taskfile
 	vertex := &ast.TaskfileVertex{
@@ -356,9 +269,6 @@ func (r *Reader) include(ctx context.Context, node Node) error {
 			includeNode, err := NewNode(entrypoint, include.Dir, r.insecure,
 				WithParent(node),
 				WithChecksum(include.Checksum),
-				WithCACert(r.caCert),
-				WithCert(r.cert),
-				WithCertKey(r.certKey),
 			)
 			if err != nil {
 				if include.Optional {
@@ -549,9 +459,9 @@ func (r *Reader) readRemoteNodeContent(ctx context.Context, node RemoteNode) ([]

 	// If there is no manual checksum pin, run the automatic checks
 	if node.Checksum() == "" {
-		// Prompt the user if required (unless host is trusted)
+		// Prompt the user if required
 		prompt := cache.ChecksumPrompt(checksum)
-		if prompt != "" && !r.isTrusted(node.Location()) {
+		if prompt != "" {
 			if err := func() error {
 				r.promptMutex.Lock()
 				defer r.promptMutex.Unlock()
--- a/taskfile/taskfile.go
+++ b/taskfile/taskfile.go
@@ -12,8 +12,7 @@ import (
 )

 var (
-	// DefaultTaskfiles is the list of Taskfile file names supported by default.
-	DefaultTaskfiles = []string{
+	defaultTaskfiles = []string{
 		"Taskfile.yml",
 		"taskfile.yml",
 		"Taskfile.yaml",
@@ -29,7 +28,6 @@ var (
 		"text/x-yaml",
 		"application/yaml",
 		"application/x-yaml",
-		"application/octet-stream",
 	}
 )

@@ -38,7 +36,7 @@ var (
 // at the given URL with any of the default Taskfile files names. If any of
 // these match a file, the first matching path will be returned. If no files are
 // found, an error will be returned.
-func RemoteExists(ctx context.Context, u url.URL, client *http.Client) (*url.URL, error) {
+func RemoteExists(ctx context.Context, u url.URL) (*url.URL, error) {
 	// Create a new HEAD request for the given URL to check if the resource exists
 	req, err := http.NewRequestWithContext(ctx, "HEAD", u.String(), nil)
 	if err != nil {
@@ -46,7 +44,7 @@ func RemoteExists(ctx context.Context, u url.URL, client *http.Client) (*url.URL
 	}

 	// Request the given URL
-	resp, err := client.Do(req)
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		if ctx.Err() != nil {
 			return nil, fmt.Errorf("checking remote file: %w", ctx.Err())
@@ -68,7 +66,7 @@ func RemoteExists(ctx context.Context, u url.URL, client *http.Client) (*url.URL

 	// If the request was not successful, append the default Taskfile names to
 	// the URL and return the URL of the first successful request
-	for _, taskfile := range DefaultTaskfiles {
+	for _, taskfile := range defaultTaskfiles {
 		// Fixes a bug with JoinPath where a leading slash is not added to the
 		// path if it is empty
 		if u.Path == "" {
@@ -78,7 +76,7 @@ func RemoteExists(ctx context.Context, u url.URL, client *http.Client) (*url.URL
 		req.URL = alt

 		// Try the alternative URL
-		resp, err = client.Do(req)
+		resp, err = http.DefaultClient.Do(req)
 		if err != nil {
 			return nil, errors.TaskfileFetchFailedError{URI: u.Redacted()}
 		}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Pete Davison	5128a98ee2	feat: test wildcards	2025-08-11 12:00:34 +00:00
Pete Davison	8353dffc7a	fix: executor and formatter tests	2025-08-11 12:00:34 +00:00
Pete Davison	6e80b401e6	feat: remove entrypoint from the executor	2025-08-11 12:00:34 +00:00
Pete Davison	1402e2baaf	refactor: merge Setup into NewExecutor	2025-08-11 12:00:34 +00:00
Pete Davison	4b99f60039	refactor: split executor and reader	2025-08-11 12:00:34 +00:00
@@ -1 +1 @@
 .50.0
 .44.1