diff --git a/.github/actions/c-chain-reexecution-benchmark/action.yml b/.github/actions/c-chain-reexecution-benchmark/action.yml
index 85546ceba8a6..a42e163921ad 100644
--- a/.github/actions/c-chain-reexecution-benchmark/action.yml
+++ b/.github/actions/c-chain-reexecution-benchmark/action.yml
@@ -2,10 +2,10 @@ name: 'C-Chain Re-Execution Benchmark'
 description: 'Run C-Chain re-execution benchmark'
 
 inputs:
-  task:
-    description: 'Task name to execute from Taskfile.yml. Leave empty to use custom inputs below.'
+  test:
+    description: 'Test name to run (e.g., hashdb-101-250k). Leave empty to use custom inputs below.'
     default: ''
-  # Custom inputs (alternative to task-based approach)
+  # Custom inputs (used when test is not provided)
   config:
     description: 'The config to pass to the VM for the benchmark. See BenchmarkReexecuteRange for details.'
     default: ''
@@ -50,10 +50,6 @@ inputs:
     description: 'The password for the Prometheus instance.'
     required: true
     default: ''
-  workspace:
-    description: 'Working directory to use for the benchmark.'
-    required: true
-    default: ${{ github.workspace }}
   github-token:
     description: 'GitHub token provided to GitHub Action Benchmark.'
     required: true
@@ -126,54 +122,30 @@ runs:
         role-to-assume: ${{ inputs.aws-role }}
         aws-region: ${{ inputs.aws-region }}
         role-duration-seconds: ${{ inputs.aws-role-duration-seconds }}
-    - name: Validate inputs
-      shell: bash
-      run: |
-        if [[ -z "${{ inputs.task }}" ]]; then
-          # Granular mode - validate required inputs
-          missing=()
-          [[ -z "${{ inputs.block-dir-src }}" ]] && missing+=("block-dir-src")
-          [[ -z "${{ inputs.current-state-dir-src }}" ]] && missing+=("current-state-dir-src")
-          [[ -z "${{ inputs.start-block }}" ]] && missing+=("start-block")
-          [[ -z "${{ inputs.end-block }}" ]] && missing+=("end-block")
-
-          if [[ ${#missing[@]} -gt 0 ]]; then
-            echo "::error::When 'task' is empty, the following inputs are required: ${missing[*]}"
-            exit 1
-          fi
-        fi
-    - name: Set task env
+    - name: Set benchmark output file
       shell: bash
-      run: |
-        TIMESTAMP=$(date '+%Y%m%d-%H%M%S')
-        echo "EXECUTION_DATA_DIR=/tmp/reexecution-data-${TIMESTAMP}" >> "$GITHUB_ENV"
-        echo "BENCHMARK_OUTPUT_FILE=${GITHUB_WORKSPACE}/benchmark-output.json" >> "$GITHUB_ENV"
+      run: echo "BENCHMARK_OUTPUT_FILE=${GITHUB_WORKSPACE}/benchmark-output.json" >> "$GITHUB_ENV"
     - name: Run C-Chain Re-execution Benchmark
       shell: nix develop --impure --command bash -x {0}
-      run: |
-        if [[ -n "${{ inputs.task }}" ]]; then
-          # Task-based approach
-          ./scripts/run_task.sh ${{ inputs.task }} \
-            BENCHMARK_OUTPUT_FILE="${{ env.BENCHMARK_OUTPUT_FILE }}" \
-            EXECUTION_DATA_DIR="${{ env.EXECUTION_DATA_DIR }}"
-        else
-          # Granular approach
-          ./scripts/run_task.sh reexecute-cchain-range-with-copied-data \
-            CONFIG=${{ inputs.config }} \
-            EXECUTION_DATA_DIR=${{ env.EXECUTION_DATA_DIR }} \
-            BLOCK_DIR_SRC=${{ inputs.block-dir-src }} \
-            CURRENT_STATE_DIR_SRC=${{ inputs.current-state-dir-src }} \
-            START_BLOCK=${{ inputs.start-block }} \
-            END_BLOCK=${{ inputs.end-block }} \
-            BENCHMARK_OUTPUT_FILE="${{ env.BENCHMARK_OUTPUT_FILE }}"
-        fi
+      run: ./scripts/run_task.sh test-cchain-reexecution -- "${{ inputs.test || '' }}"
       env:
+        # Test configuration overrides
+        BLOCK_DIR_SRC: ${{ inputs.block-dir-src }}
+        CURRENT_STATE_DIR_SRC: ${{ inputs.current-state-dir-src }}
+        START_BLOCK: ${{ inputs.start-block }}
+        END_BLOCK: ${{ inputs.end-block }}
+        CONFIG: ${{ inputs.config }}
+        # Execution environment
+        BENCHMARK_OUTPUT_FILE: ${{ env.BENCHMARK_OUTPUT_FILE }}
+        PUSH_POST_STATE: ${{ inputs.push-post-state }}
+        # Runner and metrics
         RUNNER_TYPE: ${{ inputs.runner_type }}
         METRICS_COLLECTOR_ENABLED: ${{ inputs.prometheus-username != '' }}
         PROMETHEUS_URL: ${{ inputs.prometheus-url }}
         PROMETHEUS_PUSH_URL: ${{ inputs.prometheus-push-url }}
         PROMETHEUS_USERNAME: ${{ inputs.prometheus-username }}
         PROMETHEUS_PASSWORD: ${{ inputs.prometheus-password }}
+        # Github metadata
         GH_REPO: ${{ inputs.repository-owner }}/${{ inputs.repository-name }}
         GH_WORKFLOW: ${{ inputs.workflow }}
         GH_RUN_ID: ${{ inputs.run-id }}
@@ -188,10 +160,3 @@ runs:
         summary-always: true
         github-token: ${{ inputs.github-token }}
         auto-push: ${{ inputs.push-github-action-benchmark }}
-    - name: Push Post-State to S3
-      if: inputs.push-post-state != ''
-      shell: nix develop --impure --command bash -x {0}
-      run: |
-        ./scripts/run_task.sh export-dir-to-s3 \
-          SRC=${{ env.EXECUTION_DATA_DIR }}/current-state/ \
-          DST=${{ inputs.push-post-state }}
diff --git a/.github/workflows/c-chain-reexecution-benchmark-container.json b/.github/workflows/c-chain-reexecution-benchmark-container.json
index dfb8ce6df230..79e3be9a82dd 100644
--- a/.github/workflows/c-chain-reexecution-benchmark-container.json
+++ b/.github/workflows/c-chain-reexecution-benchmark-container.json
@@ -3,7 +3,7 @@
         "include": [
             {
                 "runner": "ubuntu-latest",
-                "task": "c-chain-reexecution-hashdb-101-250k",
+                "test": "hashdb-101-250k",
                 "timeout-minutes": 30
             },
             {
@@ -21,12 +21,12 @@
         "include": [
             {
                 "runner": "avago-runner-m6i-4xlarge-ebs-fast",
-                "task": "c-chain-reexecution-hashdb-33m-33m500k",
+                "test": "hashdb-33m-33m500k",
                 "timeout-minutes": 1440
             },
             {
                 "runner": "avago-runner-i4i-4xlarge-local-ssd",
-                "task": "c-chain-reexecution-hashdb-33m-33m500k",
+                "test": "hashdb-33m-33m500k",
                 "timeout-minutes": 1440
             }
         ]
diff --git a/.github/workflows/c-chain-reexecution-benchmark-container.yml b/.github/workflows/c-chain-reexecution-benchmark-container.yml
index 8c14edfecf30..483029c1f21f 100644
--- a/.github/workflows/c-chain-reexecution-benchmark-container.yml
+++ b/.github/workflows/c-chain-reexecution-benchmark-container.yml
@@ -4,8 +4,8 @@ on:
   pull_request:
   workflow_dispatch:
     inputs:
-      task:
-        description: 'Taskfile task to execute (e.g., c-chain-reexecution-hashdb-101-250k)'
+      test:
+        description: 'Test name (e.g., hashdb-101-250k, firewood-33m-33m500k). Leave empty for custom.'
         default: ''
       config:
         description: 'The config to pass to the VM for the benchmark. See BenchmarkReexecuteRange for details.'
@@ -51,8 +51,8 @@ jobs:
           if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
             {
               echo "matrix<<EOF"
-              printf '{ "include": [{ "task": "%s", "start-block": "%s", "end-block": "%s", "block-dir-src": "%s", "current-state-dir-src": "%s", "config": "%s", "runner": "%s", "timeout-minutes": %s }] }\n' \
-                "${{ github.event.inputs.task }}" \
+              printf '{ "include": [{ "test": "%s", "start-block": "%s", "end-block": "%s", "block-dir-src": "%s", "current-state-dir-src": "%s", "config": "%s", "runner": "%s", "timeout-minutes": %s }] }\n' \
+                "${{ github.event.inputs.test }}" \
                 "${{ github.event.inputs.start-block }}" \
                 "${{ github.event.inputs.end-block }}" \
                 "${{ github.event.inputs.block-dir-src }}" \
@@ -97,7 +97,7 @@ jobs:
       - name: Run C-Chain Re-Execution Benchmark
         uses: ./.github/actions/c-chain-reexecution-benchmark
         with:
-          task: ${{ matrix.task }}
+          test: ${{ matrix.test }}
           config: ${{ matrix.config }}
           start-block: ${{ matrix.start-block }}
           end-block: ${{ matrix.end-block }}
diff --git a/.github/workflows/c-chain-reexecution-benchmark-gh-native.json b/.github/workflows/c-chain-reexecution-benchmark-gh-native.json
index 57e20bcc97ab..1adc2898d824 100644
--- a/.github/workflows/c-chain-reexecution-benchmark-gh-native.json
+++ b/.github/workflows/c-chain-reexecution-benchmark-gh-native.json
@@ -3,17 +3,17 @@
         "include": [
             {
               "runner": "ubuntu-latest",
-              "task": "c-chain-reexecution-hashdb-101-250k",
+              "test": "hashdb-101-250k",
               "timeout-minutes": 30
             },
             {
                 "runner": "blacksmith-4vcpu-ubuntu-2404",
-                "task": "c-chain-reexecution-hashdb-101-250k",
+                "test": "hashdb-101-250k",
                 "timeout-minutes": 30
             },
             {
                 "runner": "blacksmith-4vcpu-ubuntu-2404",
-                "task": "c-chain-reexecution-hashdb-archive-101-250k",
+                "test": "hashdb-archive-101-250k",
                 "timeout-minutes": 30
             }
         ]
diff --git a/.github/workflows/c-chain-reexecution-benchmark-gh-native.yml b/.github/workflows/c-chain-reexecution-benchmark-gh-native.yml
index 40da14bdca45..d5ed9a6433c5 100644
--- a/.github/workflows/c-chain-reexecution-benchmark-gh-native.yml
+++ b/.github/workflows/c-chain-reexecution-benchmark-gh-native.yml
@@ -4,8 +4,8 @@ on:
   pull_request:
   workflow_dispatch:
     inputs:
-      task:
-        description: 'Taskfile task to execute (e.g., c-chain-reexecution-hashdb-101-250k)'
+      test:
+        description: 'Test name (e.g., hashdb-101-250k, firewood-33m-33m500k). Leave empty for custom.'
         default: ''
       config:
         description: 'The config to pass to the VM for the benchmark. See BenchmarkReexecuteRange for details.'
@@ -51,8 +51,8 @@ jobs:
           if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
             {
               echo "matrix<<EOF"
-              printf '{ "include": [{ "task": "%s", "start-block": "%s", "end-block": "%s", "block-dir-src": "%s", "current-state-dir-src": "%s", "config": "%s", "runner": "%s", "timeout-minutes": %s }] }\n' \
-                "${{ github.event.inputs.task }}" \
+              printf '{ "include": [{ "test": "%s", "start-block": "%s", "end-block": "%s", "block-dir-src": "%s", "current-state-dir-src": "%s", "config": "%s", "runner": "%s", "timeout-minutes": %s }] }\n' \
+                "${{ github.event.inputs.test }}" \
                 "${{ github.event.inputs.start-block }}" \
                 "${{ github.event.inputs.end-block }}" \
                 "${{ github.event.inputs.block-dir-src }}" \
@@ -87,7 +87,7 @@ jobs:
       - name: Run C-Chain Re-Execution Benchmark
         uses: ./.github/actions/c-chain-reexecution-benchmark
         with:
-          task: ${{ matrix.task }}
+          test: ${{ matrix.test }}
           config: ${{ matrix.config }}
           start-block: ${{ matrix.start-block }}
           end-block: ${{ matrix.end-block }}
diff --git a/Taskfile.yml b/Taskfile.yml
index 6bf9314b8aad..a7967241f62b 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -3,10 +3,11 @@
 # If in the nix dev shell, `task` is available.
 # To install nix, `./scripts/run_task.sh install-nix`
 
-version: '3'
+# - Tasks should be simple entrypoints to functionality exposed by scripts or code.
+# - Avoid the temptation to use task vars to define an API surface. Prefer configuring the
+#   underlying script or code via CLI args and/or env vars.
 
-env:
-  S3_BOOTSTRAP_BUCKET: 's3://avalanchego-bootstrap-testing'
+version: '3'
 
 tasks:
   default: ./scripts/run_task.sh --list
@@ -102,21 +103,7 @@ tasks:
 
   export-cchain-block-range:
     desc: Export range of C-Chain blocks from source to target directory.
-    vars:
-      BLOCK_DIR_SRC: '{{.BLOCK_DIR_SRC}}'
-      BLOCK_DIR_DST: '{{.BLOCK_DIR_DST}}'
-      START_BLOCK: '{{.START_BLOCK}}'
-      END_BLOCK: '{{.END_BLOCK}}'
-    cmds:
-      - cmd: go run github.com/ava-labs/avalanchego/tests/reexecute/blockexport --block-dir-src={{.BLOCK_DIR_SRC}} --block-dir-dst={{.BLOCK_DIR_DST}} --start-block={{.START_BLOCK}} --end-block={{.END_BLOCK}}
-
-  export-dir-to-s3:
-    desc: Copies a directory to s3
-    vars:
-      SRC: '{{.SRC}}'
-      DST: '{{.DST}}'
-    cmds:
-      - cmd: bash -x ./scripts/copy_dir.sh {{.SRC}} {{.DST}}
+    cmd: go run github.com/ava-labs/avalanchego/tests/reexecute/blockexport {{.CLI_ARGS}}
 
   generate-mocks:
     desc: Generates testing mocks
@@ -143,29 +130,9 @@ tasks:
     desc: Runs ginkgo against the current working directory
     cmd: ./bin/ginkgo build {{.USER_WORKING_DIR}}
 
-  import-cchain-reexecute-range:
-    desc: Imports the C-Chain block and state data to re-execute. Defaults to import the first 200 and the current state created with the default config of the C-Chain (hashdb).
-    vars:
-      EXECUTION_DATA_DIR: '{{.EXECUTION_DATA_DIR}}'
-      BLOCK_DIR_SRC: '{{.BLOCK_DIR_SRC | default (printf "%s/cchain-mainnet-blocks-200-ldb/**" .S3_BOOTSTRAP_BUCKET)}}'
-      CURRENT_STATE_DIR_SRC: '{{.CURRENT_STATE_DIR_SRC | default (printf "%s/cchain-current-state-hashdb-full-100/**" .S3_BOOTSTRAP_BUCKET)}}'
-    cmds:
-      - task: import-s3-to-dir
-        vars:
-          SRC: '{{.BLOCK_DIR_SRC}}'
-          DST: '{{.EXECUTION_DATA_DIR}}/blocks'
-      - task: import-s3-to-dir
-        vars:
-          SRC: '{{.CURRENT_STATE_DIR_SRC}}'
-          DST: '{{.EXECUTION_DATA_DIR}}/current-state'
-
-  import-s3-to-dir:
-    desc: Imports an S3 path to a local directory.
-    vars:
-      SRC: '{{.SRC}}'
-      DST: '{{.DST}}'
-    cmds:
-      - cmd: bash -x ./scripts/copy_dir.sh {{.SRC}} {{.DST}}
+  import-chain-data:
+    desc: Imports the C-Chain block and state data to re-execute.
+    cmd: ./scripts/import_cchain_data.sh
 
   install-nix:
     desc: Installs nix with an OS-appropriate installer
@@ -201,134 +168,6 @@ tasks:
     desc: Runs shellcheck to check sanity of shell scripts
     cmd: ./scripts/shellcheck.sh
 
-  reexecute-cchain-range:
-    desc: Re-execute a range of C-Chain blocks.
-    vars:
-      TASK_NAME: '{{.TASK_NAME | default .TASK}}'
-      CURRENT_STATE_DIR: '{{.CURRENT_STATE_DIR}}'
-      BLOCK_DIR: '{{.BLOCK_DIR}}'
-      CONFIG: '{{.CONFIG | default ""}}'
-      START_BLOCK: '{{.START_BLOCK}}'
-      END_BLOCK: '{{.END_BLOCK}}'
-      LABELS: '{{.LABELS | default ""}}'
-      BENCHMARK_OUTPUT_FILE: '{{.BENCHMARK_OUTPUT_FILE | default ""}}'
-      TIMESTAMP: '{{.TIMESTAMP | default (now | date "20060102-150405")}}'
-      EXECUTION_DATA_DIR: '{{.EXECUTION_DATA_DIR | default (printf "/tmp/%s-%s" .TASK_NAME .TIMESTAMP)}}'
-    cmd: |
-      CURRENT_STATE_DIR={{.CURRENT_STATE_DIR}} \
-      BLOCK_DIR={{.BLOCK_DIR}} \
-      CONFIG={{.CONFIG}} \
-      START_BLOCK={{.START_BLOCK}} \
-      END_BLOCK={{.END_BLOCK}} \
-      LABELS={{.LABELS}} \
-      BENCHMARK_OUTPUT_FILE={{.BENCHMARK_OUTPUT_FILE}} \
-      EXECUTION_DATA_DIR={{.EXECUTION_DATA_DIR}} \
-      bash -x ./scripts/benchmark_cchain_range.sh
-    # Runtime context variables are read from environment by the script:
-    # - RUNNER_TYPE (execution environment)
-    # - METRICS_SERVER_PORT (monitoring config)
-    # - METRICS_SERVER_ENABLED (runtime monitoring decision)
-    # - METRICS_COLLECTOR_ENABLED (runtime monitoring decision)
-    # - PROMETHEUS_URL, PROMETHEUS_USERNAME, PROMETHEUS_PASSWORD (monitoring config)
-    # - GH_REPO, GH_WORKFLOW, GH_RUN_ID, etc. (GitHub context)
-
-  reexecute-cchain-range-with-copied-data:
-    desc: Combines import-cchain-reexecute-range and reexecute-cchain-range
-    vars:
-      TASK_NAME: '{{.TASK_NAME}}'
-      BLOCK_DIR_SRC: '{{.BLOCK_DIR_SRC}}'
-      CURRENT_STATE_DIR_SRC: '{{.CURRENT_STATE_DIR_SRC}}'
-      CONFIG: '{{.CONFIG}}'
-      START_BLOCK: '{{.START_BLOCK}}'
-      END_BLOCK: '{{.END_BLOCK}}'
-      TIMESTAMP: '{{.TIMESTAMP | default (now | date "20060102-150405")}}'
-      EXECUTION_DATA_DIR: '{{.EXECUTION_DATA_DIR | default (printf "/tmp/%s-%s" .TASK_NAME .TIMESTAMP)}}'
-    cmds:
-      - task: import-cchain-reexecute-range
-        vars:
-          BLOCK_DIR_SRC: '{{.S3_BOOTSTRAP_BUCKET}}/{{.BLOCK_DIR_SRC}}/**'
-          CURRENT_STATE_DIR_SRC: '{{.S3_BOOTSTRAP_BUCKET}}/{{.CURRENT_STATE_DIR_SRC}}/**'
-          EXECUTION_DATA_DIR: '{{.EXECUTION_DATA_DIR}}'
-      - task: reexecute-cchain-range
-        vars:
-          TASK_NAME: '{{.TASK_NAME}}'
-          BLOCK_DIR: '{{.EXECUTION_DATA_DIR}}/blocks'
-          CURRENT_STATE_DIR: '{{.EXECUTION_DATA_DIR}}/current-state'
-          CONFIG: '{{.CONFIG}}'
-          START_BLOCK: '{{.START_BLOCK}}'
-          END_BLOCK: '{{.END_BLOCK}}'
-          EXECUTION_DATA_DIR: '{{.EXECUTION_DATA_DIR}}'
-
-  c-chain-reexecution-hashdb-101-250k:
-    desc: C-Chain re-execution from block 101 to 250k with hashdb
-    cmds:
-      - task: reexecute-cchain-range-with-copied-data
-        vars:
-          TASK_NAME: '{{.TASK}}'
-          START_BLOCK: 101
-          END_BLOCK: 250000
-          BLOCK_DIR_SRC: 'cchain-mainnet-blocks-1m-ldb'
-          CURRENT_STATE_DIR_SRC: 'cchain-current-state-hashdb-full-100'
-
-  c-chain-reexecution-hashdb-archive-101-250k:
-    desc: C-Chain re-execution from block 101 to 250k with hashdb archive
-    cmds:
-      - task: reexecute-cchain-range-with-copied-data
-        vars:
-          TASK_NAME: '{{.TASK}}'
-          START_BLOCK: 101
-          END_BLOCK: 250000
-          BLOCK_DIR_SRC: 'cchain-mainnet-blocks-1m-ldb'
-          CURRENT_STATE_DIR_SRC: 'cchain-current-state-hashdb-archive-100'
-          CONFIG: archive
-
-  c-chain-reexecution-hashdb-33m-33m500k:
-    desc: C-Chain re-execution from block 33m to 33.5m with hashdb
-    cmds:
-      - task: reexecute-cchain-range-with-copied-data
-        vars:
-          TASK_NAME: '{{.TASK}}'
-          START_BLOCK: 33000001
-          END_BLOCK: 33500000
-          BLOCK_DIR_SRC: 'cchain-mainnet-blocks-30m-40m-ldb'
-          CURRENT_STATE_DIR_SRC: 'cchain-current-state-hashdb-full-33m'
-
-  c-chain-reexecution-firewood-33m-33m500k:
-    desc: C-Chain re-execution from block 33m to 33.5m with firewood
-    cmds:
-      - task: reexecute-cchain-range-with-copied-data
-        vars:
-          TASK_NAME: '{{.TASK}}'
-          START_BLOCK: 33000001
-          END_BLOCK: 33500000
-          BLOCK_DIR_SRC: 'cchain-mainnet-blocks-30m-40m-ldb'
-          CURRENT_STATE_DIR_SRC: 'cchain-current-state-firewood-33m'
-          CONFIG: firewood
-
-  c-chain-reexecution-firewood-33m-40m:
-    desc: C-Chain re-execution from block 33m to 40m with firewood
-    cmds:
-      - task: reexecute-cchain-range-with-copied-data
-        vars:
-          TASK_NAME: '{{.TASK}}'
-          START_BLOCK: 33000001
-          END_BLOCK: 40000000
-          BLOCK_DIR_SRC: 'cchain-mainnet-blocks-30m-40m-ldb'
-          CURRENT_STATE_DIR_SRC: 'cchain-current-state-firewood-33m'
-          CONFIG: firewood
-
-  c-chain-reexecution-firewood-101-250k:
-    desc: C-Chain re-execution from block 101 to 250k with firewood
-    cmds:
-      - task: reexecute-cchain-range-with-copied-data
-        vars:
-          TASK_NAME: '{{.TASK}}'
-          START_BLOCK: 101
-          END_BLOCK: 250000
-          BLOCK_DIR_SRC: 'cchain-mainnet-blocks-1m-ldb'
-          CURRENT_STATE_DIR_SRC: 'cchain-current-state-firewood-100'
-          CONFIG: firewood
-
   test-bootstrap-monitor-e2e:
     desc: Runs bootstrap monitor e2e tests
     cmd: bash -x ./scripts/tests.e2e.bootstrap_monitor.sh
@@ -358,6 +197,10 @@ tasks:
     desc: Runs test of cross-platform docker image build
     cmd: bash -x scripts/tests.build_image.sh
 
+  test-cchain-reexecution:
+    desc: Runs C-Chain re-execution test. Run without args to see available tests.
+    cmd: ./scripts/benchmark_cchain_range.sh {{.CLI_ARGS}}
+
   test-e2e:
     desc: Runs e2e tests
     cmds:
diff --git a/scripts/benchmark_cchain_range.sh b/scripts/benchmark_cchain_range.sh
index 379aca3172c6..df37f8a01fb5 100755
--- a/scripts/benchmark_cchain_range.sh
+++ b/scripts/benchmark_cchain_range.sh
@@ -2,24 +2,167 @@
 
 set -euo pipefail
 
-# This script runs the C-Chain re-execution benchmark with a single iteration.
-# It expects the following environment variables to be set:
-#   BLOCK_DIR: Path or S3 URL to the block directory or zip.
-#   CURRENT_STATE_DIR: Path or S3 URL to the current state directory or zip.
-#   START_BLOCK: The starting block height (exclusive).
-#   END_BLOCK: The ending block height (inclusive).
-#   RUNNER_TYPE (optional): Runner type/label to include in benchmark naming.
-#   LABELS (optional): Comma-separated key=value pairs for metric labels.
-#   BENCHMARK_OUTPUT_FILE (optional): If set, benchmark output is also written to this file.
-#   METRICS_SERVER_ENABLED (optional): If set, enables the metrics server.
-#   METRICS_SERVER_PORT (optional): If set, determines the port the metrics server will listen to.
-#   METRICS_COLLECTOR_ENABLED (optional): If set, enables the metrics collector.
-
-: "${BLOCK_DIR:?BLOCK_DIR must be set}"
-: "${CURRENT_STATE_DIR:?CURRENT_STATE_DIR must be set}"
-: "${START_BLOCK:?START_BLOCK must be set}"
-: "${END_BLOCK:?END_BLOCK must be set}"
+# C-Chain Re-execution Benchmark Script
+#
+# Usage:
+#   ./benchmark_cchain_range.sh [test-name]
+#
+# To see available tests: use `help` as the test name or invoke
+# without a test name and without required env vars.
+#
+# Test names configure defaults for S3 sources and block ranges.
+# All defaults can be overridden via environment variables.
+#
+# Environment variables:
+#   Data sources (provide S3 sources OR local paths):
+#     BLOCK_DIR_SRC: S3 object key for blocks (triggers S3 import).
+#     CURRENT_STATE_DIR_SRC: S3 object key for state (triggers S3 import).
+#     BLOCK_DIR: Path to local block directory.
+#     CURRENT_STATE_DIR: Path to local current state directory.
+#
+#   Required:
+#     START_BLOCK: The starting block height (inclusive).
+#     END_BLOCK: The ending block height (inclusive).
+#
+#   Optional:
+#     CONFIG: VM config preset (default, archive, firewood).
+#     LABELS: Comma-separated key=value pairs for metric labels.
+#     BENCHMARK_OUTPUT_FILE: If set, benchmark output is also written to this file.
+#     METRICS_SERVER_ENABLED: If set, enables the metrics server.
+#     METRICS_SERVER_PORT: If set, determines the port the metrics server will listen to.
+#     METRICS_COLLECTOR_ENABLED: If set, enables the metrics collector.
+#     PUSH_POST_STATE: S3 destination to push current-state after execution.
 
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# CI-aware error function
+error() {
+    if [[ "${GITHUB_ACTIONS:-}" == "true" ]]; then
+        echo "::error::$1"
+    else
+        echo "Error: $1" >&2
+    fi
+    exit 1
+}
+
+show_usage() {
+    cat <<EOF
+Usage: $0 [test-name]
+
+Available tests:
+  help                         - Show this help message
+  default                      - Quick test run (blocks 101-200, hashdb)
+  hashdb-101-250k              - Blocks 101-250k with hashdb
+  hashdb-archive-101-250k      - Blocks 101-250k with hashdb archive
+  hashdb-33m-33m500k           - Blocks 33m-33.5m with hashdb
+  firewood-101-250k            - Blocks 101-250k with firewood
+  firewood-33m-33m500k         - Blocks 33m-33.5m with firewood
+  firewood-33m-40m             - Blocks 33m-40m with firewood
+EOF
+}
+
+# Set defaults based on test name (if provided)
+TEST_NAME="${1:-}"
+if [[ -n "$TEST_NAME" ]]; then
+    shift
+    case "$TEST_NAME" in
+        help)
+            show_usage
+            exit 0
+            ;;
+        default)
+            BLOCK_DIR_SRC="${BLOCK_DIR_SRC:-cchain-mainnet-blocks-200-ldb}"
+            CURRENT_STATE_DIR_SRC="${CURRENT_STATE_DIR_SRC:-cchain-current-state-hashdb-full-100}"
+            START_BLOCK="${START_BLOCK:-101}"
+            END_BLOCK="${END_BLOCK:-200}"
+            ;;
+        hashdb-101-250k)
+            BLOCK_DIR_SRC="${BLOCK_DIR_SRC:-cchain-mainnet-blocks-1m-ldb}"
+            CURRENT_STATE_DIR_SRC="${CURRENT_STATE_DIR_SRC:-cchain-current-state-hashdb-full-100}"
+            START_BLOCK="${START_BLOCK:-101}"
+            END_BLOCK="${END_BLOCK:-250000}"
+            ;;
+        hashdb-archive-101-250k)
+            BLOCK_DIR_SRC="${BLOCK_DIR_SRC:-cchain-mainnet-blocks-1m-ldb}"
+            CURRENT_STATE_DIR_SRC="${CURRENT_STATE_DIR_SRC:-cchain-current-state-hashdb-archive-100}"
+            START_BLOCK="${START_BLOCK:-101}"
+            END_BLOCK="${END_BLOCK:-250000}"
+            CONFIG="${CONFIG:-archive}"
+            ;;
+        hashdb-33m-33m500k)
+            BLOCK_DIR_SRC="${BLOCK_DIR_SRC:-cchain-mainnet-blocks-30m-40m-ldb}"
+            CURRENT_STATE_DIR_SRC="${CURRENT_STATE_DIR_SRC:-cchain-current-state-hashdb-full-33m}"
+            START_BLOCK="${START_BLOCK:-33000001}"
+            END_BLOCK="${END_BLOCK:-33500000}"
+            ;;
+        firewood-101-250k)
+            BLOCK_DIR_SRC="${BLOCK_DIR_SRC:-cchain-mainnet-blocks-1m-ldb}"
+            CURRENT_STATE_DIR_SRC="${CURRENT_STATE_DIR_SRC:-cchain-current-state-firewood-100}"
+            START_BLOCK="${START_BLOCK:-101}"
+            END_BLOCK="${END_BLOCK:-250000}"
+            CONFIG="${CONFIG:-firewood}"
+            ;;
+        firewood-33m-33m500k)
+            BLOCK_DIR_SRC="${BLOCK_DIR_SRC:-cchain-mainnet-blocks-30m-40m-ldb}"
+            CURRENT_STATE_DIR_SRC="${CURRENT_STATE_DIR_SRC:-cchain-current-state-firewood-33m}"
+            START_BLOCK="${START_BLOCK:-33000001}"
+            END_BLOCK="${END_BLOCK:-33500000}"
+            CONFIG="${CONFIG:-firewood}"
+            ;;
+        firewood-33m-40m)
+            BLOCK_DIR_SRC="${BLOCK_DIR_SRC:-cchain-mainnet-blocks-30m-40m-ldb}"
+            CURRENT_STATE_DIR_SRC="${CURRENT_STATE_DIR_SRC:-cchain-current-state-firewood-33m}"
+            START_BLOCK="${START_BLOCK:-33000001}"
+            END_BLOCK="${END_BLOCK:-40000000}"
+            CONFIG="${CONFIG:-firewood}"
+            ;;
+        *)
+            error "Unknown test '$TEST_NAME'"
+            ;;
+    esac
+fi
+
+# Determine data source: S3 import or local paths
+if [[ -n "${BLOCK_DIR_SRC:-}" && -n "${CURRENT_STATE_DIR_SRC:-}" ]]; then
+    # S3 mode - import data
+    TIMESTAMP=$(date '+%Y%m%d-%H%M%S')
+    EXECUTION_DATA_DIR="${EXECUTION_DATA_DIR:-/tmp/reexec-${TEST_NAME:-custom}-${TIMESTAMP}}"
+
+    BLOCK_DIR_SRC="${BLOCK_DIR_SRC}" \
+    CURRENT_STATE_DIR_SRC="${CURRENT_STATE_DIR_SRC}" \
+    EXECUTION_DATA_DIR="${EXECUTION_DATA_DIR}" \
+    "${SCRIPT_DIR}/import_cchain_data.sh"
+
+    BLOCK_DIR="${EXECUTION_DATA_DIR}/blocks"
+    CURRENT_STATE_DIR="${EXECUTION_DATA_DIR}/current-state"
+elif [[ -n "${BLOCK_DIR_SRC:-}" || -n "${CURRENT_STATE_DIR_SRC:-}" ]]; then
+    error "Both BLOCK_DIR_SRC and CURRENT_STATE_DIR_SRC must be provided together"
+elif [[ -z "${BLOCK_DIR:-}" || -z "${CURRENT_STATE_DIR:-}" ]]; then
+    show_usage
+    echo ""
+    echo "Env vars status:"
+    echo "  S3 sources:"
+    [[ -n "${BLOCK_DIR_SRC:-}" ]] && echo "    BLOCK_DIR_SRC: ${BLOCK_DIR_SRC}" || echo "    BLOCK_DIR_SRC: (not set)"
+    [[ -n "${CURRENT_STATE_DIR_SRC:-}" ]] && echo "    CURRENT_STATE_DIR_SRC: ${CURRENT_STATE_DIR_SRC}" || echo "    CURRENT_STATE_DIR_SRC: (not set)"
+    echo "  Local paths:"
+    [[ -n "${BLOCK_DIR:-}" ]] && echo "    BLOCK_DIR: ${BLOCK_DIR}" || echo "    BLOCK_DIR: (not set)"
+    [[ -n "${CURRENT_STATE_DIR:-}" ]] && echo "    CURRENT_STATE_DIR: ${CURRENT_STATE_DIR}" || echo "    CURRENT_STATE_DIR: (not set)"
+    echo "  Block range:"
+    [[ -n "${START_BLOCK:-}" ]] && echo "    START_BLOCK: ${START_BLOCK}" || echo "    START_BLOCK: (not set)"
+    [[ -n "${END_BLOCK:-}" ]] && echo "    END_BLOCK: ${END_BLOCK}" || echo "    END_BLOCK: (not set)"
+    exit 1
+fi
+
+# Validate block range
+if [[ -z "${START_BLOCK:-}" || -z "${END_BLOCK:-}" ]]; then
+    error "START_BLOCK and END_BLOCK are required"
+fi
+
+echo "=== C-Chain Re-execution: ${TEST_NAME:-custom} ==="
+echo "Blocks: ${START_BLOCK} - ${END_BLOCK}"
+echo "Config: ${CONFIG:-default}"
+
+echo "=== Running re-execution ==="
 go run github.com/ava-labs/avalanchego/tests/reexecute/c \
   --block-dir="${BLOCK_DIR}" \
   --current-state-dir="${CURRENT_STATE_DIR}" \
@@ -32,3 +175,8 @@ go run github.com/ava-labs/avalanchego/tests/reexecute/c \
   ${METRICS_SERVER_ENABLED:+--metrics-server-enabled="${METRICS_SERVER_ENABLED}"} \
   ${METRICS_SERVER_PORT:+--metrics-server-port="${METRICS_SERVER_PORT}"} \
   ${METRICS_COLLECTOR_ENABLED:+--metrics-collector-enabled="${METRICS_COLLECTOR_ENABLED}"}
+
+if [[ -n "${PUSH_POST_STATE:-}" ]]; then
+    echo "=== Pushing post-state to S3 ==="
+    "${SCRIPT_DIR}/copy_dir.sh" "${CURRENT_STATE_DIR}/" "${PUSH_POST_STATE}"
+fi
diff --git a/scripts/import_cchain_data.sh b/scripts/import_cchain_data.sh
new file mode 100755
index 000000000000..31af15974d70
--- /dev/null
+++ b/scripts/import_cchain_data.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+# Import C-Chain blocks and state from S3
+#
+# Required env vars:
+#   BLOCK_DIR_SRC         - S3 object key for blocks (e.g., cchain-mainnet-blocks-200-ldb)
+#   CURRENT_STATE_DIR_SRC - S3 object key for state (e.g., cchain-current-state-hashdb-full-100)
+#   EXECUTION_DATA_DIR    - Local directory to store imported data
+#
+# Result:
+#   Creates $EXECUTION_DATA_DIR/blocks and $EXECUTION_DATA_DIR/current-state
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+S3_BOOTSTRAP_BUCKET="${S3_BOOTSTRAP_BUCKET:-s3://avalanchego-bootstrap-testing}"
+
+: "${BLOCK_DIR_SRC:?BLOCK_DIR_SRC must be set}"
+: "${CURRENT_STATE_DIR_SRC:?CURRENT_STATE_DIR_SRC must be set}"
+: "${EXECUTION_DATA_DIR:?EXECUTION_DATA_DIR must be set}"
+
+echo "=== Importing blocks from S3 ==="
+"${SCRIPT_DIR}/copy_dir.sh" "${S3_BOOTSTRAP_BUCKET}/${BLOCK_DIR_SRC}/**" "${EXECUTION_DATA_DIR}/blocks"
+
+echo "=== Importing state from S3 ==="
+"${SCRIPT_DIR}/copy_dir.sh" "${S3_BOOTSTRAP_BUCKET}/${CURRENT_STATE_DIR_SRC}/**" "${EXECUTION_DATA_DIR}/current-state"
diff --git a/tests/reexecute/c/README.md b/tests/reexecute/c/README.md
index d8d124edc351..281eff22a346 100644
--- a/tests/reexecute/c/README.md
+++ b/tests/reexecute/c/README.md
@@ -2,7 +2,7 @@
 
 The C-Chain benchmarks support re-executing a range of mainnet C-Chain blocks against a provided snapshot of the current state as of some initial state.
 
-AvalancheGo provides a [Taskfile](https://taskfile.dev/) with commands to manage the import/export of data required for re-execution (block range and current state) and triggering a benchmark run.
+Benchmarks can be invoked by running `./scripts/run_task.sh test-cchain-reexecution` or `./scripts/benchmark_cchain_range.sh`.
 
 ## Prerequisites
 
@@ -56,26 +56,29 @@ Running the re-execution test in CI will implicitly set `METRICS_COLLECTOR_ENABL
 
 Let's run the default benchmark to get started. Make sure that you have completed the [Prerequisites](#prerequisites) section because it is required to copy the data from S3.
 
-### Using Predefined Tasks
+### Using Predefined Tests
 
-You can run `./scripts/run_task.sh --list | grep "c-chain-reexecution"` to list predefined tasks for common re-execution scenarios.
+Run the script with `help` as the test name to see available tests:
 
-To run a predefined task:
 ```bash
-./scripts/run_task.sh c-chain-reexecution-hashdb-101-250k
+./scripts/benchmark_cchain_range.sh help
 ```
 
-These tasks automatically download the required data from S3 and run the benchmark with the appropriate configuration.
+To run a predefined test:
+```bash
+./scripts/benchmark_cchain_range.sh hashdb-101-250k
+```
 
-### Using Custom Parameters
+These tests automatically download the required data from S3 and run the benchmark with the appropriate configuration.
 
-For custom benchmark runs:
+### Using Custom Parameters
 
-[Taskfile](https://taskfile.dev/) supports reading arguments via both environment variables and named arguments on the command line, so we'll set `EXECUTION_DATA_DIR` and use the defaults for the remainder of the parameters:
+For custom benchmark runs, provide S3 sources or local paths via environment variables:
 
 ```bash
+# Export env vars that you want to be available to all future script invocations
 export EXECUTION_DATA_DIR=$HOME/.reexecute-cchain/default
-task reexecute-cchain-range-with-copied-data
+BLOCK_DIR_SRC=cchain-mainnet-blocks-1m-ldb CURRENT_STATE_DIR_SRC=cchain-current-state-hashdb-full-100 START_BLOCK=101 END_BLOCK=250000 ./scripts/benchmark_cchain_range.sh
 ```
 
 This performs the following steps:
@@ -132,11 +135,11 @@ First, we will import the first 10k blocks. To see what block databases are avai
 s5cmd ls s3://avalanchego-bootstrap-testing | grep blocks
 ```
 
-In this case, we will use the directory: `s3://avalanchego-bootstrap-testing/cchain-mainnet-blocks-10k-ldb/`. To import it, run the import task:
+In this case, we will use the directory: `s3://avalanchego-bootstrap-testing/cchain-mainnet-blocks-10k-ldb/`. To import it:
 
 ```bash
 export EXECUTION_DATA_DIR=$HOME/.reexecute-cchain/walkthrough
-task import-s3-to-dir SRC=s3://avalanchego-bootstrap-testing/cchain-mainnet-blocks-10k-ldb/** DST=$EXECUTION_DATA_DIR/blocks
+./scripts/copy_dir.sh "s3://avalanchego-bootstrap-testing/cchain-mainnet-blocks-10k-ldb/**" "$EXECUTION_DATA_DIR/blocks"
 ```
 
 Next, we need to want to execute the range of blocks [1, N]. We use 1 as the initial start block, since VM initialization vacuously executes the genesis block.
@@ -153,7 +156,7 @@ To generate this from scratch, we can use a directory path for `CURRENT_STATE_DI
 ```bash
 export CURRENT_STATE_DIR=$EXECUTION_DATA_DIR/current-state
 export BLOCK_DIR=$EXECUTION_DATA_DIR/blocks
-task reexecute-cchain-range START_BLOCK=1 END_BLOCK=100
+START_BLOCK=1 END_BLOCK=100 ./scripts/benchmark_cchain_range.sh
 ```
 
 This initializes the contents of `$EXECUTION_DATA_DIR/current-state` to include two subdirectories:
@@ -192,34 +195,34 @@ $HOME/exec-data
 
 After generating the `$EXECUTION_DATA_DIR/current-state` directory from executing the first segment of blocks, we can take a snapshot of the current state and push to S3 (or copy to another location including a local directory if preferred) for re-use.
 
-Since we are already using the S3 bucket `s3://avalanchego-bootstrap-testing`, we'll re-use it here. We'll use the `export-dir-to-s3` task, which takes in two parameters:
+Since we are already using the S3 bucket `s3://avalanchego-bootstrap-testing`, we'll re-use it here. We'll use the `copy-dir.sh` script, which takes in two parameters:
 
-- `SRC` - local path to recursive copy contents from
-- `DST` - S3 bucket destination path
+-- local path to recursive copy contents from
+-- S3 bucket destination path
 
 To avoid clobbering useful data, `export-dir-to-s3` will first attempt to check that the destination does not yet exist and that the path does not have any nesting. For example, `s3://avalanchego-bootstrap-testing/target-dir/` is valid, but `s3://avalanchego-bootstrap-testing/nested/target-dir/` is invalid because it contains two levels of nesting.
 
 As a result, if you run into a warning using this command, check the current contents using either the AWS Console or `s5cmd ls` and pick a valid, unused prefix.
 
 ```bash
-task export-dir-to-s3 SRC=$EXECUTION_DATA_DIR/current-state/ DST=s3://avalanchego-bootstrap-testing/cchain-current-state-test/
+./scripts/copy_dir.sh "$EXECUTION_DATA_DIR/current-state/" "s3://avalanchego-bootstrap-testing/cchain-current-state-test/"
 ```
 
 ### Re-Execute C-Chain Range
 
-Now that we've pushed the current-state back to S3, we can run the target range of blocks [101, 200] either re-using the data we already have locally or copying the data in fresh using the `reexecute-cchain-range-with-copied-data` task.
+Now that we've pushed the current-state back to S3, we can run the target range of blocks [101, 200] either re-using the data we already have locally or copying the data in fresh using the `benchmark_cchain_range.sh` script.
 
-First, let's continue executing using the already available `CURRENT_STATE_DIR` and `BLOCK_DIR`. Since we have already exported these values, the task will pick them up and we can set only the `START_BLOCK` and `END_BLOCK` parameters:
+First, let's continue executing using the already available `CURRENT_STATE_DIR` and `BLOCK_DIR`. Since we have already exported these values, the script will pick them up and we can set only the `START_BLOCK` and `END_BLOCK` parameters:
 
 ```bash
-task reexecute-cchain-range START_BLOCK=101 END_BLOCK=200
+START_BLOCK=101 END_BLOCK=200 ./scripts/benchmark_cchain_range.sh
 ```
 
 Note: if you attempt to re-execute a second time on the same data set, it will fail because the current state has been updated to block 200.
 
 ### Re-Execute C-Chain Range with Copied Data
 
-Next, we can re-execute the same range using the `CURRENT_STATE_DIR` that we exported to S3 using `reexecute-cchain-with-copied-data`.
+Next, we can re-execute the same range using the `CURRENT_STATE_DIR` that we exported to S3.
 
 This time we will copy the same block directory from S3 and copy the state snapshot that we just exported into S3 to pick up re-execution from where we left off.
 
@@ -234,12 +237,12 @@ Specify the following parameters:
 We'll use a new `EXECUTION_DATA_DIR` for this run to avoid conflicts with previous runs from this walkthrough:
 
 ```bash
-task reexecute-cchain-range-with-copied-data EXECUTION_DATA_DIR=$HOME/.reexecute-cchain/reexecute-with-copied-data BLOCK_DIR_SRC=s3://avalanchego-bootstrap-testing/cchain-mainnet-blocks-10k-ldb/** CURRENT_STATE_DIR_SRC=s3://avalanchego-bootstrap-testing/cchain-current-state-test/** START_BLOCK=101 END_BLOCK=10000
+BLOCK_DIR_SRC=cchain-mainnet-blocks-10k-ldb CURRENT_STATE_DIR_SRC=cchain-current-state-test START_BLOCK=101 END_BLOCK=10000 EXECUTION_DATA_DIR=$HOME/.reexecute-cchain/reexecute-with-copied-data ./scripts/benchmark_cchain_range.sh
 ```
 
 ## Predefined Configs
 
-To support testing the VM in multiple configurations, the benchmark supports a set of pre-defined configs passed via the Task variable ex. `CONFIG=archive`.
+To support testing the VM in multiple configurations, the benchmark supports a set of pre-defined configs passed via the `CONFIG` environment variable.
 
 The currently supported options are: "default", "archive", and "firewood".
 
@@ -255,12 +258,12 @@ To export metrics for a local run, set the environment variables `METRICS_COLLEC
 
 ```bash
 export METRICS_COLLECTOR_ENABLED=true
-./scripts/run_task.sh c-chain-reexecution-hashdb-101-250k
+./scripts/benchmark_cchain_range.sh hashdb-101-250k
 ```
 
-You can view granular C-Chain processing metrics with the label attached to this job (job="c-chain-reexecution") [here](https://grafana-poc.avax-dev.network/d/Gl1I20mnk/c-chain?orgId=1&from=now-5m&to=now&timezone=browser&var-datasource=P1809F7CD0C75ACF3&var-filter=job%7C%3D%7Cc-chain-reexecution&var-chain=C&refresh=10s).  
+You can view granular C-Chain processing metrics with the label attached to this job (job="c-chain-reexecution") [here](https://grafana-poc.avax-dev.network/d/Gl1I20mnk/c-chain?orgId=1&from=now-5m&to=now&timezone=browser&var-datasource=P1809F7CD0C75ACF3&var-filter=job%7C%3D%7Cc-chain-reexecution&var-chain=C&refresh=10s).
 
-**NOTE: Prometheus credentials are required for collection**  
+**NOTE: Prometheus credentials are required for collection**
 
 ---
 
@@ -294,15 +297,15 @@ Both workflows provide three triggers:
 The manual workflow takes in all parameters specified by the user. To more easily specify a CI matrix and avoid GitHub's pain inducing matrix syntax, we define simple JSON files with the exact set of configs to run for each `pull_request` and `schedule` trigger. To add a new job for either of these triggers, simply define the entry in JSON and add it to run on the desired workflow.
 
 The workflows support two approaches:
-1. **Task-based**: Specify a predefined `task` name (e.g., `"task": "c-chain-reexecution-firewood-101-250k"`)
-2. **Custom parameters**: Specify individual parameters with `"task": ""` and provide `config`, `start-block`, `end-block`, `block-dir-src`, `current-state-dir-src`
+1. **Test-based**: Specify a predefined `test` name (e.g., `"test": "firewood-101-250k"`)
+2. **Custom parameters**: Leave `test` empty and provide `config`, `start-block`, `end-block`, `block-dir-src`, `current-state-dir-src`
 
-For example, to add a new task-based Firewood benchmark to execute the block range [101, 250K] on a daily basis, add the following entry under the `schedule` include array in the [GH Native JSON file](../../../.github/workflows/c-chain-reexecution-benchmark-gh-native.json).
+For example, to add a Firewood benchmark to execute the block range [101, 250K] on a daily basis, add the following entry under the `schedule` include array in the [GH Native JSON file](../../../.github/workflows/c-chain-reexecution-benchmark-gh-native.json).
 
 ```json
 {
     "runner": "blacksmith-4vcpu-ubuntu-2404",
-    "task": "c-chain-reexecution-firewood-101-250k",
+    "test": "firewood-101-250k",
     "timeout-minutes": 30
 }
 ```
@@ -311,11 +314,11 @@ For example, to add a new task-based Firewood benchmark to execute the block ran
 
 To trigger runs conveniently, you can use the [GitHub CLI](https://cli.github.com/manual/gh_workflow_run) to trigger workflows.
 
-### Using a Predefined Task
+### Using a Predefined Test
 
 ```bash
 gh workflow run "C-Chain Re-Execution Benchmark GH Native" \
-  -f task=c-chain-reexecution-firewood-101-250k \
+  -f test=firewood-101-250k \
   -f runner=blacksmith-4vcpu-ubuntu-2404 \
   -f timeout-minutes=60
 ```
@@ -324,7 +327,6 @@ gh workflow run "C-Chain Re-Execution Benchmark GH Native" \
 
 ```bash
 gh workflow run "C-Chain Re-Execution Benchmark GH Native" \
-  -f task="" \
   -f block-dir-src=cchain-mainnet-blocks-1m-ldb \
   -f current-state-dir-src=cchain-current-state-hashdb-full-100 \
   -f start-block=101 \