diff --git a/.azure-pipelines/gpu-tests.yml b/.azure-pipelines/gpu-tests.yml
index a941c232..bc1d9d12 100644
--- a/.azure-pipelines/gpu-tests.yml
+++ b/.azure-pipelines/gpu-tests.yml
@@ -65,6 +65,7 @@ jobs:
         HF_HUB_CACHE: /opt/interpretune/hf_cache/hub
         TRANSFORMERS_CACHE: /opt/interpretune/hf_cache/transformers
         XDG_CACHE_HOME: /opt/interpretune/hf_cache
+        APPLY_POST_UPGRADES: "false"
 
     workspace:
       clean: outputs
@@ -96,16 +97,21 @@ jobs:
 
       - bash: |
           . /tmp/venvs/it_dev/bin/activate
-          python -m pip install --upgrade pip setuptools wheel build
-          python -m pip install -r requirements/ci/requirements.txt -r requirements/platform_dependent.txt --no-warn-script-location
+          python -m pip install --upgrade pip setuptools setuptools-scm wheel build
+          python -m pip install -r requirements/ci/requirements.txt -r requirements/ci/platform_dependent.txt --no-warn-script-location
           python -m pip install -e '.[test,examples,lightning]'  --no-warn-script-location
-          python -m pip install --upgrade -r requirements/post_upgrades.txt  --no-warn-script-location
+          if ([ "${APPLY_POST_UPGRADES:-}" = "1" ] || [ "${APPLY_POST_UPGRADES:-}" = "true" ]) && [ -s requirements/ci/post_upgrades.txt ]; then
+            echo "Applying post-upgrades (requirements/ci/post_upgrades.txt)..."
+            python -m pip install --upgrade -r requirements/ci/post_upgrades.txt --cache-dir "$PIP_CACHE_DIR"
+          else
+            echo "Skipping post-upgrades (either disabled or file empty)."
+          fi
+          python -m pip list
         displayName: 'Install dependencies'
 
       - bash: |
           . /tmp/venvs/it_dev/bin/activate
-          python requirements/collect_env_details.py
-          python scripts/ci_print_env_versions.py
+          python requirements/utils/collect_env_details.py
         displayName: 'Env details and package versions'
 
       - bash: |
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 33e862cb..45db93e3 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -27,12 +27,12 @@ but remember, bugs with code are fixed faster!
 
 <!--
 Please copy and paste the output from our environment collection script:
-https://raw.githubusercontent.com/speediedan/interpretune/main/requirements/collect_env_details.py
+https://raw.githubusercontent.com/speediedan/interpretune/main/requirements/utils/collect_env_details.py
 (For security purposes, please check the contents of the script before running it)
 
 You can get the script and run it with:
 ```bash
-wget https://raw.githubusercontent.com/speediedan/interpretune/main/requirements/collect_env_details.py
+wget https://raw.githubusercontent.com/speediedan/interpretune/main/requirements/utils/collect_env_details.py
 python collect_env_details.py
 ```
 
diff --git a/.github/actions/install-ci-dependencies/action.yml b/.github/actions/install-ci-dependencies/action.yml
index b8afd1dd..923d3c90 100644
--- a/.github/actions/install-ci-dependencies/action.yml
+++ b/.github/actions/install-ci-dependencies/action.yml
@@ -17,13 +17,13 @@ runs:
     - name: Set up venv and install ci dependencies
       shell: bash
       run: |
-        python -m pip install --upgrade pip setuptools wheel build --cache-dir "$PIP_CACHE_DIR"
+        python -m pip install --upgrade pip setuptools setuptools-scm wheel build --cache-dir "$PIP_CACHE_DIR"
         # Prefer CI pinned requirements if present
         if [ -f requirements/ci/requirements.txt ]; then
           pip install -r requirements/ci/requirements.txt --cache-dir "$PIP_CACHE_DIR"
           python -m pip install -e '.[test,examples,lightning]' --cache-dir "$PIP_CACHE_DIR"
         else
-          python -m pip install -e '.[test,examples,lightning]' -c requirements/ci_constraints.txt --cache-dir "$PIP_CACHE_DIR"
+          python -m pip install -e '.[test,examples,lightning]' --cache-dir "$PIP_CACHE_DIR"
         fi
         if [ "${{ inputs.show_pip_list }}" = "true" ]; then
           pip list
@@ -33,9 +33,9 @@ runs:
       shell: bash
       run: |
         # Install platform-dependent packages with flexible constraints to allow platform-specific resolution
-        if [ -f requirements/platform_dependent.txt ] && [ -s requirements/platform_dependent.txt ]; then
-          echo "Installing platform-dependent packages..."
-          python -m pip install -r requirements/platform_dependent.txt --cache-dir "$PIP_CACHE_DIR" || echo "Some platform-dependent packages may not be available on this platform, continuing..."
+        if [ -f requirements/ci/platform_dependent.txt ] && [ -s requirements/ci/platform_dependent.txt ]; then
+          echo "Installing platform-dependent packages from requirements/ci/platform_dependent.txt..."
+          python -m pip install -r requirements/ci/platform_dependent.txt --cache-dir "$PIP_CACHE_DIR" || echo "Some platform-dependent packages may not be available on this platform, continuing..."
         else
           echo "No platform-dependent packages to install."
         fi
@@ -45,9 +45,9 @@ runs:
       env:
         APPLY_POST_UPGRADES: ${{ inputs.apply_post_upgrades }}
       run: |
-        if ([ "${APPLY_POST_UPGRADES}" = "1" ] || [ "${APPLY_POST_UPGRADES}" = "true" ]) && [ -s requirements/post_upgrades.txt ]; then
-          echo "Applying post-upgrades..."
-          python -m pip install --upgrade -r requirements/post_upgrades.txt --cache-dir "$PIP_CACHE_DIR"
+        if ([ "${APPLY_POST_UPGRADES}" = "1" ] || [ "${APPLY_POST_UPGRADES}" = "true" ]) && [ -s requirements/ci/post_upgrades.txt ]; then
+          echo "Applying post-upgrades (requirements/ci/post_upgrades.txt)..."
+          python -m pip install --upgrade -r requirements/ci/post_upgrades.txt --cache-dir "$PIP_CACHE_DIR"
           if [ "${{ inputs.show_pip_list }}" = "true" ]; then
             pip list
           fi
diff --git a/.github/actions/regen-ci-reqs/action.yml b/.github/actions/regen-ci-reqs/action.yml
index 212fdb60..8acae805 100644
--- a/.github/actions/regen-ci-reqs/action.yml
+++ b/.github/actions/regen-ci-reqs/action.yml
@@ -12,7 +12,7 @@ inputs:
   compare_paths:
     description: Space-separated list of files/paths to compare with git diff
     required: false
-    default: "requirements/ci/requirements.txt requirements/post_upgrades.txt requirements/platform_dependent.txt"
+    default: "requirements/ci/requirements.txt requirements/ci/post_upgrades.txt requirements/ci/platform_dependent.txt"
   patch_path:
     description: Path to write the patch file
     required: false
@@ -34,7 +34,7 @@ runs:
     - name: Run regen (pip-compile)
       shell: bash
       run: |
-        python requirements/regen_reqfiles.py --mode pip-compile --ci-output-dir=${{ inputs.ci_output_dir }}
+        python requirements/utils/regen_reqfiles.py --mode pip-compile --ci-output-dir=${{ inputs.ci_output_dir }}
 
     - id: check
       name: Check for diffs and write patch
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 4fad98f3..b72aa741 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -35,11 +35,9 @@ Always install dependencies in order to avoid conflicts:
 
 ```bash
 # Basic development setup
-python -m pip install --upgrade pip setuptools wheel build
-python -m pip install -r requirements/ci/requirements.txt -r requirements/platform_dependent.txt
+python -m pip install --upgrade pip setuptools setuptools-scm wheel build
+python -m pip install -r requirements/ci/requirements.txt -r requirements/ci/platform_dependent.txt
 python -m pip install -e '.[test,examples,lightning]'
-# enabled until further notice (will be removed from instructions once no longer necessary)
-pip install --upgrade -r requirements/post_upgrades.txt
 
 # If circuit-tracer install fails, use the built-in tool after basic install:
 pip install interpretune[examples]
@@ -55,8 +53,8 @@ For complex setups, use the provided build script:
 # Standard development build (recommended for dev work)
 ./scripts/build_it_env.sh --repo_home=${PWD} --target_env_name=it_latest
 
-# Build without circuit-tracer commit pin
-./scripts/build_it_env.sh --repo_home=${PWD} --target_env_name=it_latest --no_commit_pin
+# Build with a circuit-tracer commit pin
+./scripts/build_it_env.sh --repo_home=${PWD} --target_env_name=it_latest
 ```
 
 ### Linting and Code Quality
@@ -128,7 +126,6 @@ src/it_examples/            # Example experiments
 - `.pre-commit-config.yaml` - Code quality hooks
 - `requirements/` - Pinned dependency files
   - `base.txt` - Core dependencies
-  - `ci_constraints.txt` - CI version pins
   - `test.txt`, `examples.txt`, etc. - Optional dependency groups
 
 ### Key Entry Points
@@ -183,8 +180,7 @@ When updating top-level requirements or periodically refreshing CI pins, use the
 Run these commands from your repo home after activating ensuring you've activated any relevant venv (e.g. `source ~/.venvs/${target_env_name}/bin/activate`):
 
 ```bash
-python requirements/regen_reqfiles.py && \
-python requirements/regen_reqfiles.py --mode pip-compile --ci-output-dir=requirements/ci
+python requirements/utils/regen_reqfiles.py --mode pip-compile --ci-output-dir=requirements/ci
 ```
 
 Notes:
diff --git a/.github/workflows/ci_test-full.yml b/.github/workflows/ci_test-full.yml
index 6e89cb35..d13a0022 100644
--- a/.github/workflows/ci_test-full.yml
+++ b/.github/workflows/ci_test-full.yml
@@ -171,7 +171,7 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ${{ env.PIP_CACHE_DIR }}/wheels
-          key: ${{ runner.os }}-pip-wheels-${{ steps.set_time_period.outputs.TIME_PERIOD }}-py${{ matrix.python-version }}-${{ hashFiles('requirements/ci/requirements.txt') }}-${{ hashFiles('requirements/post_upgrades.txt') }}-${{ hashFiles('requirements/platform_dependent.txt') }}
+          key: ${{ runner.os }}-pip-wheels-${{ steps.set_time_period.outputs.TIME_PERIOD }}-py${{ matrix.python-version }}-${{ hashFiles('requirements/ci/requirements.txt') }}-${{ hashFiles('requirements/ci/post_upgrades.txt') }}-${{ hashFiles('requirements/ci/platform_dependent.txt') }}
           restore-keys: |
             ${{ runner.os }}-pip-wheels-${{ steps.set_time_period.outputs.TIME_PERIOD }}-py${{ matrix.python-version }}-
 
diff --git a/.github/workflows/copilot-setup-steps.yml b/.github/workflows/copilot-setup-steps.yml
index 161e9260..b7f39427 100644
--- a/.github/workflows/copilot-setup-steps.yml
+++ b/.github/workflows/copilot-setup-steps.yml
@@ -47,7 +47,7 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ${{ env.PIP_CACHE_DIR }}/wheels
-          key: ubuntu-22.04-pip-wheels-${{ steps.set_time_period.outputs.TIME_PERIOD }}-py3.12-${{ hashFiles('requirements/ci/requirements.txt') }}-${{ hashFiles('requirements/post_upgrades.txt') }}-${{ hashFiles('requirements/platform_dependent.txt') }}
+          key: ubuntu-22.04-pip-wheels-${{ steps.set_time_period.outputs.TIME_PERIOD }}-py3.12-${{ hashFiles('requirements/ci/requirements.txt') }}-${{ hashFiles('requirements/ci/post_upgrades.txt') }}-${{ hashFiles('requirements/ci/platform_dependent.txt') }}
           restore-keys: |
             ubuntu-22.04-pip-wheels-${{ steps.set_time_period.outputs.TIME_PERIOD }}-py3.12-
 
diff --git a/.github/workflows/regen-ci-req-check.yml b/.github/workflows/regen-ci-req-check.yml
index f7b4a803..af6a87cc 100644
--- a/.github/workflows/regen-ci-req-check.yml
+++ b/.github/workflows/regen-ci-req-check.yml
@@ -21,7 +21,7 @@ jobs:
         with:
           python_version: '3.12'
           ci_output_dir: requirements/ci
-          compare_paths: "requirements/ci/requirements.txt requirements/post_upgrades.txt requirements/platform_dependent.txt"
+          compare_paths: "requirements/ci/requirements.txt requirements/ci/post_upgrades.txt requirements/ci/platform_dependent.txt"
           patch_path: /tmp/regen_diff.patch
 
       - name: Create PR with updated pins
diff --git a/.github/workflows/regen-ci-req-report.yml b/.github/workflows/regen-ci-req-report.yml
index 5ca3d3ef..8b83bb11 100644
--- a/.github/workflows/regen-ci-req-report.yml
+++ b/.github/workflows/regen-ci-req-report.yml
@@ -62,7 +62,7 @@ jobs:
         with:
           python_version: '3.12'
           ci_output_dir: requirements/ci
-          compare_paths: "requirements/ci/requirements.txt requirements/post_upgrades.txt requirements/platform_dependent.txt"
+          compare_paths: "requirements/ci/requirements.txt requirements/ci/post_upgrades.txt requirements/ci/platform_dependent.txt"
           patch_path: /tmp/regen_diff.patch
 
       - name: Upload regen diff (if present)
diff --git a/.github/workflows/type-check.yml b/.github/workflows/type-check.yml
index 40a97600..4cee9920 100644
--- a/.github/workflows/type-check.yml
+++ b/.github/workflows/type-check.yml
@@ -73,14 +73,14 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ${{ env.PIP_CACHE_DIR }}/wheels
-          key: ubuntu-22.04-pip-wheels-${{ steps.set_time_period.outputs.TIME_PERIOD }}-py3.12-${{ hashFiles('requirements/ci/requirements.txt') }}-${{ hashFiles('requirements/post_upgrades.txt') }}-${{ hashFiles('requirements/platform_dependent.txt') }}
+          key: ubuntu-22.04-pip-wheels-${{ steps.set_time_period.outputs.TIME_PERIOD }}-py3.12-${{ hashFiles('requirements/ci/requirements.txt') }}-${{ hashFiles('requirements/ci/post_upgrades.txt') }}-${{ hashFiles('requirements/ci/platform_dependent.txt') }}
           restore-keys: |
             ubuntu-22.04-pip-wheels-${{ steps.set_time_period.outputs.TIME_PERIOD }}-py3.12-
 
       - name: Install CI dependencies
         uses: ./.github/actions/install-ci-dependencies
         with:
-          apply_post_upgrades: ${{ vars.APPLY_POST_UPGRADES || 'true' }}
+          apply_post_upgrades: ${{ vars.APPLY_POST_UPGRADES || 'false' }}
 
       - name: Check type stubs are up to date
         id: check_stubs
diff --git a/MANIFEST.in b/MANIFEST.in
index 0f1f90fc..476e79aa 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -17,15 +17,8 @@ include requirements.txt
 # Excludes
 # -----------------------------------------------------------------------
 # ci requirements
-recursive-exclude requirements/ci *
-
-# misc dev req files
-exclude requirements/ci_constraints.txt
-exclude requirements/post_upgrades.txt
-exclude requirements/collect_env_details.py
-exclude requirements/regen_reqfiles.py
-exclude requirements/circuit_tracer_pin.txt
-exclude requirements/platform_dependent.txt
+prune requirements/ci
+prune requirements/utils
 
 # legacy/duplicate packaging config files from the sdist
 # Note: setuptools writes a small setup.cfg and interpretune.egg-info dir into the sdist release tree that would require
diff --git a/Makefile b/Makefile
index f9743637..64c9848b 100644
--- a/Makefile
+++ b/Makefile
@@ -3,6 +3,7 @@
 .PHONY: help lint test build sdist wheel clean
 
 export SPHINX_MOCK_REQUIREMENTS=1
+# TODO: remove this once CT is available via PyPI or our own package index
 export IT_USE_CT_COMMIT_PIN="1"
 
 help:
@@ -32,8 +33,6 @@ lint:
 test: clean
 	pip install -r requirements/devel.txt
 	# TODO: remove this once no longer necessary
-	pip install --upgrade -r requirements/post_upgrades.txt
-	# TODO: remove this once no longer necessary
 	@echo "Using IT_USE_CT_COMMIT_PIN for circuit-tracer installation"
 	interpretune-install-circuit-tracer
 	# run tests with coverage (cpu-only, running gpu standalone tests required for full coverage)
diff --git a/docs/CIRCUIT_TRACER_INSTALLATION.md b/docs/CIRCUIT_TRACER_INSTALLATION.md
index 808cbfbf..c7e06065 100644
--- a/docs/CIRCUIT_TRACER_INSTALLATION.md
+++ b/docs/CIRCUIT_TRACER_INSTALLATION.md
@@ -51,7 +51,7 @@ This installs circuit-tracer from a specific tested commit for maximum compatibi
 ### Using Version-based Installation
 
 ```bash
-interpretune-install-circuit-tracer --no-commit-pin
+interpretune-install-circuit-tracer
 ```
 
 This attempts to install circuit-tracer from PyPI (currently not available, will fail).
@@ -78,8 +78,8 @@ For development environments, the build scripts handle circuit-tracer installati
 # Standard development build (uses commit pin)
 ./scripts/build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest
 
-# Development build without commit pin
-./scripts/build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --no_commit_pin
+# Development build without CT commit pin
+./scripts/build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest
 
 # Development build with local circuit-tracer source
 ./scripts/build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --ct_from_source=${HOME}/repos/circuit-tracer
diff --git a/pyproject.toml b/pyproject.toml
index 8cf81497..8fa5a12a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -36,7 +36,7 @@ dependencies = [
     "sae_lens >= 6.3.1",  # use new sae_lens API
     "torch >=2.7.1",
     "tabulate >= 0.9.0",
-    "datasets >= 2.2.0",
+    "datasets >= 4.0.0",
     "jsonargparse[signatures] >= 4.35.0",  # replace this req once adding fts req
     # "finetuning-scheduler[possible_future_it_plugin] >= 2.5.0",
 ]
@@ -49,7 +49,6 @@ dependencies = [
 
 [project.entry-points."console_scripts"]
 interpretune = "interpretune.base.components.cli:bootstrap_cli"
-interpretune-install-circuit-tracer = "interpretune.tools.install_circuit_tracer:main"
 
 [project.optional-dependencies]
 
@@ -76,13 +75,13 @@ examples = [
 "evaluate",
 "scikit-learn",
 "neuronpedia",
-# TODO: add our packaged circuit-tracer dep (either origin or fork) once it is available and remove the
+# TODO: add our packaged circuit-tracer dep (either pypi or pypi fork) once it is available and remove the
 #       `install_circuit_tracer` tool
-# "circuit-tracer @ git+https://github.com/speediedan/circuit-tracer.git@6c74ea291c410bb3391e572cd6a8d020be714922",
+# "circuit-tracer @ git+https://github.com/speediedan/circuit-tracer.git@75fd21f666cbdaece57eca561b4342ad84746b40",
 ]
 
 docs = [
-"sphinx >=4.0,<5.0 ",
+"sphinx >= 4.0",
 "myst-parser >= 0.18.1",
 "nbsphinx >= 0.8.5",
 "pandoc >= 1.0",
@@ -131,7 +130,6 @@ namespaces = true
 [tool.setuptools_scm]
 fallback_version = "0.1.0.dev0"
 
-
 [tool.ruff]
 line-length = 120
 # Enable Pyflakes `E` and `F` codes by default.
@@ -245,5 +243,4 @@ platform_dependent = ["bitsandbytes"]
 
 # packages that should be applied as post-upgrades (package -> desired_version)
 [tool.ci_pinning.post_upgrades]
-datasets = "==4.0.0"
-fsspec = ">=2025.3.0"
+# no packages currently require post installation upgrades
diff --git a/requirements/base.txt b/requirements/base.txt
index 29ffd88d..7b1ae9da 100644
--- a/requirements/base.txt
+++ b/requirements/base.txt
@@ -2,5 +2,5 @@ transformer_lens >= 2.15.4
 sae_lens >= 6.3.1
 torch >=2.7.1
 tabulate >= 0.9.0
-datasets >= 2.2.0
+datasets >= 4.0.0
 jsonargparse[signatures] >= 4.35.0
diff --git a/requirements/ci/circuit_tracer_pin.txt b/requirements/ci/circuit_tracer_pin.txt
new file mode 100644
index 00000000..6a35da0c
--- /dev/null
+++ b/requirements/ci/circuit_tracer_pin.txt
@@ -0,0 +1 @@
+75fd21f666cbdaece57eca561b4342ad84746b40
diff --git a/requirements/platform_dependent.txt b/requirements/ci/platform_dependent.txt
similarity index 100%
rename from requirements/platform_dependent.txt
rename to requirements/ci/platform_dependent.txt
diff --git a/requirements/ci/post_upgrades.txt b/requirements/ci/post_upgrades.txt
new file mode 100644
index 00000000..e69de29b
diff --git a/requirements/ci/requirements.in b/requirements/ci/requirements.in
index 154b91d3..061401d8 100644
--- a/requirements/ci/requirements.in
+++ b/requirements/ci/requirements.in
@@ -2,6 +2,7 @@ transformer_lens >= 2.15.4
 sae_lens >= 6.3.1
 torch >=2.7.1
 tabulate >= 0.9.0
+datasets >= 4.0.0
 jsonargparse[signatures] >= 4.35.0
 finetuning-scheduler >= 2.5.0
 peft
@@ -28,4 +29,4 @@ psycopg
 toml
 pip-tools
 huggingface_hub[hf_xet]
-git+https://github.com/speediedan/circuit-tracer.git@6c74ea291c410bb3391e572cd6a8d020be714922#egg=circuit-tracer
+git+https://github.com/speediedan/circuit-tracer.git@75fd21f666cbdaece57eca561b4342ad84746b40#egg=circuit-tracer
diff --git a/requirements/ci/requirements.txt b/requirements/ci/requirements.txt
index 24c57c78..fdf59ecb 100644
--- a/requirements/ci/requirements.txt
+++ b/requirements/ci/requirements.txt
@@ -2,21 +2,27 @@
 # This file is autogenerated by pip-compile with Python 3.12
 # by the following command:
 #
-#    pip-compile --output-file=requirements/ci/requirements.txt requirements/ci/requirements.in
+#    pip-compile --cert=None --client-cert=None --index-url=None --output-file=requirements/ci/requirements.txt --pip-args=None requirements/ci/requirements.in
 #
-circuit-tracer @ git+https://github.com/speediedan/circuit-tracer.git@6c74ea291c410bb3391e572cd6a8d020be714922
+circuit-tracer @ git+https://github.com/speediedan/circuit-tracer.git@75fd21f666cbdaece57eca561b4342ad84746b40
     # via -r requirements/ci/requirements.in
 coverage==7.10.6
     # via
     #   -r requirements/ci/requirements.in
     #   nbval
-evaluate==0.4.5
+datasets==4.1.1
+    # via
+    #   -r requirements/ci/requirements.in
+    #   evaluate
+    #   sae-lens
+    #   transformer-lens
+evaluate==0.4.6
     # via -r requirements/ci/requirements.in
 finetuning-scheduler==2.5.3
     # via -r requirements/ci/requirements.in
 gdown==5.2.0
     # via -r requirements/ci/requirements.in
-huggingface-hub[hf-xet]==0.34.5
+huggingface-hub[hf-xet]==0.35.0
     # via
     #   -r requirements/ci/requirements.in
     #   accelerate
@@ -27,7 +33,9 @@ huggingface-hub[hf-xet]==0.34.5
     #   tokenizers
     #   transformers
 ipywidgets==8.1.7
-    # via -r requirements/ci/requirements.in
+    # via
+    #   -r requirements/ci/requirements.in
+    #   circuit-tracer
 jsonargparse[signatures,typing-extensions]==4.41.0
     # via -r requirements/ci/requirements.in
 jupyterlab==4.4.7
@@ -60,7 +68,6 @@ pyright==1.1.405
 pytest==8.4.2
     # via
     #   -r requirements/ci/requirements.in
-    #   circuit-tracer
     #   nbval
     #   pytest-rerunfailures
 pytest-rerunfailures==16.0.1
diff --git a/requirements/ci_constraints.txt b/requirements/ci_constraints.txt
deleted file mode 100644
index e74c2927..00000000
--- a/requirements/ci_constraints.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-# TODO: the need for this file should be obviated by sae_lens bumping datasets support to a modern version
-#       remove this file when sae_lens is updated
-# Pin datasets to 2.21.0 for old sae_lens requirement
-# This is necessary until sae_lens is updated to support newer datasets versions
-
-datasets==2.21.0
diff --git a/requirements/circuit_tracer_pin.txt b/requirements/circuit_tracer_pin.txt
deleted file mode 100644
index d17c6f1e..00000000
--- a/requirements/circuit_tracer_pin.txt
+++ /dev/null
@@ -1 +0,0 @@
-6c74ea291c410bb3391e572cd6a8d020be714922
diff --git a/requirements/collect_env_details.py b/requirements/collect_env_details.py
deleted file mode 100644
index f6f4c2ab..00000000
--- a/requirements/collect_env_details.py
+++ /dev/null
@@ -1,88 +0,0 @@
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Initially based on: https://bit.ly/34f7gDv
-"""Diagnose your system and show basic information.
-
-This server mainly to get detail info for better bug reporting.
-"""
-
-import os
-import platform
-
-import numpy
-import torch
-import tqdm
-
-import lightning.pytorch
-
-import finetuning_scheduler
-
-LEVEL_OFFSET = "\t"
-KEY_PADDING = 20
-
-
-def info_system():
-    return {
-        "OS": platform.system(),
-        "architecture": platform.architecture(),
-        "version": platform.version(),
-        "processor": platform.processor(),
-        "python": platform.python_version(),
-    }
-
-
-def info_cuda():
-    return {
-        "GPU": [torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())],
-        "available": torch.cuda.is_available(),
-        "version": torch.version.cuda,
-    }
-
-
-def info_packages():
-    return {
-        "numpy": numpy.__version__,
-        "pyTorch_version": torch.__version__,
-        "pyTorch_git_version": torch.version.git_version,
-        "pyTorch_debug": torch.version.debug,
-        "pytorch-lightning": lightning.pytorch.__version__,
-        "finetuning-scheduler": finetuning_scheduler.__version__,
-        "tqdm": tqdm.__version__,
-    }
-
-
-def nice_print(details, level=0):
-    lines = []
-    for k in sorted(details):
-        key = f"* {k}:" if level == 0 else f"- {k}:"
-        if isinstance(details[k], dict):
-            lines += [level * LEVEL_OFFSET + key]
-            lines += nice_print(details[k], level + 1)
-        elif isinstance(details[k], (set, list, tuple)):
-            lines += [level * LEVEL_OFFSET + key]
-            lines += [(level + 1) * LEVEL_OFFSET + "- " + v for v in details[k]]
-        else:
-            template = "{:%is} {}" % KEY_PADDING
-            key_val = template.format(key, details[k])
-            lines += [(level * LEVEL_OFFSET) + key_val]
-    return lines
-
-
-def main():
-    details = {"System": info_system(), "CUDA": info_cuda(), "Packages": info_packages()}
-    lines = nice_print(details)
-    text = os.linesep.join(lines)
-    print(text)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/requirements/docs.txt b/requirements/docs.txt
index 9d915bf4..1ddd9b82 100644
--- a/requirements/docs.txt
+++ b/requirements/docs.txt
@@ -1,4 +1,4 @@
-sphinx >=4.0,<5.0
+sphinx >= 4.0
 myst-parser >= 0.18.1
 nbsphinx >= 0.8.5
 pandoc >= 1.0
diff --git a/requirements/post_upgrades.txt b/requirements/post_upgrades.txt
deleted file mode 100644
index 5f2dd913..00000000
--- a/requirements/post_upgrades.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-datasets==4.0.0
-fsspec>=2025.3.0
diff --git a/requirements/utils/collect_env_details.py b/requirements/utils/collect_env_details.py
new file mode 100644
index 00000000..15dc4e8f
--- /dev/null
+++ b/requirements/utils/collect_env_details.py
@@ -0,0 +1,139 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Initially based on: https://bit.ly/34f7gDv
+"""Diagnose your system and show basic information.
+
+This server mainly to get detail info for better bug reporting.
+"""
+
+import os
+import platform
+
+import argparse
+import importlib
+import importlib.metadata as md
+import torch
+
+LEVEL_OFFSET = "\t"
+KEY_PADDING = 20
+
+
+def info_system():
+    return {
+        "OS": platform.system(),
+        "architecture": platform.architecture(),
+        "version": platform.version(),
+        "processor": platform.processor(),
+        "python": platform.python_version(),
+    }
+
+
+def info_cuda():
+    return {
+        "GPU": [torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())],
+        "available": torch.cuda.is_available(),
+        "version": getattr(getattr(torch, "version", object()), "cuda", None),
+    }
+
+
+def info_packages():
+    def _pkg_version(pkg_name: str, module_name: str | None = None) -> str:
+        """Return a best-effort version for a package.
+
+        Tries to import the module and read __version__, then falls back to importlib.metadata.version(pkg_name).
+        Returns a readable failure string on error.
+        """
+        try:
+            if module_name:
+                mod = importlib.import_module(module_name)
+            else:
+                mod = importlib.import_module(pkg_name)
+            ver = getattr(mod, "__version__", None)
+            if ver:
+                return ver
+        except Exception:
+            # ignore and try metadata lookup
+            pass
+        try:
+            return md.version(pkg_name)
+        except Exception as e:
+            return f"not found ({e})"
+
+    packages = {
+        "interpretune": _pkg_version("interpretune", "interpretune"),
+        "lightning": _pkg_version("lightning", "lightning"),
+        "transformer_lens": _pkg_version("transformer_lens", "transformer_lens"),
+        "sae_lens": _pkg_version("sae_lens", "sae_lens"),
+        "circuit_tracer": _pkg_version("circuit_tracer", "circuit_tracer"),
+        "neuronpedia": _pkg_version("neuronpedia", "neuronpedia"),
+        "finetuning_scheduler": _pkg_version("finetuning_scheduler", "finetuning_scheduler"),
+        "transformers": _pkg_version("transformers", "transformers"),
+        "datasets": _pkg_version("datasets", "datasets"),
+        "numpy": _pkg_version("numpy", "numpy"),
+        "tqdm": _pkg_version("tqdm", "tqdm"),
+    }
+
+    # Add PyTorch-specific runtime info as separate keys to preserve previous fields
+    packages.update(
+        {
+            "torch": getattr(torch, "__version__", packages.get("torch", "not found")),
+            "torch_git_version": getattr(getattr(torch, "version", object()), "git_version", "not found"),
+            "torch_debug_mode": getattr(getattr(torch, "version", object()), "debug", "not found"),
+        }
+    )
+
+    return packages
+
+
+def nice_print(details, level=0):
+    lines = []
+    for k in sorted(details):
+        key = f"* {k}:" if level == 0 else f"- {k}:"
+        if isinstance(details[k], dict):
+            lines += [level * LEVEL_OFFSET + key]
+            lines += nice_print(details[k], level + 1)
+        elif isinstance(details[k], (set, list, tuple)):
+            lines += [level * LEVEL_OFFSET + key]
+            lines += [(level + 1) * LEVEL_OFFSET + "- " + v for v in details[k]]
+        else:
+            template = "{:%is} {}" % KEY_PADDING
+            key_val = template.format(key, details[k])
+            lines += [(level * LEVEL_OFFSET) + key_val]
+    return lines
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Diagnose system and print environment/package details",
+    )
+    parser.add_argument(
+        "--packages-only",
+        action="store_true",
+        help="Output only the package versions (JSON-like printed dict)",
+    )
+    args = parser.parse_args()
+
+    packages = info_packages()
+    if args.packages_only:
+        # Print packages section only in a compact, human-readable form
+        lines = nice_print({"Key Package Versions": packages})
+        print(os.linesep.join(lines))
+        return
+
+    details = {"System": info_system(), "CUDA": info_cuda(), "Packages": packages}
+    lines = nice_print(details)
+    text = os.linesep.join(lines)
+    print(text)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/requirements/regen_reqfiles.py b/requirements/utils/regen_reqfiles.py
similarity index 60%
rename from requirements/regen_reqfiles.py
rename to requirements/utils/regen_reqfiles.py
index a5bfeac5..d4b01735 100644
--- a/requirements/regen_reqfiles.py
+++ b/requirements/utils/regen_reqfiles.py
@@ -6,14 +6,56 @@
 import shutil
 import toml
 import re
+from dataclasses import dataclass
+from typing import Dict, List
+
+# Commit-based pin selection logic
+# --------------------------------
+# This module supports a small workflow for installing important helper
+# packages either from a version bound declared in `pyproject.toml` (preferred)
+# or from a specific commit SHA recorded in a pin file under
+# `requirements/ci/<pin_filename>`. The selection rules are:
+# 1. If the package-specific environment variable (e.g. `IT_USE_CT_COMMIT_PIN`)
+#    is set to a truthy value ("1", "true", "yes"), the pin-file-based
+#    commit installation is selected.
+# 2. Otherwise, if the package appears in the pyproject location declared by
+#    its mapping (for example the `examples` optional extra), the pyproject
+#    requirement (including any version bounds) is used.
+# 3. If neither of the above applies, the code falls back to the pin file (if
+#    present) as a best-effort final option.
+#
+# The mapping `DEP_COMMIT_PINS` at the top of this file controls which
+# packages participate in this flow; add new entries to enable the same
+# behavior for other packages.
 
 # Paths
 REQ_DIR = os.path.dirname(os.path.abspath(__file__))
-REPO_ROOT = os.path.dirname(REQ_DIR)
+REPO_ROOT = os.path.dirname(os.path.dirname(REQ_DIR))
 PYPROJECT_PATH = os.path.join(REPO_ROOT, "pyproject.toml")
 CI_REQ_DIR = os.path.join(REPO_ROOT, "requirements", "ci")
-POST_UPGRADES_PATH = os.path.join(REPO_ROOT, "requirements", "post_upgrades.txt")
-CIRCUIT_TRACER_PIN = os.path.join(REPO_ROOT, "requirements", "circuit_tracer_pin.txt")
+POST_UPGRADES_PATH = os.path.join(CI_REQ_DIR, "post_upgrades.txt")
+
+
+@dataclass
+class DepCommitPin:
+    package_name: str
+    env_var: str
+    dep_def_loc: str  # e.g. 'examples' for examples extra or 'dependencies' for a base dependency
+    pin_filename: str
+    repo_base_url: str
+
+
+# Mapping for packages that support commit-pin installation. Add new entries
+# here to enable the same behavior for other packages.
+DEP_COMMIT_PINS: Dict[str, DepCommitPin] = {
+    "circuit-tracer": DepCommitPin(
+        package_name="circuit-tracer",
+        env_var="IT_USE_CT_COMMIT_PIN",
+        dep_def_loc="examples",
+        pin_filename="circuit_tracer_pin.txt",
+        repo_base_url="https://github.com/speediedan/circuit-tracer.git",
+    ),
+}
 
 os.makedirs(REQ_DIR, exist_ok=True)
 os.makedirs(CI_REQ_DIR, exist_ok=True)
@@ -30,23 +72,24 @@ def load_pyproject():
         return toml.load(f)
 
 
-def convert_circuit_tracer_pin():
-    """Read requirements/circuit_tracer_pin.txt and return a list of VCS requirement lines.
+def convert_pin_file(pin_file_path: str, repo_base_url: str, pkg_name: str) -> List[str]:
+    """Read a pin file and convert lines into pip-installable requirement strings.
 
-    The file may contain a single commit SHA; translate that to a git+ URL usable by pip. If the file already contains a
-    full VCS spec, return it as-is.
+    Each non-empty, non-comment line may be:
+      - a bare commit hash (40 or 64 hex chars) -> convert to git+{repo}@{hash}#egg={pkg}
+      - a git+ URL or a name@rev entry -> return as-is
+      - any other string -> returned as-is
     """
-    if not os.path.exists(CIRCUIT_TRACER_PIN):
+    if not os.path.exists(pin_file_path):
         return []
-    out = []
-    with open(CIRCUIT_TRACER_PIN, "r") as f:
+    out: List[str] = []
+    with open(pin_file_path, "r") as f:
         for line in f:
             s = line.strip()
             if not s or s.startswith("#"):
                 continue
-            # if it looks like a 40-char SHA, translate
             if all(c in "0123456789abcdef" for c in s.lower()) and len(s) in (40, 64):
-                out.append(f"git+https://github.com/speediedan/circuit-tracer.git@{s}#egg=circuit-tracer")
+                out.append(f"git+{repo_base_url}@{s}#egg={pkg_name}")
             elif s.startswith("git+") or "@" in s:
                 out.append(s)
             else:
@@ -57,10 +100,14 @@ def convert_circuit_tracer_pin():
 def generate_top_level_files(pyproject, output_dir=REQ_DIR):
     project = pyproject.get("project", {})
     core_reqs = project.get("dependencies", [])
-    write_file(os.path.join(output_dir, "base.txt"), core_reqs)
+    # Write top-level requirement files into the repository-level `requirements/` directory
+    repo_requirements_dir = os.path.join(REPO_ROOT, "requirements")
+    os.makedirs(repo_requirements_dir, exist_ok=True)
+
+    write_file(os.path.join(repo_requirements_dir, "base.txt"), core_reqs)
     opt_deps = project.get("optional-dependencies", {})
     for group, reqs in opt_deps.items():
-        write_file(os.path.join(output_dir, f"{group}.txt"), reqs)
+        write_file(os.path.join(repo_requirements_dir, f"{group}.txt"), reqs)
 
 
 def generate_pip_compile_inputs(pyproject, ci_output_dir=CI_REQ_DIR):
@@ -69,110 +116,125 @@ def generate_pip_compile_inputs(pyproject, ci_output_dir=CI_REQ_DIR):
     post_upgrades = tool_cfg.get("post_upgrades", {}) or {}
     platform_dependent = tool_cfg.get("platform_dependent", []) or []
 
-    # Build requirements.in lines from top-level dependencies and optional groups
     req_in_lines = []
     platform_dependent_lines = []
     direct_packages = []
 
     def normalize_package_name(name):
-        """Normalize package names to handle underscores vs dashes."""
         return name.lower().replace("_", "-")
 
     def add_lines_from(list_or_none):
         if not list_or_none:
             return
         for r in list_or_none:
-            # extract an approximate package name (handles extras and simple specifiers)
             parts = re.split(r"[\s\[\]=<>!;@]", r)
             pkg_name = parts[0].lower() if parts and parts[0] else ""
-
-            # skip any packages that are declared in post_upgrades mapping
             if normalize_package_name(pkg_name) in {normalize_package_name(k) for k in post_upgrades}:
                 continue
-
-            # separate platform-dependent packages for special handling (supports glob patterns)
             is_platform_pkg = any(
                 fnmatch.fnmatch(normalize_package_name(pkg_name), normalize_package_name(pattern))
                 for pattern in platform_dependent
             )
             if is_platform_pkg:
                 platform_dependent_lines.append(r)
-                direct_packages.append(pkg_name)  # Still track as direct package
+                direct_packages.append(pkg_name)
                 continue
 
             req_in_lines.append(r)
-            direct_packages.append(pkg_name)  # Track as direct package
+            direct_packages.append(pkg_name)
 
-    # Only include direct dependencies that we want to constrain
-    # Core dependencies - always include these as they are our main requirements
     add_lines_from(project.get("dependencies", []))
 
-    # Include specific optional dependencies that we want to constrain for CI
     opt_deps = project.get("optional-dependencies", {})
-
-    # Groups we want to include completely for CI (test, examples, and lightning are needed for CI functionality)
     groups_to_include_completely = ["test", "examples", "lightning"]
 
-    # Process optional dependencies
     for group, reqs in opt_deps.items():
         if not reqs:
             continue
 
         if group in groups_to_include_completely:
-            # Include all packages from test and examples groups
             add_lines_from(reqs)
         else:
-            # For other groups, only include packages that are explicitly listed in post_upgrades or are
-            # platform-dependent; otherwise skip to avoid pulling in large optional groups transitively.
             for req in reqs:
                 parts = re.split(r"[\s\[\]=<>!;@]", req)
                 pkg_name = parts[0].lower() if parts and parts[0] else ""
-
-                # skip any packages that are declared in post_upgrades mapping
                 post_upgrade_names = {normalize_package_name(k) for k in post_upgrades}
                 if normalize_package_name(pkg_name) in post_upgrade_names:
                     continue
-
-                # separate platform-dependent packages for special handling (supports glob patterns)
                 is_platform_pkg = any(
                     fnmatch.fnmatch(normalize_package_name(pkg_name), normalize_package_name(pattern))
                     for pattern in platform_dependent
                 )
                 if is_platform_pkg:
                     platform_dependent_lines.append(req)
-                    direct_packages.append(pkg_name)  # Still track as direct package
+                    direct_packages.append(pkg_name)
                     continue
-
-                # otherwise skip: don't include other group's packages unless listed in groups_to_include_completely
                 continue
 
-    # include circuit-tracer pin(s) if present
-    circuit_tracer_lines = convert_circuit_tracer_pin()
-    req_in_lines.extend(circuit_tracer_lines)
-    # Add circuit-tracer to direct packages
-    for line in circuit_tracer_lines:
-        if "circuit-tracer" in line or "circuit_tracer" in line:
-            direct_packages.append("circuit-tracer")
+    def determine_dep_commit_lines(dep_key: str, pyproject: dict) -> List[str]:
+        """Generalized selection logic for a dependency that supports commit-pin installs.
+
+        Returns a list of requirement strings to add to requirements.in (may be empty).
+        """
+        if dep_key not in DEP_COMMIT_PINS:
+            return []
+
+        cfg = DEP_COMMIT_PINS[dep_key]
+        env_flag = os.getenv(cfg.env_var, "").lower()
+        if env_flag in ("1", "true", "yes"):
+            print(f"{cfg.env_var} is set -> using pin file {cfg.pin_filename} for {cfg.package_name}")
+            pin_path = os.path.join(CI_REQ_DIR, cfg.pin_filename)
+            return convert_pin_file(pin_path, cfg.repo_base_url, cfg.package_name)
+
+        # Look for the dependency in the declared pyproject extra/base location
+        project = pyproject.get("project", {})
+        if cfg.dep_def_loc == "dependencies":
+            candidates = project.get("dependencies", []) or []
+        else:
+            opt_deps = project.get("optional-dependencies", {}) or {}
+            candidates = opt_deps.get(cfg.dep_def_loc, []) or []
+
+        for req in candidates:
+            if cfg.package_name in req.lower() or cfg.package_name.replace("-", "_") in req.lower():
+                print(
+                    f"Found {cfg.package_name} in pyproject.{cfg.dep_def_loc} ->",
+                    "using pyproject-specified requirement:",
+                    req,
+                )
+                return [req]
+
+        # fallback to pin file
+        print(
+            f"{cfg.package_name} not found in pyproject.{cfg.dep_def_loc};",
+            f"falling back to pin file {cfg.pin_filename} if present",
+        )
+        pin_path = os.path.join(CI_REQ_DIR, cfg.pin_filename)
+        return convert_pin_file(pin_path, cfg.repo_base_url, cfg.package_name)
+
+    # Ascertain commit-pin dependencies via the DEP_COMMIT_PINS mapping.
+    for dep_key, cfg in DEP_COMMIT_PINS.items():
+        dep_lines = determine_dep_commit_lines(dep_key, pyproject)
+        if not dep_lines:
+            continue
+        req_in_lines.extend(dep_lines)
+        # Track the package as a direct package when appropriate
+        for line in dep_lines:
+            if cfg.package_name in line or cfg.package_name.replace("-", "_") in line:
+                direct_packages.append(cfg.package_name)
 
-    # write requirements.in
     in_path = os.path.join(ci_output_dir, "requirements.in")
     write_file(in_path, req_in_lines)
 
-    # write post_upgrades.txt using the version specifiers provided in pyproject
-    # pyproject may specify exact pins like '==4.0.0' or ranges like '>=2025.3.0'
     post_lines = []
     for pkg, spec in post_upgrades.items():
         spec_str = spec.strip()
-        # If the spec doesn't start with a comparator, assume exact match
         if re.match(r"^[<>=!].+", spec_str):
             post_lines.append(f"{pkg}{spec_str}")
         else:
-            # treat bare version as exact
             post_lines.append(f"{pkg}=={spec_str}")
     write_file(POST_UPGRADES_PATH, post_lines)
 
-    # write platform_dependent.txt with flexible constraints
-    platform_path = os.path.join(REQ_DIR, "platform_dependent.txt")
+    platform_path = os.path.join(CI_REQ_DIR, "platform_dependent.txt")
     write_file(platform_path, platform_dependent_lines)
 
     return in_path, POST_UPGRADES_PATH, platform_path, direct_packages
@@ -183,7 +245,6 @@ def run_pip_compile(req_in_path, output_path):
     if not pip_compile:
         print("pip-compile not found in PATH; install pip-tools to generate full pinned requirements.txt")
         return False
-    # Use --upgrade to ensure we don't rely on cached/resolved older versions when regenerating pins
     cmd = [pip_compile, "--output-file", output_path, req_in_path, "--upgrade"]
     print("Running:", " ".join(shlex.quote(c) for c in cmd))
     subprocess.check_call(cmd)
@@ -191,13 +252,6 @@ def run_pip_compile(req_in_path, output_path):
 
 
 def post_process_pinned_requirements(requirements_path, platform_dependent_path, platform_patterns, direct_packages):
-    """Post-process the pinned requirements to move platform-dependent packages to separate file and filter out
-    transitive dependencies to only keep direct dependencies.
-
-    This handles cases where:
-    1. Platform-dependent direct dependencies need to be moved to separate file for flexible installation
-    2. Transitive dependencies get pinned but we only want to constrain direct dependencies
-    """
     if not os.path.exists(requirements_path):
         return
 
@@ -207,14 +261,11 @@ def post_process_pinned_requirements(requirements_path, platform_dependent_path,
     requirements_lines = []
     platform_dependent_lines = []
 
-    # Load existing platform-dependent packages
     existing_platform_deps = []
     if os.path.exists(platform_dependent_path):
         with open(platform_dependent_path, "r") as f:
             existing_platform_deps = [line.strip() for line in f if line.strip() and not line.startswith("#")]
 
-    # Convert direct packages to normalized form (lowercase, replace underscores with dashes)
-    # This handles the fact that pip normalizes package names
     def normalize_package_name(name):
         return name.lower().replace("_", "-")
 
@@ -223,70 +274,48 @@ def normalize_package_name(name):
     i = 0
     while i < len(lines):
         line = lines[i].strip()
-
-        # Always include header comments and empty lines
         if not line or line.startswith("#"):
             requirements_lines.append(lines[i])
             i += 1
             continue
 
-        # This is a package line (e.g., "accelerate==1.10.0")
-        # Extract package name from pinned requirement
-
-        # Handle special cases like git packages first
         if " @ " in line:
-            # For git packages like "circuit-tracer @ git+...", extract the package name
             pkg_name = line.split(" @ ")[0].strip().lower()
         else:
-            # For regular packages, extract name before any extras, version specifiers, etc.
-            # Handle extras like "jsonargparse[signatures,typing-extensions]==4.40.2"
             parts = re.split(r"[\[\]=<>!;]", line)
             pkg_name = parts[0].strip().lower() if parts else ""
 
-        # Normalize package name for comparison
         pkg_name_normalized = normalize_package_name(pkg_name)
 
-        # Check if this package matches any platform-dependent pattern
         is_platform_dependent = any(
             fnmatch.fnmatch(pkg_name_normalized, pattern.replace("_", "-")) for pattern in platform_patterns
         )
 
-        # Check if this is a direct dependency we want to constrain
         is_direct_dependency = pkg_name_normalized in direct_packages_normalized
 
         if is_platform_dependent:
-            # Convert pinned requirement back to flexible constraint
-            # e.g., "nvidia-cublas-cu12==12.8.4.1" -> "nvidia-cublas-cu12"
             flexible_req = pkg_name_normalized
             platform_dependent_lines.append(flexible_req)
-            # Skip this package and its associated comment lines
             i += 1
-            # Skip subsequent comment lines that belong to this package
             while i < len(lines) and lines[i].strip().startswith("#"):
                 i += 1
         elif is_direct_dependency:
-            # Keep direct dependencies that we explicitly want to constrain
             requirements_lines.append(lines[i])
             i += 1
-            # Keep the associated comment lines too
             while i < len(lines) and lines[i].strip().startswith("#"):
                 requirements_lines.append(lines[i])
                 i += 1
         else:
-            # Skip transitive dependencies that we don't want to constrain
             i += 1
-            # Skip subsequent comment lines that belong to this package
             while i < len(lines) and lines[i].strip().startswith("#"):
                 i += 1
 
-    # Write back the filtered requirements.txt
     with open(requirements_path, "w") as f:
         for line in requirements_lines:
             f.write(line.rstrip() + "\n")
 
-    # Update platform_dependent.txt with both existing and newly found packages
     all_platform_deps = list(set(existing_platform_deps + platform_dependent_lines))
-    all_platform_deps.sort()  # Keep consistent ordering
+    all_platform_deps.sort()
 
     with open(platform_dependent_path, "w") as f:
         for pkg in all_platform_deps:
@@ -301,18 +330,14 @@ def main():
 
     pyproject = load_pyproject()
 
-    # always keep the simple top-level files for developer convenience
     generate_top_level_files(pyproject)
 
     if args.mode == "pip-compile":
         in_path, post_path, platform_path, direct_packages = generate_pip_compile_inputs(pyproject, args.ci_output_dir)
-        # attempt to run pip-compile to produce a fully pinned requirements.txt
         out_path = os.path.join(args.ci_output_dir, "requirements.txt")
         try:
             success = run_pip_compile(in_path, out_path)
             if success:
-                # Post-process to move platform-dependent packages from pinned requirements
-                # and filter out transitive dependencies to only keep direct dependencies
                 tool_cfg = pyproject.get("tool", {}).get("ci_pinning", {})
                 platform_dependent = tool_cfg.get("platform_dependent", []) or []
                 post_process_pinned_requirements(out_path, platform_path, platform_dependent, direct_packages)
diff --git a/scripts/build_it_env.sh b/scripts/build_it_env.sh
index 8aa0ee27..5501f980 100755
--- a/scripts/build_it_env.sh
+++ b/scripts/build_it_env.sh
@@ -17,7 +17,6 @@ unset torch_test_channel
 unset fts_from_source
 unset ct_from_source
 unset pip_install_flags
-unset no_commit_pin
 unset regen_with_pip_compile
 unset apply_post_upgrades
 unset no_ci_reqs
@@ -25,42 +24,41 @@ unset no_ci_reqs
 usage(){
 >&2 cat << EOF
 Usage: $0
-   [ --repo_home input]
-   [ --target_env_name input ]
-   [ --torch_dev_ver input ]
-   [ --torch_test_channel ]
-   [ --fts_from_source "path" ]
-   [ --ct_from_source "path" ]
-   [ --pip_install_flags "flags" ]
-   [ --no_commit_pin ]
+   [ --repo-home input]
+   [ --target-env-name input ]
+   [ --torch-dev-ver input ]
+   [ --torch-test-channel ]
+   [ --fts-from-source "path" ]
+   [ --ct-from-source "path" ]
+   [ --pip-install-flags "flags" ]
    [ --no-ci-reqs ]
-   [ --regen_with_pip_compile ]
-   [ --apply_post_upgrades ]
+   [ --regen-with-pip-compile ]
+   [ --apply-post-upgrades ]
    [ --help ]
    Examples:
     # build latest:
-    #   ./build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest
+    #   ./build_it_env.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest
     # build latest with specific pytorch nightly:
-    #   ./build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --torch_dev_ver=dev20240201
+    #   ./build_it_env.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest --torch-dev-ver=dev20240201
     # build latest with torch test channel:
-    #   ./build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --torch_test_channel
+    #   ./build_it_env.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest --torch-test-channel
     # build latest with FTS from source:
-    #   ./build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --fts_from_source=${HOME}/repos/finetuning-scheduler
+    #   ./build_it_env.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest --fts-from-source=${HOME}/repos/finetuning-scheduler
     # build latest with circuit-tracer from source:
-    #   ./build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --ct_from_source=${HOME}/repos/circuit-tracer
+    #   ./build_it_env.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest --ct-from-source=${HOME}/repos/circuit-tracer
     # build latest with no cache directory:
-    #   ./build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --pip_install_flags="--no-cache-dir"
-    # build latest without using CI commit pinning:
-    #   ./build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --no_commit_pin
+    #   ./build_it_env.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest --pip-install-flags="--no-cache-dir"
+    # build latest without using CT commit pinning:
+    #   ./build_it_env.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest
     # build latest and regenerate CI pinned requirements:
-    #   ./build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --regen_with_pip_compile
+    #   ./build_it_env.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest --regen-with-pip-compile
     # build latest and apply post-upgrades:
-    #   ./build_it_env.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --apply_post_upgrades
+    #   ./build_it_env.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest --apply-post-upgrades
 EOF
 exit 1
 }
 
-args=$(getopt -o '' --long repo_home:,target_env_name:,torch_dev_ver:,torch_test_channel,fts_from_source:,ct_from_source:,pip_install_flags:,no_commit_pin,no-ci-reqs,regen_with_pip_compile,apply_post_upgrades,help -- "$@")
+args=$(getopt -o '' --long repo-home:,target-env-name:,torch-dev-ver:,torch-test-channel,fts-from-source:,ct-from-source:,pip-install-flags:,no-ci-reqs,regen-with-pip-compile,apply-post-upgrades,help -- "$@")
 if [[ $? -gt 0 ]]; then
   usage
 fi
@@ -69,17 +67,16 @@ eval set -- ${args}
 while :
 do
   case $1 in
-    --repo_home)  repo_home=$2    ; shift 2  ;;
-    --target_env_name)  target_env_name=$2  ; shift 2 ;;
-    --torch_dev_ver)   torch_dev_ver=$2   ; shift 2 ;;
-    --torch_test_channel)   torch_test_channel=1 ; shift  ;;
-    --fts_from_source)   fts_from_source=$2 ; shift 2 ;;
-    --ct_from_source)   ct_from_source=$2 ; shift 2 ;;
-    --pip_install_flags)   pip_install_flags=$2 ; shift 2 ;;
-    --no_commit_pin)   no_commit_pin=1 ; shift  ;;
+    --repo-home)  repo_home=$2    ; shift 2  ;;
+    --target-env-name)  target_env_name=$2  ; shift 2 ;;
+    --torch-dev-ver)   torch_dev_ver=$2   ; shift 2 ;;
+    --torch-test-channel)   torch_test_channel=1 ; shift  ;;
+    --fts-from-source)   fts_from_source=$2 ; shift 2 ;;
+    --ct-from-source)   ct_from_source=$2 ; shift 2 ;;
+    --pip-install-flags)   pip_install_flags=$2 ; shift 2 ;;
     --no-ci-reqs)      no_ci_reqs=1 ; shift ;;
-    --regen_with_pip_compile) regen_with_pip_compile=1 ; shift ;;
-    --apply_post_upgrades) apply_post_upgrades=1 ; shift ;;
+    --regen-with-pip-compile) regen_with_pip_compile=1 ; shift ;;
+    --apply-post-upgrades) apply_post_upgrades=1 ; shift ;;
     --help)    usage      ; shift   ;;
     # -- means the end of the arguments; drop this, and break out of the while loop
     --) shift; break ;;
@@ -91,6 +88,21 @@ done
 # Use pip_install_flags in pip commands
 pip_install_flags=${pip_install_flags:-""}
 
+# Expand leading ~ in common path arguments so users can pass --repo-home=~/repos/...
+expand_tilde(){
+    local p="$1"
+    if [[ -n "$p" ]] && [[ "$p" == ~* ]]; then
+        # Use eval to expand ~ reliably
+        eval echo "$p"
+    else
+        echo "$p"
+    fi
+}
+
+repo_home=$(expand_tilde "${repo_home}")
+fts_from_source=$(expand_tilde "${fts_from_source}")
+ct_from_source=$(expand_tilde "${ct_from_source}")
+
 # Source common utility functions
 source ${repo_home}/scripts/infra_utils.sh
 
@@ -139,23 +151,16 @@ it_install(){
 
     # Optionally regenerate CI pinned requirements (pip-compile mode) if requested
     if [[ -n ${regen_with_pip_compile} ]]; then
+        python -m pip install ${pip_install_flags} toml pip-tools
         echo "Regenerating CI pinned requirements (pip-compile mode)"
-        python ${repo_home}/requirements/regen_reqfiles.py --mode pip-compile --ci-output-dir ${repo_home}/requirements/ci || true
+        python ${repo_home}/requirements/utils/regen_reqfiles.py --mode pip-compile --ci-output-dir ${repo_home}/requirements/ci
     fi
 
     # If CI pinned requirements don't exist and user did not disable ci-reqs, regenerate them
     if [[ -z ${no_ci_reqs} ]] && [[ ! -f ${repo_home}/requirements/ci/requirements.txt ]]; then
+        python -m pip install ${pip_install_flags} toml pip-tools
         echo "CI pinned requirements not found; regenerating requirements.in and post_upgrades."
-        python ${repo_home}/requirements/regen_reqfiles.py --mode pip-compile --ci-output-dir ${repo_home}/requirements/ci || true
-    fi
-
-    # Set IT_USE_CT_COMMIT_PIN by default, unless --no_commit_pin is specified
-    if [[ -z ${no_commit_pin} ]]; then
-        export IT_USE_CT_COMMIT_PIN="1"
-        echo "Using IT_USE_CT_COMMIT_PIN for circuit-tracer installation"
-    else
-        unset IT_USE_CT_COMMIT_PIN
-        echo "Using version-based circuit-tracer installation"
+        python ${repo_home}/requirements/utils/regen_reqfiles.py --mode pip-compile --ci-output-dir ${repo_home}/requirements/ci
     fi
 
     # Install project and extras; prefer CI pinned requirements if available
@@ -163,40 +168,33 @@ it_install(){
         # Install pinned requirements, then install editable package so CLI modules (interpretune.*) are importable
         python -m pip install ${pip_install_flags} -r ${repo_home}/requirements/ci/requirements.txt -r requirements/docs.txt || true
         # Ensure interpretune package is installed (editable install recommended during dev)
-        python -m pip install ${pip_install_flags} -e ".[test,examples,lightning]" || true
+        python -m pip install ${pip_install_flags} -e ".[test,examples,lightning,profiling]"
     else
-        python -m pip install ${pip_install_flags} -e ".[test,examples,lightning]" -r requirements/docs.txt
+        python -m pip install ${pip_install_flags} -e ".[test,examples,lightning,profiling]" -r requirements/docs.txt
     fi
 
     cd ${repo_home}
     # Optionally apply post-upgrades if requested and file exists
-    if [[ -n ${apply_post_upgrades} ]] && [[ -s ${repo_home}/requirements/post_upgrades.txt ]]; then
-        echo "Applying post-upgrades from requirements/post_upgrades.txt"
-        pip install --upgrade -r ${repo_home}/requirements/post_upgrades.txt || true
+    if [[ -n ${apply_post_upgrades} ]] && [[ -s ${repo_home}/requirements/ci/post_upgrades.txt ]]; then
+        echo "Applying post-upgrades from requirements/ci/post_upgrades.txt"
+        pip install --upgrade -r ${repo_home}/requirements/ci/post_upgrades.txt || true
     else
         echo "Skipping post-upgrades (flag not set or file empty)."
     fi
 
     if [[ -n ${ct_from_source} ]]; then
         echo "Installing circuit-tracer from source at ${ct_from_source}"
+        # Try uninstalling both import-style package name and hyphenated distribution name to avoid conflicts
+        python -m pip uninstall -y circuit_tracer || true
+        python -m pip uninstall -y circuit-tracer || true
         cd ${ct_from_source}
         python -m pip install ${pip_install_flags} -e .
-    else
-        echo "Installing circuit-tracer via interpretune CLI tool"
-        # Use the interpretune CLI tool to install circuit-tracer
-        if [[ -n ${IT_USE_CT_COMMIT_PIN} ]]; then
-            python -m interpretune.tools.install_circuit_tracer
-        else
-            python -m interpretune.tools.install_circuit_tracer --no-commit-pin
-        fi
     fi
 
     pyright -p pyproject.toml
     pre-commit install
     git lfs install
-    python ${repo_home}/requirements/collect_env_details.py
-    # Print environment/package diagnostics using the CI helper script
-    python ${repo_home}/scripts/ci_print_env_versions.py ${repo_home}
+    python ${repo_home}/requirements/utils/collect_env_details.py --packages-only
 }
 
 d=`date +%Y%m%d%H%M%S`
diff --git a/scripts/ci_print_env_versions.py b/scripts/ci_print_env_versions.py
deleted file mode 100644
index ead72aa9..00000000
--- a/scripts/ci_print_env_versions.py
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-"""Print environment diagnostics and versions of key runtime packages for CI."""
-
-from __future__ import annotations
-import importlib.metadata as md
-import sys
-
-
-def version_of(pkg: str) -> str:
-    try:
-        return md.version(pkg)
-    except Exception as e:
-        return f"not found ({e})"
-
-
-def main(repo_home: str) -> None:
-    packages = [
-        "torch",
-        "lightning",
-        "transformer_lens",
-        "sae_lens",
-        "finetuning_scheduler",
-        "interpretune",
-        "datasets",
-    ]
-
-    for p in packages:
-        print(f"{p} version: {version_of(p)}")
-
-
-if __name__ == "__main__":
-    # Allow caller to pass repo_home as first arg; default to current working dir
-    repo_home = sys.argv[1] if len(sys.argv) > 1 else "."
-    main(repo_home)
diff --git a/scripts/gen_it_coverage.sh b/scripts/gen_it_coverage.sh
index 0b828cbb..69866627 100755
--- a/scripts/gen_it_coverage.sh
+++ b/scripts/gen_it_coverage.sh
@@ -14,25 +14,23 @@ unset run_all_and_examples
 unset no_export_cov_xml
 unset pip_install_flags
 unset self_test_only
-unset no_commit_pin
 unset apply_post_upgrades
 
 usage(){
 >&2 cat << EOF
 Usage: $0
-   [ --repo_home input]
-   [ --target_env_name input ]
-   [ --torch_dev_ver input ]
-   [ --torch_test_channel ]
-   [ --no_rebuild_base ]
-   [ --fts_from_source "path" ]
-   [ --ct_from_source "path" ]
-   [ --run_all_and_examples ]
-   [ --no_export_cov_xml ]
-   [ --pip_install_flags "flags" ]
-   [ --self_test_only ]
-   [ --no_commit_pin ]
-    [ --apply_post_upgrades ]
+    [ --repo-home input]
+    [ --target-env-name input ]
+    [ --torch-dev-ver input ]
+    [ --torch-test-channel ]
+    [ --no-rebuild-base ]
+    [ --fts-from-source "path" ]
+    [ --ct-from-source "path" ]
+    [ --run-all-and-examples ]
+    [ --no-export-cov-xml ]
+    [ --pip-install-flags "flags" ]
+    [ --self-test-only ]
+     [ --apply-post-upgrades ]
    [ --help ]
    Examples:
     # generate it_latest coverage without rebuilding the it_latest base environment:
@@ -47,13 +45,13 @@ Usage: $0
     #   ./gen_it_coverage.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --pip_install_flags="--no-cache-dir"
     # generate it_latest coverage with self_test_only:
     #   ./gen_it_coverage.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --self_test_only
-    # generate it_latest coverage without using CI commit pinning:
-    #   ./gen_it_coverage.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --no_commit_pin
+    # generate it_latest coverage using CT commit pinning:
+    #   ./gen_it_coverage.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --ct_commit_pin
 EOF
 exit 1
 }
 
-args=$(getopt -o '' --long repo_home:,target_env_name:,torch_dev_ver:,torchvision_dev_ver:,torch_test_channel,no_rebuild_base,fts_from_source:,ct_from_source:,run_all_and_examples,no_export_cov_xml,pip_install_flags:,self_test_only,no_commit_pin,apply_post_upgrades,help -- "$@")
+args=$(getopt -o '' --long repo-home:,target-env-name:,torch-dev-ver:,torchvision-dev-ver:,torch-test-channel,no-rebuild-base,fts-from-source:,ct-from-source:,run-all-and-examples,no-export-cov-xml,pip-install-flags:,self-test-only,apply-post-upgrades,help -- "$@")
 if [[ $? -gt 0 ]]; then
   usage
 fi
@@ -62,19 +60,18 @@ eval set -- ${args}
 while :
 do
   case $1 in
-    --repo_home)  repo_home=$2    ; shift 2  ;;
-    --target_env_name)  target_env_name=$2  ; shift 2 ;;
-    --torch_dev_ver)   torch_dev_ver=$2   ; shift 2 ;;
-    --torch_test_channel)   torch_test_channel=1 ; shift  ;;
-    --no_rebuild_base)   no_rebuild_base=1 ; shift  ;;
-    --fts_from_source)   fts_from_source=$2 ; shift 2 ;;
-    --ct_from_source)   ct_from_source=$2 ; shift 2 ;;
-    --run_all_and_examples)   run_all_and_examples=1 ; shift  ;;
-    --no_export_cov_xml)   no_export_cov_xml=1 ; shift ;;
-    --pip_install_flags)   pip_install_flags=$2 ; shift 2 ;;
-    --self_test_only)   self_test_only=1 ; shift ;;
-    --no_commit_pin)   no_commit_pin=1 ; shift ;;
-    --apply_post_upgrades)   apply_post_upgrades=1 ; shift ;;
+    --repo-home)  repo_home=$2    ; shift 2  ;;
+    --target-env-name)  target_env_name=$2  ; shift 2 ;;
+    --torch-dev-ver)   torch_dev_ver=$2   ; shift 2 ;;
+    --torch-test-channel)   torch_test_channel=1 ; shift  ;;
+    --no-rebuild-base)   no_rebuild_base=1 ; shift  ;;
+    --fts-from-source)   fts_from_source=$2 ; shift 2 ;;
+    --ct-from-source)   ct_from_source=$2 ; shift 2 ;;
+    --run-all-and-examples)   run_all_and_examples=1 ; shift  ;;
+    --no-export-cov-xml)   no_export_cov_xml=1 ; shift ;;
+    --pip-install-flags)   pip_install_flags=$2 ; shift 2 ;;
+    --self-test-only)   self_test_only=1 ; shift ;;
+    --apply-post-upgrades)   apply_post_upgrades=1 ; shift ;;
     --help)    usage      ; shift   ;;
     --) shift; break ;;
     *) >&2 echo Unsupported option: $1
@@ -117,41 +114,36 @@ env_rebuild(){
     # Prepare pip_install_flags parameter if set
     pip_flags_param=""
     if [[ -n "${pip_install_flags}" ]]; then
-        pip_flags_param="--pip_install_flags=\"${pip_install_flags}\""
+        pip_flags_param="--pip-install-flags=\"${pip_install_flags}\""
     fi
 
     fts_from_source_param=""
     if [[ -n "${fts_from_source}" ]]; then
-        fts_from_source_param="--fts_from_source=${fts_from_source}"
+        fts_from_source_param="--fts-from-source=${fts_from_source}"
     fi
 
     ct_from_source_param=""
     if [[ -n "${ct_from_source}" ]]; then
-        ct_from_source_param="--ct_from_source=${ct_from_source}"
-    fi
-
-    no_commit_pin_param=""
-    if [[ -n "${no_commit_pin}" ]]; then
-        no_commit_pin_param="--no_commit_pin"
+        ct_from_source_param="--ct-from-source=${ct_from_source}"
     fi
 
     apply_post_upgrades_param=""
     if [[ -n "${apply_post_upgrades}" ]]; then
-        apply_post_upgrades_param="--apply_post_upgrades"
+        apply_post_upgrades_param="--apply-post-upgrades"
     fi
 
     case $1 in
         it_latest )
             if [[ -n ${torch_dev_ver} ]]; then
-                ${repo_home}/scripts/build_it_env.sh --repo_home=${repo_home} --target_env_name=$1 --torch_dev_ver=${torch_dev_ver} ${fts_from_source_param} ${ct_from_source_param} ${pip_flags_param} ${no_commit_pin_param} ${apply_post_upgrades_param}
+                ${repo_home}/scripts/build_it_env.sh --repo-home=${repo_home} --target-env-name=$1 --torch-dev-ver=${torch_dev_ver} ${fts_from_source_param} ${ct_from_source_param} ${pip_flags_param} ${ct_commit_pin_param} ${apply_post_upgrades_param}
             elif [[ $torch_test_channel -eq 1 ]]; then
-                ${repo_home}/scripts/build_it_env.sh --repo_home=${repo_home} --target_env_name=$1 --torch_test_channel  ${fts_from_source_param} ${ct_from_source_param} ${pip_flags_param} ${no_commit_pin_param} ${apply_post_upgrades_param}
+                ${repo_home}/scripts/build_it_env.sh --repo-home=${repo_home} --target-env-name=$1 --torch-test-channel  ${fts_from_source_param} ${ct_from_source_param} ${pip_flags_param} ${ct_commit_pin_param} ${apply_post_upgrades_param}
             else
-                ${repo_home}/scripts/build_it_env.sh --repo_home=${repo_home} --target_env_name=$1 ${fts_from_source_param} ${ct_from_source_param} ${pip_flags_param} ${no_commit_pin_param} ${apply_post_upgrades_param}
+                ${repo_home}/scripts/build_it_env.sh --repo-home=${repo_home} --target-env-name=$1 ${fts_from_source_param} ${ct_from_source_param} ${pip_flags_param} ${ct_commit_pin_param} ${apply_post_upgrades_param}
             fi
             ;;
         it_release )
-            ${repo_home}/scripts/build_it_env.sh --repo_home=${repo_home} --target_env_name=$1 ${fts_from_source_param} ${ct_from_source_param} ${pip_flags_param} ${no_commit_pin_param} ${apply_post_upgrades_param}
+            ${repo_home}/scripts/build_it_env.sh --repo-home=${repo_home} --target-env-name=$1 ${fts_from_source_param} ${ct_from_source_param} ${pip_flags_param} ${ct_commit_pin_param} ${apply_post_upgrades_param}
             ;;
         *)
             echo "no matching environment found, exiting..." >> $coverage_session_log
diff --git a/scripts/manage_standalone_processes.sh b/scripts/manage_standalone_processes.sh
index 91ab9c3c..90445fd1 100755
--- a/scripts/manage_standalone_processes.sh
+++ b/scripts/manage_standalone_processes.sh
@@ -4,7 +4,7 @@
 # Usage examples:
 #   ./manage_standalone_processes.sh /path/to/script.sh --arg1 value1 --arg2 value2
 #   ./manage_standalone_processes.sh python -m pytest tests/some_test.py
-#   ./manage_standalone_processes.sh --use_nohup /path/to/script.sh --arg1 value1
+#   ./manage_standalone_processes.sh --use-nohup /path/to/script.sh --arg1 value1
 set -eo pipefail
 
 # Default configuration
@@ -13,7 +13,7 @@ USE_NOHUP=false
 # Process flags
 while [[ "$1" == --* ]]; do
   case "$1" in
-    --use_nohup)
+    --use-nohup)
       USE_NOHUP=true
       shift
       ;;
diff --git a/scripts/update_profiling_memory_stats.sh b/scripts/update_profiling_memory_stats.sh
index cd237e22..bf43c690 100755
--- a/scripts/update_profiling_memory_stats.sh
+++ b/scripts/update_profiling_memory_stats.sh
@@ -10,18 +10,18 @@ unset working_dir
 usage(){
 >&2 cat << EOF
 Usage: $0
-   [ --repo_home input ]
-   [ --target_env_name input ]
-   [ --working_dir input ]
+  [ --repo-home input ]
+  [ --target-env-name input ]
+  [ --working-dir input ]
    [ --help ]
    Examples:
 	# update profiling memory stats for it_latest:
-	#   ./update_profiling_memory_stats.sh --repo_home=${HOME}/repos/interpretune --target_env_name=it_latest --working_dir=/tmp
+	#   ./update_profiling_memory_stats.sh --repo-home=${HOME}/repos/interpretune --target-env-name=it_latest --working-dir=/tmp
 EOF
 exit 1
 }
 
-args=$(getopt -o '' --long repo_home:,target_env_name:,working_dir:,help -- "$@")
+args=$(getopt -o '' --long repo-home:,target-env-name:,working-dir:,help -- "$@")
 if [[ $? -gt 0 ]]; then
   usage
 fi
@@ -30,9 +30,9 @@ eval set -- ${args}
 while :
 do
   case $1 in
-    --repo_home)  repo_home=$2    ; shift 2  ;;
-    --target_env_name)  target_env_name=$2  ; shift 2 ;;
-    --working_dir)  working_dir=$2    ; shift 2  ;;
+    --repo-home)  repo_home=$2    ; shift 2  ;;
+    --target-env-name)  target_env_name=$2  ; shift 2 ;;
+    --working-dir)  working_dir=$2    ; shift 2  ;;
     --help)    usage      ; shift   ;;
     --) shift; break ;;
     *) >&2 echo Unsupported option: $1
diff --git a/src/interpretune/tools/__init__.py b/src/interpretune/tools/__init__.py
deleted file mode 100644
index f4d4eb7e..00000000
--- a/src/interpretune/tools/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Tools package for interpretune utilities."""
diff --git a/src/interpretune/tools/install_circuit_tracer.py b/src/interpretune/tools/install_circuit_tracer.py
deleted file mode 100644
index f8e0e0b2..00000000
--- a/src/interpretune/tools/install_circuit_tracer.py
+++ /dev/null
@@ -1,102 +0,0 @@
-"""Circuit-tracer installation utilities for interpretune."""
-
-import argparse
-import os
-import subprocess
-from pathlib import Path
-
-
-def install_circuit_tracer(use_commit_pin: bool = True, verbose: bool = False):
-    """Install circuit-tracer with appropriate dependencies."""
-
-    # Inline the utility functions to avoid importing interpretune package
-    def should_use_commit_pin():
-        """Check if we should use commit pin based on environment variable."""
-        return os.getenv("IT_USE_CT_COMMIT_PIN", "").lower() in ["true", "1", "yes"]
-
-    def get_circuit_tracer_commit():
-        """Get the pinned circuit-tracer commit hash."""
-        repo_root = Path(__file__).parent.parent.parent.parent
-        pin_file = repo_root / "requirements" / "circuit_tracer_pin.txt"
-
-        if pin_file.exists():
-            with open(pin_file, "r") as f:
-                for line in f:
-                    line = line.strip()
-                    if line and not line.startswith("#"):
-                        return line
-        return "6c74ea291c410bb3391e572cd6a8d020be714922"  # fallback
-
-    # Determine installation mode
-    if use_commit_pin is None:
-        use_commit_pin = should_use_commit_pin()
-
-    print(f"Installing circuit-tracer (commit_pin={use_commit_pin})...")
-
-    # Build requirements list
-    requirements = []
-
-    # Add circuit-tracer itself
-    if use_commit_pin:
-        commit_hash = get_circuit_tracer_commit()
-        circuit_tracer_url = f"git+https://github.com/speediedan/circuit-tracer.git@{commit_hash}"
-        requirements.append(f"{circuit_tracer_url}")
-    else:
-        requirements.append("circuit-tracer")
-
-    if not requirements:
-        print("No circuit-tracer requirements to install.")
-        return
-
-    # Install each requirement
-    for req in requirements:
-        # Split requirement and any flags
-        parts = req.split()
-        base_req = parts[0]
-        flags = parts[1:] if len(parts) > 1 else []
-
-        cmd = ["pip", "install", base_req] + flags
-
-        if verbose:
-            print(f"Running: {' '.join(cmd)}")
-
-        try:
-            result = subprocess.run(cmd, check=True, capture_output=not verbose, text=True)
-            if verbose and result.stdout:
-                print(result.stdout)
-        except subprocess.CalledProcessError as e:
-            print(f"Error installing {base_req}: {e}")
-            if e.stderr:
-                print(f"Error output: {e.stderr}")
-            return False
-
-    print("✅ Circuit-tracer installation completed successfully!")
-    return True
-
-
-def main():
-    """CLI entry point for circuit-tracer installation."""
-    parser = argparse.ArgumentParser(description="Install circuit-tracer for interpretune examples")
-    parser.add_argument(
-        "--no-commit-pin", action="store_true", help="Use version-based installation instead of commit pin"
-    )
-    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
-
-    args = parser.parse_args()
-
-    use_commit_pin = not args.no_commit_pin
-
-    # Set environment variable for consistency
-    if use_commit_pin:
-        os.environ["IT_USE_CT_COMMIT_PIN"] = "1"
-    else:
-        os.environ["IT_USE_CT_COMMIT_PIN"] = "0"
-
-    success = install_circuit_tracer(use_commit_pin, args.verbose)
-
-    if not success:
-        exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tests/core/test_regen_reqfiles.py b/tests/core/test_regen_reqfiles.py
index 3b5b4695..1fb8fcdb 100644
--- a/tests/core/test_regen_reqfiles.py
+++ b/tests/core/test_regen_reqfiles.py
@@ -5,7 +5,7 @@
 def load_regen_module():
     spec = importlib.util.spec_from_file_location(
         "regen_reqfiles",
-        Path(__file__).resolve().parents[2] / "requirements" / "regen_reqfiles.py",
+        Path(__file__).resolve().parents[2] / "requirements" / "utils" / "regen_reqfiles.py",
     )
     mod = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(mod)
@@ -43,8 +43,8 @@ def test_generate_pip_compile_inputs_writes_files(tmp_path):
     # Redirect regen module file outputs to tmp paths so tests don't modify repo files
     regen.REQ_DIR = str(tmp_path)
     regen.CI_REQ_DIR = str(ci_out)
-    regen.POST_UPGRADES_PATH = str(tmp_path / "post_upgrades.txt")
-    regen.CIRCUIT_TRACER_PIN = str(tmp_path / "circuit_tracer_pin.txt")
+    regen.POST_UPGRADES_PATH = str(ci_out / "post_upgrades.txt")
+    regen.CIRCUIT_TRACER_PIN = str(ci_out / "circuit_tracer_pin.txt")
 
     req_in_path, post_path, platform_path, direct_packages = regen.generate_pip_compile_inputs(pyproject, str(ci_out))
 
@@ -118,9 +118,11 @@ def test_post_process_pinned_requirements(tmp_path):
     # Direct packages list (only the packages we explicitly specify)
     direct_packages = ["torch", "transformers", "peft"]
     # Redirect regen module file outputs to tmp paths so tests don't modify repo files
+    ci_out = tmp_path / "ci"
+    ci_out.mkdir()
     regen.REQ_DIR = str(tmp_path)
-    regen.POST_UPGRADES_PATH = str(tmp_path / "post_upgrades.txt")
-    regen.CIRCUIT_TRACER_PIN = str(tmp_path / "circuit_tracer_pin.txt")
+    regen.POST_UPGRADES_PATH = str(ci_out / "post_upgrades.txt")
+    regen.CIRCUIT_TRACER_PIN = str(ci_out / "circuit_tracer_pin.txt")
 
     # Run post-processing using the direct_packages defined above
     regen.post_process_pinned_requirements(
@@ -171,8 +173,8 @@ def test_post_upgrades_comparators_and_malformed(tmp_path):
     # Redirect regen module file outputs to tmp paths so tests don't modify repo files
     regen.REQ_DIR = str(tmp_path)
     regen.CI_REQ_DIR = str(ci_out)
-    regen.POST_UPGRADES_PATH = str(tmp_path / "post_upgrades.txt")
-    regen.CIRCUIT_TRACER_PIN = str(tmp_path / "circuit_tracer_pin.txt")
+    regen.POST_UPGRADES_PATH = str(ci_out / "post_upgrades.txt")
+    regen.CIRCUIT_TRACER_PIN = str(ci_out / "circuit_tracer_pin.txt")
 
     req_in_path, post_path, platform_path, direct_packages = regen.generate_pip_compile_inputs(pyproject, str(ci_out))