test(compiler): make special vars test OS-portable

Build paths from t.TempDir() so they are valid absolute paths on
Windows too (filepath.IsAbs treats `/abs/path` as non-absolute there).

.editorconfig

@@ -8,6 +8,6 @@ charset = utf-8
 trim_trailing_whitespace = true
 indent_style = tab
 
-[*.{md,mdx,yml,yaml,json,toml,htm,html,js,css,svg,sh,bash,fish}]
+[*.{md,mdx,yml,yaml,json,toml,htm,html,js,ts,vue,css,svg,sh,bash,fish}]
 indent_style = space
 indent_size = 2

.gitattributes

@@ -1,2 +1,5 @@
 * text=auto
 *.mdx -linguist-detectable
+
+# Keep LF line endings in testdata for consistent checksums across platforms
+testdata/** text eol=lf

.github/CODE_OF_CONDUCT.md

@@ -1,46 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at andrey@nering.com.br. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

.github/CONTRIBUTING.md

@@ -1,14 +0,0 @@
-## You can find our [contribution guide on our website][contributing]
-
-- Please read it carefully before opening a PR.
-- If you have any questions, you can:
-  - [Open an issue][issues]
-  - [Create a discussion][discussions]
-  - [Chat to us on Discord][discord]
-
-<!-- prettier-ignore-start -->
-[contributing]: https://taskfile.dev/contributing
-[issues]: https://github.com/go-task/task/issues
-[discussions]: https://github.com/go-task/task/discussions
-[discord]: https://discord.gg/6TY36E39UK
-<!-- prettier-ignore-end -->

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-github: [andreynering, pd93, vmaerten]
-open_collective: task
-custom: https://taskfile.dev/donate/

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,20 +0,0 @@
----
-name: Bug Report
-about: Use this to report bugs and issues
----
-
-<!--
-
-Thanks for your bug report!
-
-Before submitting this issue, please make sure the same problem was not
-already reported by someone else.
-
-Please describe the bug you're facing. Consider pasting example Taskfiles
-showing how to reproduce the problem.
-
--->
-
-- Task version:
-- Operating system:
-- Experiments enabled:

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,69 @@
+name: '🐞 Bug Report'
+description: Report a bug in Task.
+labels: ['state: needs-triage']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your bug report!
+
+        Before submitting, please check the list of [existing issues](https://github.com/go-task/task/issues) and make sure the same bug was not already reported by someone else.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Describe the bug you're seeing.
+      placeholder: |
+        - What did you do?
+        - What did you expect to happen?
+        - What happened instead?
+    validations:
+      required: true
+
+  - type: input
+    id: version
+    attributes:
+      label: Version
+      description: What version(s) of Task is the issue occurring on?
+    validations:
+      required: true
+
+  - type: input
+    id: os
+    attributes:
+      label: Operating system
+      description: What operating system(s) is the issue occurring on?
+    validations:
+      required: true
+
+  - type: dropdown
+    id: experiments
+    attributes:
+      label: Experiments Enabled
+      description: Do you have any experiments enabled? You can check by running `task --experiments`.
+      multiple: true
+      options:
+        - Env Precedence
+        - Gentle Force
+        - Map Variables (1)
+        - Map Variables (2)
+        - Remote Taskfiles
+    validations:
+      required: false
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Example Taskfile
+      description: |
+        If you have a Taskfile that reproduces the issue, please paste it here.
+        This will be automatically formatted into code, so no need for backticks.
+      render: YAML
+      placeholder: |
+        version: '3'
+
+        tasks:
+          default:
+            cmds:
+              - 'echo "This Taskfile is buggy :("'

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +1,11 @@
 blank_issues_enabled: false
 contact_links:
-  - name: Extension for Visual Studio Code
+  - name: '🔌 Task for Visual Studio Code'
     url: https://github.com/go-task/vscode-task
-    about: Issues related to the Visual Studio Code extension should be opened here.
-  - name: Help forum on Discord
-    url: https://discord.gg/6TY36E39UK
-    about: 'The Discord #help channel is the best way to get help from the community.'
-  - name: Questions, Ideas and General Discussions
+    about: 'Issues related to the Visual Studio Code extension should be opened here.'
+  - name: '💬 Help forum on Discord'
+    url: https://discord.com/channels/974121106208354339/1025054680289660989
+    about: 'The #help channel on our Discord is the best way to get help from the community.'
+  - name: '❓ Questions, Ideas and General Discussions'
     url: https://github.com/go-task/task/discussions
-    about: Ask questions and discuss general ideas with the community.
+    about: 'Ask questions and discuss general ideas with the community.'

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,15 +0,0 @@
----
-name: Feature Request
-about: Use this to make feature requests
----
-
-<!--
-
-Describe in detail what feature do you want to see in Task.
-Give examples if possible.
-
-Please, search if this wasn't proposed before, and if this is more like an idea
-than a strong feature request, consider opening a
-[discussion](https://github.com/go-task/task/discussions) instead.
-
--->

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,23 @@
+name: '✨ Feature Request'
+description: Suggest a new feature or enhancement for Task.
+labels: ['state: needs-triage']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your feature request!
+
+        Before submitting, please check the list of [existing issues](https://github.com/go-task/task/issues) and make sure the same change was not already requested by someone else.
+        If your request is more of an idea than a feature request, consider opening a [discussion](https://github.com/go-task/task/discussions) instead.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Describe the feature/enhancement you want to see in Task.
+      placeholder: |
+        - Give a general overview of the feature/enhancement.
+        - Explain problem is the change trying to solve.
+        - Give examples of how you would use the feature.
+    validations:
+      required: true

.github/dependabot.yml

@@ -1,24 +0,0 @@
-version: 2
-
-updates:
-  - package-ecosystem: gomod
-    directory: /
-    schedule:
-      interval: weekly
-      day: saturday
-      time: '08:00'
-      timezone: America/Sao_Paulo
-    labels:
-      - "area: dependencies"
-      - "lang: go"
-
-  - package-ecosystem: npm
-    directory: /
-    schedule:
-      interval: weekly
-      day: saturday
-      time: '08:00'
-      timezone: America/Sao_Paulo
-    labels:
-      - "area: dependencies"
-      - "lang: javascript"

.github/pull_request_template.md

@@ -7,3 +7,5 @@ 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/)

.github/renovate.json

@@ -3,46 +3,34 @@
   "extends": [
     "config:recommended",
     "group:allNonMajor",
-    "schedule:monthly"
+    "schedule:weekly",
+    ":semanticCommitTypeAll(chore)"
   ],
   "mode": "full",
-  "reviewers": ["team:developer"],
+  "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"],
-      "groupName": "Github Action",
-      "labels": ["area: github actions", "area: dependencies"],
-      "matchPackageNames": [
-        "*"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
+      "addLabels": ["area: github actions"]
     },
     {
-      "matchManagers": ["npm", "nvm"],
-      "groupName": "Website",
-      "labels": ["lang: javascript", "area: dependencies"],
-      "matchPackageNames": [
-        "*"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
+      "matchCategories": ["js", "node"],
+      "addLabels": ["lang: javascript"]
     },
     {
-      "matchManagers": ["gomod"],
-      "groupName": "golang",
-      "labels": ["lang: go", "area: dependencies"],
-      "matchPackageNames": [
-        "*"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
+      "matchCategories": ["golang"],
+      "addLabels": ["lang: go"]
     }
   ]
 }

.github/workflows/issue-awaiting-response.yml

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

.github/workflows/issue-closed.yml

@@ -4,13 +4,16 @@ on:
   issues:
     types: [closed]
 
+permissions:
+  issues: write
+
 jobs:
   issue-closed:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{secrets.GH_PAT}}
+          github-token: ${{secrets.GITHUB_TOKEN}}
           script: |
             const labels = await github.paginate(
               github.rest.issues.listLabelsOnIssue, {

.github/workflows/issue-experiment.yml

@@ -2,16 +2,19 @@ name: issue experiment
 
 on:
   issues:
-    types: [labeled]
+    types: [field_added]
+
+permissions:
+  issues: write
 
 jobs:
-  issue-experiment-proposed:
-    if: github.event.label.name == format('experiment{0} proposed', ':')
+  issue-experiment-proposal:
+    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'proposal'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{secrets.GH_PAT}}
+          github-token: ${{secrets.GITHUB_TOKEN}}
           script: |
             github.rest.issues.createComment({
               issue_number: context.issue.number,
@@ -20,12 +23,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.label.name == format('experiment{0} draft', ':')
+    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'draft'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{secrets.GH_PAT}}
+          github-token: ${{secrets.GITHUB_TOKEN}}
           script: |
             github.rest.issues.createComment({
               issue_number: context.issue.number,
@@ -34,12 +37,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.label.name == format('experiment{0} candidate', ':')
+    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'candidate'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{secrets.GH_PAT}}
+          github-token: ${{secrets.GITHUB_TOKEN}}
           script: |
             github.rest.issues.createComment({
               issue_number: context.issue.number,
@@ -48,12 +51,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.label.name == format('experiment{0} stable', ':')
+    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'stable'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{secrets.GH_PAT}}
+          github-token: ${{secrets.GITHUB_TOKEN}}
           script: |
             github.rest.issues.createComment({
               issue_number: context.issue.number,
@@ -62,12 +65,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.label.name == format('experiment{0} released', ':')
+    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'released'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{secrets.GH_PAT}}
+          github-token: ${{secrets.GITHUB_TOKEN}}
           script: |
             github.rest.issues.createComment({
               issue_number: context.issue.number,
@@ -82,12 +85,12 @@ jobs:
               state: 'closed'
             })
   issue-experiment-abandoned:
-    if: github.event.label.name == format('experiment{0} abandoned', ':')
+    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'abandoned'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{secrets.GH_PAT}}
+          github-token: ${{secrets.GITHUB_TOKEN}}
           script: |
             github.rest.issues.createComment({
               issue_number: context.issue.number,
@@ -102,12 +105,12 @@ jobs:
               state: 'closed'
             })
   issue-experiment-superseded:
-    if: github.event.label.name == format('experiment{0} superseded', ':')
+    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'superseded'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{secrets.GH_PAT}}
+          github-token: ${{secrets.GITHUB_TOKEN}}
           script: |
             github.rest.issues.createComment({
               issue_number: context.issue.number,

.github/workflows/issue-needs-triage.yml

@@ -4,13 +4,16 @@ on:
   issues:
     types: [opened]
 
+permissions:
+  issues: write
+
 jobs:
   issue-needs-triage:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
-          github-token: ${{secrets.GH_PAT}}
+          github-token: ${{secrets.GITHUB_TOKEN}}
           script: |
             const labels = await github.paginate(
               github.rest.issues.listLabelsOnIssue, {

.github/workflows/lint.yml

@@ -8,51 +8,39 @@ on:
     branches:
       - main
 
+permissions:
+  contents: read
+
 jobs:
   lint:
     name: Lint
     strategy:
       matrix:
-        go-version: [1.22.x, 1.23.x]
+        go-version: [1.25.10, 1.26.x]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-go@v5
+      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
           go-version: ${{matrix.go-version}}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@1e7e51e771db61008b38414a730f564565cf7c20 # v9.2.0
         with:
-          version: v1.60.1
+          version: v2.12.2
 
   lint-jsonschema:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
-          python-version: 3.12
+          python-version: 3.14
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: install check-jsonschema
         run: python -m pip install 'check-jsonschema==0.27.3'
 
       - name: check-jsonschema (metaschema)
-        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@v44
-        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.')
+        run: check-jsonschema --check-metaschema website/src/public/schema.json

.github/workflows/pr-build.yml

@@ -0,0 +1,69 @@
+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@1a80836c5c9d9e5755a25cb59ec6f45a3b5f41a8 # 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

.github/workflows/release-nightly.yml

@@ -0,0 +1,34 @@
+name: Release 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
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        with:
+          go-version: 1.26.x
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@1a80836c5c9d9e5755a25cb59ec6f45a3b5f41a8 # v7
+        with:
+          distribution: goreleaser-pro
+          version: latest
+          args: release --clean --nightly -f .goreleaser-nightly.yml
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          GORELEASER_KEY: ${{secrets.GORELEASER_KEY}}
+          CLOUDSMITH_TOKEN: ${{secrets.CLOUDSMITH_TOKEN}}

.github/workflows/release.yml

@@ -3,24 +3,58 @@ name: goreleaser
 on:
   push:
     tags:
-      - 'v*'
+      - "v*"
+
+permissions:
+  id-token: write # Required for OIDC
+  contents: write
 
 jobs:
   goreleaser:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
 
       - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
-          go-version: 1.22.x
+          go-version: 1.26.x
+
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.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@0e279bb959325dab635dd2c09392533439d90093 # v6
+        with:
+          package_json_file: "website/package.json"
+          run_install: "true"
 
       - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v2
+        uses: goreleaser/goreleaser-action@1a80836c5c9d9e5755a25cb59ec6f45a3b5f41a8 # v7
         with:
+          distribution: goreleaser-pro
           version: latest
-          args: release --clean
+          args: release --clean --draft
         env:
-          GITHUB_TOKEN: ${{secrets.GH_PAT}}
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          GH_GORELEASER_TOKEN: ${{secrets.GH_GORELEASER_TOKEN}}
+          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 }}

.github/workflows/security.yml

@@ -0,0 +1,19 @@
+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

.github/workflows/test.yml

@@ -8,31 +8,26 @@ on:
     branches:
       - main
 
+permissions:
+  contents: read
+
 jobs:
   test:
     name: Test
     strategy:
+      fail-fast: false
       matrix:
-        go-version: [1.22.x, 1.23.x]
+        go-version: [1.25.10, 1.26.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@v5
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         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: ./bin/task test --output=group --output-group-begin='::group::{{.TASK}}' --output-group-end='::endgroup::'
+        run: go run ./cmd/task test

.gitignore

@@ -35,3 +35,4 @@ tags
 /testdata/vars/v1
 /tmp
 node_modules
+website/.netlify/

.golangci.yml

@@ -1,18 +1,47 @@
-# NOTE(@andreynering): The linters listed here are additions on top of
-# those enabled by default:
-#
-# https://golangci-lint.run/usage/linters/#enabled-by-default
+version: "2"
+
+formatters:
+  enable:
+    - gofumpt
+    - goimports
+    - gci
+  settings:
+    gci:
+      sections:
+        - standard
+        - default
+        - prefix(github.com/go-task)
+        - localmodule
 
 linters:
   enable:
-    - goimports
-    - gofmt
-    - gofumpt
-
-linters-settings:
-  goimports:
-    local-prefixes: github.com/go-task
-  gofmt:
-    rewrite-rules:
-      - pattern: 'interface{}'
-        replacement: 'any'
+    - depguard
+    - gosec
+    - mirror
+    - misspell
+    - modernize
+    - noctx
+    - paralleltest
+    - thelper
+    - tparallel
+    - usetesting
+  settings:
+    gosec:
+      excludes:
+        - G306
+    depguard:
+      rules:
+        main:
+          files:
+            - $all
+            - '!$test'
+            - '!**/errors/*.go'
+          deny:
+            - pkg: errors
+              desc: Use github.com/go-task/task/v3/errors instead
+  exclusions:
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling

.goreleaser-nightly.yml

@@ -0,0 +1,15 @@
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+version: 2
+pro: true
+
+release:
+  name_template: 'v{{.Version}}'
+
+nightly:
+  publish_release: true
+  keep_single_release: true
+  version_template: "{{incminor .Version}}-nightly"
+
+includes:
+  - from_file:
+      path: ./.goreleaser.yml

.goreleaser-pr.yml

@@ -0,0 +1,31 @@
+# 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'

.goreleaser.yml

@@ -22,6 +22,8 @@ builds:
         goarch: '386'
       - goos: darwin
         goarch: riscv64
+      - goos: windows
+        goarch: arm
       - goos: windows
         goarch: riscv64
     env:
@@ -30,42 +32,46 @@ builds:
     flags:
       - -trimpath
     ldflags:
-      - -s -w # Don't set main.version.
+      - "-s -w"
+      - "{{if .IsNightly}}-X github.com/go-task/task/v3/internal/version.version={{.Version}}{{end}}"
 
 gomod:
   proxy: true
 
 archives:
-  - name_template: "{{.Binary}}_{{.Os}}_{{.Arch}}"
+  - name_template: '{{.Binary}}_{{.Os}}_{{.Arch}}'
     files:
       - README.md
       - LICENSE
       - completion/**/*
     format_overrides:
       - goos: windows
-        format: zip
+        formats: [zip]
 
-release:
-  draft: true
+git:
+  ignore_tags:
+    - "{{if not .IsNightly}}nightly{{end}}"
 
 snapshot:
-  version_template: "{{.Tag}}"
+  version_template: '{{.Version}}'
 
 checksum:
-  name_template: "task_checksums.txt"
+  name_template: 'task_checksums.txt'
 
 nfpms:
   - vendor: Task
     homepage: https://taskfile.dev
-    maintainer: Andrey Nering <andrey@nering.com.br>
-    description: Simple task runner written in Go
+    maintainer: The Task authors <task@taskfile.dev>
+    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+    section: golang
     license: MIT
     conflicts:
       - taskwarrior
     formats:
       - deb
       - rpm
-    file_name_template: "{{.ProjectName}}_{{.Os}}_{{.Arch}}"
+      - apk
+    file_name_template: '{{.ProjectName}}_{{.Version}}_{{.Os}}_{{.Arch}}'
     contents:
       - src: completion/bash/task.bash
         dst: /etc/bash_completion.d/task
@@ -76,15 +82,15 @@ nfpms:
 
 brews:
   - name: go-task
-    description: Task runner / simpler Make alternative written in Go
+    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
     license: MIT
     homepage: https://taskfile.dev
     directory: Formula
     repository:
       owner: go-task
       name: homebrew-tap
-    test:
-      system "#{bin}/task", "--help"
+      token: "{{.Env.GH_GORELEASER_TOKEN}}" # So that it runs as the task-bot user
+    test: system "#{bin}/task", "--help"
     install: |-
       bin.install "task"
       bash_completion.install "completion/bash/task.bash" => "task"
@@ -97,8 +103,8 @@ brews:
 winget:
   - name: Task
     publisher: Task
-    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.
+    short_description: The modern task runner.
+    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
     license: MIT
     homepage: https://taskfile.dev/
     publisher_url: https://taskfile.dev/
@@ -107,7 +113,7 @@ winget:
     commit_author:
       name: task-bot
       email: 106601941+task-bot@users.noreply.github.com
-    commit_msg_template: "chore: bump {{.PackageIdentifier}} to {{.Tag}}"
+    commit_msg_template: 'chore: release {{.PackageIdentifier}} {{.Tag}}'
     release_notes_url: https://github.com/go-task/task/releases/tag/{{.Tag}}
     tags:
       - build
@@ -121,13 +127,50 @@ winget:
       - task-runner
       - taskfile
       - tool
-    skip_upload: true
     repository:
-      owner: microsoft
+      owner: go-task
       name: winget-pkgs
+      branch: 'task-{{.Version}}'
+      token: "{{.Env.GH_GORELEASER_TOKEN}}" # So that it runs as the task-bot user
       pull_request:
         enabled: true
+        draft: false
+        check_boxes: true
         base:
-          owner: go-task
+          owner: microsoft
           name: winget-pkgs
-          branch: "bump-task-to-{{.Tag}}"
+          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

.mockery.yaml

@@ -1,4 +1,8 @@
-with-expecter: true
-keeptree: true
-case: underscore
-output: ./internal/mocks
+all: False
+template: testify
+filename: '{{base (trimSuffix ".go" .InterfaceFile)}}_mock.go'
+packages:
+  github.com/go-task/task/v3/internal/fingerprint:
+    interfaces:
+      SourcesCheckable:
+      StatusCheckable:

.nvmrc

@@ -1 +0,0 @@
-18.12.1

.taskrc.yml

@@ -0,0 +1,4 @@
+experiments:
+  GENTLE_FORCE: 0
+  REMOTE_TASKFILES: 0
+  ENV_PRECEDENCE: 0

.vscode/settings-sample.json

@@ -1,15 +1,12 @@
 {
   "yaml.schemas": {
-    "./website/static/schema.json": [
-      "Taskfile.yml",
-      "tmp/**/*.yml"
+    "./website/src/public/schema.json": [
+        "Taskfile.yml",
+        "Taskfile.yaml",
+        "taskfile.yml",
+        "taskfile.yaml"
     ]
   },
-  "search.exclude": {
-    "**/versioned_docs": true,
-    "**/versioned_sidesbars": true,
-    "**/i18n": true
-  },
   "gopls": {
       "formatting.local": "github.com/go-task"
   },

CHANGELOG.md

@@ -1,5 +1,536 @@
 # Changelog
 
+## v3.51.1 - 2026-05-16
+
+- A significant performance boost was achieved for large Taskfiles (monorepos)
+  by skipping templating altogether when the string is static (#2820 by @romnn).
+- Added `absPath` template function that resolves a path to its absolute form,
+  cleaning `..` and `.` components (#2681, #2788 by @mateenanjum).
+- Added `joinEnv` function to join paths based on your oprating system: `;` for
+  Windows and `:` elsewhere, and `joinUrl` to join URL paths. Also, added two
+  new special variables: `FILE_PATH_SEPARATOR` which returns `\` on Windows
+  and `/` elsewhere, and `PATH_LIST_SEPARATOR` which returns `;` on Windows and
+  `:` elsewhere (#2406, #2408 by @solvingj).
+- Update the shell interpreter with a regression fix (#2812, #2832 by
+  @andreynering).
+- Fix potential panic with the shell interpreter (#2810 by @trulede).
+
+## 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
+  called (#2309, #2323 by @maxmzkrcensys)
+- Fixed install script for some ARM platforms (#1516, #2291 by @trulede).
+- Fixed a regression where fingerprinting was not working correctly if the path
+  to you Taskfile contained a space (#2321, #2322 by @pd93).
+- Reverted a breaking change to `randInt` (#2312, #2316 by @pd93).
+- Made new variables `TEST_NAME` and `TEST_DIR` available in fixture tests
+  (#2265 by @pd93).
+
+## v3.44.0 - 2025-06-08
+
+- Added `uuid`, `randInt` and `randIntN` template functions (#1346, #2225 by
+  @pd93).
+- Added new `CLI_ARGS_LIST` array variable which contains the arguments passed
+  to Task after the `--` (the same as `CLI_ARGS`, but an array instead of a
+  string). (#2138, #2139, #2140 by @pd93).
+- Added `toYaml` and `fromYaml` templating functions (#2217, #2219 by @pd93).
+- Added `task` field the `--list --json` output (#2256 by @aleksandersh).
+- Added the ability to
+  [pin included taskfiles](https://taskfile.dev/next/experiments/remote-taskfiles/#manual-checksum-pinning)
+  by specifying a checksum. This works with both local and remote Taskfiles
+  (#2222, #2223 by @pd93).
+- When using the
+  [Remote Taskfiles experiment](https://github.com/go-task/task/issues/1317),
+  any credentials used in the URL will now be redacted in Task's output (#2100,
+  #2220 by @pd93).
+- Fixed fuzzy suggestions not working when misspelling a task name (#2192, #2200
+  by @vmaerten).
+- Fixed a bug where taskfiles in directories containing spaces created
+  directories in the wrong location (#2208, #2216 by @pd93).
+- Added support for dual JSON schema files, allowing changes without affecting
+  the current schema. The current schemas will only be updated during releases.
+  (#2211 by @vmaerten).
+- Improved fingerprint documentation by specifying that the method can be set at
+  the root level to apply to all tasks (#2233 by @vmaerten).
+- Fixed some watcher regressions after #2048 (#2199, #2202, #2241, #2196 by
+  @wazazaby, #2271 by @andreynering).
+
+## v3.43.3 - 2025-04-27
+
+Reverted the changes made in #2113 and #2186 that affected the
+`USER_WORKING_DIR` and built-in variables. This fixes #2206, #2195, #2207 and
+#2208.
+
+## v3.43.2 - 2025-04-21
+
+- Fixed regresion of `CLI_ARGS` being exposed as the wrong type (#2190, #2191 by
+  @vmaerten).
+
+## v3.43.1 - 2025-04-21
+
+- Significant improvements were made to the watcher. We migrated from
+  [watcher](https://github.com/radovskyb/watcher) to
+  [fsnotify](https://github.com/fsnotify/fsnotify). The former library used
+  polling, which means Task had a high CPU usage when watching too many files.
+  `fsnotify` uses proper the APIs from each operating system to watch files,
+  which means a much better performance. The default interval changed from 5
+  seconds to 100 milliseconds, because now it configures the wait time for
+  duplicated events, instead of the polling time (#2048 by @andreynering, #1508,
+  #985, #1179).
+- The [Map Variables experiment](https://github.com/go-task/task/issues/1585)
+  was made generally available so you can now
+  [define map variables in your Taskfiles!](https://taskfile.dev/usage/#variables)
+  (#1585, #1547, #2081 by @pd93).
+- Wildcards can now
+  [match multiple tasks](https://taskfile.dev/usage/#wildcard-arguments) (#2072,
+  #2121 by @pd93).
+- Added the ability to
+  [loop over the files specified by the `generates` keyword](https://taskfile.dev/usage/#looping-over-your-tasks-sources-or-generated-files).
+  This works the same way as looping over sources (#2151 by @sedyh).
+- Added the ability to resolve variables when defining an include variable
+  (#2108, #2113 by @pd93).
+- A few changes have been made to the
+  [Remote Taskfiles experiment](https://github.com/go-task/task/issues/1317)
+  (#1402, #2176 by @pd93):
+  - Cached files are now prioritized over remote ones.
+  - Added an `--expiry` flag which sets the TTL for a remote file cache. By
+    default the value will be 0 (caching disabled). If Task is running in
+    offline mode or fails to make a connection, it will fallback on the cache.
+- `.taskrc` files can now be used from subdirectories and will be searched for
+  recursively up the file tree in the same way that Taskfiles are (#2159, #2166
+  by @pd93).
+- The default taskfile (output when using the `--init` flag) is now an embedded
+  file in the binary instead of being stored in the code (#2112 by @pd93).
+- Improved the way we report the Task version when using the `--version` flag or
+  `{{.TASK_VERSION}}` variable. This should now be more consistent and easier
+  for package maintainers to use (#2131 by @pd93).
+- Fixed a bug where globstar (`**`) matching in `sources` only resolved the
+  first result (#2073, #2075 by @pd93).
+- Fixed a bug where sorting tasks by "none" would use the default sorting
+  instead of leaving tasks in the order they were defined (#2124, #2125 by
+  @trulede).
+- Fixed Fish completion on newer Fish versions (#2130 by @atusy).
+- Fixed a bug where undefined/null variables resolved to an empty string instead
+  of `nil` (#1911, #2144 by @pd93).
+- The `USER_WORKING_DIR` special now will now properly account for the `--dir`
+  (`-d`) flag, if given (#2102, #2103 by @jaynis, #2186 by @andreynering).
+- Fix Fish completions when `--global` (`-g`) is given (#2134 by @atusy).
+- Fixed variables not available when using `defer:` (#1909, #2173 by @vmaerten).
+
+#### Package API
+
+- The [`Executor`](https://pkg.go.dev/github.com/go-task/task/v3#Executor) now
+  uses the functional options pattern (#2085, #2147, #2148 by @pd93).
+- The functional options for the
+  [`taskfile.Reader`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Reader)
+  and
+  [`taskfile.Snippet`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Snippet)
+  types no longer have the `Reader`/`Snippet` respective prefixes (#2148 by
+  @pd93).
+- [`taskfile.Reader`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Reader)
+  no longer accepts a
+  [`taskfile.Node`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Node).
+  Instead nodes are passed directly into the
+  [`Reader.Read`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Reader.Read)
+  method (#2169 by @pd93).
+- [`Reader.Read`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Reader.Read)
+  also now accepts a [`context.Context`](https://pkg.go.dev/context#Context)
+  (#2176 by @pd93).
+
+## v3.42.1 - 2025-03-10
+
+- Fixed a bug where some special variables caused a type error when used global
+  variables (#2106, #2107 by @pd93).
+
+## v3.42.0 - 2025-03-08
+
+- Made `--init` less verbose by default and respect `--silent` and `--verbose`
+  flags (#2009, #2011 by @HeCorr).
+- `--init` now accepts a file name or directory as an argument (#2008, #2018 by
+  @HeCorr).
+- Fix a bug where an HTTP node's location was being mutated incorrectly (#2007
+  by @jeongukjae).
+- Fixed a bug where allowed values didn't work with dynamic var (#2032, #2033 by
+  @vmaerten).
+- Use only the relevant checker (timestamp or checksum) to improve performance
+  (#2029, #2031 by @vmaerten).
+- Print warnings when attempting to enable an inactive experiment or an active
+  experiment with an invalid value (#1979, #2049 by @pd93).
+- Refactored the experiments package and added tests (#2049 by @pd93).
+- Show allowed values when a variable with an enum is missing (#2027, #2052 by
+  @vmaerten).
+- Refactored how snippets in error work and added tests (#2068 by @pd93).
+- Fixed a bug where errors decoding commands were sometimes unhelpful (#2068 by
+  @pd93).
+- Fixed a bug in the Taskfile schema where `defer` statements in the shorthand
+  `cmds` syntax were not considered valid (#2068 by @pd93).
+- Refactored how task sorting functions work (#1798 by @pd93).
+- Added a new `.taskrc.yml` (or `.taskrc.yaml`) file to let users enable
+  experiments (similar to `.env`) (#1982 by @vmaerten).
+- Added new [Getting Started docs](https://taskfile.dev/getting-started) (#2086
+  by @pd93).
+- Allow `matrix` to use references to other variables (#2065, #2069 by @pd93).
+- Fixed a bug where, when a dynamic variable is provided, even if it is not
+  used, all other variables become unavailable in the templating system within
+  the include (#2092 by @vmaerten).
+
+#### Package API
+
+Unlike our CLI tool,
+[Task's package API is not currently stable](https://taskfile.dev/reference/package).
+In an effort to ease the pain of breaking changes for our users, we will be
+providing changelogs for our package API going forwards. The hope is that these
+changes will provide a better long-term experience for our users and allow to
+stabilize the API in the future. #121 now tracks this piece of work.
+
+- Bumped the minimum required Go version to 1.23 (#2059 by @pd93).
+- [`task.InitTaskfile`](https://pkg.go.dev/github.com/go-task/task/v3#InitTaskfile)
+  (#2011, ff8c913 by @HeCorr and @pd93)
+  - No longer accepts an `io.Writer` (output is now the caller's
+    responsibility).
+  - The path argument can now be a filename OR a directory.
+  - The function now returns the full path of the generated file.
+- [`TaskfileDecodeError.WithFileInfo`](https://pkg.go.dev/github.com/go-task/task/v3/errors#TaskfileDecodeError.WithFileInfo)
+  now accepts a string instead of the arguments required to generate a snippet
+  (#2068 by @pd93).
+  - The caller is now expected to create the snippet themselves (see below).
+- [`TaskfileSnippet`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Snippet)
+  and related code moved from the `errors` package to the `taskfile` package
+  (#2068 by @pd93).
+- Renamed `TaskMissingRequiredVars` to
+  [`TaskMissingRequiredVarsError`](https://pkg.go.dev/github.com/go-task/task/v3/errors#TaskMissingRequiredVarsError)
+  (#2052 by @vmaerten).
+- Renamed `TaskNotAllowedVars` to
+  [`TaskNotAllowedVarsError`](https://pkg.go.dev/github.com/go-task/task/v3/errors#TaskNotAllowedVarsError)
+  (#2052 by @vmaerten).
+- The
+  [`taskfile.Reader`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Reader)
+  is now constructed using the functional options pattern (#2082 by @pd93).
+- Removed our internal `logger.Logger` from the entire `taskfile` package (#2082
+  by @pd93).
+  - Users are now expected to pass a custom debug/prompt functions into
+    [`taskfile.Reader`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#Reader)
+    if they want this functionality by using the new
+    [`WithDebugFunc`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#WithDebugFunc)
+    and
+    [`WithPromptFunc`](https://pkg.go.dev/github.com/go-task/task/v3/taskfile#WithPromptFunc)
+    functional options.
+- Remove `Range` functions in the `taskfile/ast` package in favour of new
+  iterator functions (#1798 by @pd93).
+- `ast.Call` was moved from the `taskfile/ast` package to the main `task`
+  package (#2084 by @pd93).
+- `ast.Tasks.FindMatchingTasks` was moved from the `taskfile/ast` package to the
+  `task.Executor.FindMatchingTasks` in the main `task` package (#2084 by @pd93).
+- The `Compiler` and its `GetVariables` and `FastGetVariables` methods were
+  moved from the `internal/compiler` package to the main `task` package (#2084
+  by @pd93).
+
+## v3.41.0 - 2025-01-18
+
+- Fixed an issue where dynamic variables were not properly logged in verbose
+  mode (#1920, #1921 by @mgbowman).
+- Support `silent` for defer statements (#1877, #1879 by @danilobuerger).
+- Added an option to exclude some tasks from being included (#1859 by
+  @vmaerten).
+- Fixed an issue where a required variable was incorrectly handled in a template
+  function (#1950, #1962 by @vmaerten).
+- Expose a new `TASK_DIR` special variable, which will contain the absolute path
+  of task directory. (#1959, #1961 by @vmaerten).
+- Fixed fatal bugs that caused concurrent map writes (#1605, #1972, #1974 by
+  @pd93, @GrahamDennis and @trim21).
+- Refactored internal ordered map implementation to use
+  [github.com/elliotchance/orderedmap](https://github.com/elliotchance/orderedmap)
+  (#1797 by @pd93).
+- Fixed a bug where variables defined at the task level were being ignored in
+  the `requires` section. (#1960, #1955, #1768 by @vmaerten and @mokeko)
+- The `CHECKSUM` and `TIMESTAMP` variables are now accessible within `cmds`
+  (#1872 by @niklasr22).
+- Updated [installation docs](https://taskfile.dev/installation) and added pip
+  installation method (#935, #1989 by @pd93).
+- Fixed a bug where dynamic variables could not access environment variables
+  (#630, #1869 by @rohm1 and @pd93).
+- Disable version check for use as an external library (#1938 by @leaanthony).
+
+## v3.40.1 - 2024-12-06
+
+- Fixed a security issue in `git-urls` by switching to the maintained fork
+  `chainguard-dev/git-urls` (#1917 by @AlekSi).
+- Added missing `platforms` property to `cmds` that use `for` (#1915 by
+  @dkarter).
+- Added misspell linter to check for misspelled English words (#1883 by
+  @christiandins).
+
+## v3.40.0 - 2024-11-05
+
+- Fixed output of some functions (e.g. `splitArgs`/`splitLines`) not working in
+  for loops (#1822, #1823 by @stawii).
+- Added a new `TASK_OFFLINE` environment variable to configure the `--offline`
+  flag and expose it as a special variable in the templating system (#1470,
+  #1716 by @vmaerten and @pd93).
+- Fixed a bug where multiple remote includes caused all prompts to display
+  without waiting for user input (#1832, #1833 by @vmaerten and @pd93).
+- When using the
+  "[Remote Taskfiles](https://taskfile.dev/experiments/remote-taskfiles/)".
+  experiment, you can now include Taskfiles from Git repositories (#1652 by
+  @vmaerten).
+- Improved the error message when a dotenv file cannot be parsed (#1842 by
+  @pbitty).
+- Fix issue with directory when using the remote experiment (#1757 by @pbitty).
+- Fixed an issue where a special variable was used in combination with a dotenv
+  file (#1232, #1810 by @vmaerten).
+- Refactor the way Task reads Taskfiles to improve readability (#1771 by
+  @pbitty).
+- Added a new option to ensure variable is within the list of values (#1827 by
+  @vmaerten).
+- Allow multiple prompts to be specified for a task (#1861, #1866 by @mfbmina).
+- Added new template function: `numCPU`, which returns the number of logical
+  CPUs usable (#1890, #1887 by @Amoghrd).
+- Fixed a bug where non-nil, empty dynamic variables are returned as an empty
+  interface (#1903, #1904 by @pd93).
+
+## v3.39.2 - 2024-09-19
+
+- Fix dynamic variables not working properly for a defer: statement (#1803,
+  #1818 by @vmaerten).
+
 ## v3.39.1 - 2024-09-18
 
 - Added Renovate configuration to automatically create PRs to keep dependencies
@@ -259,8 +790,8 @@
 - Added the
   [Remote Taskfiles experiment](https://taskfile.dev/experiments/remote-taskfiles)
   as a draft (#1152, #1317 by @pd93).
-- Improve performance of content checksuming on `sources:` by replacing md5 with
-  [XXH3](https://xxhash.com/) which is much faster. This is a soft breaking
+- Improve performance of content checksumming on `sources:` by replacing md5
+  with [XXH3](https://xxhash.com/) which is much faster. This is a soft breaking
   change because checksums will be invalidated when upgrading to this release
   (#1325 by @ReillyBrogan).
 
@@ -319,7 +850,7 @@
 - Deprecated `version: 2` schema. This will be removed in the next major release
   (#1197, #1198, #1199 by @pd93).
 - Added a new `prompt:` prop to set a warning prompt to be shown before running
-  a potential dangurous task (#100, #1163 by @MaxCheetham,
+  a potential dangerous task (#100, #1163 by @MaxCheetham,
   [Documentation](https://taskfile.dev/usage/#warning-prompts)).
 - Added support for single command task syntax. With this change, it's now
   possible to declare just `cmd:` in a task, avoiding the more complex
@@ -334,7 +865,7 @@
   percentage (#1173 by @misitebao).
 - Starting on this release, official binaries for FreeBSD will be available to
   download (#1068 by @andreynering).
-- Fix some errors being unintendedly supressed (#1134 by @clintmod).
+- Fix some errors being unintendedly suppressed (#1134 by @clintmod).
 - Fix a nil pointer error when `version` is omitted from a Taskfile (#1148,
   #1149 by @pd93).
 - Fix duplicate error message when a task does not exists (#1141, #1144 by
@@ -407,8 +938,8 @@ it a go and let us know what you think via a
 - Fixed a bug where tasks were sometimes incorrectly marked as internal (#1007
   by @pd93).
 - Update to Go 1.20 (bump minimum version to 1.19) (#1010 by @pd93)
-- Added environment variable `FORCE_COLOR` support to force color output.
-  Usefull for environments without TTY (#1003 by @automation-stack)
+- Added environment variable `FORCE_COLOR` support to force color output. Useful
+  for environments without TTY (#1003 by @automation-stack)
 
 ## v3.20.0 - 2023-01-14
 
@@ -763,7 +1294,7 @@ it a go and let us know what you think via a
 
 - Fix error code for the `--help` flag (#300, #330).
 - Print version to stdout instead of stderr (#299, #329).
-- Supress `context` errors when using the `--watch` flag (#313, #317).
+- Suppress `context` errors when using the `--watch` flag (#313, #317).
 - Support templating on description (#276, #283).
 
 ## v2.8.0 - 2019-12-07
@@ -772,7 +1303,7 @@ it a go and let us know what you think via a
   parallel (#266).
 - Fixed bug where calling the `task` CLI only informing global vars would not
   execute the `default` task.
-- Add hability to silent all tasks by adding `silent: true` a the root of the
+- Add ability to silent all tasks by adding `silent: true` a the root of the
   Taskfile.
 
 ## v2.7.1 - 2019-11-10
@@ -914,7 +1445,7 @@ document, since it describes in depth what changed for this version.
 ## v1.4.3 - 2017-09-07
 
 - Allow assigning variables to tasks at run time via CLI (#33)
-- Added suport for multiline variables from sh (#64)
+- Added support for multiline variables from sh (#64)
 - Fixes env: remove square braces and evaluate shell (#62)
 - Watch: change watch library and few fixes and improvements
 - When use watching, cancel and restart long running process on file change (#59
@@ -974,7 +1505,7 @@ document, since it describes in depth what changed for this version.
 - More tests and Travis integration
 - Watch a task (experimental)
 - Possibility to call another task
-- Fix "=" not being reconized in variables/environment variables
+- Fix "=" not being recognized in variables/environment variables
 - Tasks can now have a description, and help will print them (#10)
 - Task dependencies now run concurrently
 - Support for a default task (#16)

README.md

@@ -1,15 +1,49 @@
 <div align="center">
   <a href="https://taskfile.dev">
-    <img src="website/static/img/logo.svg" width="200px" height="200px" />
+    <img src="website/src/public/img/logo.svg" width="200px" height="200px" />
   </a>
 
-  <h1>Task</h1>
+  <h1>Task: The Modern Task Runner</h1>
 
   <p>
-    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>.
+    A fast, cross-platform build tool inspired by Make, designed for modern workflows.
   </p>
 
   <p>
-    <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://fosstodon.org/@task">Mastodon</a> | <a href="https://discord.gg/6TY36E39UK">Discord</a>
+    <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>
   </p>
+
+  <h1>Gold Sponsors</h1>
+
+  <table>
+    <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" />
+        </a>
+      </td>
+    </tr>
+  </table>
 </div>

Taskfile.yml

@@ -8,6 +8,7 @@ includes:
 
 vars:
   BIN: "{{.ROOT_DIR}}/bin"
+  GOTESTSUM_FORMAT: '{{if .CI}}github-actions{{else}}pkgname{{end}}'
 
 env:
   CGO_ENABLED: '0'
@@ -18,36 +19,59 @@ tasks:
       - task: lint
       - task: test
 
+  run:
+    desc: Runs Task
+    cmds:
+      - go run ./cmd/task {{.CLI_ARGS}}
+
   install:
     desc: Installs Task
     aliases: [i]
     sources:
       - './**/*.go'
+      - go.mod
     cmds:
       - go install -v ./cmd/task
 
   generate:
-    desc: Runs Mockery to create mocks
     aliases: [gen, g]
+    desc: Runs all generate tasks
+    cmds:
+      - task: generate:mocks
+      - task: generate:fixtures
+
+  generate:mocks:
+    desc: Runs Mockery to create mocks
+    aliases: [gen:mocks, g:mocks]
     deps: [install:mockery]
     sources:
       - "internal/fingerprint/checker.go"
     generates:
       - "internal/mocks/*.go"
     cmds:
-      - "{{.BIN}}/mockery --dir ./internal/fingerprint --name SourcesCheckable"
-      - "{{.BIN}}/mockery --dir ./internal/fingerprint --name StatusCheckable"
+      - find . -type f -name *_mock.go -delete
+      - "{{.BIN}}/mockery"
+
+  generate:fixtures:
+    desc: Runs tests and generates golden fixture files
+    aliases: [gen:fixtures, g:fixtures]
+    env:
+      GOLDIE_UPDATE: 'true'
+      GOLDIE_TEMPLATE: 'true'
+    cmds:
+      - find ./testdata -name '*.golden' -delete
+      - go test ./...
 
   install:mockery:
     desc: Installs mockgen; a tool to generate mock files
     vars:
-      MOCKERY_VERSION: v2.24.0
+      MOCKERY_VERSION: v3.2.2
     env:
       GOBIN: "{{.BIN}}"
     status:
       - go version -m {{.BIN}}/mockery | grep github.com/vektra/mockery | grep {{.MOCKERY_VERSION}}
     cmds:
-      - go install github.com/vektra/mockery/v2@{{.MOCKERY_VERSION}}
+      - GOBIN="{{.BIN}}" go install github.com/vektra/mockery/v3@{{.MOCKERY_VERSION}}
 
   mod:
     desc: Downloads and tidy Go modules
@@ -68,6 +92,7 @@ tasks:
     sources:
       - './**/*.go'
       - .golangci.yml
+      - go.mod
     cmds:
       - golangci-lint run
 
@@ -76,9 +101,19 @@ tasks:
     sources:
       - './**/*.go'
       - .golangci.yml
+      - go.mod
     cmds:
       - golangci-lint run --fix
 
+  format:
+    desc: Runs golangci-lint and formats any Go files
+    aliases: [fmt, f]
+    sources:
+      - './**/*.go'
+      - .golangci.yml
+    cmds:
+      - golangci-lint fmt
+
   sleepit:build:
     desc: Builds the sleepit test helper
     sources:
@@ -98,31 +133,57 @@ tasks:
   test:
     desc: Runs test suite
     aliases: [t]
-    deps: [install]
+    deps: [gotestsum:install]
+    sources:
+      - "**/*.go"
+      - "testdata/**/*"
     cmds:
-      - go test {{catLines .GO_PACKAGES}}
-    vars:
-      GO_PACKAGES:
-        sh: go list ./...
+      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' ./...
+
+  test:watch:
+    desc: Runs test suite with watch tests included
+    deps: [sleepit:build, gotestsum:install]
+    cmds:
+      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' ./... -tags 'watch'
 
   test:all:
     desc: Runs test suite with signals and watch tests included
-    deps: [install, sleepit:build]
+    deps: [sleepit:build, gotestsum:install]
     cmds:
-      - go test {{catLines .GO_PACKAGES}} -tags 'signals watch'
-    vars:
-      GO_PACKAGES:
-        sh: go list ./...
+      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' -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:
-      - go install github.com/goreleaser/goreleaser@latest
+      - go install github.com/goreleaser/goreleaser/v2@latest
+
+  gorelease:install:
+    desc: "Installs gorelease: https://pkg.go.dev/golang.org/x/exp/cmd/gorelease"
+    status:
+      - command -v gorelease
+    cmds:
+      - go install golang.org/x/exp/cmd/gorelease@latest
+
+  api:check:
+    desc: Checks what changes have been made to the public API
+    deps: [gorelease:install]
+    vars:
+      LATEST:
+        sh: git describe --tags --abbrev=0
+    cmds:
+      - gorelease -base={{.LATEST}}
 
   release:*:
     desc: Prepare the project for a new release
@@ -137,7 +198,7 @@ tasks:
       - Push the commit/tag to the repository
       - Create a GitHub release
 
-      To use the task, simply run "task release:<version>" where "<version>" is is one of:
+      To use the task, run "task release:<version>" where "<version>" is is one of:
 
       - "major" - Bumps the major number
       - "minor" - Bumps the minor number
@@ -152,7 +213,6 @@ 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"
@@ -167,20 +227,7 @@ tasks:
       - "git add --all"
       - "git commit -m v{{.VERSION}}"
       - "git push"
-      - "git tag v{{.VERSION}}"
+      - "git tag -a v{{.VERSION}} -m 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
-
-  packages:
-    cmds:
-      - echo '{{.GO_PACKAGES}}'
-    vars:
-      GO_PACKAGES:
-        sh: go list ./...
-    silent: true

args/args.go

@@ -3,17 +3,34 @@ package args
 import (
 	"strings"
 
+	"github.com/spf13/pflag"
+	"mvdan.cc/sh/v3/syntax"
+
+	"github.com/go-task/task/v3"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
+// Get fetches the remaining arguments after CLI parsing and splits them into
+// two groups: the arguments before the double dash (--) and the arguments after
+// the double dash.
+func Get() ([]string, []string, error) {
+	args := pflag.Args()
+	doubleDashPos := pflag.CommandLine.ArgsLenAtDash()
+
+	if doubleDashPos == -1 {
+		return args, nil, nil
+	}
+	return args[:doubleDashPos], args[doubleDashPos:], nil
+}
+
 // Parse parses command line argument: tasks and global variables
-func Parse(args ...string) ([]*ast.Call, *ast.Vars) {
-	calls := []*ast.Call{}
-	globals := &ast.Vars{}
+func Parse(args ...string) ([]*task.Call, *ast.Vars) {
+	calls := []*task.Call{}
+	globals := ast.NewVars()
 
 	for _, arg := range args {
 		if !strings.Contains(arg, "=") {
-			calls = append(calls, &ast.Call{Task: arg})
+			calls = append(calls, &task.Call{Task: arg})
 			continue
 		}
 
@@ -24,6 +41,18 @@ func Parse(args ...string) ([]*ast.Call, *ast.Vars) {
 	return calls, globals
 }
 
+func ToQuotedString(args []string) (string, error) {
+	var quotedCliArgs []string
+	for _, arg := range args {
+		quotedCliArg, err := syntax.Quote(arg, syntax.LangBash)
+		if err != nil {
+			return "", err
+		}
+		quotedCliArgs = append(quotedCliArgs, quotedCliArg)
+	}
+	return strings.Join(quotedCliArgs, " "), nil
+}
+
 func splitVar(s string) (string, string) {
 	pair := strings.SplitN(s, "=", 2)
 	return pair[0], pair[1]

args/args_test.go

@@ -6,20 +6,22 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
+	"github.com/go-task/task/v3"
 	"github.com/go-task/task/v3/args"
-	"github.com/go-task/task/v3/internal/omap"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestArgs(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		Args            []string
-		ExpectedCalls   []*ast.Call
+		ExpectedCalls   []*task.Call
 		ExpectedGlobals *ast.Vars
 	}{
 		{
 			Args: []string{"task-a", "task-b", "task-c"},
-			ExpectedCalls: []*ast.Call{
+			ExpectedCalls: []*task.Call{
 				{Task: "task-a"},
 				{Task: "task-b"},
 				{Task: "task-c"},
@@ -27,81 +29,98 @@ func TestArgs(t *testing.T) {
 		},
 		{
 			Args: []string{"task-a", "FOO=bar", "task-b", "task-c", "BAR=baz", "BAZ=foo"},
-			ExpectedCalls: []*ast.Call{
+			ExpectedCalls: []*task.Call{
 				{Task: "task-a"},
 				{Task: "task-b"},
 				{Task: "task-c"},
 			},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"FOO": {Value: "bar"},
-						"BAR": {Value: "baz"},
-						"BAZ": {Value: "foo"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
 					},
-					[]string{"FOO", "BAR", "BAZ"},
-				),
-			},
+				},
+				&ast.VarElement{
+					Key: "BAR",
+					Value: ast.Var{
+						Value: "baz",
+					},
+				},
+				&ast.VarElement{
+					Key: "BAZ",
+					Value: ast.Var{
+						Value: "foo",
+					},
+				},
+			),
 		},
 		{
 			Args: []string{"task-a", "CONTENT=with some spaces"},
-			ExpectedCalls: []*ast.Call{
+			ExpectedCalls: []*task.Call{
 				{Task: "task-a"},
 			},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"CONTENT": {Value: "with some spaces"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "CONTENT",
+					Value: ast.Var{
+						Value: "with some spaces",
 					},
-					[]string{"CONTENT"},
-				),
-			},
+				},
+			),
 		},
 		{
 			Args: []string{"FOO=bar", "task-a", "task-b"},
-			ExpectedCalls: []*ast.Call{
+			ExpectedCalls: []*task.Call{
 				{Task: "task-a"},
 				{Task: "task-b"},
 			},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"FOO": {Value: "bar"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
 					},
-					[]string{"FOO"},
-				),
-			},
+				},
+			),
 		},
 		{
 			Args:          nil,
-			ExpectedCalls: []*ast.Call{},
+			ExpectedCalls: []*task.Call{},
 		},
 		{
 			Args:          []string{},
-			ExpectedCalls: []*ast.Call{},
+			ExpectedCalls: []*task.Call{},
 		},
 		{
 			Args:          []string{"FOO=bar", "BAR=baz"},
-			ExpectedCalls: []*ast.Call{},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"FOO": {Value: "bar"},
-						"BAR": {Value: "baz"},
+			ExpectedCalls: []*task.Call{},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
 					},
-					[]string{"FOO", "BAR"},
-				),
-			},
+				},
+				&ast.VarElement{
+					Key: "BAR",
+					Value: ast.Var{
+						Value: "baz",
+					},
+				},
+			),
 		},
 	}
 
 	for i, test := range tests {
 		t.Run(fmt.Sprintf("TestArgs%d", i+1), func(t *testing.T) {
+			t.Parallel()
+
 			calls, globals := args.Parse(test.Args...)
 			assert.Equal(t, test.ExpectedCalls, calls)
 			if test.ExpectedGlobals.Len() > 0 || globals.Len() > 0 {
-				assert.Equal(t, test.ExpectedGlobals.Keys(), globals.Keys())
-				assert.Equal(t, test.ExpectedGlobals.Values(), globals.Values())
+				assert.Equal(t, test.ExpectedGlobals, globals)
+				assert.Equal(t, test.ExpectedGlobals, globals)
 			}
 		})
 	}

call.go

@@ -1,9 +1,11 @@
-package ast
+package task
+
+import "github.com/go-task/task/v3/taskfile/ast"
 
 // Call is the parameters to a task call
 type Call struct {
 	Task     string
-	Vars     *Vars
+	Vars     *ast.Vars
 	Silent   bool
 	Indirect bool // True if the task was called by another task
 }

cmd/release/main.go

@@ -1,30 +1,25 @@
 package main
 
 import (
-	"errors"
 	"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/docs/changelog.mdx"
-	docsSource      = "website/docs"
-	docsTarget      = "website/versioned_docs/version-latest"
+	changelogTarget = "website/src/docs/changelog.md"
+	versionFile     = "internal/version/version.txt"
 )
 
-var (
-	changelogReleaseRegex = regexp.MustCompile(`## Unreleased`)
-	versionRegex          = regexp.MustCompile(`(?m)^  "version": "\d+\.\d+\.\d+",$`)
-)
+var changelogReleaseRegex = regexp.MustCompile(`## Unreleased`)
 
 // Flags
 var (
@@ -48,7 +43,7 @@ func release() error {
 		return errors.New("error: expected version number")
 	}
 
-	version, err := getVersion()
+	version, err := getVersion(versionFile)
 	if err != nil {
 		return err
 	}
@@ -66,28 +61,18 @@ func release() error {
 		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 {
+	if err := setVersionFile(versionFile, version); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func getVersion() (*semver.Version, error) {
-	cmd := exec.Command("git", "describe", "--tags", "--abbrev=0")
-	b, err := cmd.Output()
+func getVersion(filename string) (*semver.Version, error) {
+	b, err := os.ReadFile(filename)
 	if err != nil {
 		return nil, err
 	}
-
 	return semver.NewVersion(strings.TrimSpace(string(b)))
 }
 
@@ -132,37 +117,21 @@ 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 {
+	if err := os.WriteFile(changelogSource, []byte(changelog), 0o644); err != nil { //nolint:gosec
 		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
-	changelog = fmt.Sprintf("---\n%s\n---\n\n%s", frontmatter, changelog)
+	changelogWithFrontmatter := fmt.Sprintf("---\n%s\n---\n\n%s", frontmatter, changelogWithVPre)
 
 	// Write the changelog to the target file
-	return os.WriteFile(changelogTarget, []byte(changelog), 0o644)
+	return os.WriteFile(changelogTarget, []byte(changelogWithFrontmatter), 0o644) //nolint:gosec
 }
 
-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 setVersionFile(fileName string, version *semver.Version) error {
+	return os.WriteFile(fileName, []byte(version.String()+"\n"), 0o644)
 }

cmd/sleepit/sleepit.go

@@ -159,7 +159,7 @@ func worker(
 	return workerDone
 }
 
-// Do some work and then return, so that the caller can decide wether to continue or not.
+// Do some work and then return, so that the caller can decide whether to continue or not.
 // Return true when all work is done.
 func doSomeWork(deadline time.Time) bool {
 	if time.Now().After(deadline) {

cmd/task/task.go

@@ -4,20 +4,19 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"strings"
+	"path/filepath"
+	"strconv"
 
 	"github.com/spf13/pflag"
-	"mvdan.cc/sh/v3/syntax"
 
 	"github.com/go-task/task/v3"
 	"github.com/go-task/task/v3/args"
 	"github.com/go-task/task/v3/errors"
-	"github.com/go-task/task/v3/internal/experiments"
+	"github.com/go-task/task/v3/experiments"
+	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/internal/flags"
 	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/sort"
-	ver "github.com/go-task/task/v3/internal/version"
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/internal/version"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
@@ -30,21 +29,36 @@ 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 {
-	logger := &logger.Logger{
+	log := &logger.Logger{
 		Stdout:  os.Stdout,
 		Stderr:  os.Stderr,
 		Verbose: flags.Verbose,
@@ -55,11 +69,12 @@ func run() error {
 		return err
 	}
 
-	dir := flags.Dir
-	entrypoint := flags.Entrypoint
+	if err := experiments.Validate(); err != nil {
+		log.Warnf("%s\n", err.Error())
+	}
 
 	if flags.Version {
-		fmt.Printf("Task version: %s\n", ver.GetVersionWithSum())
+		fmt.Println(version.GetVersionWithBuildInfo())
 		return nil
 	}
 
@@ -69,7 +84,7 @@ func run() error {
 	}
 
 	if flags.Experiments {
-		return experiments.List(logger)
+		return log.PrintExperiments()
 	}
 
 	if flags.Init {
@@ -77,9 +92,28 @@ func run() error {
 		if err != nil {
 			return err
 		}
-		if err := task.InitTaskfile(os.Stdout, wd); err != nil {
+		args, _, err := args.Get()
+		if err != nil {
 			return err
 		}
+		path := wd
+		if len(args) > 0 {
+			name := args[0]
+			if filepathext.IsExtOnly(name) {
+				name = filepathext.SmartJoin(filepath.Dir(name), "Taskfile"+filepath.Ext(name))
+			}
+			path = filepathext.SmartJoin(wd, name)
+		}
+		finalPath, err := task.InitTaskfile(path)
+		if err != nil {
+			return err
+		}
+		if !flags.Silent {
+			if flags.Verbose {
+				log.Outf(logger.Default, "%s\n", task.DefaultTaskfile)
+			}
+			log.Outf(logger.Green, "Taskfile created: %s\n", filepathext.TryAbsToRel(finalPath))
+		}
 		return nil
 	}
 
@@ -92,81 +126,30 @@ func run() error {
 		return nil
 	}
 
-	if flags.Global {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return fmt.Errorf("task: Failed to get user home directory: %w", err)
-		}
-		dir = home
-	}
-
-	var taskSorter sort.TaskSorter
-	switch flags.TaskSort {
-	case "none":
-		taskSorter = &sort.Noop{}
-	case "alphanumeric":
-		taskSorter = &sort.AlphaNumeric{}
-	}
-
-	e := task.Executor{
-		Dir:         dir,
-		Entrypoint:  entrypoint,
-		Force:       flags.Force,
-		ForceAll:    flags.ForceAll,
-		Insecure:    flags.Insecure,
-		Download:    flags.Download,
-		Offline:     flags.Offline,
-		Timeout:     flags.Timeout,
-		Watch:       flags.Watch,
-		Verbose:     flags.Verbose,
-		Silent:      flags.Silent,
-		AssumeYes:   flags.AssumeYes,
-		Dry:         flags.Dry || flags.Status,
-		Summary:     flags.Summary,
-		Parallel:    flags.Parallel,
-		Color:       flags.Color,
-		Concurrency: flags.Concurrency,
-		Interval:    flags.Interval,
-
-		Stdin:  os.Stdin,
-		Stdout: os.Stdout,
-		Stderr: os.Stderr,
-
-		OutputStyle: flags.Output,
-		TaskSorter:  taskSorter,
-	}
-	listOptions := task.NewListOptions(flags.List, flags.ListAll, flags.ListJson, flags.NoStatus)
-	if err := listOptions.Validate(); err != nil {
+	e := task.NewExecutor(
+		flags.WithFlags(),
+		task.WithVersionCheck(true),
+	)
+	if err := e.Setup(); err != nil {
 		return err
 	}
 
-	err := e.Setup()
-	if err != nil {
-		return err
-	}
-	if experiments.AnyVariables.Enabled {
-		logger.Warnf("The 'Any Variables' experiment flag is no longer required to use non-map variable types. If you wish to use map variables, please use 'TASK_X_MAP_VARIABLES' instead. See https://github.com/go-task/task/issues/1585\n")
-	}
-
-	// If the download flag is specified, we should stop execution as soon as
-	// taskfile is downloaded
-	if flags.Download {
-		return nil
-	}
-
 	if flags.ClearCache {
-		cache, err := taskfile.NewCache(e.TempDir.Remote)
-		if err != nil {
-			return err
-		}
-		return cache.Clear()
-	}
-
-	if (listOptions.ShouldListTasks()) && flags.Silent {
-		return e.ListTaskNames(flags.ListAll)
+		cachePath := filepath.Join(e.TempDir.Remote, "remote")
+		return os.RemoveAll(cachePath)
 	}
 
+	listOptions := task.NewListOptions(
+		flags.List,
+		flags.ListAll,
+		flags.ListJson,
+		flags.NoStatus,
+		flags.Nested,
+	)
 	if listOptions.ShouldListTasks() {
+		if flags.Silent {
+			return e.ListTaskNames(flags.ListAll)
+		}
 		foundTasks, err := e.ListTasks(listOptions)
 		if err != nil {
 			return err
@@ -177,29 +160,35 @@ func run() error {
 		return nil
 	}
 
-	var (
-		calls   []*ast.Call
-		globals *ast.Vars
-	)
-
-	tasksAndVars, cliArgs, err := getArgs()
+	// Parse the remaining arguments
+	cliArgsPreDash, cliArgsPostDash, err := args.Get()
 	if err != nil {
 		return err
 	}
-
-	calls, globals = args.Parse(tasksAndVars...)
+	calls, globals := args.Parse(cliArgsPreDash...)
 
 	// If there are no calls, run the default task instead
 	if len(calls) == 0 {
-		calls = append(calls, &ast.Call{Task: "default"})
+		calls = append(calls, &task.Call{Task: "default"})
 	}
 
-	globals.Set("CLI_ARGS", ast.Var{Value: cliArgs})
-	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})
+	// 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)
 	if !flags.Watch {
 		e.InterceptInterruptSignals()
 	}
@@ -212,24 +201,3 @@ func run() error {
 
 	return e.Run(ctx, calls...)
 }
-
-func getArgs() ([]string, string, error) {
-	var (
-		args          = pflag.Args()
-		doubleDashPos = pflag.CommandLine.ArgsLenAtDash()
-	)
-
-	if doubleDashPos == -1 {
-		return args, "", nil
-	}
-
-	var quotedCliArgs []string
-	for _, arg := range args[doubleDashPos:] {
-		quotedCliArg, err := syntax.Quote(arg, syntax.LangBash)
-		if err != nil {
-			return nil, "", err
-		}
-		quotedCliArgs = append(quotedCliArgs, quotedCliArg)
-	}
-	return args[:doubleDashPos], strings.Join(quotedCliArgs, " "), nil
-}

compiler.go

@@ -0,0 +1,254 @@
+package task
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"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/templater"
+	"github.com/go-task/task/v3/internal/version"
+	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+type Compiler struct {
+	Dir            string
+	Entrypoint     string
+	UserWorkingDir string
+
+	TaskfileEnv  *ast.Vars
+	TaskfileVars *ast.Vars
+
+	Logger *logger.Logger
+
+	dynamicCache   map[string]string
+	muDynamicCache sync.Mutex
+}
+
+func (c *Compiler) GetTaskfileVariables() (*ast.Vars, error) {
+	return c.getVariables(nil, nil, true)
+}
+
+func (c *Compiler) GetVariables(t *ast.Task, call *Call) (*ast.Vars, error) {
+	return c.getVariables(t, call, true)
+}
+
+func (c *Compiler) FastGetVariables(t *ast.Task, call *Call) (*ast.Vars, error) {
+	return c.getVariables(t, call, false)
+}
+
+func (c *Compiler) getVariables(t *ast.Task, call *Call, evaluateShVars bool) (*ast.Vars, error) {
+	result := env.GetEnviron()
+	specialVars, err := c.getSpecialVars(t, call)
+	if err != nil {
+		return nil, err
+	}
+	for k, v := range specialVars {
+		result.Set(k, ast.Var{Value: v})
+	}
+
+	getRangeFunc := func(dir string) func(k string, v ast.Var) error {
+		return func(k string, v ast.Var) error {
+			cache := &templater.Cache{Vars: result}
+			// Replace values
+			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})
+				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})
+				return nil
+			}
+			// Now we can check for errors since we've handled all the cases when we don't want to evaluate
+			if err := cache.Err(); err != nil {
+				return err
+			}
+			// 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})
+				return nil
+			}
+			// If the variable is dynamic, we need to resolve it first
+			static, err := c.HandleDynamicVar(newVar, dir, env.GetFromVars(result))
+			if err != nil {
+				return err
+			}
+			result.Set(k, ast.Var{Value: static})
+			return nil
+		}
+	}
+	rangeFunc := getRangeFunc(c.Dir)
+
+	var taskRangeFunc func(k string, v ast.Var) error
+	if t != nil {
+		// NOTE(@andreynering): We're manually joining these paths here because
+		// this is the raw task, not the compiled one.
+		cache := &templater.Cache{Vars: result}
+		dir := templater.Replace(t.Dir, cache)
+		if err := cache.Err(); err != nil {
+			return nil, err
+		}
+		dir = filepathext.SmartJoin(c.Dir, dir)
+		taskRangeFunc = getRangeFunc(dir)
+	}
+
+	for k, v := range c.TaskfileEnv.All() {
+		if err := rangeFunc(k, v); err != nil {
+			return nil, err
+		}
+	}
+	for k, v := range c.TaskfileVars.All() {
+		if err := rangeFunc(k, v); err != nil {
+			return nil, err
+		}
+	}
+	if t != nil {
+		for k, v := range t.IncludeVars.All() {
+			if err := rangeFunc(k, v); err != nil {
+				return nil, err
+			}
+		}
+		for k, v := range t.IncludedTaskfileVars.All() {
+			if err := taskRangeFunc(k, v); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	if t == nil || call == nil {
+		return result, nil
+	}
+
+	for k, v := range call.Vars.All() {
+		if err := rangeFunc(k, v); err != nil {
+			return nil, err
+		}
+	}
+	for k, v := range t.Vars.All() {
+		if err := taskRangeFunc(k, v); err != nil {
+			return nil, err
+		}
+	}
+
+	return result, nil
+}
+
+func (c *Compiler) HandleDynamicVar(v ast.Var, dir string, e []string) (string, error) {
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	// If the variable is not dynamic or it is empty, return an empty string
+	if v.Sh == nil || *v.Sh == "" {
+		return "", nil
+	}
+
+	if c.dynamicCache == nil {
+		c.dynamicCache = make(map[string]string, 30)
+	}
+	if result, ok := c.dynamicCache[*v.Sh]; ok {
+		return result, nil
+	}
+
+	// NOTE(@andreynering): If a var have a specific dir, use this instead
+	if v.Dir != "" {
+		dir = v.Dir
+	}
+
+	var stdout bytes.Buffer
+	opts := &execext.RunCommandOptions{
+		Command: *v.Sh,
+		Dir:     dir,
+		Stdout:  &stdout,
+		Stderr:  c.Logger.Stderr,
+		Env:     e,
+	}
+	if err := execext.RunCommand(context.Background(), opts); err != nil {
+		return "", fmt.Errorf(`task: Command "%s" failed: %s`, opts.Command, err)
+	}
+
+	// Trim a single trailing newline from the result to make most command
+	// output easier to use in shell commands.
+	result := strings.TrimSuffix(stdout.String(), "\r\n")
+	result = strings.TrimSuffix(result, "\n")
+
+	c.dynamicCache[*v.Sh] = result
+	c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", *v.Sh, result)
+
+	return result, nil
+}
+
+// ResetCache clear the dynamic variables cache
+func (c *Compiler) ResetCache() {
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	c.dynamicCache = nil
+}
+
+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.
+	var rootTaskfile, rootDir string
+	if taskfile.IsRemoteEntrypoint(c.Entrypoint) {
+		rootTaskfile = c.Entrypoint
+		rootDir = ""
+	} else {
+		rootTaskfile = filepath.ToSlash(filepathext.SmartJoin(c.Dir, c.Entrypoint))
+		rootDir = filepath.ToSlash(c.Dir)
+	}
+
+	allVars := map[string]string{
+		"TASK_EXE":            filepath.ToSlash(os.Args[0]),
+		"ROOT_TASKFILE":       rootTaskfile,
+		"ROOT_DIR":            rootDir,
+		"USER_WORKING_DIR":    filepath.ToSlash(c.UserWorkingDir),
+		"TASK_VERSION":        version.GetVersion(),
+		"PATH_LIST_SEPARATOR": string(os.PathListSeparator),
+		"FILE_PATH_SEPARATOR": string(os.PathSeparator),
+	}
+	if t != nil {
+		allVars["TASK"] = t.Task
+		if taskfile.IsRemoteEntrypoint(t.Location.Taskfile) {
+			allVars["TASKFILE"] = t.Location.Taskfile
+			allVars["TASKFILE_DIR"] = ""
+			switch {
+			case t.Dir == "":
+				allVars["TASK_DIR"] = filepath.ToSlash(c.UserWorkingDir)
+			case filepath.IsAbs(t.Dir):
+				allVars["TASK_DIR"] = filepath.ToSlash(t.Dir)
+			default:
+				allVars["TASK_DIR"] = filepath.ToSlash(filepathext.SmartJoin(c.UserWorkingDir, t.Dir))
+			}
+		} else {
+			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))
+		}
+	} else {
+		allVars["TASK"] = ""
+		allVars["TASK_DIR"] = ""
+		allVars["TASKFILE"] = ""
+		allVars["TASKFILE_DIR"] = ""
+	}
+	if call != nil {
+		allVars["ALIAS"] = call.Task
+	} else {
+		allVars["ALIAS"] = ""
+	}
+
+	return allVars, nil
+}

compiler_internal_test.go

@@ -0,0 +1,135 @@
+package task
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+func TestGetSpecialVarsRemote(t *testing.T) {
+	t.Parallel()
+
+	uwd := t.TempDir()
+	uwdSlash := filepath.ToSlash(uwd)
+	localProj := filepath.Join(uwd, "proj")
+	localProjSlash := filepath.ToSlash(localProj)
+	localTaskfile := filepath.Join(localProj, "Taskfile.yml")
+	localTaskfileSlash := filepath.ToSlash(localTaskfile)
+	absTaskDir := filepath.Join(uwd, "opt", "work")
+	absTaskDirSlash := filepath.ToSlash(absTaskDir)
+
+	tests := []struct {
+		name             string
+		entrypoint       string
+		compilerDir      string
+		taskDir          string
+		taskfileLocation string
+		wantRootTaskfile string
+		wantRootDir      string
+		wantTaskfile     string
+		wantTaskfileDir  string
+		wantTaskDir      string
+	}{
+		{
+			name:             "local entrypoint, local task",
+			entrypoint:       localTaskfile,
+			compilerDir:      localProj,
+			taskDir:          "",
+			taskfileLocation: localTaskfile,
+			wantRootTaskfile: localTaskfileSlash,
+			wantRootDir:      localProjSlash,
+			wantTaskfile:     localTaskfileSlash,
+			wantTaskfileDir:  localProjSlash,
+			wantTaskDir:      localProjSlash,
+		},
+		{
+			name:             "https entrypoint, empty task.dir",
+			entrypoint:       "https://taskfile.dev/Taskfile.yml",
+			compilerDir:      "",
+			taskDir:          "",
+			taskfileLocation: "https://taskfile.dev/Taskfile.yml",
+			wantRootTaskfile: "https://taskfile.dev/Taskfile.yml",
+			wantRootDir:      "",
+			wantTaskfile:     "https://taskfile.dev/Taskfile.yml",
+			wantTaskfileDir:  "",
+			wantTaskDir:      uwdSlash,
+		},
+		{
+			name:             "https entrypoint, relative task.dir",
+			entrypoint:       "https://taskfile.dev/Taskfile.yml",
+			compilerDir:      "",
+			taskDir:          "subdir",
+			taskfileLocation: "https://taskfile.dev/Taskfile.yml",
+			wantRootTaskfile: "https://taskfile.dev/Taskfile.yml",
+			wantRootDir:      "",
+			wantTaskfile:     "https://taskfile.dev/Taskfile.yml",
+			wantTaskfileDir:  "",
+			wantTaskDir:      filepath.ToSlash(filepathext.SmartJoin(uwd, "subdir")),
+		},
+		{
+			name:             "https entrypoint, absolute task.dir",
+			entrypoint:       "https://taskfile.dev/Taskfile.yml",
+			compilerDir:      "",
+			taskDir:          absTaskDir,
+			taskfileLocation: "https://taskfile.dev/Taskfile.yml",
+			wantRootTaskfile: "https://taskfile.dev/Taskfile.yml",
+			wantRootDir:      "",
+			wantTaskfile:     "https://taskfile.dev/Taskfile.yml",
+			wantTaskfileDir:  "",
+			wantTaskDir:      absTaskDirSlash,
+		},
+		{
+			name:             "git entrypoint",
+			entrypoint:       "https://github.com/foo/bar.git//Taskfile.yml?ref=main",
+			compilerDir:      "",
+			taskDir:          "",
+			taskfileLocation: "https://github.com/foo/bar.git//Taskfile.yml?ref=main",
+			wantRootTaskfile: "https://github.com/foo/bar.git//Taskfile.yml?ref=main",
+			wantRootDir:      "",
+			wantTaskfile:     "https://github.com/foo/bar.git//Taskfile.yml?ref=main",
+			wantTaskfileDir:  "",
+			wantTaskDir:      uwdSlash,
+		},
+		{
+			name:             "local root, remote included task",
+			entrypoint:       localTaskfile,
+			compilerDir:      localProj,
+			taskDir:          "",
+			taskfileLocation: "https://taskfile.dev/included.yml",
+			wantRootTaskfile: localTaskfileSlash,
+			wantRootDir:      localProjSlash,
+			wantTaskfile:     "https://taskfile.dev/included.yml",
+			wantTaskfileDir:  "",
+			wantTaskDir:      uwdSlash,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			c := &Compiler{
+				Dir:            tt.compilerDir,
+				Entrypoint:     tt.entrypoint,
+				UserWorkingDir: uwd,
+			}
+			task := &ast.Task{
+				Task:     "mytask",
+				Dir:      tt.taskDir,
+				Location: &ast.Location{Taskfile: tt.taskfileLocation},
+			}
+
+			vars, err := c.getSpecialVars(task, nil)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.wantRootTaskfile, vars["ROOT_TASKFILE"], "ROOT_TASKFILE")
+			assert.Equal(t, tt.wantRootDir, vars["ROOT_DIR"], "ROOT_DIR")
+			assert.Equal(t, tt.wantTaskfile, vars["TASKFILE"], "TASKFILE")
+			assert.Equal(t, tt.wantTaskfileDir, vars["TASKFILE_DIR"], "TASKFILE_DIR")
+			assert.Equal(t, tt.wantTaskDir, vars["TASK_DIR"], "TASK_DIR")
+		})
+	}
+}

completion/bash/task.bash

@@ -1,6 +1,7 @@
 # vim: set tabstop=2 shiftwidth=2 expandtab:
 
 _GO_TASK_COMPLETION_LIST_OPTION='--list-all'
+TASK_CMD="${TASK_EXE:-task}"
 
 function _task()
 {
@@ -21,10 +22,14 @@ function _task()
 
   # Handle special arguments of options.
   case "$prev" in
-    -d|--dir)
+    -d|--dir|--remote-cache-dir)
       _filedir -d
       return $?
     ;;
+    --cacert|--cert|--cert-key)
+      _filedir
+      return $?
+    ;;
     -t|--taskfile)
       _filedir yaml || return $?
       _filedir yml
@@ -52,4 +57,4 @@ function _task()
   __ltrim_colon_completions "$cur"
 }
 
-complete -F _task task
+complete -F _task "$TASK_CMD"

completion/fish/task.fish

@@ -1,8 +1,52 @@
-set GO_TASK_PROGNAME task
+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
+
+function __task_get_tasks --description "Prints all available tasks with their description" --inherit-variable GO_TASK_PROGNAME
+  # Check if the global task is requested
+  set -l global_task false
+  commandline --current-process | read --tokenize --list --local cmd_args
+  for arg in $cmd_args
+    if test "_$arg" = "_--"
+      break # ignore arguments to be passed to the task
+    end
+    if test "_$arg" = "_--global" -o "_$arg" = "_-g"
+      set global_task true
+      break
+    end
+  end
 
-function __task_get_tasks --description "Prints all available tasks with their description"
   # Read the list of tasks (and potential errors)
-  $GO_TASK_PROGNAME --list-all 2>&1 | read -lz rawOutput
+  if $global_task
+    $GO_TASK_PROGNAME --global --list-all
+  else
+    $GO_TASK_PROGNAME --list-all
+  end 2>&1 | read -lz rawOutput
 
   # Return on non-zero exit code (for cases when there is no Taskfile found or etc.)
   if test $status -ne 0
@@ -10,28 +54,67 @@ 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/\* \(.*\):\s*\(.*\)\s*(\(aliases.*\))/\1\t\2\t\3/' -e 's/\* \(.*\):\s*\(.*\)/\1\t\2/'| string split0)
+  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)
   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)"
+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 -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'
+# 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'

completion/ps/task.ps1

@@ -5,22 +5,86 @@ Register-ArgumentCompleter -CommandName task -ScriptBlock {
 
 	if ($commandName.StartsWith('-')) {
 		$completions = @(
-			[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')
+			# 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')
 		)
 
+		# 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) }
 	}
 

completion/zsh/_task

@@ -1,67 +1,151 @@
 #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=($TASK_CMD)
     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
-        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
+
+    # 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
     fi
 
     (( enabled )) || return 0
 
     scripts=()
-    for item in "${(@)${(f)$("${cmd[@]}" $_GO_TASK_COMPLETION_LIST_OPTION)}[2,-1]#\* }"; do
+
+    # 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
         task="${item%%:[[:space:]]*}"
-        desc="${item##[^[:space:]]##[[:space:]]##}"
-        scripts+=( "${task//:/\\:}:$desc" )
+
+        if [[ "$show_desc" == "true" ]]; then
+            local desc="${item##[^[:space:]]##[[:space:]]##}"
+            scripts+=( "${task//:/\\:}:$desc" )
+        else
+            scripts+=( "$task" )
+        fi
     done
-    _describe 'Task to run' scripts
+
+    if [[ "$show_desc" == "true" ]]; then
+        _describe 'Task to run' scripts
+    else
+        compadd -Q -a scripts
+    fi
 }
 
 _task() {
-    _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'
+    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
 }
 
 # don't run the completion function when being source-ed or eval-ed

errors/error_taskfile_decode.go

@@ -2,36 +2,15 @@ package errors
 
 import (
 	"bytes"
-	"embed"
+	"cmp"
 	"errors"
 	"fmt"
-	"regexp"
 	"strings"
 
-	"github.com/alecthomas/chroma/v2"
-	"github.com/alecthomas/chroma/v2/quick"
-	"github.com/alecthomas/chroma/v2/styles"
 	"github.com/fatih/color"
-	"gopkg.in/yaml.v3"
+	"go.yaml.in/yaml/v3"
 )
 
-//go:embed themes/*.xml
-var embedded embed.FS
-
-var typeErrorRegex = regexp.MustCompile(`line \d+: (.*)`)
-
-func init() {
-	r, err := embedded.Open("themes/task.xml")
-	if err != nil {
-		panic(err)
-	}
-	style, err := chroma.NewXMLStyle(r)
-	if err != nil {
-		panic(err)
-	}
-	styles.Register(style)
-}
-
 type (
 	TaskfileDecodeError struct {
 		Message  string
@@ -39,15 +18,9 @@ type (
 		Line     int
 		Column   int
 		Tag      string
-		Snippet  TaskfileSnippet
+		Snippet  string
 		Err      error
 	}
-	TaskfileSnippet struct {
-		Lines     []string
-		StartLine int
-		EndLine   int
-		Padding   int
-	}
 )
 
 func NewTaskfileDecodeError(err error, node *yaml.Node) *TaskfileDecodeError {
@@ -77,10 +50,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", extractTypeErrorMessage(message)))
+					fmt.Fprintln(buf, color.RedString("- %s", message))
 				}
 			} else {
-				fmt.Fprintln(buf, color.RedString("err:  %s", extractTypeErrorMessage(te.Errors[0])))
+				fmt.Fprintln(buf, color.RedString("err:  %s", te.Errors[0]))
 			}
 		} else {
 			// Otherwise print the error message normally
@@ -88,38 +61,44 @@ func (err *TaskfileDecodeError) Error() string {
 		}
 	}
 	fmt.Fprintln(buf, color.RedString("file: %s:%d:%d", err.Location, err.Line, err.Column))
+	fmt.Fprint(buf, err.Snippet)
+	return buf.String()
+}
 
-	// Print the snippet
-	maxLineNumberDigits := digits(err.Snippet.EndLine)
-	lineNumberSpacer := strings.Repeat(" ", maxLineNumberDigits)
-	columnSpacer := strings.Repeat(" ", err.Column-1)
-	for i, line := range err.Snippet.Lines {
-		currentLine := err.Snippet.StartLine + i + 1
+func (err *TaskfileDecodeError) Debug() string {
+	const indentWidth = 2
+	buf := &bytes.Buffer{}
+	fmt.Fprintln(buf, "TaskfileDecodeError:")
 
-		lineIndicator := " "
-		if currentLine == err.Line {
-			lineIndicator = ">"
-		}
-		columnIndicator := "^"
+	// Recursively loop through the error chain and print any details
+	var debug func(error, int)
+	debug = func(err error, indent int) {
+		indentStr := strings.Repeat(" ", indent*indentWidth)
 
-		// Print each line
-		lineIndicator = color.RedString(lineIndicator)
-		columnIndicator = color.RedString(columnIndicator)
-		lineNumberFormat := fmt.Sprintf("%%%dd", maxLineNumberDigits)
-		lineNumber := fmt.Sprintf(lineNumberFormat, currentLine)
-		fmt.Fprintf(buf, "%s %s | %s", lineIndicator, lineNumber, line)
-
-		// Print the column indicator
-		if currentLine == err.Line {
-			fmt.Fprintf(buf, "\n  %s | %s%s", lineNumberSpacer, columnSpacer, columnIndicator)
+		// Nothing left to unwrap
+		if err == nil {
+			fmt.Fprintf(buf, "%sEnd of chain\n", indentStr)
+			return
 		}
 
-		// If there are more lines to print, add a newline
-		if i < len(err.Snippet.Lines)-1 {
-			fmt.Fprintln(buf)
+		// Taskfile decode error
+		decodeErr := &TaskfileDecodeError{}
+		if errors.As(err, &decodeErr) {
+			fmt.Fprintf(buf, "%s%s (%s:%d:%d)\n",
+				indentStr,
+				cmp.Or(decodeErr.Message, "<no_message>"),
+				decodeErr.Location,
+				decodeErr.Line,
+				decodeErr.Column,
+			)
+			debug(errors.Unwrap(err), indent+1)
+			return
 		}
+
+		fmt.Fprintf(buf, "%s%s\n", indentStr, err)
+		debug(errors.Unwrap(err), indent+1)
 	}
-
+	debug(err, 0)
 	return buf.String()
 }
 
@@ -141,39 +120,8 @@ func (err *TaskfileDecodeError) WithTypeMessage(t string) *TaskfileDecodeError {
 	return err
 }
 
-func (err *TaskfileDecodeError) WithFileInfo(location string, b []byte, padding int) *TaskfileDecodeError {
-	buf := &bytes.Buffer{}
-	if err := quick.Highlight(buf, string(b), "yaml", "terminal", "task"); err != nil {
-		buf.WriteString(string(b))
-	}
-	lines := strings.Split(buf.String(), "\n")
-	start := max(err.Line-1-padding, 0)
-	end := min(err.Line+padding, len(lines)-1)
-
+func (err *TaskfileDecodeError) WithFileInfo(location string, snippet string) *TaskfileDecodeError {
 	err.Location = location
-	err.Snippet = TaskfileSnippet{
-		Lines:     lines[start:end],
-		StartLine: start,
-		EndLine:   end,
-		Padding:   padding,
-	}
-
+	err.Snippet = snippet
 	return err
 }
-
-func extractTypeErrorMessage(message string) string {
-	matches := typeErrorRegex.FindStringSubmatch(message)
-	if len(matches) == 2 {
-		return matches[1]
-	}
-	return message
-}
-
-func digits(number int) int {
-	count := 0
-	for number != 0 {
-		number /= 10
-		count += 1
-	}
-	return count
-}

errors/errors.go

@@ -8,6 +8,11 @@ const (
 	CodeUnknown            // Used when no other exit code is appropriate
 )
 
+// TaskRC related exit codes
+const (
+	CodeTaskRCNotFoundError int = iota + 50
+)
+
 // Taskfile related exit codes
 const (
 	CodeTaskfileNotFound int = iota + 100
@@ -21,6 +26,7 @@ const (
 	CodeTaskfileNetworkTimeout
 	CodeTaskfileInvalid
 	CodeTaskfileCycle
+	CodeTaskfileDoesNotMatchChecksum
 )
 
 // Task related exit codes
@@ -32,6 +38,7 @@ const (
 	CodeTaskCalledTooManyTimes
 	CodeTaskCancelled
 	CodeTaskMissingRequiredVars
+	CodeTaskNotAllowedVars
 )
 
 // TaskError extends the standard error interface with a Code method. This code will

errors/errors_task.go

@@ -1,6 +1,7 @@
 package errors
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 
@@ -46,12 +47,17 @@ func (err *TaskRunError) Code() int {
 }
 
 func (err *TaskRunError) TaskExitCode() int {
-	if c, ok := interp.IsExitStatus(err.Err); ok {
-		return int(c)
+	var exit interp.ExitStatus
+	if errors.As(err.Err, &exit) {
+		return int(exit)
 	}
 	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
@@ -141,20 +147,62 @@ func (err *TaskCancelledNoTerminalError) Code() int {
 	return CodeTaskCancelled
 }
 
-// TaskMissingRequiredVars is returned when a task is missing required variables.
-type TaskMissingRequiredVars struct {
+// TaskMissingRequiredVarsError is returned when a task is missing required variables.
+
+type MissingVar struct {
+	Name          string
+	AllowedValues []string
+}
+type TaskMissingRequiredVarsError struct {
 	TaskName    string
-	MissingVars []string
+	MissingVars []MissingVar
 }
 
-func (err *TaskMissingRequiredVars) Error() string {
+func (v MissingVar) String() string {
+	if len(v.AllowedValues) == 0 {
+		return v.Name
+	}
+	return fmt.Sprintf("%s (allowed values: %v)", v.Name, v.AllowedValues)
+}
+
+func (err *TaskMissingRequiredVarsError) Error() string {
+	vars := make([]string, 0, len(err.MissingVars))
+	for _, v := range err.MissingVars {
+		vars = append(vars, v.String())
+	}
+
 	return fmt.Sprintf(
 		`task: Task %q cancelled because it is missing required variables: %s`,
 		err.TaskName,
-		strings.Join(err.MissingVars, ", "),
-	)
+		strings.Join(vars, ", "))
 }
 
-func (err *TaskMissingRequiredVars) Code() int {
+func (err *TaskMissingRequiredVarsError) Code() int {
 	return CodeTaskMissingRequiredVars
 }
+
+type NotAllowedVar struct {
+	Value string
+	Enum  []string
+	Name  string
+}
+
+type TaskNotAllowedVarsError struct {
+	TaskName       string
+	NotAllowedVars []NotAllowedVar
+}
+
+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
+	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
+	}
+
+	return builder.String()
+}
+
+func (err *TaskNotAllowedVarsError) Code() int {
+	return CodeTaskNotAllowedVars
+}

errors/errors_taskfile.go

@@ -3,6 +3,7 @@ package errors
 import (
 	"fmt"
 	"net/http"
+	"path/filepath"
 	"time"
 
 	"github.com/Masterminds/semver/v3"
@@ -11,16 +12,23 @@ import (
 // TaskfileNotFoundError is returned when no appropriate Taskfile is found when
 // searching the filesystem.
 type TaskfileNotFoundError struct {
-	URI  string
-	Walk bool
+	URI         string
+	Walk        bool
+	AskInit     bool
+	OwnerChange bool
 }
 
 func (err TaskfileNotFoundError) Error() string {
 	var walkText string
-	if err.Walk {
-		walkText = " (or any of the parent directories)"
+	if err.OwnerChange {
+		walkText = " (or any of the parent directories until ownership changed)."
+	} else if err.Walk {
+		walkText = " (or any of the parent directories)."
 	}
-	return fmt.Sprintf(`task: No Taskfile found at %q%s`, err.URI, walkText)
+	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)
 }
 
 func (err TaskfileNotFoundError) Code() int {
@@ -47,7 +55,7 @@ type TaskfileInvalidError struct {
 }
 
 func (err TaskfileInvalidError) Error() string {
-	return fmt.Sprintf("task: Failed to parse %s:\n%v", err.URI, err.Err)
+	return fmt.Sprintf("task: Failed to parse %s:\n%v", filepath.ToSlash(err.URI), err.Err)
 }
 
 func (err TaskfileInvalidError) Code() int {
@@ -66,7 +74,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`, err.URI, statusText)
+	return fmt.Sprintf(`task: Download of %q failed%s`, filepath.ToSlash(err.URI), statusText)
 }
 
 func (err TaskfileFetchFailedError) Code() int {
@@ -82,7 +90,7 @@ type TaskfileNotTrustedError struct {
 func (err *TaskfileNotTrustedError) Error() string {
 	return fmt.Sprintf(
 		`task: Taskfile %q not trusted by user`,
-		err.URI,
+		filepath.ToSlash(err.URI),
 	)
 }
 
@@ -99,7 +107,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`,
-		err.URI,
+		filepath.ToSlash(err.URI),
 	)
 }
 
@@ -116,7 +124,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`,
-		err.URI,
+		filepath.ToSlash(err.URI),
 	)
 }
 
@@ -137,12 +145,12 @@ func (err *TaskfileVersionCheckError) Error() string {
 	if err.SchemaVersion == nil {
 		return fmt.Sprintf(
 			`task: Missing schema version in Taskfile %q`,
-			err.URI,
+			filepath.ToSlash(err.URI),
 		)
 	}
 	return fmt.Sprintf(
 		"task: Invalid schema version in Taskfile %q:\nSchema version (%s) %s",
-		err.URI,
+		filepath.ToSlash(err.URI),
 		err.SchemaVersion.String(),
 		err.Message,
 	)
@@ -155,19 +163,14 @@ func (err *TaskfileVersionCheckError) Code() int {
 // TaskfileNetworkTimeoutError is returned when the user attempts to use a remote
 // Taskfile but a network connection could not be established within the timeout.
 type TaskfileNetworkTimeoutError struct {
-	URI          string
-	Timeout      time.Duration
-	CheckedCache bool
+	URI     string
+	Timeout time.Duration
 }
 
 func (err *TaskfileNetworkTimeoutError) Error() string {
-	var cacheText string
-	if err.CheckedCache {
-		cacheText = " and no offline copy was found in the cache"
-	}
 	return fmt.Sprintf(
-		`task: Network connection timed out after %s while attempting to download Taskfile %q%s`,
-		err.Timeout, err.URI, cacheText,
+		`task: Network connection timed out after %s while attempting to download Taskfile %q`,
+		err.Timeout, filepath.ToSlash(err.URI),
 	)
 }
 
@@ -184,11 +187,32 @@ type TaskfileCycleError struct {
 
 func (err TaskfileCycleError) Error() string {
 	return fmt.Sprintf("task: include cycle detected between %s <--> %s",
-		err.Source,
-		err.Destination,
+		filepath.ToSlash(err.Source),
+		filepath.ToSlash(err.Destination),
 	)
 }
 
 func (err TaskfileCycleError) Code() int {
 	return CodeTaskfileCycle
 }
+
+// TaskfileDoesNotMatchChecksum is returned when a Taskfile's checksum does not
+// match the one pinned in the parent Taskfile.
+type TaskfileDoesNotMatchChecksum struct {
+	URI              string
+	ExpectedChecksum string
+	ActualChecksum   string
+}
+
+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.ActualChecksum,
+		err.ExpectedChecksum,
+	)
+}
+
+func (err *TaskfileDoesNotMatchChecksum) Code() int {
+	return CodeTaskfileDoesNotMatchChecksum
+}

errors/errors_taskrc.go

@@ -0,0 +1,20 @@
+package errors
+
+import "fmt"
+
+type TaskRCNotFoundError struct {
+	URI  string
+	Walk bool
+}
+
+func (err TaskRCNotFoundError) Error() string {
+	var walkText string
+	if err.Walk {
+		walkText = " (or any of the parent directories)"
+	}
+	return fmt.Sprintf(`task: No Task config file found at %q%s`, err.URI, walkText)
+}
+
+func (err TaskRCNotFoundError) Code() int {
+	return CodeTaskRCNotFoundError
+}

executor.go

@@ -0,0 +1,619 @@
+package task
+
+import (
+	"context"
+	"io"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/puzpuzpuz/xsync/v4"
+	"github.com/sajari/fuzzy"
+
+	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/internal/output"
+	"github.com/go-task/task/v3/internal/sort"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+type (
+	// An ExecutorOption is any type that can apply a configuration to an
+	// [Executor].
+	ExecutorOption interface {
+		ApplyToExecutor(*Executor)
+	}
+	// An Executor is used for processing Taskfile(s) and executing the task(s)
+	// 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
+
+		// I/O
+		Stdin  io.Reader
+		Stdout io.Writer
+		Stderr io.Writer
+
+		// Internal
+		Taskfile           *ast.Taskfile
+		Logger             *logger.Logger
+		Compiler           *Compiler
+		Output             output.Output
+		OutputStyle        ast.Output
+		TaskSorter         sort.Sorter
+		UserWorkingDir     string
+		EnableVersionCheck bool
+
+		fuzzyModel     *fuzzy.Model
+		fuzzyModelOnce sync.Once
+
+		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
+	}
+)
+
+// NewExecutor creates a new [Executor] and applies the given functional options
+// to it.
+func NewExecutor(opts ...ExecutorOption) *Executor {
+	e := &Executor{
+		Timeout:              time.Second * 10,
+		Stdin:                os.Stdin,
+		Stdout:               os.Stdout,
+		Stderr:               os.Stderr,
+		Logger:               nil,
+		Compiler:             nil,
+		Output:               nil,
+		OutputStyle:          ast.Output{},
+		TaskSorter:           sort.AlphaNumericWithRootTasksFirst,
+		UserWorkingDir:       "",
+		fuzzyModel:           nil,
+		concurrencySemaphore: nil,
+		taskCallCount:        map[string]*int32{},
+		mkdirMutexMap:        map[string]*sync.Mutex{},
+		executionHashes:      map[string]context.Context{},
+		executionHashesMutex: sync.Mutex{},
+	}
+	e.Options(opts...)
+	return e
+}
+
+// Options loops through the given [ExecutorOption] functions and applies them
+// to the [Executor].
+func (e *Executor) Options(opts ...ExecutorOption) {
+	for _, opt := range opts {
+		opt.ApplyToExecutor(e)
+	}
+}
+
+// WithDir sets the working directory of the [Executor]. By default, the
+// directory is set to the user's current working directory.
+func WithDir(dir string) ExecutorOption {
+	return &dirOption{dir}
+}
+
+type dirOption struct {
+	dir string
+}
+
+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
+}
+
+// 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 {
+	return &tempDirOption{tempDir}
+}
+
+type tempDirOption struct {
+	tempDir TempDir
+}
+
+func (o *tempDirOption) ApplyToExecutor(e *Executor) {
+	e.TempDir = o.tempDir
+}
+
+// WithForce ensures that the [Executor] always runs a task, even when
+// fingerprinting or prompts would normally stop it.
+func WithForce(force bool) ExecutorOption {
+	return &forceOption{force}
+}
+
+type forceOption struct {
+	force bool
+}
+
+func (o *forceOption) ApplyToExecutor(e *Executor) {
+	e.Force = o.force
+}
+
+// WithForceAll ensures that the [Executor] always runs all tasks (including
+// subtasks), even when fingerprinting or prompts would normally stop them.
+func WithForceAll(forceAll bool) ExecutorOption {
+	return &forceAllOption{forceAll}
+}
+
+type forceAllOption struct {
+	forceAll bool
+}
+
+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.
+func WithWatch(watch bool) ExecutorOption {
+	return &watchOption{watch}
+}
+
+type watchOption struct {
+	watch bool
+}
+
+func (o *watchOption) ApplyToExecutor(e *Executor) {
+	e.Watch = o.watch
+}
+
+// WithVerbose tells the [Executor] to output more information about the tasks
+// that are run.
+func WithVerbose(verbose bool) ExecutorOption {
+	return &verboseOption{verbose}
+}
+
+type verboseOption struct {
+	verbose bool
+}
+
+func (o *verboseOption) ApplyToExecutor(e *Executor) {
+	e.Verbose = o.verbose
+}
+
+// WithSilent tells the [Executor] to suppress all output except for the output
+// of the tasks that are run.
+func WithSilent(silent bool) ExecutorOption {
+	return &silentOption{silent}
+}
+
+type silentOption struct {
+	silent bool
+}
+
+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}
+}
+
+type assumeYesOption struct {
+	assumeYes bool
+}
+
+func (o *assumeYesOption) ApplyToExecutor(e *Executor) {
+	e.AssumeYes = o.assumeYes
+}
+
+// WithAssumeTerm is used for testing purposes to simulate a terminal.
+func WithAssumeTerm(assumeTerm bool) ExecutorOption {
+	return &assumeTermOption{assumeTerm}
+}
+
+type assumeTermOption struct {
+	assumeTerm bool
+}
+
+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 {
+	return &dryOption{dry}
+}
+
+type dryOption struct {
+	dry bool
+}
+
+func (o *dryOption) ApplyToExecutor(e *Executor) {
+	e.Dry = o.dry
+}
+
+// WithSummary tells the [Executor] to output a summary of the given tasks
+// instead of running them.
+func WithSummary(summary bool) ExecutorOption {
+	return &summaryOption{summary}
+}
+
+type summaryOption struct {
+	summary bool
+}
+
+func (o *summaryOption) ApplyToExecutor(e *Executor) {
+	e.Summary = o.summary
+}
+
+// WithParallel tells the [Executor] to run tasks given in the same call in
+// parallel.
+func WithParallel(parallel bool) ExecutorOption {
+	return &parallelOption{parallel}
+}
+
+type parallelOption struct {
+	parallel bool
+}
+
+func (o *parallelOption) ApplyToExecutor(e *Executor) {
+	e.Parallel = o.parallel
+}
+
+// WithColor tells the [Executor] whether or not to output using colorized
+// strings.
+func WithColor(color bool) ExecutorOption {
+	return &colorOption{color}
+}
+
+type colorOption struct {
+	color bool
+}
+
+func (o *colorOption) ApplyToExecutor(e *Executor) {
+	e.Color = o.color
+}
+
+// WithConcurrency sets the maximum number of tasks that the [Executor] can run
+// in parallel.
+func WithConcurrency(concurrency int) ExecutorOption {
+	return &concurrencyOption{concurrency}
+}
+
+type concurrencyOption struct {
+	concurrency int
+}
+
+func (o *concurrencyOption) ApplyToExecutor(e *Executor) {
+	e.Concurrency = o.concurrency
+}
+
+// WithInterval sets the interval at which the [Executor] will wait for
+// duplicated events before running a task.
+func WithInterval(interval time.Duration) ExecutorOption {
+	return &intervalOption{interval}
+}
+
+type intervalOption struct {
+	interval time.Duration
+}
+
+func (o *intervalOption) ApplyToExecutor(e *Executor) {
+	e.Interval = o.interval
+}
+
+// WithOutputStyle sets the output style of the [Executor]. By default, the
+// output style is set to the style defined in the Taskfile.
+func WithOutputStyle(outputStyle ast.Output) ExecutorOption {
+	return &outputStyleOption{outputStyle}
+}
+
+type outputStyleOption struct {
+	outputStyle ast.Output
+}
+
+func (o *outputStyleOption) ApplyToExecutor(e *Executor) {
+	e.OutputStyle = o.outputStyle
+}
+
+// WithTaskSorter sets the sorter that the [Executor] will use to sort tasks. By
+// default, the sorter is set to sort tasks alphabetically, but with tasks with
+// no namespace (in the root Taskfile) first.
+func WithTaskSorter(sorter sort.Sorter) ExecutorOption {
+	return &taskSorterOption{sorter}
+}
+
+type taskSorterOption struct {
+	sorter sort.Sorter
+}
+
+func (o *taskSorterOption) ApplyToExecutor(e *Executor) {
+	e.TaskSorter = o.sorter
+}
+
+// WithStdin sets the [Executor]'s standard input [io.Reader].
+func WithStdin(stdin io.Reader) ExecutorOption {
+	return &stdinOption{stdin}
+}
+
+type stdinOption struct {
+	stdin io.Reader
+}
+
+func (o *stdinOption) ApplyToExecutor(e *Executor) {
+	e.Stdin = o.stdin
+}
+
+// WithStdout sets the [Executor]'s standard output [io.Writer].
+func WithStdout(stdout io.Writer) ExecutorOption {
+	return &stdoutOption{stdout}
+}
+
+type stdoutOption struct {
+	stdout io.Writer
+}
+
+func (o *stdoutOption) ApplyToExecutor(e *Executor) {
+	e.Stdout = o.stdout
+}
+
+// WithStderr sets the [Executor]'s standard error [io.Writer].
+func WithStderr(stderr io.Writer) ExecutorOption {
+	return &stderrOption{stderr}
+}
+
+type stderrOption struct {
+	stderr io.Writer
+}
+
+func (o *stderrOption) ApplyToExecutor(e *Executor) {
+	e.Stderr = o.stderr
+}
+
+// WithIO sets the [Executor]'s standard input, output, and error to the same
+// [io.ReadWriter].
+func WithIO(rw io.ReadWriter) ExecutorOption {
+	return &ioOption{rw}
+}
+
+type ioOption struct {
+	rw io.ReadWriter
+}
+
+func (o *ioOption) ApplyToExecutor(e *Executor) {
+	e.Stdin = o.rw
+	e.Stdout = o.rw
+	e.Stderr = o.rw
+}
+
+// WithVersionCheck tells the [Executor] whether or not to check the version of
+func WithVersionCheck(enableVersionCheck bool) ExecutorOption {
+	return &versionCheckOption{enableVersionCheck}
+}
+
+type versionCheckOption struct {
+	enableVersionCheck bool
+}
+
+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
+}

experiments/errors.go

@@ -0,0 +1,35 @@
+package experiments
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/go-task/task/v3/internal/slicesext"
+)
+
+type InvalidValueError struct {
+	Name          string
+	AllowedValues []int
+	Value         int
+}
+
+func (err InvalidValueError) Error() string {
+	return fmt.Sprintf(
+		"task: Experiment %q has an invalid value %q (allowed values: %s)",
+		err.Name,
+		err.Value,
+		strings.Join(slicesext.Convert(err.AllowedValues, strconv.Itoa), ", "),
+	)
+}
+
+type InactiveError struct {
+	Name string
+}
+
+func (err InactiveError) Error() string {
+	return fmt.Sprintf(
+		"task: Experiment %q is inactive and cannot be enabled",
+		err.Name,
+	)
+}

experiments/experiment.go

@@ -0,0 +1,67 @@
+package experiments
+
+import (
+	"fmt"
+	"slices"
+	"strconv"
+
+	"github.com/go-task/task/v3/taskrc/ast"
+)
+
+type Experiment struct {
+	Name          string // The name of the experiment.
+	AllowedValues []int  // The values that can enable this experiment.
+	Value         int    // The version of the experiment that is enabled.
+}
+
+// New creates a new experiment with the given name and sets the values that can
+// enable it.
+func New(xName string, config *ast.TaskRC, allowedValues ...int) Experiment {
+	var value int
+	if config != nil {
+		value = config.Experiments[xName]
+	}
+
+	if value == 0 {
+		value, _ = strconv.Atoi(getEnv(xName))
+	}
+
+	x := Experiment{
+		Name:          xName,
+		AllowedValues: allowedValues,
+		Value:         value,
+	}
+	xList = append(xList, x)
+	return x
+}
+
+func (x Experiment) Enabled() bool {
+	return slices.Contains(x.AllowedValues, x.Value)
+}
+
+func (x Experiment) Active() bool {
+	return len(x.AllowedValues) > 0
+}
+
+func (x Experiment) Valid() error {
+	if !x.Active() && x.Value != 0 {
+		return &InactiveError{
+			Name: x.Name,
+		}
+	}
+	if !x.Enabled() && x.Value != 0 {
+		return &InvalidValueError{
+			Name:          x.Name,
+			AllowedValues: x.AllowedValues,
+			Value:         x.Value,
+		}
+	}
+	return nil
+}
+
+func (x Experiment) String() string {
+	if x.Enabled() {
+		return fmt.Sprintf("on (%d)", x.Value)
+	}
+	return "off"
+}

experiments/experiment_test.go

@@ -0,0 +1,140 @@
+package experiments_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/go-task/task/v3/experiments"
+	"github.com/go-task/task/v3/taskrc/ast"
+)
+
+func TestNew(t *testing.T) {
+	const (
+		exampleExperiment    = "EXAMPLE"
+		exampleExperimentEnv = "TASK_X_EXAMPLE"
+	)
+	tests := []struct {
+		name          string
+		config        *ast.TaskRC
+		allowedValues []int
+		env           int
+		wantEnabled   bool
+		wantActive    bool
+		wantValid     error
+		wantValue     int
+	}{
+		{
+			name:        `[] allowed, env=""`,
+			wantEnabled: false,
+			wantActive:  false,
+		},
+		{
+			name:        `[] allowed, env="1"`,
+			env:         1,
+			wantEnabled: false,
+			wantActive:  false,
+			wantValid: &experiments.InactiveError{
+				Name: exampleExperiment,
+			},
+			wantValue: 1,
+		},
+		{
+			name:          `[1] allowed, env=""`,
+			allowedValues: []int{1},
+			wantEnabled:   false,
+			wantActive:    true,
+		},
+		{
+			name:          `[1] allowed, env="1"`,
+			allowedValues: []int{1},
+			env:           1,
+			wantEnabled:   true,
+			wantActive:    true,
+			wantValue:     1,
+		},
+		{
+			name:          `[1] allowed, env="2"`,
+			allowedValues: []int{1},
+			env:           2,
+			wantEnabled:   false,
+			wantActive:    true,
+			wantValid: &experiments.InvalidValueError{
+				Name:          exampleExperiment,
+				AllowedValues: []int{1},
+				Value:         2,
+			},
+			wantValue: 2,
+		},
+		{
+			name:          `[1, 2] allowed, env="1"`,
+			allowedValues: []int{1, 2},
+			env:           1,
+			wantEnabled:   true,
+			wantActive:    true,
+			wantValue:     1,
+		},
+		{
+			name:          `[1, 2] allowed, env="1"`,
+			allowedValues: []int{1, 2},
+			env:           2,
+			wantEnabled:   true,
+			wantActive:    true,
+			wantValue:     2,
+		},
+		{
+			name: `[1] allowed, config="1"`,
+			config: &ast.TaskRC{
+				Experiments: map[string]int{
+					exampleExperiment: 1,
+				},
+			},
+			allowedValues: []int{1},
+			wantEnabled:   true,
+			wantActive:    true,
+			wantValue:     1,
+		},
+		{
+			name: `[1] allowed, config="2"`,
+			config: &ast.TaskRC{
+				Experiments: map[string]int{
+					exampleExperiment: 2,
+				},
+			},
+			allowedValues: []int{1},
+			wantEnabled:   false,
+			wantActive:    true,
+			wantValid: &experiments.InvalidValueError{
+				Name:          exampleExperiment,
+				AllowedValues: []int{1},
+				Value:         2,
+			},
+			wantValue: 2,
+		},
+		{
+			name: `[1, 2] allowed, env="1", config="2"`,
+			config: &ast.TaskRC{
+				Experiments: map[string]int{
+					exampleExperiment: 2,
+				},
+			},
+			allowedValues: []int{1, 2},
+			env:           1,
+			wantEnabled:   true,
+			wantActive:    true,
+			wantValue:     2,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Setenv(exampleExperimentEnv, strconv.Itoa(tt.env))
+			x := experiments.New(exampleExperiment, tt.config, tt.allowedValues...)
+			assert.Equal(t, exampleExperiment, x.Name)
+			assert.Equal(t, tt.wantEnabled, x.Enabled())
+			assert.Equal(t, tt.wantActive, x.Active())
+			assert.Equal(t, tt.wantValid, x.Valid())
+			assert.Equal(t, tt.wantValue, x.Value)
+		})
+	}
+}

experiments/experiments.go

@@ -0,0 +1,89 @@
+package experiments
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/joho/godotenv"
+
+	"github.com/go-task/task/v3/taskrc"
+	"github.com/go-task/task/v3/taskrc/ast"
+)
+
+const envPrefix = "TASK_X_"
+
+// Active experiments.
+var (
+	GentleForce     Experiment
+	RemoteTaskfiles Experiment
+	EnvPrecedence   Experiment
+)
+
+// Inactive experiments. These are experiments that cannot be enabled, but are
+// preserved for error handling.
+var (
+	AnyVariables Experiment
+	MapVariables Experiment
+)
+
+// An internal list of all the initialized experiments used for iterating.
+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)
+	// Initialize the experiments
+	GentleForce = New("GENTLE_FORCE", config, 1)
+	RemoteTaskfiles = New("REMOTE_TASKFILES", config, 1)
+	EnvPrecedence = New("ENV_PRECEDENCE", config, 1)
+	AnyVariables = New("ANY_VARIABLES", config)
+	MapVariables = New("MAP_VARIABLES", config)
+}
+
+// Validate checks if any experiments have been enabled while being inactive.
+// If one is found, the function returns an error.
+func Validate() error {
+	for _, x := range List() {
+		if err := x.Valid(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func List() []Experiment {
+	return xList
+}
+
+func getEnv(xName string) string {
+	envName := fmt.Sprintf("%s%s", envPrefix, xName)
+	return os.Getenv(envName)
+}
+
+func getFilePath(filename, dir string) string {
+	if dir != "" {
+		return filepath.Join(dir, filename)
+	}
+	return filename
+}
+
+func readDotEnv(dir string) {
+	env, err := godotenv.Read(getFilePath(".env", dir))
+	if err != nil {
+		return
+	}
+
+	// If the env var is an experiment, set it.
+	for key, value := range env {
+		if strings.HasPrefix(key, envPrefix) {
+			os.Setenv(key, value)
+		}
+	}
+}

formatter_test.go

@@ -0,0 +1,236 @@
+package task_test
+
+import (
+	"bytes"
+	"path/filepath"
+	"testing"
+
+	"github.com/sebdah/goldie/v2"
+	"github.com/stretchr/testify/require"
+
+	"github.com/go-task/task/v3"
+	"github.com/go-task/task/v3/experiments"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+type (
+	// A FormatterTestOption is a function that configures an [FormatterTest].
+	FormatterTestOption interface {
+		applyToFormatterTest(*FormatterTest)
+	}
+	// A FormatterTest is a test wrapper around a [task.Executor] to make it
+	// easy to write tests for the task formatter. See [NewFormatterTest] for
+	// information on creating and running FormatterTests. These tests use
+	// fixture files to assert whether the result of the output is correct. If
+	// Task's behavior has been changed, the fixture files can be updated by
+	// running `task gen:fixtures`.
+	FormatterTest struct {
+		TaskTest
+		task           string
+		vars           map[string]any
+		executorOpts   []task.ExecutorOption
+		listOptions    task.ListOptions
+		wantSetupError bool
+		wantListError  bool
+	}
+)
+
+// NewFormatterTest sets up a new [task.Executor] with the given options and
+// runs a task with the given [FormatterTestOption]s. The output of the task is
+// written to a set of fixture files depending on the configuration of the test.
+func NewFormatterTest(t *testing.T, opts ...FormatterTestOption) {
+	t.Helper()
+	tt := &FormatterTest{
+		task: "default",
+		vars: map[string]any{},
+		TaskTest: TaskTest{
+			experiments:         map[*experiments.Experiment]int{},
+			fixtureTemplateData: map[string]any{},
+		},
+	}
+	// Apply the functional options
+	for _, opt := range opts {
+		opt.applyToFormatterTest(tt)
+	}
+	// Enable any experiments that have been set
+	for x, v := range tt.experiments {
+		prev := *x
+		*x = experiments.Experiment{
+			Name:          prev.Name,
+			AllowedValues: []int{v},
+			Value:         v,
+		}
+		t.Cleanup(func() {
+			*x = prev
+		})
+	}
+	tt.run(t)
+}
+
+// Functional options
+
+// WithListOptions sets the list options for the formatter.
+func WithListOptions(opts task.ListOptions) FormatterTestOption {
+	return &listOptionsTestOption{opts}
+}
+
+type listOptionsTestOption struct {
+	listOptions task.ListOptions
+}
+
+func (opt *listOptionsTestOption) applyToFormatterTest(t *FormatterTest) {
+	t.listOptions = opt.listOptions
+}
+
+// WithListError tells the test to expect an error when running the formatter.
+// A fixture will be created with the output of any errors.
+func WithListError() FormatterTestOption {
+	return &listErrorTestOption{}
+}
+
+type listErrorTestOption struct{}
+
+func (opt *listErrorTestOption) applyToFormatterTest(t *FormatterTest) {
+	t.wantListError = true
+}
+
+// Helpers
+
+// writeFixtureErrList is a wrapper for writing the output of an error when
+// running the formatter to a fixture file.
+func (tt *FormatterTest) writeFixtureErrList(
+	t *testing.T,
+	g *goldie.Goldie,
+	err error,
+) {
+	t.Helper()
+	tt.writeFixture(t, g, "err-list", []byte(err.Error()))
+}
+
+// run is the main function for running the test. It sets up the task executor,
+// runs the task, and writes the output to a fixture file.
+func (tt *FormatterTest) run(t *testing.T) {
+	t.Helper()
+	f := func(t *testing.T) {
+		t.Helper()
+		var buf bytes.Buffer
+
+		opts := append(
+			tt.executorOpts,
+			task.WithStdout(&buf),
+			task.WithStderr(&buf),
+		)
+
+		// 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 {
+			require.Error(t, err)
+			tt.writeFixtureErrSetup(t, g, err)
+			tt.writeFixtureBuffer(t, g, buf)
+			return
+		} else {
+			require.NoError(t, err)
+		}
+
+		// Create the task call
+		vars := ast.NewVars()
+		for key, value := range tt.vars {
+			vars.Set(key, ast.Var{Value: value})
+		}
+
+		// Run the formatter and check for errors
+		if _, err := e.ListTasks(tt.listOptions); tt.wantListError {
+			require.Error(t, err)
+			tt.writeFixtureErrList(t, g, err)
+			tt.writeFixtureBuffer(t, g, buf)
+			return
+		} else {
+			require.NoError(t, err)
+		}
+
+		tt.writeFixtureBuffer(t, g, buf)
+	}
+
+	// Run the test (with a name if it has one)
+	if tt.name != "" {
+		t.Run(tt.name, f)
+	} else {
+		f(t)
+	}
+}
+
+func TestNoLabelInList(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/label_list"),
+		),
+		WithListOptions(task.ListOptions{
+			ListOnlyTasksWithDescriptions: true,
+		}),
+	)
+}
+
+// task -al case 1: listAll list all tasks
+func TestListAllShowsNoDesc(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/list_mixed_desc"),
+		),
+		WithListOptions(task.ListOptions{
+			ListAllTasks: true,
+		}),
+	)
+}
+
+// task -al case 2: !listAll list some tasks (only those with desc)
+func TestListCanListDescOnly(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/list_mixed_desc"),
+		),
+		WithListOptions(task.ListOptions{
+			ListOnlyTasksWithDescriptions: true,
+		}),
+	)
+}
+
+func TestListDescInterpolation(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/list_desc_interpolation"),
+		),
+		WithListOptions(task.ListOptions{
+			ListOnlyTasksWithDescriptions: true,
+		}),
+	)
+}
+
+func TestJsonListFormat(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/json_list_format"),
+		),
+		WithListOptions(task.ListOptions{
+			FormatTaskListAsJSON: true,
+		}),
+		WithFixtureTemplating(),
+	)
+}

go.mod

@@ -1,39 +1,136 @@
 module github.com/go-task/task/v3
 
-go 1.22.0
+go 1.25.10
 
 require (
+	charm.land/bubbles/v2 v2.1.0
+	charm.land/bubbletea/v2 v2.0.6
+	charm.land/lipgloss/v2 v2.0.3
 	github.com/Ladicle/tabwriter v1.0.0
-	github.com/Masterminds/semver/v3 v3.3.0
-	github.com/alecthomas/chroma/v2 v2.14.0
-	github.com/davecgh/go-spew v1.1.1
+	github.com/Masterminds/semver/v3 v3.5.0
+	github.com/alecthomas/chroma/v2 v2.24.1
+	github.com/chainguard-dev/git-urls v1.0.2
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
 	github.com/dominikbraun/graph v0.23.0
-	github.com/fatih/color v1.17.0
+	github.com/elliotchance/orderedmap/v3 v3.1.0
+	github.com/fatih/color v1.19.0
+	github.com/fsnotify/fsnotify v1.10.1
 	github.com/go-task/slim-sprig/v3 v3.0.0
-	github.com/go-task/template v0.1.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/mattn/go-zglob v0.0.6
 	github.com/mitchellh/hashstructure/v2 v2.0.2
-	github.com/otiai10/copy v1.14.0
-	github.com/radovskyb/watcher v1.0.7
+	github.com/puzpuzpuz/xsync/v4 v4.5.0
 	github.com/sajari/fuzzy v1.0.0
-	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.9.0
-	github.com/zeebo/xxh3 v1.0.2
-	golang.org/x/sync v0.8.0
-	golang.org/x/term v0.24.0
-	gopkg.in/yaml.v3 v3.0.1
-	mvdan.cc/sh/v3 v3.9.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.43.0
+	mvdan.cc/sh/moreinterp v0.0.0-20260120230322-19def062a997
+	mvdan.cc/sh/v3 v3.13.2-0.20260510185049-f5c6e2779117
 )
 
 require (
-	github.com/dlclark/regexp2 v1.11.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
+	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.3 // indirect
+	github.com/charmbracelet/ultraviolet v0.0.0-20260416155717-489999b90468 // indirect
+	github.com/charmbracelet/x/ansi v0.11.7 // 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
+	github.com/dlclark/regexp2 v1.12.0 // 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.4.0 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.23 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // 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/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
+	github.com/spiffe/go-spiffe/v2 v2.6.0 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
-	golang.org/x/sys v0.25.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // 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.51.0 // indirect
+	golang.org/x/net v0.54.0 // indirect
+	golang.org/x/oauth2 v0.36.0 // indirect
+	golang.org/x/sys v0.44.0 // indirect
+	golang.org/x/text v0.37.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
 )

go.sum

@@ -1,86 +1,329 @@
+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.6 h1:UHN/91OyuhaOFGSrBXQ/hMZD8IO1Uc4BvHlgHXL2WJo=
+charm.land/bubbletea/v2 v2.0.6/go.mod h1:MH/D8ZLlN3op37vQvijKuU29g3rqTp+aQapURFonF9g=
+charm.land/lipgloss/v2 v2.0.3 h1:yM2zJ4Cf5Y51b7RHIwioil4ApI/aypFXXVHSwlM6RzU=
+charm.land/lipgloss/v2 v2.0.3/go.mod h1:7myLU9iG/3xluAWzpY/fSxYYHCgoKTie7laxk6ATwXA=
+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=
 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.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0=
-github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
-github.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=
-github.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
-github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
-github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
-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/creack/pty v1.1.21 h1:1/QdRyBaHHJP61QkWMXlOIBfsgdDeeKfK8SYVUWJKf0=
-github.com/creack/pty v1.1.21/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+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/Masterminds/semver/v3 v3.5.0 h1:kQceYJfbupGfZOKZQg0kou0DgAKhzDg2NZPAwZ/2OOE=
+github.com/Masterminds/semver/v3 v3.5.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+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/chroma/v2 v2.24.1 h1:m5ffpfZbIb++k8AqFEKy9uVgY12xIQtBsQlc6DfZJQM=
+github.com/alecthomas/chroma/v2 v2.24.1/go.mod h1:l+ohZ9xRXIbGe7cIW+YZgOGbvuVLjMps/FYN/CwuabI=
+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/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.3 h1:QPa1IWkYI+AOB+fE+mg/5/4HRMZcaXex9t5KX76i20Q=
+github.com/charmbracelet/colorprofile v0.4.3/go.mod h1:/zT4BhpD5aGFpqQQqw7a+VtHCzu+zrQtt1zhMt9mR4Q=
+github.com/charmbracelet/ultraviolet v0.0.0-20260416155717-489999b90468 h1:Q9fO0y1Zo5KB/5Vu8JZoLGm1N3RzF9bNj3Ao3xoR+Ac=
+github.com/charmbracelet/ultraviolet v0.0.0-20260416155717-489999b90468/go.mod h1:bAAz7dh/FTYfC+oiHavL4mX1tOIBZ0ZwYjSi3qE6ivM=
+github.com/charmbracelet/x/ansi v0.11.7 h1:kzv1kJvjg2S3r9KHo8hDdHFQLEqn4RBCb39dAYC84jI=
+github.com/charmbracelet/x/ansi v0.11.7/go.mod h1:9qGpnAVYz+8ACONkZBUWPtL7lulP9No6p1epAihUZwQ=
+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/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s=
+github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
-github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+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/dlclark/regexp2 v1.12.0 h1:0j4c5qQmnC6XOWNjP3PIXURXN2gWx76rd3KvgdPkCz8=
+github.com/dlclark/regexp2 v1.12.0/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/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
-github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
+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/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/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
+github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
+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/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.1.0 h1:ym/r2G937RZA1bsgiWedNnY9e5kxDT+3YcoAnuIetTE=
-github.com/go-task/template v0.1.0/go.mod h1:RgwRaZK+kni/hJJ7/AaOE2lPQFPbAdji/DyhC6pxo4k=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+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/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/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
-github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+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/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=
+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/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/lucasb-eyer/go-colorful v1.4.0 h1:UtrWVfLdarDgc44HcS7pYloGHJUjHV/4FwW4TvVgFr4=
+github.com/lucasb-eyer/go-colorful v1.4.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-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-zglob v0.0.6 h1:mP8RnmCgho4oaUYDIDn6GNxYk+qJGUs8fJLn+twYj2A=
-github.com/mattn/go-zglob v0.0.6/go.mod h1:MxxjyoXXnMxfIpxTK2GAkw1w8glPsQILx3N5wrKakiY=
+github.com/mattn/go-runewidth v0.0.23 h1:7ykA0T0jkPpzSvMS5i9uoNn2Xy3R383f9HDx3RybWcw=
+github.com/mattn/go-runewidth v0.0.23/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/otiai10/copy v1.14.0 h1:dCI/t1iTdYGtkvCuBG2BgR6KZa83PTclw4U5n2wAllU=
-github.com/otiai10/copy v1.14.0/go.mod h1:ECfuL02W+/FkTWZWgQqXPWZgW9oeKCSQ5qVfSc4qc4w=
-github.com/otiai10/mint v1.5.1 h1:XaPLeE+9vGbuyEHem1JNk3bYc7KKqyI/na0/mLd/Kks=
-github.com/otiai10/mint v1.5.1/go.mod h1:MJm72SBthJjz8qhefc4z1PYEieWmy8Bku7CjcAqyUSM=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+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/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/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/radovskyb/watcher v1.0.7 h1:AYePLih6dpmS32vlHfhCeli8127LzkIgwJGcwwe8tUE=
-github.com/radovskyb/watcher v1.0.7/go.mod h1:78okwvY5wPdzcb1UYnip1pvrZNIVEIh/Cm+ZuvsUYIg=
-github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
-github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+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.5.0 h1:vOSWu6b57/emh+L/Cw0BeQfvxa/cogFywXHeGUxQxAg=
+github.com/puzpuzpuz/xsync/v4 v4.5.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/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/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+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/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/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.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+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/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.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
-github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+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.51.0 h1:IBPXwPfKxY7cWQZ38ZCIRPI50YLeevDLlLnyC5wRGTI=
+golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8=
+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.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
+golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
+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=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
-golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM=
-golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
+golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ=
+golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4=
+golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk=
+golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
+golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
+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=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/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/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/v3 v3.9.0 h1:it14fyjCdQUk4jf/aYxLO3FG8jFarR9GzMCtnlvvD7c=
-mvdan.cc/sh/v3 v3.9.0/go.mod h1:cdBk8bgoiBI7lSZqK5JhUuq7OB64VQ7fgm85xelw3Nk=
+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.2-0.20260503214111-9e7dd28c81cf h1:3mGRe/xSr7fd9m+c5FSab/CSCtADsbdMcyhYGdVR6DY=
+mvdan.cc/sh/v3 v3.13.2-0.20260503214111-9e7dd28c81cf/go.mod h1:lXJ8SexMvEVcHCoDvAGLZgFJ9Wsm2sulmoNEXGhYZD0=
+mvdan.cc/sh/v3 v3.13.2-0.20260510185049-f5c6e2779117 h1:BfzdGSjcnJBb8sPNLudpzTml8zFUxS1N0N/v9IIS6tQ=
+mvdan.cc/sh/v3 v3.13.2-0.20260510185049-f5c6e2779117/go.mod h1:lXJ8SexMvEVcHCoDvAGLZgFJ9Wsm2sulmoNEXGhYZD0=

help.go

@@ -24,15 +24,17 @@ type ListOptions struct {
 	ListAllTasks                  bool
 	FormatTaskListAsJSON          bool
 	NoStatus                      bool
+	Nested                        bool
 }
 
 // NewListOptions creates a new ListOptions instance
-func NewListOptions(list, listAll, listAsJson, noStatus bool) ListOptions {
+func NewListOptions(list, listAll, listAsJson, noStatus, nested bool) ListOptions {
 	return ListOptions{
 		ListOnlyTasksWithDescriptions: list,
 		ListAllTasks:                  listAll,
 		FormatTaskListAsJSON:          listAsJson,
 		NoStatus:                      noStatus,
+		Nested:                        nested,
 	}
 }
 
@@ -41,20 +43,6 @@ func (o ListOptions) ShouldListTasks() bool {
 	return o.ListOnlyTasksWithDescriptions || o.ListAllTasks
 }
 
-// Validate validates that the collection of list-related options are in a valid configuration
-func (o ListOptions) Validate() error {
-	if o.ListOnlyTasksWithDescriptions && o.ListAllTasks {
-		return fmt.Errorf("task: cannot use --list and --list-all at the same time")
-	}
-	if o.FormatTaskListAsJSON && !o.ShouldListTasks() {
-		return fmt.Errorf("task: --json only applies to --list or --list-all")
-	}
-	if o.NoStatus && !o.FormatTaskListAsJSON {
-		return fmt.Errorf("task: --no-status only applies to --json with --list or --list-all")
-	}
-	return nil
-}
-
 // Filters returns the slice of FilterFunc which filters a list
 // of ast.Task according to the given ListOptions
 func (o ListOptions) Filters() []FilterFunc {
@@ -77,7 +65,7 @@ func (e *Executor) ListTasks(o ListOptions) (bool, error) {
 		return false, err
 	}
 	if o.FormatTaskListAsJSON {
-		output, err := e.ToEditorOutput(tasks, o.NoStatus)
+		output, err := e.ToEditorOutput(tasks, o.NoStatus, o.Nested)
 		if err != nil {
 			return false, err
 		}
@@ -128,18 +116,14 @@ func (e *Executor) ListTaskNames(allTasks bool) error {
 		w = e.Stdout
 	}
 
-	// Get the list of tasks and sort them
-	tasks := e.Taskfile.Tasks.Values()
-
 	// Sort the tasks
 	if e.TaskSorter == nil {
-		e.TaskSorter = &sort.AlphaNumericWithRootTasksFirst{}
+		e.TaskSorter = sort.AlphaNumericWithRootTasksFirst
 	}
-	e.TaskSorter.Sort(tasks)
 
 	// Create a list of task names
 	taskNames := make([]string, 0, e.Taskfile.Tasks.Len())
-	for _, task := range tasks {
+	for task := range e.Taskfile.Tasks.Values(e.TaskSorter) {
 		if (allTasks || task.Desc != "") && !task.Internal {
 			taskNames = append(taskNames, strings.TrimRight(task.Task, ":"))
 			for _, alias := range task.Aliases {
@@ -153,32 +137,17 @@ func (e *Executor) ListTaskNames(allTasks bool) error {
 	return nil
 }
 
-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,
-	}
+func (e *Executor) ToEditorOutput(tasks []*ast.Task, noStatus bool, nested bool) (*editors.Namespace, error) {
 	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 {
-			o.Tasks[i] = editors.Task{
-				Name:     tasks[i].Name(),
-				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,
-				},
-			}
+			editorTask := editors.NewTask(tasks[i])
 
 			if noStatus {
+				editorTasks[i] = editorTask
 				return nil
 			}
 
@@ -197,10 +166,35 @@ func (e *Executor) ToEditorOutput(tasks []*ast.Task, noStatus bool) (*editors.Ta
 				return err
 			}
 
-			o.Tasks[i].UpToDate = upToDate
-
+			editorTask.UpToDate = &upToDate
+			editorTasks[i] = editorTask
 			return nil
 		})
 	}
-	return o, g.Wait()
+	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()
 }

init.go

@@ -1,41 +1,50 @@
 package task
 
 import (
-	"fmt"
-	"io"
+	_ "embed"
 	"os"
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/taskfile"
 )
 
-const defaultTaskfile = `# https://taskfile.dev
+const defaultFilename = "Taskfile.yml"
 
-version: '3'
+//go:embed taskfile/templates/default.yml
+var DefaultTaskfile string
 
-vars:
-  GREETING: Hello, World!
-
-tasks:
-  default:
-    cmds:
-      - echo "{{.GREETING}}"
-    silent: true
-`
-
-const defaultTaskfileName = "Taskfile.yml"
-
-// InitTaskfile Taskfile creates a new Taskfile
-func InitTaskfile(w io.Writer, dir string) error {
-	f := filepathext.SmartJoin(dir, defaultTaskfileName)
-
-	if _, err := os.Stat(f); err == nil {
-		return errors.TaskfileAlreadyExistsError{}
+// InitTaskfile creates a new Taskfile at path.
+//
+// path can be either a file path or a directory path.
+// If path is a directory, path/Taskfile.yml will be created.
+//
+// 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() {
+		return path, errors.TaskfileAlreadyExistsError{}
 	}
 
-	if err := os.WriteFile(f, []byte(defaultTaskfile), 0o644); err != nil {
-		return err
+	if info != nil && info.IsDir() {
+		// path was a directory, check if there is a Taskfile already
+		if hasDefaultTaskfile(path) {
+			return path, errors.TaskfileAlreadyExistsError{}
+		}
+		path = filepathext.SmartJoin(path, defaultFilename)
 	}
-	fmt.Fprintf(w, "%s created in the current directory\n", defaultTaskfile)
-	return nil
+
+	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
 }

init_test.go

@@ -0,0 +1,52 @@
+package task_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/go-task/task/v3"
+	"github.com/go-task/task/v3/internal/filepathext"
+)
+
+func TestInitDir(t *testing.T) {
+	t.Parallel()
+
+	const dir = "testdata/init"
+	file := filepathext.SmartJoin(dir, "Taskfile.yml")
+
+	_ = os.Remove(file)
+	if _, err := os.Stat(file); err == nil {
+		t.Errorf("Taskfile.yml should not exist")
+	}
+
+	if _, err := task.InitTaskfile(dir); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := os.Stat(file); err != nil {
+		t.Errorf("Taskfile.yml should exist")
+	}
+
+	_ = os.Remove(file)
+}
+
+func TestInitFile(t *testing.T) {
+	t.Parallel()
+
+	const dir = "testdata/init"
+	file := filepathext.SmartJoin(dir, "Tasks.yml")
+
+	_ = os.Remove(file)
+	if _, err := os.Stat(file); err == nil {
+		t.Errorf("Tasks.yml should not exist")
+	}
+
+	if _, err := task.InitTaskfile(file); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := os.Stat(file); err != nil {
+		t.Errorf("Tasks.yml should exist")
+	}
+	_ = os.Remove(file)
+}

install-task.sh

@@ -64,21 +64,15 @@ get_binaries() {
   case "$PLATFORM" in
     darwin/amd64) BINARIES="task" ;;
     darwin/arm64) BINARIES="task" ;;
-    darwin/armv5) BINARIES="task" ;;
-    darwin/armv6) BINARIES="task" ;;
-    darwin/armv7) BINARIES="task" ;;
+    darwin/arm) BINARIES="task" ;;
     linux/386) BINARIES="task" ;;
     linux/amd64) BINARIES="task" ;;
     linux/arm64) BINARIES="task" ;;
-    linux/armv5) BINARIES="task" ;;
-    linux/armv6) BINARIES="task" ;;
-    linux/armv7) BINARIES="task" ;;
+    linux/arm) BINARIES="task" ;;
     windows/386) BINARIES="task" ;;
     windows/amd64) BINARIES="task" ;;
     windows/arm64) BINARIES="task" ;;
-    windows/armv5) BINARIES="task" ;;
-    windows/armv6) BINARIES="task" ;;
-    windows/armv7) BINARIES="task" ;;
+    windows/arm) BINARIES="task" ;;
     *)
       log_crit "platform $PLATFORM is not supported.  Make sure this script is up-to-date and file request at https://github.com/${PREFIX}/issues/new"
       exit 1

internal/compiler/compiler.go

@@ -1,194 +0,0 @@
-package compiler
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	"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/templater"
-	"github.com/go-task/task/v3/internal/version"
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-type Compiler struct {
-	Dir            string
-	Entrypoint     string
-	UserWorkingDir string
-
-	TaskfileEnv  *ast.Vars
-	TaskfileVars *ast.Vars
-
-	Logger *logger.Logger
-
-	dynamicCache   map[string]string
-	muDynamicCache sync.Mutex
-}
-
-func (c *Compiler) GetTaskfileVariables() (*ast.Vars, error) {
-	return c.getVariables(nil, nil, true)
-}
-
-func (c *Compiler) GetVariables(t *ast.Task, call *ast.Call) (*ast.Vars, error) {
-	return c.getVariables(t, call, true)
-}
-
-func (c *Compiler) FastGetVariables(t *ast.Task, call *ast.Call) (*ast.Vars, error) {
-	return c.getVariables(t, call, false)
-}
-
-func (c *Compiler) getVariables(t *ast.Task, call *ast.Call, evaluateShVars bool) (*ast.Vars, error) {
-	result := GetEnviron()
-	if t != nil {
-		specialVars, err := c.getSpecialVars(t, call)
-		if err != nil {
-			return nil, err
-		}
-		for k, v := range specialVars {
-			result.Set(k, ast.Var{Value: v})
-		}
-	}
-
-	getRangeFunc := func(dir string) func(k string, v ast.Var) error {
-		return func(k string, v ast.Var) error {
-			cache := &templater.Cache{Vars: result}
-			// Replace values
-			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
-			if !evaluateShVars && newVar.Value == nil {
-				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})
-				return nil
-			}
-			// Now we can check for errors since we've handled all the cases when we don't want to evaluate
-			if err := cache.Err(); err != nil {
-				return err
-			}
-			// If the variable is not dynamic, we can set it and return
-			if newVar.Value != nil || newVar.Sh == "" {
-				result.Set(k, ast.Var{Value: newVar.Value})
-				return nil
-			}
-			// If the variable is dynamic, we need to resolve it first
-			static, err := c.HandleDynamicVar(newVar, dir)
-			if err != nil {
-				return err
-			}
-			result.Set(k, ast.Var{Value: static})
-			return nil
-		}
-	}
-	rangeFunc := getRangeFunc(c.Dir)
-
-	var taskRangeFunc func(k string, v ast.Var) error
-	if t != nil {
-		// NOTE(@andreynering): We're manually joining these paths here because
-		// this is the raw task, not the compiled one.
-		cache := &templater.Cache{Vars: result}
-		dir := templater.Replace(t.Dir, cache)
-		if err := cache.Err(); err != nil {
-			return nil, err
-		}
-		dir = filepathext.SmartJoin(c.Dir, dir)
-		taskRangeFunc = getRangeFunc(dir)
-	}
-
-	if err := c.TaskfileEnv.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-	if err := c.TaskfileVars.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-	if t != nil {
-		if err := t.IncludeVars.Range(rangeFunc); err != nil {
-			return nil, err
-		}
-		if err := t.IncludedTaskfileVars.Range(taskRangeFunc); err != nil {
-			return nil, err
-		}
-	}
-
-	if t == nil || call == nil {
-		return result, nil
-	}
-
-	if err := call.Vars.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-	if err := t.Vars.Range(taskRangeFunc); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-func (c *Compiler) HandleDynamicVar(v ast.Var, dir string) (string, error) {
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	if c.dynamicCache == nil {
-		c.dynamicCache = make(map[string]string, 30)
-	}
-	if result, ok := c.dynamicCache[v.Sh]; ok {
-		return result, nil
-	}
-
-	// NOTE(@andreynering): If a var have a specific dir, use this instead
-	if v.Dir != "" {
-		dir = v.Dir
-	}
-
-	var stdout bytes.Buffer
-	opts := &execext.RunCommandOptions{
-		Command: v.Sh,
-		Dir:     dir,
-		Stdout:  &stdout,
-		Stderr:  c.Logger.Stderr,
-	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
-		return "", fmt.Errorf(`task: Command "%s" failed: %s`, opts.Command, err)
-	}
-
-	// Trim a single trailing newline from the result to make most command
-	// output easier to use in shell commands.
-	result := strings.TrimSuffix(stdout.String(), "\r\n")
-	result = strings.TrimSuffix(result, "\n")
-
-	c.dynamicCache[v.Sh] = result
-	c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", v.Sh, result)
-
-	return result, nil
-}
-
-// ResetCache clear the dymanic variables cache
-func (c *Compiler) ResetCache() {
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	c.dynamicCache = nil
-}
-
-func (c *Compiler) getSpecialVars(t *ast.Task, call *ast.Call) (map[string]string, error) {
-	return map[string]string{
-		"TASK":             t.Task,
-		"ALIAS":            call.Task,
-		"TASK_EXE":         filepath.ToSlash(os.Args[0]),
-		"ROOT_TASKFILE":    filepathext.SmartJoin(c.Dir, c.Entrypoint),
-		"ROOT_DIR":         c.Dir,
-		"TASKFILE":         t.Location.Taskfile,
-		"TASKFILE_DIR":     filepath.Dir(t.Location.Taskfile),
-		"USER_WORKING_DIR": c.UserWorkingDir,
-		"TASK_VERSION":     version.GetVersion(),
-	}, nil
-}

internal/compiler/env.go

@@ -1,20 +0,0 @@
-package compiler
-
-import (
-	"os"
-	"strings"
-
-	"github.com/go-task/task/v3/taskfile/ast"
-)
-
-// GetEnviron the all return all environment variables encapsulated on a
-// ast.Vars
-func GetEnviron() *ast.Vars {
-	m := &ast.Vars{}
-	for _, e := range os.Environ() {
-		keyVal := strings.SplitN(e, "=", 2)
-		key, val := keyVal[0], keyVal[1]
-		m.Set(key, ast.Var{Value: val})
-	}
-	return m
-}

internal/deepcopy/deepcopy.go

@@ -2,12 +2,23 @@ package deepcopy
 
 import (
 	"reflect"
+
+	"github.com/elliotchance/orderedmap/v3"
 )
 
 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
@@ -38,6 +49,21 @@ func Map[K comparable, V any](orig map[K]V) map[K]V {
 	return c
 }
 
+func OrderedMap[K comparable, V any](orig *orderedmap.OrderedMap[K, V]) *orderedmap.OrderedMap[K, V] {
+	if orig.Len() == 0 {
+		return orderedmap.NewOrderedMap[K, V]()
+	}
+	c := orderedmap.NewOrderedMap[K, V]()
+	for pair := orig.Front(); pair != nil; pair = pair.Next() {
+		if copyable, ok := any(pair.Value).(Copier[V]); ok {
+			c.Set(pair.Key, copyable.DeepCopy())
+		} else {
+			c.Set(pair.Key, pair.Value)
+		}
+	}
+	return c
+}
+
 // TraverseStringsFunc runs the given function on every string in the given
 // value by traversing it recursively. If the given value is a string, the
 // function will run on a copy of the string and return it. If the value is a
@@ -55,7 +81,7 @@ func TraverseStringsFunc[T any](v T, fn func(v string) (string, error)) (T, erro
 	traverseFunc = func(copy, v reflect.Value) error {
 		switch v.Kind() {
 
-		case reflect.Ptr:
+		case reflect.Pointer:
 			// Unwrap the pointer
 			originalValue := v.Elem()
 			// If the pointer is nil, do nothing

internal/editors/output.go

@@ -1,18 +1,24 @@
 package editors
 
+import (
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
 type (
-	// Taskfile wraps task list output for use in editor integrations (e.g. VSCode, etc)
-	Taskfile struct {
-		Tasks    []Task `json:"tasks"`
-		Location string `json:"location"`
+	// 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"`
 	}
 	// Task describes a single task
 	Task struct {
 		Name     string    `json:"name"`
+		Task     string    `json:"task"`
 		Desc     string    `json:"desc"`
 		Summary  string    `json:"summary"`
 		Aliases  []string  `json:"aliases"`
-		UpToDate bool      `json:"up_to_date"`
+		UpToDate *bool     `json:"up_to_date,omitempty"`
 		Location *Location `json:"location"`
 	}
 	// Location describes a task's location in a taskfile
@@ -22,3 +28,59 @@ 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)
+}

internal/env/env.go

@@ -3,21 +3,44 @@ package env
 import (
 	"fmt"
 	"os"
+	"strconv"
+	"strings"
+	"time"
 
-	"github.com/go-task/task/v3/internal/experiments"
+	"github.com/go-task/task/v3/experiments"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
+const taskVarPrefix = "TASK_"
+
+// GetEnviron the all return all environment variables encapsulated on a
+// ast.Vars
+func GetEnviron() *ast.Vars {
+	m := ast.NewVars()
+	for _, e := range os.Environ() {
+		keyVal := strings.SplitN(e, "=", 2)
+		key, val := keyVal[0], keyVal[1]
+		m.Set(key, ast.Var{Value: val})
+	}
+	return m
+}
+
 func Get(t *ast.Task) []string {
 	if t.Env == nil {
 		return nil
 	}
+
+	return GetFromVars(t.Env)
+}
+
+func GetFromVars(env *ast.Vars) []string {
 	environ := os.Environ()
-	for k, v := range t.Env.ToCacheMap() {
+
+	for k, v := range env.ToCacheMap() {
 		if !isTypeAllowed(v) {
 			continue
 		}
-		if !experiments.EnvPrecedence.Enabled {
+		if !experiments.EnvPrecedence.Enabled() {
 			if _, alreadySet := os.LookupEnv(k); alreadySet {
 				continue
 			}
@@ -36,3 +59,67 @@ func isTypeAllowed(v any) bool {
 		return false
 	}
 }
+
+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
+}

internal/execext/coreutils.go

@@ -0,0 +1,20 @@
+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"
+	}
+}

internal/execext/exec.go

@@ -2,21 +2,24 @@ package execext
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"strings"
-	"time"
 
+	"mvdan.cc/sh/moreinterp/coreutils"
 	"mvdan.cc/sh/v3/expand"
 	"mvdan.cc/sh/v3/interp"
-	"mvdan.cc/sh/v3/shell"
 	"mvdan.cc/sh/v3/syntax"
+
+	"github.com/go-task/task/v3/errors"
 )
 
-// RunCommandOptions is the options for the RunCommand func
+// ErrNilOptions is returned when a nil options is given
+var ErrNilOptions = errors.New("execext: nil options given")
+
+// RunCommandOptions is the options for the [RunCommand] func.
 type RunCommandOptions struct {
 	Command   string
 	Dir       string
@@ -28,9 +31,6 @@ type RunCommandOptions struct {
 	Stderr    io.Writer
 }
 
-// ErrNilOptions is returned when a nil options is given
-var ErrNilOptions = errors.New("execext: nil options given")
-
 // RunCommand runs a shell command
 func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 	if opts == nil {
@@ -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(execHandler),
+		interp.ExecHandlers(execHandlers()...),
 		interp.OpenHandler(openHandler),
 		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
 		dirOption(opts.Dir),
@@ -90,26 +90,63 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 	return r.Run(ctx, p)
 }
 
-// Expand is a helper to mvdan.cc/shell.Fields that returns the first field
-// if available.
-func Expand(s string) (string, error) {
+func escape(s string) string {
 	s = filepath.ToSlash(s)
 	s = strings.ReplaceAll(s, " ", `\ `)
 	s = strings.ReplaceAll(s, "&", `\&`)
 	s = strings.ReplaceAll(s, "(", `\(`)
 	s = strings.ReplaceAll(s, ")", `\)`)
-	fields, err := shell.Fields(s, nil)
+	return s
+}
+
+// ExpandLiteral is a wrapper around [expand.Literal]. It will escape the input
+// string, expand any shell symbols (such as '~') and resolve any environment
+// variables.
+func ExpandLiteral(s string) (string, error) {
+	if s == "" {
+		return "", nil
+	}
+	p := syntax.NewParser()
+	word, err := p.Document(strings.NewReader(s))
 	if err != nil {
 		return "", err
 	}
-	if len(fields) > 0 {
-		return fields[0], nil
+	cfg := &expand.Config{
+		Env:      expand.FuncEnviron(os.Getenv),
+		ReadDir2: os.ReadDir,
+		GlobStar: true,
 	}
-	return "", nil
+	return expand.Literal(cfg, word)
 }
 
-func execHandler(next interp.ExecHandlerFunc) interp.ExecHandlerFunc {
-	return interp.DefaultExecHandler(15 * time.Second)
+// ExpandFields is a wrapper around [expand.Fields]. It will escape the input
+// string, expand any shell symbols (such as '~') and resolve any environment
+// variables. It also expands brace expressions ({a.b}) and globs (*/**) and
+// returns the results as a list of strings.
+func ExpandFields(s string) ([]string, error) {
+	s = escape(s)
+	p := syntax.NewParser()
+	var words []*syntax.Word
+	for w, err := range p.WordsSeq(strings.NewReader(s)) {
+		if err != nil {
+			return nil, err
+		}
+		words = append(words, w)
+	}
+	cfg := &expand.Config{
+		Env:      expand.FuncEnviron(os.Getenv),
+		ReadDir2: os.ReadDir,
+		GlobStar: true,
+		NullGlob: true,
+	}
+	return expand.Fields(cfg, words...)
+}
+
+func execHandlers() (handlers []func(next interp.ExecHandlerFunc) interp.ExecHandlerFunc) {
+	if useGoCoreUtils {
+		handlers = append(handlers, coreutils.ExecHandler)
+	}
+	return handlers
 }
 
 func openHandler(ctx context.Context, path string, flag int, perm os.FileMode) (io.ReadWriteCloser, error) {

internal/exp/maps.go

@@ -1,26 +0,0 @@
-// This package is intended as a place to copy functions from the
-// golang.org/x/exp package. Copying these functions allows us to rely on our
-// own code instead of an external package that may change unpredictably in the
-// future.
-//
-// It also prevents problems with transitive dependencies whereby a
-// package that imports Task (and therefore our version of golang.org/x/exp)
-// cannot import a different version of golang.org/x/exp.
-//
-// Finally, it serves as a place to track functions that may be able to be
-// removed in the future if they are added to the standard library. This is also
-// why this package is under the internal directory since these functions are
-// not intended to be used outside of Task.
-package exp
-
-import "cmp"
-
-// Keys is a copy of https://pkg.go.dev/golang.org/x/exp@v0.0.0-20240103183307-be819d1f06fc/maps#Keys.
-// This is not yet included in the standard library. See https://github.com/golang/go/issues/61538.
-func Keys[K cmp.Ordered, V any](m map[K]V) []K {
-	var keys []K
-	for key := range m {
-		keys = append(keys, key)
-	}
-	return keys
-}

internal/experiments/experiments.go

@@ -1,112 +0,0 @@
-package experiments
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-
-	"github.com/Ladicle/tabwriter"
-	"github.com/joho/godotenv"
-	"github.com/spf13/pflag"
-
-	"github.com/go-task/task/v3/internal/logger"
-)
-
-const envPrefix = "TASK_X_"
-
-type Experiment struct {
-	Name    string
-	Enabled bool
-	Value   string
-}
-
-// A list of experiments.
-var (
-	GentleForce     Experiment
-	RemoteTaskfiles Experiment
-	AnyVariables    Experiment
-	MapVariables    Experiment
-	EnvPrecedence   Experiment
-)
-
-func init() {
-	readDotEnv()
-	GentleForce = New("GENTLE_FORCE")
-	RemoteTaskfiles = New("REMOTE_TASKFILES")
-	AnyVariables = New("ANY_VARIABLES", "1", "2")
-	MapVariables = New("MAP_VARIABLES", "1", "2")
-	EnvPrecedence = New("ENV_PRECEDENCE")
-}
-
-func New(xName string, enabledValues ...string) Experiment {
-	if len(enabledValues) == 0 {
-		enabledValues = []string{"1"}
-	}
-	value := getEnv(xName)
-	return Experiment{
-		Name:    xName,
-		Enabled: slices.Contains(enabledValues, value),
-		Value:   value,
-	}
-}
-
-func (x Experiment) String() string {
-	if x.Enabled {
-		return fmt.Sprintf("on (%s)", x.Value)
-	}
-	return "off"
-}
-
-func getEnv(xName string) string {
-	envName := fmt.Sprintf("%s%s", envPrefix, xName)
-	return os.Getenv(envName)
-}
-
-func getEnvFilePath() string {
-	// Parse the CLI flags again to get the directory/taskfile being run
-	// We use a flagset here so that we can parse a subset of flags without exiting on error.
-	var dir, taskfile string
-	fs := pflag.NewFlagSet("experiments", pflag.ContinueOnError)
-	fs.StringVarP(&dir, "dir", "d", "", "Sets directory of execution.")
-	fs.StringVarP(&taskfile, "taskfile", "t", "", `Choose which Taskfile to run. Defaults to "Taskfile.yml".`)
-	fs.Usage = func() {}
-	_ = fs.Parse(os.Args[1:])
-	// If the directory is set, find a .env file in that directory.
-	if dir != "" {
-		return filepath.Join(dir, ".env")
-	}
-	// If the taskfile is set, find a .env file in the directory containing the Taskfile.
-	if taskfile != "" {
-		return filepath.Join(filepath.Dir(taskfile), ".env")
-	}
-	// Otherwise just use the current working directory.
-	return ".env"
-}
-
-func readDotEnv() {
-	env, _ := godotenv.Read(getEnvFilePath())
-	// If the env var is an experiment, set it.
-	for key, value := range env {
-		if strings.HasPrefix(key, envPrefix) {
-			os.Setenv(key, value)
-		}
-	}
-}
-
-func printExperiment(w io.Writer, l *logger.Logger, x Experiment) {
-	l.FOutf(w, logger.Yellow, "* ")
-	l.FOutf(w, logger.Green, x.Name)
-	l.FOutf(w, logger.Default, ": \t%s\n", x.String())
-}
-
-func List(l *logger.Logger) error {
-	w := tabwriter.NewWriter(os.Stdout, 0, 8, 0, ' ', 0)
-	printExperiment(w, l, GentleForce)
-	printExperiment(w, l, RemoteTaskfiles)
-	printExperiment(w, l, MapVariables)
-	printExperiment(w, l, EnvPrecedence)
-	return w.Flush()
-}

internal/filepathext/filepathext.go

@@ -55,3 +55,9 @@ func TryAbsToRel(abs string) string {
 
 	return rel
 }
+
+// IsExtOnly checks whether path points to a file with no name but with
+// an extension, i.e. ".yaml"
+func IsExtOnly(path string) bool {
+	return filepath.Base(path) == filepath.Ext(path)
+}

internal/fingerprint/checker_mock.go

@@ -0,0 +1,320 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package fingerprint
+
+import (
+	"context"
+
+	"github.com/go-task/task/v3/taskfile/ast"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMockStatusCheckable creates a new instance of MockStatusCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockStatusCheckable(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockStatusCheckable {
+	mock := &MockStatusCheckable{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockStatusCheckable is an autogenerated mock type for the StatusCheckable type
+type MockStatusCheckable struct {
+	mock.Mock
+}
+
+type MockStatusCheckable_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockStatusCheckable) EXPECT() *MockStatusCheckable_Expecter {
+	return &MockStatusCheckable_Expecter{mock: &_m.Mock}
+}
+
+// IsUpToDate provides a mock function for the type MockStatusCheckable
+func (_mock *MockStatusCheckable) IsUpToDate(ctx context.Context, t *ast.Task) (bool, error) {
+	ret := _mock.Called(ctx, t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IsUpToDate")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *ast.Task) (bool, error)); ok {
+		return returnFunc(ctx, t)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *ast.Task) bool); ok {
+		r0 = returnFunc(ctx, t)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *ast.Task) error); ok {
+		r1 = returnFunc(ctx, t)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockStatusCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
+type MockStatusCheckable_IsUpToDate_Call struct {
+	*mock.Call
+}
+
+// IsUpToDate is a helper method to define mock.On call
+//   - ctx
+//   - t
+func (_e *MockStatusCheckable_Expecter) IsUpToDate(ctx interface{}, t interface{}) *MockStatusCheckable_IsUpToDate_Call {
+	return &MockStatusCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", ctx, t)}
+}
+
+func (_c *MockStatusCheckable_IsUpToDate_Call) Run(run func(ctx context.Context, t *ast.Task)) *MockStatusCheckable_IsUpToDate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *MockStatusCheckable_IsUpToDate_Call) Return(b bool, err error) *MockStatusCheckable_IsUpToDate_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *MockStatusCheckable_IsUpToDate_Call) RunAndReturn(run func(ctx context.Context, t *ast.Task) (bool, error)) *MockStatusCheckable_IsUpToDate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockSourcesCheckable creates a new instance of MockSourcesCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockSourcesCheckable(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSourcesCheckable {
+	mock := &MockSourcesCheckable{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockSourcesCheckable is an autogenerated mock type for the SourcesCheckable type
+type MockSourcesCheckable struct {
+	mock.Mock
+}
+
+type MockSourcesCheckable_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockSourcesCheckable) EXPECT() *MockSourcesCheckable_Expecter {
+	return &MockSourcesCheckable_Expecter{mock: &_m.Mock}
+}
+
+// IsUpToDate provides a mock function for the type MockSourcesCheckable
+func (_mock *MockSourcesCheckable) IsUpToDate(t *ast.Task) (bool, error) {
+	ret := _mock.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IsUpToDate")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) (bool, error)); ok {
+		return returnFunc(t)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) bool); ok {
+		r0 = returnFunc(t)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(*ast.Task) error); ok {
+		r1 = returnFunc(t)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockSourcesCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
+type MockSourcesCheckable_IsUpToDate_Call struct {
+	*mock.Call
+}
+
+// IsUpToDate is a helper method to define mock.On call
+//   - t
+func (_e *MockSourcesCheckable_Expecter) IsUpToDate(t interface{}) *MockSourcesCheckable_IsUpToDate_Call {
+	return &MockSourcesCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", t)}
+}
+
+func (_c *MockSourcesCheckable_IsUpToDate_Call) Run(run func(t *ast.Task)) *MockSourcesCheckable_IsUpToDate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *MockSourcesCheckable_IsUpToDate_Call) Return(b bool, err error) *MockSourcesCheckable_IsUpToDate_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *MockSourcesCheckable_IsUpToDate_Call) RunAndReturn(run func(t *ast.Task) (bool, error)) *MockSourcesCheckable_IsUpToDate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Kind provides a mock function for the type MockSourcesCheckable
+func (_mock *MockSourcesCheckable) Kind() string {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Kind")
+	}
+
+	var r0 string
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	return r0
+}
+
+// MockSourcesCheckable_Kind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Kind'
+type MockSourcesCheckable_Kind_Call struct {
+	*mock.Call
+}
+
+// Kind is a helper method to define mock.On call
+func (_e *MockSourcesCheckable_Expecter) Kind() *MockSourcesCheckable_Kind_Call {
+	return &MockSourcesCheckable_Kind_Call{Call: _e.mock.On("Kind")}
+}
+
+func (_c *MockSourcesCheckable_Kind_Call) Run(run func()) *MockSourcesCheckable_Kind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSourcesCheckable_Kind_Call) Return(s string) *MockSourcesCheckable_Kind_Call {
+	_c.Call.Return(s)
+	return _c
+}
+
+func (_c *MockSourcesCheckable_Kind_Call) RunAndReturn(run func() string) *MockSourcesCheckable_Kind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OnError provides a mock function for the type MockSourcesCheckable
+func (_mock *MockSourcesCheckable) OnError(t *ast.Task) error {
+	ret := _mock.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnError")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) error); ok {
+		r0 = returnFunc(t)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockSourcesCheckable_OnError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnError'
+type MockSourcesCheckable_OnError_Call struct {
+	*mock.Call
+}
+
+// OnError is a helper method to define mock.On call
+//   - t
+func (_e *MockSourcesCheckable_Expecter) OnError(t interface{}) *MockSourcesCheckable_OnError_Call {
+	return &MockSourcesCheckable_OnError_Call{Call: _e.mock.On("OnError", t)}
+}
+
+func (_c *MockSourcesCheckable_OnError_Call) Run(run func(t *ast.Task)) *MockSourcesCheckable_OnError_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *MockSourcesCheckable_OnError_Call) Return(err error) *MockSourcesCheckable_OnError_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockSourcesCheckable_OnError_Call) RunAndReturn(run func(t *ast.Task) error) *MockSourcesCheckable_OnError_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Value provides a mock function for the type MockSourcesCheckable
+func (_mock *MockSourcesCheckable) Value(t *ast.Task) (any, error) {
+	ret := _mock.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Value")
+	}
+
+	var r0 any
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) (any, error)); ok {
+		return returnFunc(t)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) any); ok {
+		r0 = returnFunc(t)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(any)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*ast.Task) error); ok {
+		r1 = returnFunc(t)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockSourcesCheckable_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Value'
+type MockSourcesCheckable_Value_Call struct {
+	*mock.Call
+}
+
+// Value is a helper method to define mock.On call
+//   - t
+func (_e *MockSourcesCheckable_Expecter) Value(t interface{}) *MockSourcesCheckable_Value_Call {
+	return &MockSourcesCheckable_Value_Call{Call: _e.mock.On("Value", t)}
+}
+
+func (_c *MockSourcesCheckable_Value_Call) Run(run func(t *ast.Task)) *MockSourcesCheckable_Value_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *MockSourcesCheckable_Value_Call) Return(v any, err error) *MockSourcesCheckable_Value_Call {
+	_c.Call.Return(v, err)
+	return _c
+}
+
+func (_c *MockSourcesCheckable_Value_Call) RunAndReturn(run func(t *ast.Task) (any, error)) *MockSourcesCheckable_Value_Call {
+	_c.Call.Return(run)
+	return _c
+}

internal/fingerprint/glob.go

@@ -2,49 +2,37 @@ package fingerprint
 
 import (
 	"os"
+	"path/filepath"
 	"sort"
 
-	"github.com/mattn/go-zglob"
-
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func Globs(dir string, globs []*ast.Glob) ([]string, error) {
-	fileMap := make(map[string]bool)
+	resultMap := make(map[string]bool)
 	for _, g := range globs {
-		matches, err := Glob(dir, g.Glob)
+		matches, err := glob(dir, g.Glob)
 		if err != nil {
 			continue
 		}
 		for _, match := range matches {
-			fileMap[match] = !g.Negate
+			resultMap[match] = !g.Negate
 		}
 	}
-	files := make([]string, 0)
-	for file, includePath := range fileMap {
-		if includePath {
-			files = append(files, file)
-		}
-	}
-	sort.Strings(files)
-	return files, nil
+	return collectKeys(resultMap), nil
 }
 
-func Glob(dir string, g string) ([]string, error) {
-	files := make([]string, 0)
+func glob(dir string, g string) ([]string, error) {
 	g = filepathext.SmartJoin(dir, g)
 
-	g, err := execext.Expand(g)
+	fs, err := execext.ExpandFields(g)
 	if err != nil {
 		return nil, err
 	}
 
-	fs, err := zglob.GlobFollowSymlinks(g)
-	if err != nil {
-		return nil, err
-	}
+	results := make(map[string]bool, len(fs))
 
 	for _, f := range fs {
 		info, err := os.Stat(f)
@@ -54,7 +42,19 @@ func Glob(dir string, g string) ([]string, error) {
 		if info.IsDir() {
 			continue
 		}
-		files = append(files, f)
+		results[f] = true
 	}
-	return files, nil
+	return collectKeys(results), nil
+}
+
+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))
+		}
+	}
+	sort.Strings(keys)
+	return keys
 }

internal/fingerprint/sources_checksum.go

@@ -53,10 +53,11 @@ 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
 			}
-			generates, err := Glob(t.Dir, g.Glob)
+			generates, err := glob(t.Dir, g.Glob)
 			if os.IsNotExist(err) {
 				return false, nil
 			}

internal/fingerprint/sources_checksum_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestNormalizeFilename(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		In, Out string
 	}{

internal/fingerprint/sources_timestamp.go

@@ -32,6 +32,28 @@ 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

internal/fingerprint/task_test.go

@@ -1,14 +1,12 @@
 package fingerprint
 
 import (
-	"context"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
-	"github.com/go-task/task/v3/internal/mocks"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
@@ -26,11 +24,13 @@ import (
 // | false             | true               | false              |
 // | false             | false              | false              |
 func TestIsTaskUpToDate(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		name                    string
 		task                    *ast.Task
-		setupMockStatusChecker  func(m *mocks.StatusCheckable)
-		setupMockSourcesChecker func(m *mocks.SourcesCheckable)
+		setupMockStatusChecker  func(m *MockStatusCheckable)
+		setupMockSourcesChecker func(m *MockSourcesCheckable)
 		expected                bool
 	}{
 		{
@@ -50,7 +50,7 @@ func TestIsTaskUpToDate(t *testing.T) {
 				Sources: []*ast.Glob{{Glob: "sources"}},
 			},
 			setupMockStatusChecker: nil,
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+			setupMockSourcesChecker: func(m *MockSourcesCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil)
 			},
 			expected: true,
@@ -62,7 +62,7 @@ func TestIsTaskUpToDate(t *testing.T) {
 				Sources: []*ast.Glob{{Glob: "sources"}},
 			},
 			setupMockStatusChecker: nil,
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+			setupMockSourcesChecker: func(m *MockSourcesCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil)
 			},
 			expected: false,
@@ -73,7 +73,7 @@ func TestIsTaskUpToDate(t *testing.T) {
 				Status:  []string{"status"},
 				Sources: nil,
 			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+			setupMockStatusChecker: func(m *MockStatusCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil)
 			},
 			setupMockSourcesChecker: nil,
@@ -85,10 +85,10 @@ func TestIsTaskUpToDate(t *testing.T) {
 				Status:  []string{"status"},
 				Sources: []*ast.Glob{{Glob: "sources"}},
 			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+			setupMockStatusChecker: func(m *MockStatusCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil)
 			},
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+			setupMockSourcesChecker: func(m *MockSourcesCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil)
 			},
 			expected: true,
@@ -99,10 +99,10 @@ func TestIsTaskUpToDate(t *testing.T) {
 				Status:  []string{"status"},
 				Sources: []*ast.Glob{{Glob: "sources"}},
 			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+			setupMockStatusChecker: func(m *MockStatusCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil)
 			},
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+			setupMockSourcesChecker: func(m *MockSourcesCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil)
 			},
 			expected: false,
@@ -113,7 +113,7 @@ func TestIsTaskUpToDate(t *testing.T) {
 				Status:  []string{"status"},
 				Sources: nil,
 			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+			setupMockStatusChecker: func(m *MockStatusCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil)
 			},
 			setupMockSourcesChecker: nil,
@@ -125,10 +125,10 @@ func TestIsTaskUpToDate(t *testing.T) {
 				Status:  []string{"status"},
 				Sources: []*ast.Glob{{Glob: "sources"}},
 			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+			setupMockStatusChecker: func(m *MockStatusCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil)
 			},
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+			setupMockSourcesChecker: func(m *MockSourcesCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil)
 			},
 			expected: false,
@@ -139,10 +139,10 @@ func TestIsTaskUpToDate(t *testing.T) {
 				Status:  []string{"status"},
 				Sources: []*ast.Glob{{Glob: "sources"}},
 			},
-			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+			setupMockStatusChecker: func(m *MockStatusCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil)
 			},
-			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+			setupMockSourcesChecker: func(m *MockSourcesCheckable) {
 				m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil)
 			},
 			expected: false,
@@ -150,18 +150,20 @@ func TestIsTaskUpToDate(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			mockStatusChecker := mocks.NewStatusCheckable(t)
+			t.Parallel()
+
+			mockStatusChecker := NewMockStatusCheckable(t)
 			if tt.setupMockStatusChecker != nil {
 				tt.setupMockStatusChecker(mockStatusChecker)
 			}
 
-			mockSourcesChecker := mocks.NewSourcesCheckable(t)
+			mockSourcesChecker := NewMockSourcesCheckable(t)
 			if tt.setupMockSourcesChecker != nil {
 				tt.setupMockSourcesChecker(mockSourcesChecker)
 			}
 
 			result, err := IsTaskUpToDate(
-				context.Background(),
+				t.Context(),
 				tt.task,
 				WithStatusChecker(mockStatusChecker),
 				WithSourcesChecker(mockSourcesChecker),

internal/flags/flags.go

@@ -1,15 +1,24 @@
 package flags
 
 import (
-	"errors"
+	"cmp"
 	"log"
 	"os"
+	"path/filepath"
+	"strconv"
 	"time"
 
+	"github.com/fatih/color"
 	"github.com/spf13/pflag"
 
-	"github.com/go-task/task/v3/internal/experiments"
+	"github.com/go-task/task/v3"
+	"github.com/go-task/task/v3/errors"
+	"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/ast"
+	"github.com/go-task/task/v3/taskrc"
+	taskrcast "github.com/go-task/task/v3/taskrc/ast"
 )
 
 const usage = `Usage: task [flags...] [task...]
@@ -35,42 +44,74 @@ Options:
 `
 
 var (
-	Version     bool
-	Help        bool
-	Init        bool
-	Completion  string
-	List        bool
-	ListAll     bool
-	ListJson    bool
-	TaskSort    string
-	Status      bool
-	NoStatus    bool
-	Insecure    bool
-	Force       bool
-	ForceAll    bool
-	Watch       bool
-	Verbose     bool
-	Silent      bool
-	AssumeYes   bool
-	Dry         bool
-	Summary     bool
-	ExitCode    bool
-	Parallel    bool
-	Concurrency int
-	Dir         string
-	Entrypoint  string
-	Output      ast.Output
-	Color       bool
-	Interval    time.Duration
-	Global      bool
-	Experiments bool
-	Download    bool
-	Offline     bool
-	ClearCache  bool
-	Timeout     time.Duration
+	Version             bool
+	Help                bool
+	Init                bool
+	Completion          string
+	List                bool
+	ListAll             bool
+	ListJson            bool
+	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
+	ExitCode            bool
+	Parallel            bool
+	Concurrency         int
+	Dir                 string
+	Entrypoint          string
+	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() {
+	// Config files can enable experiments which alter the availability and/or
+	// behavior of some flags, so we need to parse the experiments before the
+	// flags. However, we need the --taskfile and --dir flags before we can
+	// parse the experiments as they can alter the location of the config files.
+	// Because of this circular dependency, we parse the flags twice. First, we
+	// get the --taskfile and --dir flags, then we parse the experiments, then
+	// we parse the flags again to get the full set. We use a flagset here so
+	// that we can parse a subset of flags without exiting on error.
+	var dir, entrypoint string
+	fs := pflag.NewFlagSet("experiments", pflag.ContinueOnError)
+	fs.StringVarP(&dir, "dir", "d", "", "")
+	fs.StringVarP(&entrypoint, "taskfile", "t", "", "")
+	fs.Usage = func() {}
+	_ = fs.Parse(os.Args[1:])
+
+	// Parse the experiments
+	dir = cmp.Or(dir, filepath.Dir(entrypoint))
+
+	config, _ := taskrc.GetConfig(dir)
+	experiments.ParseWithConfig(dir, config)
+
+	// Parse the rest of the flags
 	log.SetFlags(0)
 	log.SetOutput(os.Stderr)
 	pflag.Usage = func() {
@@ -88,29 +129,33 @@ 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(&Insecure, "insecure", false, "Forces Task to download Taskfiles over insecure connections.")
+	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.BoolVarP(&Watch, "watch", "w", false, "Enables watch of the given task.")
-	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(&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(&Parallel, "parallel", "p", false, "Executes tasks provided on command line in parallel.")
-	pflag.BoolVarP(&Dry, "dry", "n", false, "Compiles and prints tasks in the order that they would be run, without executing them.")
+	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.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 directory of execution.")
+	pflag.StringVarP(&Dir, "dir", "d", "", "Sets the directory in which Task will execute and look for a Taskfile.")
 	pflag.StringVarP(&Entrypoint, "taskfile", "t", "", `Choose which Taskfile to run. Defaults to "Taskfile.yml".`)
 	pflag.StringVarP(&Output.Name, "output", "o", "", "Sets output style: [interleaved|group|prefixed].")
 	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", 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 tasks to run concurrently.")
+	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.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.")
 
 	// Gentle force experiment will override the force flag and add a new force-all flag
-	if experiments.GentleForce.Enabled {
+	if experiments.GentleForce.Enabled() {
 		pflag.BoolVarP(&Force, "force", "f", false, "Forces execution of the directly called task.")
 		pflag.BoolVar(&ForceAll, "force-all", false, "Forces execution of the called task and all its dependant tasks.")
 	} else {
@@ -118,14 +163,42 @@ func init() {
 	}
 
 	// Remote Taskfiles experiment will adds the "download" and "offline" flags
-	if experiments.RemoteTaskfiles.Enabled {
+	if experiments.RemoteTaskfiles.Enabled() {
 		pflag.BoolVar(&Download, "download", false, "Downloads a cached version of a remote Taskfile.")
-		pflag.BoolVar(&Offline, "offline", false, "Forces Task to only use local or cached Taskfiles.")
-		pflag.DurationVar(&Timeout, "timeout", time.Second*10, "Timeout for downloading remote Taskfiles.")
+		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(&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.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 {
@@ -138,8 +211,7 @@ func Validate() error {
 	}
 
 	if Global && Dir != "" {
-		log.Fatal("task: You can't set both --global and --dir")
-		return nil
+		return errors.New("task: You can't set both --global and --dir")
 	}
 
 	if Output.Name != "group" {
@@ -154,5 +226,130 @@ func Validate() error {
 		}
 	}
 
+	if List && ListAll {
+		return errors.New("task: cannot use --list and --list-all at the same time")
+	}
+
+	if ListJson && !List && !ListAll {
+		return errors.New("task: --json only applies to --list or --list-all")
+	}
+
+	if NoStatus && !ListJson {
+		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 {
+	return &flagsOption{}
+}
+
+type flagsOption struct{}
+
+func (o *flagsOption) ApplyToExecutor(e *task.Executor) {
+	// Set the sorter
+	var sorter sort.Sorter
+	switch TaskSort {
+	case "none":
+		sorter = sort.NoSort
+	case "alphanumeric":
+		sorter = sort.AlphaNumeric
+	}
+
+	// Change the directory to the user's home directory if the global flag is set
+	dir := Dir
+	if Global {
+		home, err := os.UserHomeDir()
+		if err == nil {
+			dir = home
+		}
+	}
+
+	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),
+		task.WithColor(Color),
+		task.WithConcurrency(Concurrency),
+		task.WithInterval(Interval),
+		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
+}

internal/fsext/fs.go

@@ -0,0 +1,208 @@
+package fsext
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/internal/sysinfo"
+)
+
+// DefaultDir will return the default directory given an entrypoint or
+// directory. If the directory is set, it will ensure it is an absolute path and
+// return it. If the entrypoint is set, but the directory is not, it will leave
+// the directory blank. If both are empty, it will default the directory to the
+// current working directory.
+func DefaultDir(entrypoint, dir string) string {
+	// If the directory is set, ensure it is an absolute path
+	if dir != "" {
+		var err error
+		dir, err = filepath.Abs(dir)
+		if err != nil {
+			return ""
+		}
+		return dir
+	}
+
+	// If the entrypoint and dir are empty, we default the directory to the current working directory
+	if entrypoint == "" {
+		wd, err := os.Getwd()
+		if err != nil {
+			return ""
+		}
+		return wd
+	}
+
+	// If the entrypoint is set, but the directory is not, we leave the directory blank
+	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
+// 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
+// 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) {
+	var err error
+	if entrypoint != "" {
+		entrypoint, err = SearchPath(entrypoint, possibleFilenames)
+		if err != nil {
+			return "", err
+		}
+		return entrypoint, nil
+	}
+	if dir == "" {
+		dir, err = os.Getwd()
+		if err != nil {
+			return "", err
+		}
+	}
+	entrypoint, err = SearchPathRecursively(dir, possibleFilenames)
+	if err != nil {
+		return "", err
+	}
+	return entrypoint, 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
+// error will be returned.
+func SearchPath(path string, possibleFilenames []string) (string, error) {
+	// Get file info about the path
+	fi, err := os.Stat(path)
+	if err != nil {
+		return "", err
+	}
+
+	// If the path exists and is a regular file, device, symlink, or named pipe,
+	// return the absolute path to it
+	if fi.Mode().IsRegular() ||
+		fi.Mode()&os.ModeDevice != 0 ||
+		fi.Mode()&os.ModeSymlink != 0 ||
+		fi.Mode()&os.ModeNamedPipe != 0 {
+		return filepath.Abs(path)
+	}
+
+	// If the path is a directory, check if any of the possible names exist
+	// in that directory
+	for _, filename := range possibleFilenames {
+		alt := filepathext.SmartJoin(path, filename)
+		if _, err := os.Stat(alt); err == nil {
+			return filepath.Abs(alt)
+		}
+	}
+
+	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.
+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
+	}
+
+	for n == -1 || len(paths) < n {
+		fpath, err := SearchPath(path, possibleFilenames)
+		if err == nil {
+			paths = append(paths, fpath)
+		}
+
+		// Get the parent path/user id
+		parentPath := filepath.Dir(path)
+		parentOwner, err := sysinfo.Owner(parentPath)
+		if err != nil {
+			return nil, 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
+		}
+
+		owner = parentOwner
+		path = parentPath
+	}
+
+	return paths, nil
+}

internal/fsext/fs_test.go

@@ -0,0 +1,224 @@
+package fsext
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDefaultDir(t *testing.T) {
+	t.Parallel()
+
+	wd, err := os.Getwd()
+	require.NoError(t, err)
+
+	tests := []struct {
+		name       string
+		entrypoint string
+		dir        string
+		expected   string
+	}{
+		{
+			name:       "default to current working directory",
+			entrypoint: "",
+			dir:        "",
+			expected:   wd,
+		},
+		{
+			name:       "resolves relative dir path",
+			entrypoint: "",
+			dir:        "./dir",
+			expected:   filepath.Join(wd, "dir"),
+		},
+		{
+			name:       "return entrypoint if set",
+			entrypoint: filepath.Join(wd, "entrypoint"),
+			dir:        "",
+			expected:   "",
+		},
+		{
+			name:       "if entrypoint and dir are set",
+			entrypoint: filepath.Join(wd, "entrypoint"),
+			dir:        filepath.Join(wd, "dir"),
+			expected:   filepath.Join(wd, "dir"),
+		},
+		{
+			name:       "if entrypoint and dir are set and dir is relative",
+			entrypoint: filepath.Join(wd, "entrypoint"),
+			dir:        "./dir",
+			expected:   filepath.Join(wd, "dir"),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			require.Equal(t, tt.expected, DefaultDir(tt.entrypoint, tt.dir))
+		})
+	}
+}
+
+func TestSearch(t *testing.T) {
+	t.Parallel()
+
+	wd, err := os.Getwd()
+	require.NoError(t, err)
+
+	tests := []struct {
+		name               string
+		entrypoint         string
+		dir                string
+		possibleFilenames  []string
+		expectedEntrypoint string
+	}{
+		{
+			name:               "find foo.txt using relative entrypoint",
+			entrypoint:         "./testdata/foo.txt",
+			possibleFilenames:  []string{"foo.txt"},
+			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+		},
+		{
+			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"),
+		},
+		{
+			name:               "find foo.txt using relative dir",
+			dir:                "./testdata",
+			possibleFilenames:  []string{"foo.txt"},
+			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+		},
+		{
+			name:               "find foo.txt using absolute dir",
+			dir:                filepath.Join(wd, "testdata"),
+			possibleFilenames:  []string{"foo.txt"},
+			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+		},
+		{
+			name:               "find foo.txt using relative dir and relative entrypoint",
+			entrypoint:         "./testdata/foo.txt",
+			dir:                "./testdata/some/other/dir",
+			possibleFilenames:  []string{"foo.txt"},
+			expectedEntrypoint: filepath.Join(wd, "testdata", "foo.txt"),
+		},
+		{
+			name:               "find fs.go using no entrypoint or dir",
+			entrypoint:         "",
+			dir:                "",
+			possibleFilenames:  []string{"fs.go"},
+			expectedEntrypoint: filepath.Join(wd, "fs.go"),
+		},
+		{
+			name:               "find ../../Taskfile.yml using no entrypoint or dir by walking",
+			entrypoint:         "",
+			dir:                "",
+			possibleFilenames:  []string{"Taskfile.yml"},
+			expectedEntrypoint: filepath.Join(wd, "..", "..", "Taskfile.yml"),
+		},
+		{
+			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"),
+		},
+		{
+			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"),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			entrypoint, 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)
+		})
+	}
+}

internal/fsnotifyext/fsnotify_dedup.go

@@ -0,0 +1,51 @@
+package fsnotifyext
+
+import (
+	"math"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+)
+
+type Deduper struct {
+	w        *fsnotify.Watcher
+	waitTime time.Duration
+}
+
+func NewDeduper(w *fsnotify.Watcher, waitTime time.Duration) *Deduper {
+	return &Deduper{
+		w:        w,
+		waitTime: waitTime,
+	}
+}
+
+// GetChan returns a chan of deduplicated [fsnotify.Event].
+//
+// [fsnotify.Chmod] operations will be skipped.
+func (d *Deduper) GetChan() <-chan fsnotify.Event {
+	channel := make(chan fsnotify.Event)
+
+	go func() {
+		timers := make(map[string]*time.Timer)
+		for {
+			event, ok := <-d.w.Events
+			switch {
+			case !ok:
+				return
+			case event.Has(fsnotify.Chmod):
+				continue
+			}
+
+			timer, ok := timers[event.String()]
+			if !ok {
+				timer = time.AfterFunc(math.MaxInt64, func() { channel <- event })
+				timer.Stop()
+				timers[event.String()] = timer
+			}
+
+			timer.Reset(d.waitTime)
+		}
+	}()
+
+	return channel
+}

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:%d", t.Task, h), err
+	return fmt.Sprintf("%s:%s:%d", t.Location.Taskfile, t.LocalName(), h), err
 }

internal/input/input.go

@@ -0,0 +1,211 @@
+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())
+}

internal/logger/logger.go

@@ -3,14 +3,16 @@ package logger
 import (
 	"bufio"
 	"io"
-	"os"
 	"slices"
 	"strconv"
 	"strings"
 
+	"github.com/Ladicle/tabwriter"
 	"github.com/fatih/color"
 
 	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/experiments"
+	"github.com/go-task/task/v3/internal/env"
 	"github.com/go-task/task/v3/internal/term"
 )
 
@@ -19,70 +21,88 @@ var (
 	ErrNoTerminal      = errors.New("no terminal")
 )
 
+var (
+	attrsReset       = envColor("COLOR_RESET", color.Reset)
+	attrsFgBlue      = envColor("COLOR_BLUE", color.FgBlue)
+	attrsFgGreen     = envColor("COLOR_GREEN", color.FgGreen)
+	attrsFgCyan      = envColor("COLOR_CYAN", color.FgCyan)
+	attrsFgYellow    = envColor("COLOR_YELLOW", color.FgYellow)
+	attrsFgMagenta   = envColor("COLOR_MAGENTA", color.FgMagenta)
+	attrsFgRed       = envColor("COLOR_RED", color.FgRed)
+	attrsFgHiBlue    = envColor("COLOR_BRIGHT_BLUE", color.FgHiBlue)
+	attrsFgHiGreen   = envColor("COLOR_BRIGHT_GREEN", color.FgHiGreen)
+	attrsFgHiCyan    = envColor("COLOR_BRIGHT_CYAN", color.FgHiCyan)
+	attrsFgHiYellow  = envColor("COLOR_BRIGHT_YELLOW", color.FgHiYellow)
+	attrsFgHiMagenta = envColor("COLOR_BRIGHT_MAGENTA", color.FgHiMagenta)
+	attrsFgHiRed     = envColor("COLOR_BRIGHT_RED", color.FgHiRed)
+)
+
 type (
 	Color     func() PrintFunc
 	PrintFunc func(io.Writer, string, ...any)
 )
 
+func None() PrintFunc {
+	c := color.New()
+	c.DisableColor()
+	return c.FprintfFunc()
+}
+
 func Default() PrintFunc {
-	return color.New(envColor("TASK_COLOR_RESET", color.Reset)...).FprintfFunc()
+	return color.New(attrsReset...).FprintfFunc()
 }
 
 func Blue() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BLUE", color.FgBlue)...).FprintfFunc()
+	return color.New(attrsFgBlue...).FprintfFunc()
 }
 
 func Green() PrintFunc {
-	return color.New(envColor("TASK_COLOR_GREEN", color.FgGreen)...).FprintfFunc()
+	return color.New(attrsFgGreen...).FprintfFunc()
 }
 
 func Cyan() PrintFunc {
-	return color.New(envColor("TASK_COLOR_CYAN", color.FgCyan)...).FprintfFunc()
+	return color.New(attrsFgCyan...).FprintfFunc()
 }
 
 func Yellow() PrintFunc {
-	return color.New(envColor("TASK_COLOR_YELLOW", color.FgYellow)...).FprintfFunc()
+	return color.New(attrsFgYellow...).FprintfFunc()
 }
 
 func Magenta() PrintFunc {
-	return color.New(envColor("TASK_COLOR_MAGENTA", color.FgMagenta)...).FprintfFunc()
+	return color.New(attrsFgMagenta...).FprintfFunc()
 }
 
 func Red() PrintFunc {
-	return color.New(envColor("TASK_COLOR_RED", color.FgRed)...).FprintfFunc()
+	return color.New(attrsFgRed...).FprintfFunc()
 }
 
 func BrightBlue() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_BLUE", color.FgHiBlue)...).FprintfFunc()
+	return color.New(attrsFgHiBlue...).FprintfFunc()
 }
 
 func BrightGreen() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_GREEN", color.FgHiGreen)...).FprintfFunc()
+	return color.New(attrsFgHiGreen...).FprintfFunc()
 }
 
 func BrightCyan() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_CYAN", color.FgHiCyan)...).FprintfFunc()
+	return color.New(attrsFgHiCyan...).FprintfFunc()
 }
 
 func BrightYellow() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_YELLOW", color.FgHiYellow)...).FprintfFunc()
+	return color.New(attrsFgHiYellow...).FprintfFunc()
 }
 
 func BrightMagenta() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_MAGENTA", color.FgHiMagenta)...).FprintfFunc()
+	return color.New(attrsFgHiMagenta...).FprintfFunc()
 }
 
 func BrightRed() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_RED", color.FgHiRed)...).FprintfFunc()
+	return color.New(attrsFgHiRed...).FprintfFunc()
 }
 
-func envColor(env string, defaultColor color.Attribute) []color.Attribute {
-	if os.Getenv("FORCE_COLOR") != "" {
-		color.NoColor = false
-	}
-
+func envColor(name string, defaultColor color.Attribute) []color.Attribute {
 	// Fetch the environment variable
-	override := os.Getenv(env)
+	override := env.GetTaskEnv(name)
 
 	// First, try splitting the string by commas (RGB shortcut syntax) and if it
 	// matches, then prepend the 256-color foreground escape sequence.
@@ -130,7 +150,7 @@ func (l *Logger) FOutf(w io.Writer, color Color, s string, args ...any) {
 		s, args = "%s", []any{s}
 	}
 	if !l.Color {
-		color = Default
+		color = None
 	}
 	print := color()
 	print(w, s, args...)
@@ -149,7 +169,7 @@ func (l *Logger) Errf(color Color, s string, args ...any) {
 		s, args = "%s", []any{s}
 	}
 	if !l.Color {
-		color = Default
+		color = None
 	}
 	print := color()
 	print(l.Stderr, s, args...)
@@ -195,3 +215,16 @@ func (l *Logger) Prompt(color Color, prompt string, defaultValue string, continu
 
 	return nil
 }
+
+func (l *Logger) PrintExperiments() error {
+	w := tabwriter.NewWriter(l.Stdout, 0, 8, 0, ' ', 0)
+	for _, x := range experiments.List() {
+		if !x.Active() {
+			continue
+		}
+		l.FOutf(w, Yellow, "* ")
+		l.FOutf(w, Green, x.Name)
+		l.FOutf(w, Default, ": \t%s\n", x.String())
+	}
+	return w.Flush()
+}

internal/mocks/sources_checkable.go

@@ -1,226 +0,0 @@
-// Code generated by mockery v2.24.0. DO NOT EDIT.
-
-package mocks
-
-import (
-	ast "github.com/go-task/task/v3/taskfile/ast"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// SourcesCheckable is an autogenerated mock type for the SourcesCheckable type
-type SourcesCheckable struct {
-	mock.Mock
-}
-
-type SourcesCheckable_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *SourcesCheckable) EXPECT() *SourcesCheckable_Expecter {
-	return &SourcesCheckable_Expecter{mock: &_m.Mock}
-}
-
-// IsUpToDate provides a mock function with given fields: t
-func (_m *SourcesCheckable) IsUpToDate(t *ast.Task) (bool, error) {
-	ret := _m.Called(t)
-
-	var r0 bool
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*ast.Task) (bool, error)); ok {
-		return rf(t)
-	}
-	if rf, ok := ret.Get(0).(func(*ast.Task) bool); ok {
-		r0 = rf(t)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	if rf, ok := ret.Get(1).(func(*ast.Task) error); ok {
-		r1 = rf(t)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SourcesCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
-type SourcesCheckable_IsUpToDate_Call struct {
-	*mock.Call
-}
-
-// IsUpToDate is a helper method to define mock.On call
-//   - t *ast.Task
-func (_e *SourcesCheckable_Expecter) IsUpToDate(t interface{}) *SourcesCheckable_IsUpToDate_Call {
-	return &SourcesCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", t)}
-}
-
-func (_c *SourcesCheckable_IsUpToDate_Call) Run(run func(t *ast.Task)) *SourcesCheckable_IsUpToDate_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*ast.Task))
-	})
-	return _c
-}
-
-func (_c *SourcesCheckable_IsUpToDate_Call) Return(_a0 bool, _a1 error) *SourcesCheckable_IsUpToDate_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SourcesCheckable_IsUpToDate_Call) RunAndReturn(run func(*ast.Task) (bool, error)) *SourcesCheckable_IsUpToDate_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Kind provides a mock function with given fields:
-func (_m *SourcesCheckable) Kind() string {
-	ret := _m.Called()
-
-	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	return r0
-}
-
-// SourcesCheckable_Kind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Kind'
-type SourcesCheckable_Kind_Call struct {
-	*mock.Call
-}
-
-// Kind is a helper method to define mock.On call
-func (_e *SourcesCheckable_Expecter) Kind() *SourcesCheckable_Kind_Call {
-	return &SourcesCheckable_Kind_Call{Call: _e.mock.On("Kind")}
-}
-
-func (_c *SourcesCheckable_Kind_Call) Run(run func()) *SourcesCheckable_Kind_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *SourcesCheckable_Kind_Call) Return(_a0 string) *SourcesCheckable_Kind_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SourcesCheckable_Kind_Call) RunAndReturn(run func() string) *SourcesCheckable_Kind_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// OnError provides a mock function with given fields: t
-func (_m *SourcesCheckable) OnError(t *ast.Task) error {
-	ret := _m.Called(t)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ast.Task) error); ok {
-		r0 = rf(t)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SourcesCheckable_OnError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnError'
-type SourcesCheckable_OnError_Call struct {
-	*mock.Call
-}
-
-// OnError is a helper method to define mock.On call
-//   - t *ast.Task
-func (_e *SourcesCheckable_Expecter) OnError(t interface{}) *SourcesCheckable_OnError_Call {
-	return &SourcesCheckable_OnError_Call{Call: _e.mock.On("OnError", t)}
-}
-
-func (_c *SourcesCheckable_OnError_Call) Run(run func(t *ast.Task)) *SourcesCheckable_OnError_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*ast.Task))
-	})
-	return _c
-}
-
-func (_c *SourcesCheckable_OnError_Call) Return(_a0 error) *SourcesCheckable_OnError_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *SourcesCheckable_OnError_Call) RunAndReturn(run func(*ast.Task) error) *SourcesCheckable_OnError_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Value provides a mock function with given fields: t
-func (_m *SourcesCheckable) Value(t *ast.Task) (interface{}, error) {
-	ret := _m.Called(t)
-
-	var r0 interface{}
-	var r1 error
-	if rf, ok := ret.Get(0).(func(*ast.Task) (interface{}, error)); ok {
-		return rf(t)
-	}
-	if rf, ok := ret.Get(0).(func(*ast.Task) interface{}); ok {
-		r0 = rf(t)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(interface{})
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(*ast.Task) error); ok {
-		r1 = rf(t)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SourcesCheckable_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Value'
-type SourcesCheckable_Value_Call struct {
-	*mock.Call
-}
-
-// Value is a helper method to define mock.On call
-//   - t *ast.Task
-func (_e *SourcesCheckable_Expecter) Value(t interface{}) *SourcesCheckable_Value_Call {
-	return &SourcesCheckable_Value_Call{Call: _e.mock.On("Value", t)}
-}
-
-func (_c *SourcesCheckable_Value_Call) Run(run func(t *ast.Task)) *SourcesCheckable_Value_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*ast.Task))
-	})
-	return _c
-}
-
-func (_c *SourcesCheckable_Value_Call) Return(_a0 interface{}, _a1 error) *SourcesCheckable_Value_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *SourcesCheckable_Value_Call) RunAndReturn(run func(*ast.Task) (interface{}, error)) *SourcesCheckable_Value_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-type mockConstructorTestingTNewSourcesCheckable interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewSourcesCheckable creates a new instance of SourcesCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewSourcesCheckable(t mockConstructorTestingTNewSourcesCheckable) *SourcesCheckable {
-	mock := &SourcesCheckable{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

internal/mocks/status_checkable.go

@@ -1,92 +0,0 @@
-// Code generated by mockery v2.24.0. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	ast "github.com/go-task/task/v3/taskfile/ast"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// StatusCheckable is an autogenerated mock type for the StatusCheckable type
-type StatusCheckable struct {
-	mock.Mock
-}
-
-type StatusCheckable_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *StatusCheckable) EXPECT() *StatusCheckable_Expecter {
-	return &StatusCheckable_Expecter{mock: &_m.Mock}
-}
-
-// IsUpToDate provides a mock function with given fields: ctx, t
-func (_m *StatusCheckable) IsUpToDate(ctx context.Context, t *ast.Task) (bool, error) {
-	ret := _m.Called(ctx, t)
-
-	var r0 bool
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ast.Task) (bool, error)); ok {
-		return rf(ctx, t)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, *ast.Task) bool); ok {
-		r0 = rf(ctx, t)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, *ast.Task) error); ok {
-		r1 = rf(ctx, t)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StatusCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
-type StatusCheckable_IsUpToDate_Call struct {
-	*mock.Call
-}
-
-// IsUpToDate is a helper method to define mock.On call
-//   - ctx context.Context
-//   - t *ast.Task
-func (_e *StatusCheckable_Expecter) IsUpToDate(ctx interface{}, t interface{}) *StatusCheckable_IsUpToDate_Call {
-	return &StatusCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", ctx, t)}
-}
-
-func (_c *StatusCheckable_IsUpToDate_Call) Run(run func(ctx context.Context, t *ast.Task)) *StatusCheckable_IsUpToDate_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*ast.Task))
-	})
-	return _c
-}
-
-func (_c *StatusCheckable_IsUpToDate_Call) Return(_a0 bool, _a1 error) *StatusCheckable_IsUpToDate_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *StatusCheckable_IsUpToDate_Call) RunAndReturn(run func(context.Context, *ast.Task) (bool, error)) *StatusCheckable_IsUpToDate_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-type mockConstructorTestingTNewStatusCheckable interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewStatusCheckable creates a new instance of StatusCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewStatusCheckable(t mockConstructorTestingTNewStatusCheckable) *StatusCheckable {
-	mock := &StatusCheckable{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

internal/omap/orderedmap.go

@@ -1,164 +0,0 @@
-package omap
-
-import (
-	"cmp"
-	"fmt"
-	"slices"
-
-	"gopkg.in/yaml.v3"
-
-	"github.com/go-task/task/v3/internal/deepcopy"
-	"github.com/go-task/task/v3/internal/exp"
-)
-
-// An OrderedMap is a wrapper around a regular map that maintains an ordered
-// list of the map's keys. This allows you to run deterministic and ordered
-// operations on the map such as printing/serializing/iterating.
-type OrderedMap[K cmp.Ordered, V any] struct {
-	s []K
-	m map[K]V
-}
-
-// New will create a new OrderedMap of the given type and return it.
-func New[K cmp.Ordered, V any]() OrderedMap[K, V] {
-	return OrderedMap[K, V]{
-		s: make([]K, 0),
-		m: make(map[K]V),
-	}
-}
-
-// FromMap will create a new OrderedMap from the given map. Since Golang maps
-// are unordered, the order of the created OrderedMap will be random.
-func FromMap[K cmp.Ordered, V any](m map[K]V) OrderedMap[K, V] {
-	om := New[K, V]()
-	om.m = m
-	om.s = exp.Keys(m)
-	return om
-}
-
-func FromMapWithOrder[K cmp.Ordered, V any](m map[K]V, order []K) OrderedMap[K, V] {
-	om := New[K, V]()
-	if len(m) != len(order) {
-		panic("length of map and order must be equal")
-	}
-	om.m = m
-	om.s = order
-	for key := range om.m {
-		if !slices.Contains(om.s, key) {
-			panic("order keys must match map keys")
-		}
-	}
-	return om
-}
-
-// Len will return the number of items in the map.
-func (om *OrderedMap[K, V]) Len() int {
-	return len(om.s)
-}
-
-// Set will set the value for a given key.
-func (om *OrderedMap[K, V]) Set(key K, value V) {
-	if om.m == nil {
-		om.m = make(map[K]V)
-	}
-	if _, ok := om.m[key]; !ok {
-		om.s = append(om.s, key)
-	}
-	om.m[key] = value
-}
-
-// Get will return the value for a given key.
-// If the key does not exist, it will return the zero value of the value type.
-func (om *OrderedMap[K, V]) Get(key K) V {
-	value, ok := om.m[key]
-	if !ok {
-		var zero V
-		return zero
-	}
-	return value
-}
-
-// Exists will return whether or not the given key exists.
-func (om *OrderedMap[K, V]) Exists(key K) bool {
-	_, ok := om.m[key]
-	return ok
-}
-
-// Sort will sort the map.
-func (om *OrderedMap[K, V]) Sort() {
-	slices.Sort(om.s)
-}
-
-// SortFunc will sort the map using the given function.
-func (om *OrderedMap[K, V]) SortFunc(less func(i, j K) int) {
-	slices.SortFunc(om.s, less)
-}
-
-// Keys will return a slice of the map's keys in order.
-func (om *OrderedMap[K, V]) Keys() []K {
-	return om.s
-}
-
-// Values will return a slice of the map's values in order.
-func (om *OrderedMap[K, V]) Values() []V {
-	var values []V
-	for _, key := range om.s {
-		values = append(values, om.m[key])
-	}
-	return values
-}
-
-// Range will iterate over the map and call the given function for each key/value.
-func (om *OrderedMap[K, V]) Range(fn func(key K, value V) error) error {
-	for _, key := range om.s {
-		if err := fn(key, om.m[key]); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Merge merges the given Vars into the caller one
-func (om *OrderedMap[K, V]) Merge(other OrderedMap[K, V]) {
-	// nolint: errcheck
-	other.Range(func(key K, value V) error {
-		om.Set(key, value)
-		return nil
-	})
-}
-
-func (om *OrderedMap[K, V]) DeepCopy() OrderedMap[K, V] {
-	return OrderedMap[K, V]{
-		s: deepcopy.Slice(om.s),
-		m: deepcopy.Map(om.m),
-	}
-}
-
-func (om *OrderedMap[K, V]) UnmarshalYAML(node *yaml.Node) error {
-	switch node.Kind {
-	// Even numbers contain the keys
-	// Odd numbers contain the values
-	case yaml.MappingNode:
-		for i := 0; i < len(node.Content); i += 2 {
-			// Decode the key
-			keyNode := node.Content[i]
-			var k K
-			if err := keyNode.Decode(&k); err != nil {
-				return err
-			}
-
-			// Decode the value
-			valueNode := node.Content[i+1]
-			var v V
-			if err := valueNode.Decode(&v); err != nil {
-				return err
-			}
-
-			// Set the key and value
-			om.Set(k, v)
-		}
-		return nil
-	}
-
-	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into variables", node.Line, node.ShortTag())
-}

internal/omap/orderedmap_test.go

@@ -1,121 +0,0 @@
-package omap
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"gopkg.in/yaml.v3"
-)
-
-func TestFromMap(t *testing.T) {
-	m := map[int]string{3: "three", 1: "one", 2: "two"}
-	om := FromMap(m)
-	assert.Len(t, om.m, 3)
-	assert.Len(t, om.s, 3)
-	assert.ElementsMatch(t, []int{1, 2, 3}, om.s)
-	for key, value := range m {
-		assert.Equal(t, om.Get(key), value)
-	}
-}
-
-func TestSetGetExists(t *testing.T) {
-	om := New[int, string]()
-	assert.False(t, om.Exists(1))
-	assert.Equal(t, "", om.Get(1))
-	om.Set(1, "one")
-	assert.True(t, om.Exists(1))
-	assert.Equal(t, "one", om.Get(1))
-}
-
-func TestSort(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-	om.Sort()
-	assert.Equal(t, []int{1, 2, 3}, om.s)
-}
-
-func TestSortFunc(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-	om.SortFunc(func(a, b int) int {
-		return b - a
-	})
-	assert.Equal(t, []int{3, 2, 1}, om.s)
-}
-
-func TestKeysValues(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-	assert.Equal(t, []int{3, 1, 2}, om.Keys())
-	assert.Equal(t, []string{"three", "one", "two"}, om.Values())
-}
-
-func Range(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-
-	expectedKeys := []int{3, 1, 2}
-	expectedValues := []string{"three", "one", "two"}
-
-	keys := make([]int, 0, len(expectedKeys))
-	values := make([]string, 0, len(expectedValues))
-
-	err := om.Range(func(key int, value string) error {
-		keys = append(keys, key)
-		values = append(values, value)
-		return nil
-	})
-
-	assert.NoError(t, err)
-	assert.ElementsMatch(t, expectedKeys, keys)
-	assert.ElementsMatch(t, expectedValues, values)
-}
-
-func TestOrderedMapMerge(t *testing.T) {
-	om1 := New[string, int]()
-	om1.Set("a", 1)
-	om1.Set("b", 2)
-
-	om2 := New[string, int]()
-	om2.Set("b", 3)
-	om2.Set("c", 4)
-
-	om1.Merge(om2)
-
-	expectedKeys := []string{"a", "b", "c"}
-	expectedValues := []int{1, 3, 4}
-
-	assert.Equal(t, len(expectedKeys), len(om1.s))
-	assert.Equal(t, len(expectedKeys), len(om1.m))
-
-	for i, key := range expectedKeys {
-		assert.True(t, om1.Exists(key))
-		assert.Equal(t, expectedValues[i], om1.Get(key))
-	}
-}
-
-func TestUnmarshalYAML(t *testing.T) {
-	yamlString := `
-3: three
-1: one
-2: two
-`
-	var om OrderedMap[int, string]
-	err := yaml.Unmarshal([]byte(yamlString), &om)
-	require.NoError(t, err)
-
-	expectedKeys := []int{3, 1, 2}
-	expectedValues := []string{"three", "one", "two"}
-
-	assert.Equal(t, expectedKeys, om.Keys())
-	assert.Equal(t, expectedValues, om.Values())
-}

internal/output/group.go

@@ -24,7 +24,6 @@ func (g Group) WrapWriter(stdOut, _ io.Writer, _ string, cache *templater.Cache)
 		if g.ErrorOnly && err == nil {
 			return nil
 		}
-
 		return gw.close()
 	}
 }
@@ -40,14 +39,22 @@ func (gw *groupWriter) Write(p []byte) (int, error) {
 }
 
 func (gw *groupWriter) close() error {
-	if gw.buff.Len() == 0 {
-		// don't print begin/end messages if there's no buffered entries
+	switch {
+	case gw.buff.Len() == 0:
 		return nil
-	}
-	if _, err := io.WriteString(gw.writer, gw.begin); err != nil {
+	case gw.begin == "" && gw.end == "":
+		_, err := io.Copy(gw.writer, &gw.buff)
+		return err
+	default:
+		_, err := io.Copy(gw.writer, gw.combinedBuff())
 		return err
 	}
-	gw.buff.WriteString(gw.end)
-	_, err := io.Copy(gw.writer, &gw.buff)
-	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
 }

internal/output/output_test.go

@@ -12,13 +12,14 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/omap"
 	"github.com/go-task/task/v3/internal/output"
 	"github.com/go-task/task/v3/internal/templater"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestInterleaved(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Interleaved{}
 	w, _, _ := o.WrapWriter(&b, io.Discard, "", nil)
@@ -30,6 +31,8 @@ func TestInterleaved(t *testing.T) {
 }
 
 func TestGroup(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Group{}
 	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
@@ -48,12 +51,15 @@ func TestGroup(t *testing.T) {
 }
 
 func TestGroupWithBeginEnd(t *testing.T) {
+	t.Parallel()
+
 	tmpl := templater.Cache{
-		Vars: &ast.Vars{
-			OrderedMap: omap.FromMap(map[string]ast.Var{
-				"VAR1": {Value: "example-value"},
-			}),
-		},
+		Vars: ast.NewVars(
+			&ast.VarElement{
+				Key:   "VAR1",
+				Value: ast.Var{Value: "example-value"},
+			},
+		),
 	}
 
 	var o output.Output = output.Group{
@@ -61,6 +67,8 @@ func TestGroupWithBeginEnd(t *testing.T) {
 		End:   "::endgroup::",
 	}
 	t.Run("simple", func(t *testing.T) {
+		t.Parallel()
+
 		var b bytes.Buffer
 		w, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
 
@@ -72,6 +80,8 @@ func TestGroupWithBeginEnd(t *testing.T) {
 		assert.Equal(t, "::group::example-value\nfoo\nbar\nbaz\n::endgroup::\n", b.String())
 	})
 	t.Run("no output", func(t *testing.T) {
+		t.Parallel()
+
 		var b bytes.Buffer
 		_, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
 		require.NoError(t, cleanup(nil))
@@ -80,6 +90,8 @@ func TestGroupWithBeginEnd(t *testing.T) {
 }
 
 func TestGroupErrorOnlySwallowsOutputOnNoError(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Group{
 		ErrorOnly: true,
@@ -94,6 +106,8 @@ func TestGroupErrorOnlySwallowsOutputOnNoError(t *testing.T) {
 }
 
 func TestGroupErrorOnlyShowsOutputOnError(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Group{
 		ErrorOnly: true,
@@ -107,7 +121,7 @@ func TestGroupErrorOnlyShowsOutputOnError(t *testing.T) {
 	assert.Equal(t, "std-out\nstd-err\n", b.String())
 }
 
-func TestPrefixed(t *testing.T) {
+func TestPrefixed(t *testing.T) { //nolint:paralleltest // cannot run in parallel
 	var b bytes.Buffer
 	l := &logger.Logger{
 		Color: false,
@@ -116,7 +130,7 @@ func TestPrefixed(t *testing.T) {
 	var o output.Output = output.NewPrefixed(l)
 	w, _, cleanup := o.WrapWriter(&b, io.Discard, "prefix", nil)
 
-	t.Run("simple use cases", func(t *testing.T) {
+	t.Run("simple use cases", func(t *testing.T) { //nolint:paralleltest // cannot run in parallel
 		b.Reset()
 
 		fmt.Fprintln(w, "foo\nbar")
@@ -126,7 +140,7 @@ func TestPrefixed(t *testing.T) {
 		require.NoError(t, cleanup(nil))
 	})
 
-	t.Run("multiple writes for a single line", func(t *testing.T) {
+	t.Run("multiple writes for a single line", func(t *testing.T) { //nolint:paralleltest // cannot run in parallel
 		b.Reset()
 
 		for _, char := range []string{"T", "e", "s", "t", "!"} {
@@ -140,6 +154,8 @@ func TestPrefixed(t *testing.T) {
 }
 
 func TestPrefixedWithColor(t *testing.T) {
+	t.Parallel()
+
 	color.NoColor = false
 
 	var b bytes.Buffer
@@ -155,6 +171,8 @@ func TestPrefixedWithColor(t *testing.T) {
 	}
 
 	t.Run("colors should loop", func(t *testing.T) {
+		t.Parallel()
+
 		for i, w := range writers {
 			b.Reset()
 
@@ -164,7 +182,11 @@ func TestPrefixedWithColor(t *testing.T) {
 			l.FOutf(&prefix, color, fmt.Sprintf("prefix-%d", i))
 
 			fmt.Fprintln(w, "foo\nbar")
-			assert.Equal(t, fmt.Sprintf("[%s] foo\n[%s] bar\n", prefix.String(), prefix.String()), b.String())
+			assert.Equal(
+				t,
+				fmt.Sprintf("[%s] foo\n[%s] bar\n", prefix.String(), prefix.String()),
+				b.String(),
+			)
 		}
 	})
 }

internal/output/prefixed.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"strings"
+	"sync"
 
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/templater"
@@ -14,20 +15,21 @@ type Prefixed struct {
 	logger  *logger.Logger
 	seen    map[string]uint
 	counter *uint
+	mutex   sync.Mutex
 }
 
-func NewPrefixed(logger *logger.Logger) Prefixed {
+func NewPrefixed(logger *logger.Logger) *Prefixed {
 	var counter uint
 
-	return Prefixed{
+	return &Prefixed{
 		seen:    make(map[string]uint),
 		counter: &counter,
 		logger:  logger,
 	}
 }
 
-func (p Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
-	pw := &prefixWriter{writer: stdOut, prefix: prefix, prefixed: &p}
+func (p *Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
+	pw := &prefixWriter{writer: stdOut, prefix: prefix, prefixed: p}
 	return pw, pw, func(error) error { return pw.close() }
 }
 
@@ -85,6 +87,9 @@ func (pw *prefixWriter) writeLine(line string) error {
 		line += "\n"
 	}
 
+	defer pw.prefixed.mutex.Unlock()
+	pw.prefixed.mutex.Lock()
+
 	idx, ok := pw.prefixed.seen[pw.prefix]
 
 	if !ok {

internal/slicesext/slicesext.go

@@ -18,3 +18,15 @@ func UniqueJoin[T cmp.Ordered](ss ...[]T) []T {
 	slices.Sort(r)
 	return slices.Compact(r)
 }
+
+func Convert[T, U any](s []T, f func(T) U) []U {
+	// Create a new slice with the same length as the input slice
+	result := make([]U, len(s))
+
+	// Convert each element using the provided function
+	for i, v := range s {
+		result[i] = f(v)
+	}
+
+	return result
+}

internal/slicesext/slicesext_test.go

@@ -0,0 +1,86 @@
+package slicesext
+
+import (
+	"math"
+	"strconv"
+	"testing"
+)
+
+func TestConvertIntToString(t *testing.T) {
+	t.Parallel()
+	input := []int{1, 2, 3, 4, 5}
+	expected := []string{"1", "2", "3", "4", "5"}
+	result := Convert(input, strconv.Itoa)
+
+	if len(result) != len(expected) {
+		t.Errorf("Expected length %d, got %d", len(expected), len(result))
+	}
+
+	for i := range expected {
+		if result[i] != expected[i] {
+			t.Errorf("At index %d: expected %v, got %v", i, expected[i], result[i])
+		}
+	}
+}
+
+func TestConvertStringToInt(t *testing.T) {
+	t.Parallel()
+	input := []string{"1", "2", "3", "4", "5"}
+	expected := []int{1, 2, 3, 4, 5}
+	result := Convert(input, func(s string) int {
+		n, _ := strconv.Atoi(s)
+		return n
+	})
+
+	if len(result) != len(expected) {
+		t.Errorf("Expected length %d, got %d", len(expected), len(result))
+	}
+
+	for i := range expected {
+		if result[i] != expected[i] {
+			t.Errorf("At index %d: expected %v, got %v", i, expected[i], result[i])
+		}
+	}
+}
+
+func TestConvertFloatToInt(t *testing.T) {
+	t.Parallel()
+	input := []float64{1.1, 2.2, 3.7, 4.5, 5.9}
+	expected := []int{1, 2, 4, 5, 6}
+	result := Convert(input, func(f float64) int {
+		return int(math.Round(f))
+	})
+
+	if len(result) != len(expected) {
+		t.Errorf("Expected length %d, got %d", len(expected), len(result))
+	}
+
+	for i := range expected {
+		if result[i] != expected[i] {
+			t.Errorf("At index %d: expected %v, got %v", i, expected[i], result[i])
+		}
+	}
+}
+
+func TestConvertEmptySlice(t *testing.T) {
+	t.Parallel()
+	input := []int{}
+	result := Convert(input, strconv.Itoa)
+
+	if len(result) != 0 {
+		t.Errorf("Expected empty slice, got length %d", len(result))
+	}
+}
+
+func TestConvertNilSlice(t *testing.T) {
+	t.Parallel()
+	var input []int
+	result := Convert(input, strconv.Itoa)
+
+	if result == nil {
+		t.Error("Expected non-nil empty slice, got nil")
+	}
+	if len(result) != 0 {
+		t.Errorf("Expected empty slice, got length %d", len(result))
+	}
+}

internal/sort/sorter.go

@@ -1,44 +1,44 @@
 package sort
 
 import (
+	"slices"
 	"sort"
 	"strings"
-
-	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-type TaskSorter interface {
-	Sort([]*ast.Task)
+// A Sorter is any function that sorts a set of tasks.
+type Sorter func(items []string, namespaces []string) []string
+
+// NoSort leaves the tasks in the order they are defined.
+func NoSort(items []string, namespaces []string) []string {
+	return items
 }
 
-type Noop struct{}
-
-func (s *Noop) Sort(tasks []*ast.Task) {}
-
-type AlphaNumeric struct{}
-
-// Tasks that are not namespaced should be listed before tasks that are.
-// We detect this by searching for a ':' in the task name.
-func (s *AlphaNumeric) Sort(tasks []*ast.Task) {
-	sort.Slice(tasks, func(i, j int) bool {
-		return tasks[i].Task < tasks[j].Task
-	})
+// AlphaNumeric sorts the JSON output so that tasks are in alpha numeric order
+// by task name.
+func AlphaNumeric(items []string, namespaces []string) []string {
+	slices.Sort(items)
+	return items
 }
 
-type AlphaNumericWithRootTasksFirst struct{}
-
-// Tasks that are not namespaced should be listed before tasks that are.
-// We detect this by searching for a ':' in the task name.
-func (s *AlphaNumericWithRootTasksFirst) Sort(tasks []*ast.Task) {
-	sort.Slice(tasks, func(i, j int) bool {
-		iContainsColon := strings.Contains(tasks[i].Task, ":")
-		jContainsColon := strings.Contains(tasks[j].Task, ":")
+// AlphaNumericWithRootTasksFirst sorts the JSON output so that tasks are in
+// alpha numeric order by task name. It will also ensure that tasks that are not
+// namespaced will be listed before tasks that are. We detect this by searching
+// for a ':' in the task name.
+func AlphaNumericWithRootTasksFirst(items []string, namespaces []string) []string {
+	if len(namespaces) > 0 {
+		return AlphaNumeric(items, namespaces)
+	}
+	sort.Slice(items, func(i, j int) bool {
+		iContainsColon := strings.Contains(items[i], ":")
+		jContainsColon := strings.Contains(items[j], ":")
 		if iContainsColon == jContainsColon {
-			return tasks[i].Task < tasks[j].Task
+			return items[i] < items[j]
 		}
 		if !iContainsColon && jContainsColon {
 			return true
 		}
 		return false
 	})
+	return items
 }