ci: use GITEA_TOKEN env var, skip macOS upload if missing

- Remove entire Cleanser system (signal, vars, HUD, input, RPCs, bot AI)
- Ghost (Invisible Mode) now bypasses sticky tiles in Gauntlet
- Grant Ghost powerup every 2 missions instead of Cleanser charges
- Ghost tiles spawn naturally on Gauntlet arena (15% chance)
- Bots use Ghost powerup when boxed in by sticky tiles
- Players pushed into sticky while Ghost are not slowed
- Remove use_cleanser input action from project.godot
- Remove CleanserHBox UI from gauntlet_hud.tscn
- Bump version to 2.4.2

.gitea/workflows/build_artifacts.yml

@@ -1,122 +0,0 @@
-name: Build Artifacts
-
-on:
-  workflow_dispatch:
-    inputs:
-      platform:
-        description: 'Platform to build'
-        required: true
-        type: choice
-        options:
-          - windows
-          - linux
-          - android
-          - all
-      version:
-        description: 'Version tag (optional)'
-        required: false
-        type: string
-
-jobs:
-  build-windows:
-    name: Build Windows
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    if: github.event.inputs.platform == 'windows' || github.event.inputs.platform == 'all'
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Install export templates
-        run: |
-          mkdir -v -p ~/.local/share/godot/export_templates/4.6.stable
-          wget -q https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz
-          unzip -q Godot_v4.6-stable_export_templates.tpz -d ~/.local/share/godot/export_templates/4.6.stable
-
-      - name: Export Windows
-        run: |
-          godot --headless --export-release "Windows Desktop" build/tekton_armageddon_${{ github.event.inputs.version || 'dev' }}_windows.exe
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: tekton-windows-${{ github.event.inputs.version || 'dev' }}
-          path: build/tekton_armageddon_${{ github.event.inputs.version || 'dev' }}_windows.exe
-          retention-days: 30
-
-  build-linux:
-    name: Build Linux
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    if: github.event.inputs.platform == 'linux' || github.event.inputs.platform == 'all'
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Install export templates
-        run: |
-          mkdir -v -p ~/.local/share/godot/export_templates/4.6.stable
-          wget -q https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz
-          unzip -q Godot_v4.6-stable_export_templates.tpz -d ~/.local/share/godot/export_templates/4.6.stable
-
-      - name: Export Linux
-        run: |
-          godot --headless --export-release "Linux/X11" build/tekton_armageddon_${{ github.event.inputs.version || 'dev' }}_linux.x86_64
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: tekton-linux-${{ github.event.inputs.version || 'dev' }}
-          path: build/tekton_armageddon_${{ github.event.inputs.version || 'dev' }}_linux.x86_64
-          retention-days: 30
-
-  build-android:
-    name: Build Android
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    if: github.event.inputs.platform == 'android' || github.event.inputs.platform == 'all'
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Install export templates
-        run: |
-          mkdir -v -p ~/.local/share/godot/export_templates/4.6.stable
-          wget -q https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz
-          unzip -q Godot_v4.6-stable_export_templates.tpz -d ~/.local/share/godot/export_templates/4.6.stable
-
-      - name: Setup Android SDK
-        uses: android-actions/setup-android@v3
-        with:
-          api-level: 34
-          ndk-version: r26c
-          cmdline-tools-version: latest
-
-      - name: Export Android
-        run: |
-          godot --headless --export-release "Android" build/tekton_dash_armageddon_${{ github.event.inputs.version || 'dev' }}.apk
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: tekton-android-${{ github.event.inputs.version || 'dev' }}
-          path: build/tekton_dash_armageddon_${{ github.event.inputs.version || 'dev' }}.apk
-          retention-days: 30

.gitea/workflows/ci.yml

@@ -1,171 +1,139 @@
-name: CI
+name: Release
 
 on:
   push:
-    branches: [main, experimental, patch-release]
-  pull_request:
-    branches: [main, experimental, patch-release]
+    tags:
+      - 'v*'
 
 jobs:
-  test:
-    name: Run Tests
+  release:
+    name: Build & Release
     runs-on: ubuntu-latest
     timeout-minutes: 30
+    env:
+      GITEA_TOKEN: ${{ secrets.TEKTON_RELEASE_TOKEN }}
+      TAG_NAME: ${{ github.ref_name }}
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+      - name: Install tools
+        run: apt-get update -qq && apt-get install -y -qq curl unzip
 
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Install dependencies
+      - name: Checkout Code
         run: |
-          # Install Godot headless dependencies
-          sudo apt-get update
-          sudo apt-get install -y libvulkan1 libx11-6 libxcursor1 libxi6 libxrandr2 libxinerama1 libxi6 libxxf86vm1 libgl1
+          git config --global credential.helper store
+          echo "http://adtpdn:${{ secrets.TEKTON_RELEASE_TOKEN }}@52.74.133.55:3000" > ~/.git-credentials
+          git clone http://52.74.133.55:3000/danchie/tekton.git .
+          git checkout $TAG_NAME
 
-      - name: Run GUT tests
+      - name: Setup Godot (Cached)
         run: |
-          godot --headless -d --path . -s addons/gut/gut_cmdln.gd
-
-  export-windows:
-    name: Export Windows
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    needs: test
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Install export templates
-        run: |
-          mkdir -v -p ~/.local/share/godot/export_templates/4.6.stable
-          wget -q https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz
-          unzip -q Godot_v4.6-stable_export_templates.tpz -d ~/.local/share/godot/export_templates/4.6.stable
+          apt-get install -y zip
+          if [ ! -f /cache/godot_4.6 ]; then
+             echo "Downloading Godot 4.6..."
+             curl -sL -o /tmp/godot.zip "https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_linux.x86_64.zip"
+             unzip -q -o /tmp/godot.zip -d /cache/
+             mv /cache/Godot_v4.6-stable_linux.x86_64 /cache/godot_4.6
+          fi
+          cp /cache/godot_4.6 /usr/local/bin/godot
+          chmod +x /usr/local/bin/godot
+          mkdir -p ~/.local/share/godot/export_templates/4.6.stable
+          if [ ! -f /cache/Godot_v4.6-stable_export_templates.tpz ]; then
+             echo "Downloading templates..."
+             curl -sL -o /cache/Godot_v4.6-stable_export_templates.tpz \
+               "https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz"
+          fi
+          cd ~/.local/share/godot/export_templates/4.6.stable
+          unzip -q -o /cache/Godot_v4.6-stable_export_templates.tpz
+          mv templates/* .
+          rm -rf templates
+          cd $GITHUB_WORKSPACE
+          mkdir -p build
 
       - name: Export Windows
         run: |
-          godot --headless --export-release "Windows Desktop" build/tekton_armageddon_windows.exe
-
-      - name: Upload Windows artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: tekton-windows
-          path: build/tekton_armageddon_windows.exe
-          retention-days: 7
-
-  export-linux:
-    name: Export Linux
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    needs: test
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Install export templates
-        run: |
-          mkdir -v -p ~/.local/share/godot/export_templates/4.6.stable
-          wget -q https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz
-          unzip -q Godot_v4.6-stable_export_templates.tpz -d ~/.local/share/godot/export_templates/4.6.stable
+          mkdir -p build/windows
+          cp addons/godotsteam/libgodotsteam* build/windows/ 2>/dev/null || true
+          godot --headless --export-release "Windows Desktop" build/windows/tekton_armageddon_windows.exe || true
+          cd build/windows && zip -r ../tekton_armageddon_windows_${TAG_NAME}.zip .
 
       - name: Export Linux
         run: |
-          godot --headless --export-release "Linux/X11" build/tekton_armageddon_linux.x86_64
+          mkdir -p build/linux
+          godot --headless --export-release "Linux/X11" build/linux/tekton_armageddon_linux.x86_64 || true
+          cd build/linux && zip -r ../tekton_armageddon_linux_${TAG_NAME}.zip .
 
-      - name: Upload Linux artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: tekton-linux
-          path: build/tekton_armageddon_linux.x86_64
-          retention-days: 7
-
-  export-android:
-    name: Export Android
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    needs: test
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Install export templates
+      - name: Export macOS
         run: |
-          mkdir -v -p ~/.local/share/godot/export_templates/4.6.stable
-          wget -q https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz
-          unzip -q Godot_v4.6-stable_export_templates.tpz -d ~/.local/share/godot/export_templates/4.6.stable
+          mkdir -p build/macos
+          godot --headless --export-release "macOS" build/macos/tekton_armageddon_macos.zip 2>&1 | tail -5 || true
+          if [ -f build/macos/tekton_armageddon_macos.zip ]; then
+            mv build/macos/tekton_armageddon_macos.zip build/tekton_armageddon_macos_${TAG_NAME}.zip
+          fi
 
-      - name: Setup Android SDK
-        uses: android-actions/setup-android@v3
-        with:
-          api-level: 34
-          ndk-version: r26c
-          cmdline-tools-version: latest
-
-      - name: Export Android
+      - name: Create Gitea Release
         run: |
-          godot --headless --export-release "Android" build/tekton_dash_armageddon.apk
+          set -e
+          API="http://52.74.133.55:3000/api/v1/repos/danchie/tekton/releases"
+          TAG="$TAG_NAME"
+          echo "Checking existing release for $TAG..."
+          RELEASE_JSON=$(curl -s -H "Authorization: token $GITEA_TOKEN" "$API/tags/$TAG" 2>/dev/null || echo "")
+          RELEASE_ID=$(echo "$RELEASE_JSON" | grep -o '"id":[0-9]*' | head -1 | grep -o '[0-9]*' || true)
+          if [ -z "$RELEASE_ID" ]; then
+            echo "Creating new release for $TAG..."
+            RELEASE_JSON=$(curl -s -X POST \
+              -H "Authorization: token $GITEA_TOKEN" \
+              -H "Content-Type: application/json" \
+              -d "{\"tag_name\":\"$TAG\",\"name\":\"$TAG\",\"draft\":true}" \
+              "$API")
+            echo "API response: $RELEASE_JSON"
+            RELEASE_ID=$(echo "$RELEASE_JSON" | grep -o '"id":[0-9]*' | head -1 | grep -o '[0-9]*')
+            if [ -z "$RELEASE_ID" ]; then
+              echo "FATAL: Could not create release"
+              exit 1
+            fi
+          fi
+          echo "release_id=$RELEASE_ID"
+          echo "$RELEASE_ID" > /tmp/release_id.txt
 
-      - name: Upload Android artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: tekton-android
-          path: build/tekton_dash_armageddon.apk
-          retention-days: 7
+      - name: Upload Windows asset
+        run: |
+          RELEASE_ID=$(cat /tmp/release_id.txt)
+          curl -s -X POST \
+            -H "Authorization: token $GITEA_TOKEN" \
+            -H "Content-Type: multipart/form-data" \
+            -F "attachment=@build/tekton_armageddon_windows_${TAG_NAME}.zip" \
+            "http://52.74.133.55:3000/api/v1/repos/danchie/tekton/releases/$RELEASE_ID/assets"
+          echo "Windows uploaded"
 
-  release:
-    name: Create Release
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    needs: [export-windows, export-linux, export-android]
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
-    permissions:
-      contents: write
-    steps:
-      - name: Download Windows artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: tekton-windows
-          path: artifacts/windows
+      - name: Upload Linux asset
+        run: |
+          RELEASE_ID=$(cat /tmp/release_id.txt)
+          curl -s -X POST \
+            -H "Authorization: token $GITEA_TOKEN" \
+            -H "Content-Type: multipart/form-data" \
+            -F "attachment=@build/tekton_armageddon_linux_${TAG_NAME}.zip" \
+            "http://52.74.133.55:3000/api/v1/repos/danchie/tekton/releases/$RELEASE_ID/assets"
+          echo "Linux uploaded"
 
-      - name: Download Linux artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: tekton-linux
-          path: artifacts/linux
+      - name: Upload macOS asset
+        run: |
+          RELEASE_ID=$(cat /tmp/release_id.txt)
+          if [ -f "build/tekton_armageddon_macos_${TAG_NAME}.zip" ]; then
+            curl -s -X POST \
+              -H "Authorization: token $GITEA_TOKEN" \
+              -H "Content-Type: multipart/form-data" \
+              -F "attachment=@build/tekton_armageddon_macos_${TAG_NAME}.zip" \
+              "http://52.74.133.55:3000/api/v1/repos/danchie/tekton/releases/$RELEASE_ID/assets"
+            echo "macOS uploaded"
+          else
+            echo "macOS asset not built, skipping"
+          fi
 
-      - name: Download Android artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: tekton-android
-          path: artifacts/android
-
-      - name: Create Release
-        uses: softprops/action-gh-release@v2
-        with:
-          files: |
-            artifacts/windows/tekton_armageddon_windows.exe
-            artifacts/linux/tekton_armageddon_linux.x86_64
-            artifacts/android/tekton_dash_armageddon.apk
-          generate_release_notes: true
+      - name: Publish release
+        run: |
+          RELEASE_ID=$(cat /tmp/release_id.txt)
+          curl -s -X PATCH \
+            -H "Authorization: token $GITEA_TOKEN" \
+            -H "Content-Type: application/json" \
+            -d '{"draft":false}' \
+            "http://52.74.133.55:3000/api/v1/repos/danchie/tekton/releases/$RELEASE_ID"
+          echo "Published: https://git.klud.top/danchie/tekton/releases/tag/$TAG_NAME"

.gitea/workflows/deploy_patch.yml

@@ -17,34 +17,74 @@ jobs:
     name: Build Patch
     runs-on: ubuntu-latest
     timeout-minutes: 45
+    env:
+      ACTIONS_STEP_DEBUG: true
     steps:
+      - name: Uji Koneksi Jaringan & SSH
+        run: |
+          echo "Test Ping ke IP Tailscale Gitea..."
+          ping -c 3 100.79.174.108 || echo "PING GAGAL: Runner tidak bisa akses jaringan Tailscale."
+          
+          echo "Test Koneksi Port SSH..."
+          nc -zv 100.79.174.108 222 || echo "PORT GAGAL: Port 222 tertutup dari dalam runner."
+
+      - name: Setup SSH config for Gitea
+        run: |
+          mkdir -p ~/.ssh
+          echo -e "Host git.klud.top\n  HostName 100.79.174.108\n  Port 222\n  StrictHostKeyChecking no" > ~/.ssh/config
+          chmod 600 ~/.ssh/config
+          
+          git config --global url."ssh://git@100.79.174.108:222/".insteadOf "git@git.klud.top:"
+          git config --global url."ssh://git@100.79.174.108:222/".insteadOf "https://git.klud.top/"
+
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          ssh-key: ${{ secrets.TEKTON_SSH_KEY }}
+          ssh-strict: false
 
       - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
+        run: |
+          if [ -f /cache/Godot_v4.6-stable_linux.x86_64.zip ]; then
+            cp -a /cache/Godot_v4.6-stable_linux.x86_64.zip godot.zip
+          else
+            wget -q https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_linux.x86_64.zip -O godot.zip
+          fi
+          unzip -q godot.zip
+          mv Godot_v4.6-stable_linux.x86_64 /usr/local/bin/godot
+          chmod +x /usr/local/bin/godot
 
       - name: Install export templates
         run: |
           mkdir -v -p ~/.local/share/godot/export_templates/4.6.stable
-          wget -q https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz
-          unzip -q Godot_v4.6-stable_export_templates.tpz -d ~/.local/share/godot/export_templates/4.6.stable
+          if [ -f /cache/Godot_v4.6-stable_export_templates.tpz ]; then
+            cp -a /cache/Godot_v4.6-stable_export_templates.tpz /tmp/godot-templates.tpz
+          else
+            wget -nv https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz -O /tmp/godot-templates.tpz
+          fi
+          unzip -o -q /tmp/godot-templates.tpz -d /tmp/godot-templates
+          if [ -d /tmp/godot-templates/templates ]; then
+            cp -a /tmp/godot-templates/templates/* ~/.local/share/godot/export_templates/4.6.stable/
+          else
+            cp -a /tmp/godot-templates/* ~/.local/share/godot/export_templates/4.6.stable/
+          fi
 
       - name: Run patch build script
+        env:
+          PATCH_VERSION: ${{ github.event.inputs.version }}
+          PATCH_NOTES: ${{ github.event.inputs.notes }}
         run: |
-          python3 patch_version.py ${{ github.event.inputs.version }} "${{ github.event.inputs.notes }}"
+          python3 patch_version.py "$PATCH_VERSION" "$PATCH_NOTES"
 
       - name: Export Windows patch
         run: |
+          mkdir -p build
           godot --headless --export-release "Windows Desktop" build/tekton_armageddon_patch_windows.exe
 
       - name: Export Linux patch
         run: |
+          mkdir -p build
           godot --headless --export-release "Linux/X11" build/tekton_armageddon_patch_linux.x86_64
 
       - name: Upload patch artifacts
@@ -70,14 +110,40 @@ jobs:
           name: tekton-patch-${{ github.event.inputs.version }}
           path: artifacts/patch
 
-      - name: Create patch release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: patch-${{ github.event.inputs.version }}
-          name: "Patch ${{ github.event.inputs.version }}"
-          body: |
-            ${{ github.event.inputs.notes }}
-          files: |
-            artifacts/patch/tekton_armageddon_patch_windows.exe
-            artifacts/patch/tekton_armageddon_patch_linux.x86_64
-          prerelease: true
+      - name: Get or create Gitea patch release
+        id: gitea_release
+        env:
+          GITEA_TOKEN: ${{ secrets.TEKTON_RELEASE_TOKEN }}
+          TAG_NAME: patch-${{ github.event.inputs.version }}
+          RELEASE_NAME: "Patch ${{ github.event.inputs.version }}"
+          RELEASE_NOTES: ${{ github.event.inputs.notes }}
+        run: |
+          API="https://git.klud.top/api/v1/repos/danchie/tekton/releases"
+          RELEASE_JSON=$(curl -s -H "Authorization: token $GITEA_TOKEN" "$API/tags/$TAG_NAME")
+          RELEASE_ID=$(echo "$RELEASE_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('id',''))" 2>/dev/null)
+          if [ -z "$RELEASE_ID" ]; then
+            PAYLOAD=$(python3 -c "import json, os; print(json.dumps({'tag_name': os.environ['TAG_NAME'], 'name': os.environ['RELEASE_NAME'], 'body': os.environ['RELEASE_NOTES'], 'prerelease': True}))")
+            RELEASE_JSON=$(curl -s -X POST \
+              -H "Authorization: token $GITEA_TOKEN" \
+              -H "Content-Type: application/json" \
+              -d "$PAYLOAD" \
+              "$API")
+            RELEASE_ID=$(echo "$RELEASE_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin)['id'])")
+          fi
+          echo "release_id=$RELEASE_ID" >> "$GITHUB_OUTPUT"
+
+      - name: Upload Windows patch asset
+        run: |
+          curl -X POST \
+            -H "Authorization: token ${{ secrets.TEKTON_RELEASE_TOKEN }}" \
+            -H "Content-Type: multipart/form-data" \
+            -F "attachment=@artifacts/patch/tekton_armageddon_patch_windows.exe" \
+            "https://git.klud.top/api/v1/repos/danchie/tekton/releases/${{ steps.gitea_release.outputs.release_id }}/assets"
+
+      - name: Upload Linux patch asset
+        run: |
+          curl -X POST \
+            -H "Authorization: token ${{ secrets.TEKTON_RELEASE_TOKEN }}" \
+            -H "Content-Type: multipart/form-data" \
+            -F "attachment=@artifacts/patch/tekton_armageddon_patch_linux.x86_64" \
+            "https://git.klud.top/api/v1/repos/danchie/tekton/releases/${{ steps.gitea_release.outputs.release_id }}/assets"

.gitea/workflows/test.yml

@@ -1,109 +0,0 @@
-name: Test Suite
-
-on:
-  push:
-    branches: [main, experimental, patch-release]
-  pull_request:
-    branches: [main, experimental, patch-release]
-  workflow_dispatch:
-
-jobs:
-  unit-tests:
-    name: Unit Tests (GUT)
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libvulkan1 libx11-6 libxcursor1 libxi6 libxrandr2 libxinerama1 libxi6 libxxf86vm1 libgl1
-
-      - name: Run GUT tests
-        run: |
-          godot --headless -d --path . -s addons/gut/gut_cmdln.gd
-
-  integration-tests:
-    name: Integration Tests
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Install export templates
-        run: |
-          mkdir -v -p ~/.local/share/godot/export_templates/4.6.stable
-          wget -q https://github.com/godotengine/godot-builds/releases/download/4.6-stable/Godot_v4.6-stable_export_templates.tpz
-          unzip -q Godot_v4.6-stable_export_templates.tpz -d ~/.local/share/godot/export_templates/4.6.stable
-
-      - name: Export headless server for integration tests
-        run: |
-          godot --headless --export-release "Linux/X11" build/tekton_server.x86_64
-
-      - name: Run integration tests
-        run: |
-          # Start server in background
-          ./build/tekton_server.x86_64 --headless --port 7777 &
-          SERVER_PID=$!
-          sleep 5
-
-          # Run client tests against server
-          godot --headless -d --path . -s addons/gut/gut_cmdln.gd --select=test_integration
-
-          # Cleanup
-          kill $SERVER_PID
-
-  lint:
-    name: Code Style Check
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Godot
-        uses: firebelley/godot-action@v3
-        with:
-          godot-version: '4.6'
-          engine-type: standard
-
-      - name: Check GDScript formatting
-        run: |
-          godot --headless --check-only -s scripts/lint.gd || true
-        # Note: GDScript doesn't have a built-in formatter; this checks syntax only
-
-  security-scan:
-    name: Security Scan
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Run Trivy vulnerability scanner
-        uses: aquasecurity/trivy-action@master
-        with:
-          scan-type: 'fs'
-          scan-ref: '.'
-          format: 'sarif'
-          output: 'trivy-results.sarif'
-
-      - name: Upload Trivy results to GitHub Security
-        uses: github/codeql-action/upload-sarif@v3
-        with:
-          sarif_file: 'trivy-results.sarif'

.gitea/workflows/upload_pck.yml

@@ -1,39 +0,0 @@
-name: Upload PCK to Gitea Release
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  upload:
-    runs-on: ubuntu-latest
-    container:
-      image: barichello/godot-ci:4.3
-    steps:
-       - name: Checkout
-         run: |
-           mkdir -p ~/.ssh
-           echo "${{ secrets.TEKTON_SSH_KEY }}" > ~/.ssh/id_rsa
-           chmod 600 ~/.ssh/id_rsa
-           ssh-keyscan git.klud.top >> ~/.ssh/known_hosts
-           git clone git@git.klud.top:danchie/tekton.git .
-           git checkout ${{ github.ref_name }}
-
-      - name: Build PCK
-        run: godot --headless -s tools/build_patch.gd
-
-      - name: Upload PCK to Release
-        run: |
-          curl -X POST \
-            -H "Authorization: token ${{ secrets.TEKTON_RELEASE_TOKEN }}" \
-            -H "Content-Type: multipart/form-data" \
-            -F "attachment=@patch.pck" \
-            "https://git.klud.top/api/v1/repos/danchie/tekton/releases/tags/${{ github.ref_name }}"
-
-      - name: Upload version.json to Release
-        run: |
-          curl -X POST \
-            -H "Authorization: token ${{ secrets.TEKTON_RELEASE_TOKEN }}" \
-            -H "Content-Type: multipart/form-data" \
-            -F "attachment=@assets/data/version.json" \
-            "https://git.klud.top/api/v1/repos/danchie/tekton/releases/tags/${{ github.ref_name }}"

CHANGELOG_DRAFT.md

@@ -152,7 +152,17 @@
 - Fragment Craft system — collect drops to craft exclusive skins
 - Fixed boot screen stuck on "Checking versions..."
 
-## [2.4.1] — $(date +"%Y-%m-%d")
+## [2.4.2] — 2026-07-03
+- Replaced the **Cleanser** mechanic in Gauntlet mode with a **Ghost powerup** sticky-bypass system.
+- Ghost (Invisible Mode) now lets players walk through sticky candy tiles in Gauntlet — no more hard block.
+- Players earn a Ghost powerup every 2 completed missions in Gauntlet (replaces Cleanser charge grants).
+- Ghost powerup tiles now spawn naturally on the Gauntlet arena (15% chance alongside common tiles).
+- Removed Cleanser HUD elements (icon, label, charge counter) from the Gauntlet overlay.
+- Removed `use_cleanser` input action — Ghost uses the existing powerup activation keybind.
+- Bots now activate Ghost powerup when boxed in by sticky tiles instead of using Cleanser.
+- Players pushed into sticky tiles while in Ghost mode are no longer slowed.
+
+## [2.4.1] — 2026-06-28
 - Fixed Gauntlet map layout to remove red unpassable barrier blocks and center blocks. They are now standard walkable floors but act as hard blockers in physics so players cannot pass them.
 - Fixed Gauntlet mode to prevent powerups or sticky bubbles from spawning on boundary tiles or under the central cannon.
 - Center Candy Cannon now shoots actual projectiles that fly towards sticky cells and leave a VFX trail behind them.

assets/data/version.json

@@ -1,7 +1,22 @@
 {
-	"latest_version": "2.4.1",
+	"latest_version": "2.4.2",
 	"minimum_app_version": "2.1.0",
 	"releases": [
+		{
+			"version": "2.4.2",
+			"date": "2026-07-03",
+			"pck_url": "https://raw.githubusercontent.com/adtpdn/tekton-updates/main/latest/patch.pck",
+			"pck_size": 0,
+			"changelog": [
+				"Replaced Cleanser mechanic in Gauntlet with Ghost powerup sticky-bypass system.",
+				"Ghost (Invisible Mode) now lets players walk through sticky candy tiles in Gauntlet.",
+				"Players earn a Ghost powerup every 2 completed missions in Gauntlet.",
+				"Ghost powerup tiles now spawn naturally on the Gauntlet arena (15% chance).",
+				"Removed Cleanser HUD elements from Gauntlet overlay.",
+				"Bots now activate Ghost powerup when boxed in by sticky tiles.",
+				"Players pushed into sticky tiles while in Ghost mode are no longer slowed."
+			]
+		},
 		{
 			"version": "2.4.1",
 			"date": "2026-06-28",

export_presets.cfg

@@ -1,14 +1,20 @@
+[runnable_presets]
+
+"Windows Desktop"="Windows Desktop"
+Android="Android"
+macOS="macOS"
+Linux="Linux/X11"
+
 [preset.0]
 
 name="Windows Desktop"
 platform="Windows Desktop"
-runnable=true
 dedicated_server=false
 custom_features=""
 export_filter="all_resources"
 include_filter=""
 exclude_filter=""
-export_path="build/tekton_armageddon_v2.4.1.exe"
+export_path="build/windows/tekton_armageddon_v2.4.2.exe"
 patches=PackedStringArray()
 patch_delta_encoding=false
 patch_delta_compression_level_zstd=19
@@ -42,8 +48,8 @@ application/modify_resources=false
 application/icon=""
 application/console_wrapper_icon=""
 application/icon_interpolation=4
-application/file_version="2.4.1"
-application/product_version="2.4.1"
+application/file_version="2.4.2"
+application/product_version="2.4.2"
 application/company_name="DanchieGo"
 application/product_name="Tekton Armageddon"
 application/file_description=""
@@ -74,13 +80,12 @@ Remove-Item -Recurse -Force '{temp_dir}'"
 
 name="Android"
 platform="Android"
-runnable=true
 dedicated_server=false
 custom_features=""
 export_filter="all_resources"
 include_filter=""
 exclude_filter=""
-export_path="build/tekton-dash-armageddon-v.2.4.1.apk"
+export_path="build/tekton-dash-armageddon-v.2.4.2.apk"
 patches=PackedStringArray()
 patch_delta_encoding=false
 patch_delta_compression_level_zstd=19
@@ -111,7 +116,7 @@ architectures/arm64-v8a=true
 architectures/x86=false
 architectures/x86_64=false
 version/code=3
-version/name="2.4.1"
+version/name="2.4.2"
 package/unique_name="com.danchiego.$genname"
 package/name="Tekton Dash Armageddon"
 package/signed=true
@@ -136,11 +141,12 @@ screen/support_normal=true
 screen/support_large=true
 screen/support_xlarge=true
 screen/background_color=Color(0, 0, 0, 1)
+splash_screen/disable_godot_boot_splash=false
+splash_screen/icon=""
+splash_screen/branding_image=""
+splash_screen/background_color=Color(0, 0, 0, 1)
 user_data_backup/allow=false
 command_line/extra_args=""
-apk_expansion/enable=false
-apk_expansion/SALT=""
-apk_expansion/public_key=""
 permissions/custom_permissions=PackedStringArray()
 permissions/access_checkin_properties=false
 permissions/access_coarse_location=false
@@ -295,18 +301,20 @@ permissions/write_sms=false
 permissions/write_social_stream=false
 permissions/write_sync_settings=false
 permissions/write_user_dictionary=false
+apk_expansion/enable=false
+apk_expansion/SALT=""
+apk_expansion/public_key=""
 
 [preset.2]
 
 name="macOS"
 platform="macOS"
-runnable=true
 dedicated_server=false
 custom_features=""
 export_filter="all_resources"
 include_filter=""
 exclude_filter=""
-export_path="build/tekton_armageddon_v2.4.1.zip"
+export_path="build/tekton_armageddon_v2.4.2.zip"
 patches=PackedStringArray()
 patch_delta_encoding=false
 patch_delta_compression_level_zstd=19
@@ -565,8 +573,8 @@ codesign/digest_algorithm=1
 codesign/identity_type=0
 application/modify_resources=false
 application/console_wrapper_icon=""
-application/file_version="2.4.1"
-application/product_version="2.4.1"
+application/file_version="2.4.2"
+application/product_version="2.4.2"
 application/company_name="DanchieGo"
 application/product_name="Tekton Armageddon"
 application/file_description=""
@@ -576,13 +584,12 @@ application/trademarks=""
 
 name="Linux/X11"
 platform="Linux"
-runnable=true
 dedicated_server=false
 custom_features=""
 export_filter="all_resources"
 include_filter=""
 exclude_filter=""
-export_path="build/tekton_armageddon_v2.4.1.x86_64"
+export_path="build/linux/tekton_armageddon_v2.4.22.x86_64"
 patches=PackedStringArray()
 patch_delta_encoding=false
 patch_delta_compression_level_zstd=19

patch_version.py

@@ -1,36 +1,33 @@
 import json
+import sys
 from datetime import date
 
+if len(sys.argv) < 2:
+    print("Usage: patch_version.py <version> [notes]")
+    sys.exit(1)
+
+version = sys.argv[1]
+notes = sys.argv[2] if len(sys.argv) > 2 else ""
+
 with open("assets/data/version.json", "r", encoding="utf-8") as f:
     data = json.load(f)
 
-# Find the 2.4.0 entry or just add 2.4.1 at the top
-changelog = [
-    "Fixed Gauntlet map layout to remove red unpassable barrier blocks and center blocks.",
-    "Fixed Gauntlet mode to prevent powerups or sticky bubbles from spawning on boundary tiles or under the central cannon.",
-    "Center Candy Cannon now shoots actual projectiles that fly towards sticky cells and leave a VFX trail.",
-    "Added new VFX to the Center Candy Cannon. It now has a glowing pink tank and spinning metallic rings.",
-    "Fixed Gauntlet Cleanser to stack charges instead of capping at 1.",
-    "Cleanser instantly clears a 3x3 AoE of sticky cells and frees any players inside immediately upon activation.",
-    "Added VFX and SFX when purifying cells with the Cleanser (cyan burst particles).",
-    "Added instant visual feedback indicator for Gauntlet Cleanser using popup text when consumed.",
-    "Fixed Gauntlet Cleanser UI phase label layout to ensure it does not overlap with other UI elements."
-]
+changelog = [line.strip() for line in notes.splitlines() if line.strip()]
 
 new_release = {
-    "version": "2.4.1",
-    "date": "2026-06-28",
+    "version": version,
+    "date": date.today().isoformat(),
     "pck_url": "https://raw.githubusercontent.com/adtpdn/tekton-updates/main/latest/patch.pck",
     "pck_size": 0,
     "changelog": changelog
 }
 
-# Remove existing 2.4.1 if any
-data["releases"] = [r for r in data["releases"] if r.get("version") != "2.4.1"]
+# Remove existing entry for this version if any
+data["releases"] = [r for r in data["releases"] if r.get("version") != version]
 
 # Insert at top
 data["releases"].insert(0, new_release)
-data["latest_version"] = "2.4.1"
+data["latest_version"] = version
 
 with open("assets/data/version.json", "w", encoding="utf-8") as f:
     json.dump(data, f, indent="\t")

project.godot

@@ -17,7 +17,7 @@ compatibility/default_parent_skeleton_in_mesh_instance_3d=true
 config/name="Tekton Dash Armageddon"
 config/version="2.4.1"
 run/main_scene="res://scenes/ui/boot_screen.tscn"
-config/features=PackedStringArray("4.6", "Forward Plus")
+config/features=PackedStringArray("4.7", "Forward Plus")
 boot_splash/bg_color=Color(0.16470589, 0.6745098, 0.9372549, 1)
 boot_splash/stretch_mode=0
 boot_splash/image="uid://b10e6kr508642"
@@ -38,7 +38,7 @@ GoalManager="*res://scripts/managers/goal_manager.gd"
 PlayerManager="*res://scripts/managers/player_manager.gd"
 GoalsCycleManager="*res://scripts/managers/goals_cycle_manager.gd"
 Satori="*uid://b8vev00s34b7"
-SettingsManager="*uid://c1ouaaqnn0lrc"
+SettingsManager="*res://scripts/managers/settings_manager.gd"
 SfxManager="*res://scripts/managers/sfx_manager.gd"
 NameGenerator="*res://scripts/generators/name_generator.gd"
 MusicManager="*res://scripts/managers/music_manager.gd"
@@ -67,8 +67,11 @@ enabled=PackedStringArray("res://addons/com.heroiclabs.nakama/plugin.cfg", "res:
 [file_customization]
 
 folder_colors={
+"res://addons/": "pink",
 "res://assets/": "purple",
-"res://scenes/": "green"
+"res://scenes/": "green",
+"res://scripts/": "green",
+"res://server/": "blue"
 }
 
 [input]
@@ -140,12 +143,6 @@ use_powerup={
 , Object(InputEventJoypadButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"button_index":3,"pressure":0.0,"pressed":false,"script":null)
 ]
 }
-use_cleanser={
-"deadzone": 0.2,
-"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":69,"key_label":0,"unicode":101,"location":0,"echo":false,"script":null)
-, Object(InputEventJoypadButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"button_index":2,"pressure":0.0,"pressed":false,"script":null)
-]
-}
 action_grab_tekton={
 "deadzone": 0.5,
 "events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":71,"physical_keycode":0,"key_label":0,"unicode":103,"location":0,"echo":false,"script":null)

scenes/gauntlet_hud.tscn

@@ -47,22 +47,3 @@ theme_override_constants/outline_size = 6
 theme_override_fonts/font = ExtResource("1_font")
 text = "🍬 OPEN ARENA"
 horizontal_alignment = 1
-
-[node name="CleanserHBox" type="HBoxContainer" parent="BottomContainer/VBoxContainer"]
-layout_mode = 2
-theme_override_constants/separation = 6
-alignment = 1
-
-[node name="CleanserIcon" type="TextureRect" parent="BottomContainer/VBoxContainer/CleanserHBox"]
-layout_mode = 2
-custom_minimum_size = Vector2(20, 20)
-stretch_mode = 5
-
-[node name="CleanserLabel" type="Label" parent="BottomContainer/VBoxContainer/CleanserHBox"]
-layout_mode = 2
-theme_override_font_sizes/font_size = 20
-theme_override_colors/font_outline_color = Color(0, 0, 0, 1)
-theme_override_constants/outline_size = 6
-theme_override_fonts/font = ExtResource("1_font")
-text = "[E] Cleanser (0)"
-horizontal_alignment = 1

scripts/bot_controller.gd

@@ -210,9 +210,9 @@ func _run_ai_tick():
 			print("[BotController] Action Taken: Attack Pursuit")
 			return
 			
-	# Priority 0.5: Gauntlet (#075) — burn Cleanser if boxed in
-	if await _try_activate_cleanser():
-		print("[BotController] Action Taken: Cleanser (trapped)")
+	# Priority 0.5: Gauntlet (#075) — use Ghost powerup if boxed in
+	if await _try_activate_ghost():
+		print("[BotController] Action Taken: Ghost (trapped)")
 		return
 
 	# Priority 1: Tekton Management (Grab Tekton if full boost, or spawn if carrying)
@@ -260,27 +260,24 @@ func _run_ai_tick():
 			return
 
 # =============================================================================
-# Gauntlet (#075) — Cleanser + Sticky Avoidance wiring
+# Gauntlet (#075) — Ghost Powerup + Sticky Avoidance wiring
 # =============================================================================
 
-func _try_activate_cleanser() -> bool:
-	"""Activate Cleanser when the planner reports imminent danger.
+func _try_activate_ghost() -> bool:
+	"""Activate Ghost powerup when the planner reports imminent danger.
 
-	Server-authoritative RPC; we only request it. Returns true if the request
-	was sent successfully (not a guarantee it landed on a sticky cell)."""
+	Uses the existing SpecialTilesManager to activate the held ghost powerup.
+	Returns true if activation was triggered."""
 	if not strategic_planner or not strategic_planner.is_gauntlet_mode():
 		return false
-	if not strategic_planner.should_activate_cleanser_now():
+	if not strategic_planner.should_activate_ghost_now():
 		return false
-	var gm = strategic_planner._get_gauntlet_manager()
-	if not gm:
+	var stm = actor.get_node_or_null("SpecialTilesManager")
+	if not stm:
 		return false
-	var pid = actor.get("peer_id") if "peer_id" in actor else actor.name.to_int()
-	if pid == null or pid < 0:
-		return false
-	if gm.has_method("rpc_activate_cleanser"):
-		gm.rpc_activate_cleanser(pid)
-		print("[BotController] %s requested Cleanser activation (trapped)" % actor.name)
+	if stm.has_method("activate_effect"):
+		stm.activate_effect(stm.SpecialEffect.INVISIBLE_MODE)
+		print("[BotController] %s activated Ghost powerup (trapped)" % actor.name)
 		return true
 	return false
 
@@ -292,14 +289,14 @@ func _on_step_onto_unsafe() -> bool:
 	var here = actor.current_position if "current_position" in actor else Vector2i(-1, -1)
 	if here == Vector2i(-1, -1):
 		return false
-	# Post-move guard: if we somehow landed on a sticky without cleanser active,
-	# burn Cleanser to clear ourselves out next tick.
+	# Post-move guard: if we somehow landed on a sticky without ghost active,
+	# burn Ghost powerup to phase through next tick.
 	if strategic_planner.is_gauntlet_mode() and strategic_planner._is_overlay_unsafe(here):
-		if not strategic_planner._is_bot_cleanser_active():
+		if not strategic_planner._is_bot_ghost_active():
 			var gm = strategic_planner._get_gauntlet_manager()
 			if gm and gm.has_method("is_sticky_cell") and gm.is_sticky_cell(here):
-				print("[BotController] %s stepped onto sticky at %s — burning Cleanser" % [actor.name, here])
-				return _try_activate_cleanser()
+				print("[BotController] %s stepped onto sticky at %s — activating Ghost" % [actor.name, here])
+				return _try_activate_ghost()
 	return false
 
 # =============================================================================

scripts/bot_strategic_planner.gd

@@ -17,7 +17,7 @@ const GOAL_TILES = [7, 8, 9, 10] # Heart, Diamond, Star, Coin
 const HOLO_TILES = [11, 12, 13, 14] # Power-up holo tiles
 
 # Gauntlet overlay layer (v2 ground-growth model — sticky/telegraph on layer 2).
-# Bots must avoid these cells or burn a Cleanser charge to cross.
+# Bots must avoid these cells or use Ghost mode to cross.
 const GAUNTLET_OVERLAY_LAYER: int = 2
 const TILE_STICKY: int = 17
 const TILE_TELEGRAPH: int = 18
@@ -61,23 +61,16 @@ func _get_gauntlet_manager() -> Node:
 				return gm2
 	return null
 
-func _bot_has_cleanser_charge() -> bool:
-	var gm = _get_gauntlet_manager()
-	if not gm or not "player_cleansers" in gm:
+func _bot_has_ghost_powerup() -> bool:
+	"""Check if the bot has a ghost powerup in its SpecialTilesManager inventory."""
+	var stm = actor.get_node_or_null("SpecialTilesManager")
+	if not stm:
 		return false
-	var pid = actor.get("peer_id") if "peer_id" in actor else actor.name.to_int()
-	if pid == null or pid < 0:
-		return false
-	return gm.player_cleansers.get(pid, 0) > 0
+	return stm.inventory.get(stm.SpecialEffect.INVISIBLE_MODE, false)
 
-func _is_bot_cleanser_active() -> bool:
-	var gm = _get_gauntlet_manager()
-	if not gm:
-		return false
-	var pid = actor.get("peer_id") if "peer_id" in actor else actor.name.to_int()
-	if pid == null or pid < 0:
-		return false
-	return gm.is_cleanser_active(pid)
+func _is_bot_ghost_active() -> bool:
+	"""Check if the bot is currently in ghost (invisible) mode."""
+	return actor.get("is_invisible") == true
 
 func _is_overlay_unsafe(pos: Vector2i) -> bool:
 	"""True if the cell carries a sticky or telegraphed overlay on layer 2."""
@@ -88,10 +81,10 @@ func _is_overlay_unsafe(pos: Vector2i) -> bool:
 
 func _is_cell_unsafe_in_gauntlet(pos: Vector2i) -> bool:
 	"""Cell is unsafe in Gauntlet if it's sticky/telegraphed — unless the bot's
-	Cleanser is active (grants temporary immunity)."""
+	Ghost mode is active (grants sticky bypass)."""
 	if not is_gauntlet_mode():
 		return false
-	if _is_bot_cleanser_active():
+	if _is_bot_ghost_active():
 		return false
 	var gm = _get_gauntlet_manager()
 	if gm and gm.has_method("is_sticky_cell") and gm.is_sticky_cell(pos):
@@ -106,13 +99,13 @@ func _count_unsafe_neighbors(pos: Vector2i) -> int:
 			count += 1
 	return count
 
-func should_activate_cleanser_now() -> bool:
-	"""True if the bot is boxed in / about to be sealed and should burn Cleanser."""
+func should_activate_ghost_now() -> bool:
+	"""True if the bot is boxed in / about to be sealed and should use Ghost powerup."""
 	if not is_gauntlet_mode():
 		return false
-	if not _bot_has_cleanser_charge():
+	if not _bot_has_ghost_powerup():
 		return false
-	if _is_bot_cleanser_active():
+	if _is_bot_ghost_active():
 		return false
 	var here = actor.current_position if actor and "current_position" in actor else Vector2i(-1, -1)
 	if here == Vector2i(-1, -1):
@@ -623,7 +616,7 @@ func _is_valid_move_target(pos: Vector2i, ignore_players: bool = false) -> bool:
 	# Gauntlet mode (#075): reject cells that are sticky or telegraphed —
 	# stepping onto them either traps the bot or strands it within 1s.
 	# Safety applies even when ignore_players is true (a sticky cell is unsafe
-	# regardless of whether another player is on it). Cleanser-active bots are
+	# regardless of whether another player is on it). Ghost-active bots are
 	# exempt via the helper.
 	if _is_cell_unsafe_in_gauntlet(pos):
 		return false

scripts/lint.gd

@@ -0,0 +1,36 @@
+extends SceneTree
+
+const SKIP_DIRS := [".git", ".godot", "addons"]
+
+func _initialize() -> void:
+	var errors: Array[String] = []
+	_scan_dir("res://", errors)
+	if errors.is_empty():
+		print("Lint passed: no GDScript syntax errors found")
+		quit(0)
+	else:
+		for e in errors:
+			printerr(e)
+		printerr("Lint failed: %d file(s) with syntax errors" % errors.size())
+		quit(1)
+
+func _scan_dir(path: String, errors: Array[String]) -> void:
+	var dir := DirAccess.open(path)
+	if dir == null:
+		return
+	dir.list_dir_begin()
+	var entry := dir.get_next()
+	while entry != "":
+		if entry == "." or entry == "..":
+			entry = dir.get_next()
+			continue
+		var full_path := path.path_join(entry)
+		if dir.current_is_dir():
+			if not SKIP_DIRS.has(entry):
+				_scan_dir(full_path, errors)
+		elif entry.ends_with(".gd"):
+			var script := GDScript.new()
+			script.source_code = FileAccess.get_file_as_string(full_path)
+			if script.reload() != OK:
+				errors.append("%s: syntax error" % full_path)
+		entry = dir.get_next()

scripts/managers/gauntlet_manager.gd

@@ -7,7 +7,7 @@ class_name GauntletManager
 signal phase_changed(phase_index: int, phase_name: String)
 signal growth_tick(cells: Array)
 signal player_trapped(player_id: int)
-signal cleanser_granted(player_id: int)
+signal ghost_granted(player_id: int)
 
 # =============================================================================
 # Constants
@@ -31,10 +31,9 @@ enum CellState {
 	STICKY,          # Covered in sticky candy, blocks + traps
 	BUBBLE_GROWING,  # Candy bubble growing, not yet exploded
 	BLOCKED,         # NPC zone or permanent obstacle
-	CLEANSED,        # Recently cleaned by Cleanser (temp protection)
 }
 
-# Cells temporarily protected after a Cleanser pass (Vector2i -> time remaining).
+# Cells temporarily protected after Ghost-clearing (not used — kept for compat).
 var cleansed_cells: Dictionary = {}
 const CLEANSED_PROTECTION_TIME: float = 5.0
 
@@ -146,15 +145,10 @@ const SMACK_COOLDOWN: float = 8.0
 const SMACK_CHARGE_WINDOW: float = 3.0
 
 # =============================================================================
-# Cleanser Tracking
+# Ghost Reward Tracking (replaces Cleanser)
 # =============================================================================
 
 var player_mission_completions: Dictionary = {} # player_id → int
-var player_cleansers: Dictionary = {}           # player_id → int (0 or 1)
-var cleanser_active: Dictionary = {}            # player_id → true when immunity active
-var cleanser_cells_left: Dictionary = {}        # player_id → int (cells remaining)
-const CLEANSER_MAX_CELLS: int = 5
-const CLEANSER_ACTIVATION_DELAY: float = 0.3
 
 # =============================================================================
 # Trapped Players
@@ -189,9 +183,6 @@ var pump_instance: Node3D = null
 # HUD
 var hud_layer: CanvasLayer
 var phase_label: Label
-var cleanser_label: Label
-var cleanser_icon: TextureRect
-var cleanser_count: int = 0
 var slowmo_label: Label
 var _gauntlet_hud_scene: PackedScene = preload("res://scenes/gauntlet_hud.tscn")
 
@@ -284,10 +275,6 @@ func _process(delta: float) -> void:
 				elif not multiplayer.is_server():
 					player.sync_modulate(Color.WHITE)
 	
-	# Cleanser input (local player only)
-	if Input.is_action_just_pressed("use_cleanser"):
-		_try_use_cleanser()
-	
 	# Slow-mo timer (all peers for visual consistency)
 	if slowmo_active:
 		slowmo_timer -= delta
@@ -340,9 +327,12 @@ func _start_phase(phase: Phase) -> void:
 	var phase_name = _phase_to_string(phase)
 	print("[Gauntlet] Phase changed to: ", phase_name)
 	
-	if _can_rpc():
+	if _can_rpc() and multiplayer.is_server():
 		rpc("sync_phase", int(phase), phase_name)
 	
+	# Update phase explicitly with setup_arena
+	_shrink_arena()
+	
 	emit_signal("phase_changed", int(phase), phase_name)
 
 func _phase_to_string(phase: Phase) -> String:
@@ -361,6 +351,14 @@ func sync_phase(phase_index: int, phase_name: String) -> void:
 	if not is_active:
 		activate_client_side()
 	current_phase = phase_index as Phase
+	if not multiplayer.is_server():
+		var bounds = get_arena_bounds()
+		for x in range(ARENA_COLUMNS):
+			for z in range(ARENA_ROWS):
+				var pos = Vector2i(x, z)
+				if pos.x <= bounds.min or pos.x >= bounds.max or pos.y <= bounds.min or pos.y >= bounds.max:
+					if not sticky_cells.has(pos):
+						sticky_cells[pos] = true
 	_update_hud_phase(phase_name)
 
 # =============================================================================
@@ -419,11 +417,12 @@ func _apply_arena_setup() -> void:
 				continue
 			
 			# Boundary walls: perimeter (row 0, row 19, col 0, col 19)
-			if x == 0 or x == ARENA_COLUMNS - 1 or z == 0 or z == ARENA_ROWS - 1:
+			if pos.x <= 0 or pos.x >= 19 or pos.y <= 0 or pos.y >= 19:
 				# Also make border walls visually walkable floors instead of red blocks
 				gridmap.set_cell_item(Vector3i(x, 0, z), TILE_WALKABLE)
 				gridmap.set_cell_item(Vector3i(x, 1, z), -1)
-				gridmap.set_cell_item(Vector3i(x, 2, z), -1)
+				gridmap.set_cell_item(Vector3i(x, 2, z), TILE_STICKY)
+				sticky_cells[pos] = true
 				continue
 			
 			# Interior: walkable floor
@@ -1004,56 +1003,6 @@ func _spawn_impact_particles(targets: Array) -> void:
 		if particles and is_instance_valid(particles):
 			particles.queue_free()
 
-# =============================================================================
-func _spawn_cleanser_particles(pos: Vector2i) -> void:
-	"""Spawn bright cleansing particles when sticky is cleared."""
-	if not main_scene or not gridmap:
-		return
-	
-	var world_pos = Vector3(
-		pos.x * gridmap.cell_size.x + gridmap.cell_size.x / 2.0,
-		0.5,
-		pos.y * gridmap.cell_size.z + gridmap.cell_size.z / 2.0
-	)
-	
-	var particles = GPUParticles3D.new()
-	particles.emitting = true
-	particles.one_shot = true
-	particles.amount = 12
-	particles.lifetime = 0.6
-	particles.explosiveness = 0.9
-	
-	var material = ParticleProcessMaterial.new()
-	material.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_SPHERE
-	material.emission_sphere_radius = 0.3
-	material.direction = Vector3(0, 1, 0)
-	material.spread = 180.0
-	material.initial_velocity_min = 3.0
-	material.initial_velocity_max = 5.0
-	material.gravity = Vector3(0, -5.0, 0)
-	material.scale_min = 0.05
-	material.scale_max = 0.15
-	
-	var mesh = SphereMesh.new()
-	mesh.radius = 0.2
-	mesh.height = 0.4
-	var spatial_mat = StandardMaterial3D.new()
-	spatial_mat.albedo_color = Color(0.2, 1.0, 1.0) # Cyan/Blue for cleanser
-	spatial_mat.emission_enabled = true
-	spatial_mat.emission = Color(0.2, 1.0, 1.0)
-	spatial_mat.emission_energy_multiplier = 3.0
-	mesh.material = spatial_mat
-	particles.draw_pass_1 = mesh
-	
-	particles.process_material = material
-	particles.position = world_pos
-	
-	main_scene.add_child(particles)
-	
-	await get_tree().create_timer(1.2).timeout
-	if particles and is_instance_valid(particles):
-		particles.queue_free()
-
 # =============================================================================
 # Sticky / Trap System
 
@@ -1065,12 +1014,15 @@ func is_cleansed_cell(pos: Vector2i) -> bool:
 
 func cell_state(pos: Vector2i) -> CellState:
 	"""Logical state of a playable cell (v2 ground-growth model)."""
+	var b = get_arena_bounds()
+	if pos.x <= b.min or pos.x >= b.max or pos.y <= b.min or pos.y >= b.max:
+		return CellState.STICKY
 	if _is_npc_zone(pos) or _is_boundary(pos):
 		return CellState.BLOCKED
-	if sticky_cells.has(pos):
+	if is_sticky_cell(pos):
 		return CellState.STICKY
 	if cleansed_cells.has(pos):
-		return CellState.CLEANSED
+		return CellState.BLOCKED # Protected from regrowth temporarily
 	if telegraphed_cells.has(pos):
 		return CellState.TELEGRAPHED
 	if bubble_cells.has(pos):
@@ -1091,8 +1043,37 @@ func _tick_cleansed_cells(delta: float) -> void:
 	for pos in expired:
 		cleansed_cells.erase(pos)
 
+func get_arena_bounds() -> Dictionary:
+	match current_phase:
+		Phase.OPEN_ARENA:
+			return {"min": 0, "max": 19} # 20x20
+		Phase.ROUTE_PRESSURE:
+			return {"min": 1, "max": 18} # 18x18
+		Phase.SURVIVAL_ENDGAME:
+			return {"min": 6, "max": 12} # 7x7
+	return {"min": 0, "max": 19}
+
+func _shrink_arena() -> void:
+	if not multiplayer.is_server(): return
+	var b = get_arena_bounds()
+	var new_sticky = []
+	for x in range(ARENA_COLUMNS):
+		for z in range(ARENA_ROWS):
+			var pos = Vector2i(x, z)
+			if _is_npc_zone(pos) or _is_boundary(pos):
+				continue
+			if pos.x <= b.min or pos.x >= b.max or pos.y <= b.min or pos.y >= b.max:
+				if not sticky_cells.has(pos):
+					new_sticky.append(pos)
+	
+	if new_sticky.size() > 0:
+		if _can_rpc() and multiplayer.is_server():
+			rpc("sync_growth_apply", new_sticky)
+		else:
+			sync_growth_apply(new_sticky)
+
 func _is_boundary(pos: Vector2i) -> bool:
-	return pos.x == 0 or pos.x == ARENA_COLUMNS - 1 or pos.y == 0 or pos.y == ARENA_ROWS - 1
+	return pos.x <= 0 or pos.x >= ARENA_COLUMNS - 1 or pos.y <= 0 or pos.y >= ARENA_ROWS - 1
 
 # =============================================================================
 # Coverage tracking (v2 target: 70-75%, down from v1's 80%)
@@ -1103,12 +1084,15 @@ const COVERAGE_TARGET_MAX: float = 0.75
 
 func playable_cell_count() -> int:
 	"""Number of cells that can ever become sticky (interior, minus NPC zone)."""
+	var b = get_arena_bounds()
 	var count := 0
 	for x in range(ARENA_COLUMNS):
 		for z in range(ARENA_ROWS):
 			var pos := Vector2i(x, z)
 			if _is_boundary(pos) or _is_npc_zone(pos):
 				continue
+			if pos.x <= b.min or pos.x >= b.max or pos.y <= b.min or pos.y >= b.max:
+				continue
 			count += 1
 	return count
 
@@ -1132,6 +1116,9 @@ const FORCED_TRAP_WINDOW: float = 30.0 # final seconds where trapping is allowed
 
 func _is_cell_passable(pos: Vector2i, extra_sticky: Dictionary = {}) -> bool:
 	"""Can a player stand on / move through this cell, given a hypothetical sticky set?"""
+	var b = get_arena_bounds()
+	if pos.x <= b.min or pos.x >= b.max or pos.y <= b.min or pos.y >= b.max:
+		return false
 	if _is_boundary(pos) or _is_npc_zone(pos):
 		return false
 	if sticky_cells.has(pos) or extra_sticky.has(pos):
@@ -1333,11 +1320,11 @@ func _calculate_bubble_score(pos: Vector2i, player_cells: Array = []) -> float:
 	return score
 
 func _bubble_score_camping(pos: Vector2i) -> float:
-	"""Reward targeting campers. +40 >5s, +60 >8s, +80 >10s-with-cleanser."""
+	"""Reward targeting campers. +40 >5s, +60 >8s, +80 >10s-with-ghost."""
 	var t := _camp_time_for_region(_region_of(pos))
 	if t > 10.0:
-		# Stronger only if a nearby player actually holds a cleanser.
-		if _any_cleanser_holder_near(pos):
+		# Stronger only if a nearby player is in ghost mode.
+		if _any_ghost_player_near(pos):
 			return 80.0
 		return 60.0
 	elif t > 8.0:
@@ -1390,22 +1377,25 @@ func _bubble_score_unfair_trap(pos: Vector2i) -> float:
 func _bubble_blast_cells(center: Vector2i) -> Array:
 	"""The 3x3 (radius 1) sticky cells a bubble at `center` would create,
 	clipped to passable/playable cells."""
+	var b = get_arena_bounds()
 	var cells: Array = []
 	for dx in range(-BUBBLE_EXPLOSION_RADIUS, BUBBLE_EXPLOSION_RADIUS + 1):
 		for dz in range(-BUBBLE_EXPLOSION_RADIUS, BUBBLE_EXPLOSION_RADIUS + 1):
 			var c := center + Vector2i(dx, dz)
 			if _is_boundary(c) or _is_npc_zone(c):
 				continue
+			if c.x <= b.min or c.x >= b.max or c.y <= b.min or c.y >= b.max:
+				continue
 			cells.append(c)
 	return cells
 
-func _any_cleanser_holder_near(pos: Vector2i) -> bool:
-	"""True if a player holding a Cleanser charge is within the camping region."""
+func _bubble_footprint(center: Vector2i) -> Array:
+	return _bubble_blast_cells(center)
+	
+func _any_ghost_player_near(pos: Vector2i) -> bool:
+	"""True if a player in ghost mode is within the camping region."""
 	for player in get_tree().get_nodes_in_group("Players"):
-		var pid = player.get("peer_id") if "peer_id" in player else -1
-		if pid == -1:
-			continue
-		if player_cleansers.get(pid, 0) <= 0:
+		if not player.get("is_invisible"):
 			continue
 		if "current_position" in player and player.current_position != null:
 			if _region_of(player.current_position) == _region_of(pos):
@@ -1501,7 +1491,7 @@ func _explode_bubble(center: Vector2i, cells: Array) -> void:
 		if "current_position" in player and player.current_position != null:
 			if blast.has(player.current_position):
 				var pid = player.get("peer_id") if "peer_id" in player else -1
-				if pid != -1 and is_cleanser_active(pid):
+				if pid != -1 and player.get("is_invisible"):
 					continue
 				apply_sticky_slow(player)
 
@@ -1608,8 +1598,8 @@ func _check_all_players_trapped() -> void:
 		var pos = player.current_position if player.get("current_position") else Vector2i(-1, -1)
 		if is_sticky_cell(pos):
 			var pid = player.get("peer_id") if "peer_id" in player else -1
-			if pid != -1 and is_cleanser_active(pid):
-				continue # cleansing players are immune to the slow
+			if pid != -1 and player.get("is_invisible"):
+				continue # ghost players are immune to the slow
 			apply_sticky_slow(player)
 
 func apply_sticky_slow(player: Node) -> void:
@@ -1641,25 +1631,22 @@ func _trap_player(player: Node) -> void:
 	NotificationManager.send_message(player, "Stuck in Candy!", NotificationManager.MessageType.WARNING)
 
 func clear_sticky_cell(pos: Vector2i) -> void:
-	"""Used by Cleanser power-up to remove a sticky cell."""
+	"""Remove a sticky cell (used when ghost player walks through)."""
 	if _can_rpc():
 		if multiplayer.is_server():
 			rpc("sync_clear_sticky_cell", pos)
 		else:
 			sync_clear_sticky_cell(pos) # Predictive local clear
-			rpc("rpc_use_cleanser", pos)
 	else:
 		sync_clear_sticky_cell(pos)
 
 @rpc("authority", "call_local", "reliable")
 func sync_clear_sticky_cell(pos: Vector2i) -> void:
 	sticky_cells.erase(pos)
-	mark_cleansed(pos) # temporary regrowth protection (v2)
+	mark_cleansed(pos) # temporary regrowth protection
 	if gridmap:
 		gridmap.set_cell_item(Vector3i(pos.x, 2, pos.y), -1)
 	
-	# Play VFX and SFX
-	_spawn_cleanser_particles(pos)
 	if SfxManager:
 		SfxManager.play("pick_up_power_tile")
 	
@@ -1667,142 +1654,6 @@ func sync_clear_sticky_cell(pos: Vector2i) -> void:
 	if main_scene and main_scene.has_method("sync_grid_item"):
 		main_scene.sync_grid_item(pos.x, 2, pos.y, -1)
 
-func _try_use_cleanser() -> void:
-	"""Local player attempts to activate Cleanser for 5-cell sticky immunity."""
-	var local_pid = multiplayer.get_unique_id()
-	var count = player_cleansers.get(local_pid, 0)
-	if count <= 0:
-		return
-	
-	# Block activation during stun
-	var all_players = get_tree().get_nodes_in_group("Players")
-	var local_player = null
-	for p in all_players:
-		var pid = p.get("peer_id") if "peer_id" in p else p.name.to_int()
-		if pid == local_pid:
-			local_player = p
-			break
-	if not local_player:
-		return
-	if local_player.get("is_frozen") or local_player.get("is_stop_frozen"):
-		return
-	# 0.3s activation delay
-	await get_tree().create_timer(CLEANSER_ACTIVATION_DELAY).timeout
-	
-	# Re-validate after delay
-	if not is_instance_valid(local_player):
-		return
-	if local_player.get("is_frozen") or local_player.get("is_stop_frozen"):
-		return
-	
-	# Consume cleanser from inventory (only if client, host relies on rpc)
-	if not multiplayer.is_server():
-		cleanser_active[local_pid] = true
-		cleanser_cells_left[local_pid] = CLEANSER_MAX_CELLS
-		player_cleansers[local_pid] = max(0, player_cleansers[local_pid] - 1)
-		update_cleanser_ui(player_cleansers[local_pid])
-	
-	NotificationManager.send_message(local_player, "Cleanser Used! (5 charges)", NotificationManager.MessageType.POWERUP)
-	
-	# Sync to server/clients
-	if not multiplayer.is_server() and _can_rpc():
-		rpc("rpc_activate_cleanser", local_pid)
-	elif multiplayer.is_server():
-		# Call RPC logic directly for host (it will set active/cells_left/consume)
-		rpc_activate_cleanser(local_pid)
-
-@rpc("any_peer", "call_local", "reliable")
-func deactivate_cleanser(player_id: int) -> void:
-	"""Deactivate cleanser immunity for a player."""
-	cleanser_active.erase(player_id)
-	cleanser_cells_left.erase(player_id)
-
-func is_cleanser_active(player_id: int) -> bool:
-	"""Check if a player has active cleanser immunity."""
-	return cleanser_active.has(player_id)
-
-func use_cleanser_cell(player_id: int) -> bool:
-	"""Use one cleanser cell. Returns true if still active, false if exhausted."""
-	if not cleanser_active.has(player_id):
-		return false
-	cleanser_cells_left[player_id] -= 1
-	if cleanser_cells_left[player_id] <= 0:
-		if _can_rpc():
-			rpc("deactivate_cleanser", player_id)
-		else:
-			deactivate_cleanser(player_id)
-		return false
-	return true
-
-func notify_movement_stopped(player_id: int, pos: Vector2i) -> void:
-	"""Called from PlayerMovementManager when a move chain settles. 
-	Previously deactivated cleanser here, but now immunity persists 
-	until charges run out to allow repeated use across safe gaps."""
-	pass
-
-@rpc("any_peer", "call_local", "reliable")
-func rpc_activate_cleanser(pid: int) -> void:
-	"""RPC for clients to activate cleanser on server."""
-	if multiplayer.is_server():
-		# Verify they actually have a cleanser charge (prevents spam/cheats)
-		if player_cleansers.get(pid, 0) <= 0:
-			return
-			
-		# Always apply the state and AoE, since this is the server authority
-		cleanser_active[pid] = true
-		cleanser_cells_left[pid] = CLEANSER_MAX_CELLS
-		player_cleansers[pid] = max(0, player_cleansers[pid] - 1)
-		if _can_rpc():
-			rpc("sync_cleanser_count", pid, player_cleansers[pid])
-		
-		# NEW: Clear 3x3 area around player
-		var all_players = get_tree().get_nodes_in_group("Players")
-		var target_player = null
-		for p in all_players:
-			var target_pid = p.get("peer_id") if "peer_id" in p else p.name.to_int()
-			if target_pid == pid:
-				target_player = p
-				break
-		
-		if gridmap and is_instance_valid(target_player):
-			var map_pos = gridmap.local_to_map(target_player.global_position)
-			var center_pos = Vector2i(map_pos.x, map_pos.z)
-			
-			# 3x3 neighborhood
-			for dx in range(-1, 2):
-				for dz in range(-1, 2):
-					var check_pos = center_pos + Vector2i(dx, dz)
-					if is_sticky_cell(check_pos):
-						clear_sticky_cell(check_pos)
-						
-			# Remove slow effect for any player in the cleansed area
-			for p in all_players:
-				if is_instance_valid(p) and p.has_method("remove_slow_effect"):
-					if gridmap:
-						var p_map_pos = gridmap.local_to_map(p.global_position)
-						var p_cell_pos = Vector2i(p_map_pos.x, p_map_pos.z)
-						if abs(p_cell_pos.x - center_pos.x) <= 1 and abs(p_cell_pos.y - center_pos.y) <= 1:
-							if _can_rpc():
-								p.rpc("remove_slow_effect")
-							else:
-								p.remove_slow_effect()
-			
-			print("[Cleanser] Server cleared 3x3 area around %s for player %d" % [center_pos, pid])
-
-@rpc("any_peer", "call_local", "reliable")
-func rpc_use_cleanser(pos: Vector2i) -> void:
-	"""RPC for clients to clear a sticky cell via Cleanser."""
-	if multiplayer.is_server():
-		clear_sticky_cell(pos)
-
-@rpc("any_peer", "call_local", "reliable")
-func rpc_consume_cleanser(pid: int) -> void:
-	"""RPC for clients to report Cleanser consumption to server."""
-	if multiplayer.is_server():
-		player_cleansers[pid] = 0
-		if _can_rpc():
-			rpc("sync_cleanser_count", pid, 0)
-
 @rpc("any_peer", "reliable")
 func rpc_trigger_slowmo() -> void:
 	"""RPC for clients to request slow-mo from server."""
@@ -1889,25 +1740,7 @@ func _setup_hud() -> void:
 	hud_layer.visible = false
 	add_child(hud_layer)
 	phase_label = hud_layer.get_node("BottomContainer/VBoxContainer/PhaseLabel")
-	cleanser_icon = hud_layer.get_node("BottomContainer/VBoxContainer/CleanserHBox/CleanserIcon")
-	cleanser_label = hud_layer.get_node("BottomContainer/VBoxContainer/CleanserHBox/CleanserLabel")
 	slowmo_label = hud_layer.get_node_or_null("TopContainer/SlowMoLabel")
-	_generate_cleanser_icon()
-
-func _generate_cleanser_icon() -> void:
-	var icon_img = Image.create(16, 16, false, Image.FORMAT_RGBA8)
-	icon_img.fill(Color(0.4, 0.9, 1.0))
-	icon_img.blend_rect(icon_img, Rect2i(2, 2, 12, 12), Vector2i(1, 1))
-	for x in range(16):
-		icon_img.set_pixel(x, 0, Color(0.2, 0.6, 0.7))
-		icon_img.set_pixel(x, 15, Color(0.2, 0.6, 0.7))
-	for y in range(16):
-		icon_img.set_pixel(0, y, Color(0.2, 0.6, 0.7))
-		icon_img.set_pixel(15, y, Color(0.2, 0.6, 0.7))
-	for i in range(4, 12):
-		icon_img.set_pixel(i, 7, Color(1.0, 1.0, 1.0, 0.8))
-		icon_img.set_pixel(7, i, Color(1.0, 1.0, 1.0, 0.8))
-	cleanser_icon.texture = ImageTexture.create_from_image(icon_img)
 
 func _update_hud_phase(phase_name: String) -> void:
 	if phase_label:
@@ -1926,20 +1759,6 @@ func _update_hud_phase(phase_name: String) -> void:
 		# Animate phase label with bounce effect
 		_animate_phase_label()
 
-func update_cleanser_ui(count: int) -> void:
-	cleanser_count = count
-	if cleanser_label:
-		cleanser_label.text = "[E] Cleanser (%d)" % count
-	# Show/hide icon based on availability
-	if cleanser_icon:
-		cleanser_icon.visible = count > 0
-		if count > 0:
-			# Pulse animation when cleanser is available
-			var tween = create_tween()
-			tween.set_loops(2)
-			tween.tween_property(cleanser_icon, "modulate", Color(1.5, 1.5, 1.5, 1), 0.3)
-			tween.tween_property(cleanser_icon, "modulate", Color.WHITE, 0.3)
-
 func _animate_phase_label() -> void:
 	"""Animate phase label with bounce effect."""
 	if not phase_label:
@@ -1964,7 +1783,7 @@ func _animate_phase_label() -> void:
 # =============================================================================
 
 func _on_goal_count_updated(peer_id: int, count: int) -> void:
-	"""Called when a player completes a goal cycle. Grant cleanser every 2 missions."""
+	"""Called when a player completes a goal cycle. Grant ghost powerup every 2 missions."""
 	if not multiplayer.is_server():
 		return
 	
@@ -1973,34 +1792,29 @@ func _on_goal_count_updated(peer_id: int, count: int) -> void:
 		player_mission_completions[peer_id] = 0
 	player_mission_completions[peer_id] += 1
 	
-	# Grant cleanser every 2 missions
+	# Grant ghost powerup every 2 missions
 	var completions = player_mission_completions[peer_id]
 	if completions % 2 == 0:
-		if not player_cleansers.has(peer_id):
-			player_cleansers[peer_id] = 0
-		
-		# Allow stacking cleanser charges instead of capping at 1
-		player_cleansers[peer_id] += 1
-		emit_signal("cleanser_granted", peer_id)
-		print("[Gauntlet] Player %d granted Cleanser (Total: %d) (mission %d)" % [peer_id, player_cleansers[peer_id], completions])
-	
-	# Sync cleanser count to HUD
-	rpc("sync_cleanser_count", peer_id, player_cleansers.get(peer_id, 0))
+		_grant_ghost_powerup(peer_id)
+
+func _grant_ghost_powerup(peer_id: int) -> void:
+	"""Grant the ghost (invisible mode) powerup to a player."""
+	var all_players = get_tree().get_nodes_in_group("Players")
+	for p in all_players:
+		var pid = p.get("peer_id") if "peer_id" in p else p.name.to_int()
+		if pid == peer_id:
+			var stm = p.get_node_or_null("SpecialTilesManager")
+			if stm and stm.has_method("add_powerup_from_item"):
+				stm.add_powerup_from_item(14) # 14 = Ghost / INVISIBLE_MODE
+				emit_signal("ghost_granted", peer_id)
+				print("[Gauntlet] Player %d granted Ghost powerup (mission %d)" % [peer_id, player_mission_completions[peer_id]])
+				NotificationManager.send_message(p, "Ghost Power Earned!", NotificationManager.MessageType.POWERUP)
+			break
 
 func _on_score_updated(peer_id: int, new_score: int) -> void:
 	"""Called when a player's score is updated."""
 	pass  # Score sync handled by GoalsCycleManager
 
-
-
-@rpc("authority", "call_local", "reliable")
-func sync_cleanser_count(peer_id: int, count: int) -> void:
-	"""Sync cleanser count to HUD for specific player."""
-	# Update local player's cleanser UI
-	var local_pid = multiplayer.get_unique_id()
-	if peer_id == local_pid:
-		update_cleanser_ui(count)
-
 # =============================================================================
 # Utility
 # =============================================================================

scripts/managers/player_movement_manager.gd

@@ -155,19 +155,15 @@ func simple_move_to(grid_position: Vector2i) -> bool:
 				player.knock_tekton()
 				return false # Don't move into the tile, just knock
 
-	# If moving into a sticky cell: slow the player (unless cleanser active,
-	# which clears the cell instead). Sticky no longer hard-traps.
+	# If moving into a sticky cell: block movement unless player is in ghost
+	# mode (is_invisible), which lets them bypass sticky tiles in gauntlet.
 	if gm and gm.is_active and gm.is_sticky_cell(grid_position):
-		var pid = player.get("peer_id") if "peer_id" in player else -1
-		if pid != -1 and gm.is_cleanser_active(pid):
-			# Cleanser immunity: clear sticky cell, use one cell, don't slow
-			gm.clear_sticky_cell(grid_position)
-			gm.use_cleanser_cell(pid)
-			print("[Move] Cleanser cleared sticky cell at %s (%d cells left)" % [grid_position, gm.cleanser_cells_left.get(pid, 0)])
+		if player.get("is_invisible"):
+			# Ghost mode: walk through sticky tile freely
+			print("[Move] Ghost mode bypassed sticky cell at %s" % grid_position)
 		else:
-			print("[Move] Player stepping into sticky cell at %s — slowed" % grid_position)
-			if player.is_multiplayer_authority() or multiplayer.is_server():
-				gm.apply_sticky_slow(player)
+			print("[Move] Failed: Blocked by Gauntlet Sticky cell at %s" % grid_position)
+			return false
 
 	rotate_towards_target(grid_position)
 	
@@ -342,12 +338,9 @@ func try_push(target_pos: Vector2i, direction: Vector2i) -> bool:
 		if main_sticky and main_sticky.get("gauntlet_manager"):
 			var gm_sticky = main_sticky.gauntlet_manager
 			if gm_sticky.is_active and gm_sticky.is_sticky_cell(pushed_to_pos):
-				var push_pid = other_player.get("peer_id") if "peer_id" in other_player else -1
-				if push_pid != -1 and gm_sticky.is_cleanser_active(push_pid):
-					# Cleanser immunity: clear sticky cell, use one cell
-					gm_sticky.clear_sticky_cell(pushed_to_pos)
-					gm_sticky.use_cleanser_cell(push_pid)
-					print("[Move] Cleanser cleared push-into-sticky at %s" % pushed_to_pos)
+				if other_player.get("is_invisible"):
+					# Ghost mode: pushed player bypasses sticky
+					print("[Move] Ghost mode bypassed push-into-sticky at %s" % pushed_to_pos)
 				else:
 					print("[Move] Player pushed into sticky cell at %s — slowed" % pushed_to_pos)
 					if multiplayer.is_server() or other_player.is_multiplayer_authority():
@@ -407,17 +400,6 @@ func _on_movement_finished():
 			emit_signal("movement_finished")
 	else:
 		current_move_direction = Vector2i.ZERO
-		# Gauntlet (#072): a Cleanser ends early once the player rests on a safe
-		# cell. Gated on gm.is_active so other game modes are never affected.
-		var gm = null
-		var main_node = player.get_tree().root.get_node_or_null("Main")
-		if main_node and main_node.get("gauntlet_manager"):
-			gm = main_node.gauntlet_manager
-		if gm and gm.is_active and player.get("current_position") != null:
-			var mpid = player.get("peer_id") if "peer_id" in player else -1
-			if mpid != -1 and gm.is_cleanser_active(mpid):
-				if multiplayer.is_server() or player.is_multiplayer_authority():
-					gm.notify_movement_stopped(mpid, player.current_position)
 		emit_signal("movement_finished")
 
 func move_to_clicked_position(grid_position: Vector2i) -> bool:

scripts/managers/special_tiles_manager.gd

@@ -547,9 +547,11 @@ func spawn_powerups_around(center: Vector2i, force_powerups: bool = true, only_c
 					# Spawn ONLY common tiles (7-10) in Stop n Go mode (User Request)
 					item_id = rng.randi_range(7, 10)
 				elif LobbyManager.is_game_mode(GameMode.Mode.GAUNTLET):
-					# Gauntlet mode: No power-up tile spawns from world.
-					# Only common tiles (7-10) spawn; Smack/Cleanser are handled separately.
-					item_id = rng.randi_range(7, 10)
+					# Gauntlet mode: mostly common tiles, but ghost (14) can spawn too.
+					if rng.randf() < 0.85:
+						item_id = rng.randi_range(7, 10)
+					else:
+						item_id = 14 # Ghost powerup only
 				else:
 					# Other modes: 80% Chance for Common Tile (7-10), 20% for PowerUp
 					if rng.randf() < 0.8: