Adds github actions.

Updated Gradle CI workflow to use newer action versions and added project version extraction step.

.env.example

@@ -1,9 +1,30 @@
-# Dev-server config for this project's tools/ scripts.
+# Configuration for tools/*.sh. Values are read as KEY=value data, not executed.
-# Plain KEY=value only (no shell expansion). Environment variables take precedence.
+# Unquoted values may contain spaces; matching outer quotes are removed.
 
+# Paper server
 PAPER_VERSION=26.2
 PAPER_BUILD=129
+PAPER_USER_AGENT="majinnaibu-plugin-dev/1.0 (https://github.com/majinnaibu)"
+JAVA_OPTS="-Xms2G -Xmx2G"
+STOP_TIMEOUT=60
 MINECRAFT_SERVER_JAR=paper-26.2-129.jar
-# Relative paths are resolved from this directory; ~/ is expanded.
+
+# Relative paths are resolved from the project root; ~/ is expanded.
 MINECRAFT_SERVER_PATH=./server
 MINECRAFT_BACKUP_PATH=./backups
+
+# Modrinth publishing
+# Release version is read from Gradle and checked against the jar's plugin.yml.
+MODRINTH_TOKEN=
+MODRINTH_PROJECT_ID=5NYwxysp
+# Optional Markdown override; empty generates notes from commits since the last tag.
+MODRINTH_CHANGELOG=
+MODRINTH_GAME_VERSIONS=26.2,26.3
+MODRINTH_LOADERS=paper
+MODRINTH_VERSION_TYPE=
+MODRINTH_DEPENDENCIES=
+MODRINTH_FILE=
+# Sync project body/README to Modrinth during publish (true/false)
+MODRINTH_SYNC_BODY=true
+MODRINTH_DESCRIPTION_FILE=docs/modrinth-description.md
+

.github/workflows/gradle.yml

@@ -0,0 +1,62 @@
+name: Java CI with Gradle
+
+on:
+  push:
+    branches: [ "main", "develop" ]
+    tags: [ "v*" ]
+  pull_request:
+    branches: [ "main", "develop" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK 25
+        uses: actions/setup-java@v6
+        with:
+          java-version: '25'
+          distribution: 'temurin'
+
+      - name: Setup Gradle 9.8.0
+        uses: gradle/actions/setup-gradle@v5
+        with:
+          gradle-version: '9.8.0'
+          cache-read-only: ${{ github.ref != 'refs/heads/develop' && github.ref != 'refs/heads/main' }}
+
+      - name: Run Unit Tests
+        run: ./gradlew test
+
+      - name: Upload Test Report
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: ScoreKeeper-test-report
+          path: |
+            build/reports/tests/test
+            build/test-results/test
+          if-no-files-found: ignore
+          retention-days: 14
+
+      - name: Build with Gradle Wrapper
+        run: ./tools/build-plugin.sh
+
+      - name: Extract Project Version
+        id: project_info
+        run: |
+          VERSION=$(./gradlew properties --no-daemon -q | awk -F ': ' '$1 == "version" {print $2}')
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Upload Plugin Artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: ScoreKeeper-${{ steps.project_info.outputs.version }}
+          path: build/libs/*.jar
+          if-no-files-found: error
+          retention-days: 14

.github/workflows/release.yml

@@ -0,0 +1,168 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Git tag to release (e.g., v1.0.0)'
+        required: true
+        type: string
+
+permissions:
+  contents: write
+
+jobs:
+  prepare-release:
+    name: Validate Tag & Prepare Release Branch
+    runs-on: ubuntu-latest
+    outputs:
+      tag_commit: ${{ steps.validate.outputs.tag_commit }}
+      tag_name: ${{ steps.validate.outputs.tag_name }}
+      release_branch: ${{ steps.validate.outputs.release_branch }}
+      version_name: ${{ steps.validate.outputs.version_name }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Configure Git identity
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Validate Tag, Develop, Main, and Create Release Branch
+        id: validate
+        run: |
+          TAG="${{ github.event.inputs.tag }}"
+          echo "Target tag: $TAG"
+
+          # Fetch remote branches and tags
+          git fetch origin develop:develop main:main --tags
+
+          # 1. Verify tag exists
+          if ! git rev-parse -q --verify "refs/tags/$TAG" > /dev/null; then
+            echo "::error::Tag '$TAG' does not exist in the repository."
+            exit 1
+          fi
+
+          TAG_COMMIT=$(git rev-list -n 1 "$TAG")
+          echo "Tag '$TAG' points to commit: $TAG_COMMIT"
+
+          # 2. Verify tag commit is in develop branch
+          if ! git merge-base --is-ancestor "$TAG_COMMIT" origin/develop; then
+            echo "::error::Tag '$TAG' (commit $TAG_COMMIT) is not in the develop branch."
+            exit 1
+          fi
+          echo "Confirmed: Tag '$TAG' is in develop branch."
+
+          # 3. Verify tag commit is in main, or fast-forward merge it to main
+          if git merge-base --is-ancestor "$TAG_COMMIT" origin/main; then
+            echo "Confirmed: Tag '$TAG' is already in main branch."
+          else
+            echo "Tag '$TAG' is not in main. Attempting fast-forward only merge..."
+            git checkout main
+            if ! git merge --ff-only "$TAG_COMMIT"; then
+              echo "::error::Tag '$TAG' cannot be fast-forward merged into main."
+              exit 1
+            fi
+            git push origin main
+            echo "Successfully fast-forward merged '$TAG' into main."
+          fi
+
+          # 4. Create and push the release/v* branch from the tag commit
+          RELEASE_BRANCH="release/${TAG}"
+          echo "Creating release branch '$RELEASE_BRANCH' from commit $TAG_COMMIT..."
+          git checkout -B "$RELEASE_BRANCH" "$TAG_COMMIT"
+          git push -u origin "$RELEASE_BRANCH" --force
+
+          VERSION_NAME="${TAG#v}"
+
+          echo "tag_commit=$TAG_COMMIT" >> $GITHUB_OUTPUT
+          echo "tag_name=$TAG" >> $GITHUB_OUTPUT
+          echo "release_branch=$RELEASE_BRANCH" >> $GITHUB_OUTPUT
+          echo "version_name=$VERSION_NAME" >> $GITHUB_OUTPUT
+
+  scorekeeper-release:
+    name: Build, Test & Publish Release
+    needs: prepare-release
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout release commit
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.prepare-release.outputs.tag_commit }}
+          fetch-depth: 0
+
+      - name: Ensure tag ref is checked out
+        run: |
+          git checkout -q "refs/tags/${{ needs.prepare-release.outputs.tag_name }}"
+
+      - name: Validate Modrinth Credentials
+        id: check_credentials
+        run: |
+          if [ -z "${{ secrets.MODRINTH_TOKEN }}" ]; then
+            echo "::warning::Modrinth release token was not provided. Release will not be published to Modrinth."
+            echo "::error::Missing MODRINTH_TOKEN secret. Please configure MODRINTH_TOKEN in repository secrets."
+            exit 1
+          fi
+
+      - name: Set up JDK 25
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '25'
+
+      - name: Setup Gradle 9.8.0
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          gradle-version: '9.8.0'
+
+      - name: Make Gradle wrapper executable
+        run: chmod +x gradlew
+
+      - name: Run Unit Tests
+        run: ./gradlew test
+
+      - name: Upload Test Report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: ScoreKeeper-test-report-${{ needs.prepare-release.outputs.tag_name }}
+          path: |
+            build/reports/tests/test
+            build/test-results/test
+          if-no-files-found: ignore
+          retention-days: 14
+
+      - name: Build ScoreKeeper Plugin Jar
+        run: ./tools/build-plugin.sh
+
+      - name: Upload Release Jar
+        if: success()
+        uses: actions/upload-artifact@v4
+        with:
+          name: ScoreKeeper-${{ needs.prepare-release.outputs.version_name }}
+          path: build/libs/*.jar
+          if-no-files-found: error
+          retention-days: 14
+
+      - name: Publish to Modrinth & Update Description
+        env:
+          MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
+          MODRINTH_VERSION: ${{ needs.prepare-release.outputs.version_name }}
+          TAG: ${{ needs.prepare-release.outputs.tag_name }}
+        run: |
+          chmod +x ./tools/publish-modrinth.sh
+          ./tools/publish-modrinth.sh
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.prepare-release.outputs.tag_name }}
+          name: ScoreKeeper ${{ needs.prepare-release.outputs.tag_name }}
+          files: build/libs/*.jar
+          generate_release_notes: true

AGENTS.md

@@ -0,0 +1,90 @@
+# Score Keeper: Shared Working Rules
+
+These rules apply to agents and human contributors. Start with
+[CONTRIBUTING.md](CONTRIBUTING.md) for setup, tasks, server safety, and release
+procedures; [README.md](README.md) is the user-facing behavior reference.
+
+## Quick orientation
+
+- Java 25, Gradle 9.8.0 wrapper, Paper 26.2/26.3 only; no Bukkit/Spigot target.
+- [ScoreKeeperPlugin.java](src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreKeeperPlugin.java)
+  owns lifecycle, buckets, UUID-keyed scores, YAML persistence, archives,
+  reporting, and scheduled high-score runs.
+- [ScoreBucket.java](src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreBucket.java)
+  validates immutable definitions; [ScoreReporting.java](src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreReporting.java)
+  defines audiences. [commands/](src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/)
+  contains eight executors wired in `onEnable` and
+  [plugin.yml](src/main/resources/plugin.yml).
+- [CONTRIBUTING.md](CONTRIBUTING.md#project-overview-and-source-map) owns the source
+  map and architecture overview. Consult the [domain reference](docs/domain-score-tracking.md)
+  or [integration reference](docs/plugin-integration-and-event-wiring.md) only when
+  the task needs their detail. There are no built-in gameplay listeners or registered API service.
+
+## Change discipline
+
+- Inspect the source and current diff before editing. Preserve unrelated work;
+  make scoped, complete changes and document intentional behavior changes.
+- Use **Score Keeper** in human-facing prose/display text. Keep `ScoreKeeper`
+  for repository URLs, plugin ID/data folder, Gradle/artifact names, and Java
+  symbols. Preserve scraper identifiers exactly as currently stored in
+  [project-description.json](docs/project-description.json).
+  Ask before renaming existing files or changing these integration identifiers.
+- Follow existing Java patterns, Adventure components, UUID identity, and
+  plugin logging. Use Spotless rather than hand-formatting Java; preserve the
+  [AGPL header](config/license-header.txt). Do not add silent error recovery or
+  success messages for failed operations.
+- Keep state and Paper API calls on the main thread. Do not introduce async
+  map access; marshal asynchronous results through Paper's synchronous scheduler.
+- Wire command/API changes across executors, manifest, lifecycle, reporting,
+  persistence, and documentation as applicable. Preserve existing public overloads
+  and legacy YAML loading unless a migration is explicitly agreed.
+- Preserve documented quirks until intentionally changed: unguarded score
+  mutations, signed integer arithmetic, lazy score entries, case-sensitive bucket
+  IDs, shutdown-only saves, and run snapshot restoration. Do not "fix" these as
+  incidental cleanup.
+- Prefer existing helpers and dependencies. Do not introduce a service layer,
+  test harness, runtime dependency, or supported platform without a task need.
+- Edit source, not generated `build/`, `bin/`, or `.gradle/` files. Never read,
+  expose, or commit `.env` credentials, server player data, or publishing tokens.
+
+## Validation
+
+- With JDK 25/JAVA_HOME configured, use `./gradlew spotlessCheck build` for Java
+  changes (`.\gradlew.bat` on Windows). For macOS/Linux bootstrapping, use
+  `./tools/build-plugin.sh spotlessCheck`. Run narrower relevant tasks when enough.
+- `./gradlew spotlessApply` applies Java style; review the resulting diff and
+  avoid unrelated formatting churn.
+- There are currently **no Java test sources/dependencies**; `test` is
+  `NO-SOURCE`, and no `integrationTest` task exists. Never claim a build proves
+  behavior or claim JUnit coverage. When tests are added, keep normal tests
+  server-free; real Paper integration tests should be explicit/opt-in.
+- Use [human-tests.md](docs/human-tests.md) for affected runtime scenarios and
+  pre-release testing. Report checks actually run and any remaining unverified
+  behavior. For docs-only work, check relative links and metadata instead of building.
+
+## Documentation and operational safety
+
+- Keep [README.md](README.md), [Modrinth description](docs/modrinth-description.md),
+  [project-description.md](docs/project-description.md), and
+  [project-description.json](docs/project-description.json) aligned with source.
+  Validate the JSON as a slug-keyed object against
+  [projects.schema.json](docs/projects.schema.json). Keep manual scenarios
+  separate from automated coverage claims.
+- When updating [project-description.json](docs/project-description.json),
+  preserve the existing top-level project key, `id`, `title`, `docId`, and all
+  image URLs (`image.url` and `headerImage.url`, when present). These are fixed
+  in the consuming project; routine metadata updates must not reset them.
+  Preserve a null or absent `headerImage` as well. Image paths such as
+  `/projects/score-keeper/logo.png` are relative to the consuming project's
+  root, not this repository: do not resolve them locally, rewrite them as
+  repository URLs, or replace them with generated/remote image URLs.
+  Change these protected fields only when the user explicitly requests it.
+- New project plans belong in [docs/](docs/); use checkboxes for actionable
+  work only. [Modernize.md](docs/Modernize.md) supersedes the historical `.cursor`
+  plan/rules. Planning/documentation tasks should not opportunistically implement
+  the plan's code changes.
+- Do not run server start/stop, deploy, restore, tagging, or publishing operations
+  without explicit authorization. Bash start/stop currently match all local
+  Java `paper-*.jar` processes; restore replaces archived top-level items.
+  PowerShell start/stop can force termination. Prefer a clean console `stop`
+  and inspect exact server paths/processes on isolated test machines.

CONTRIBUTING.md

@@ -1,156 +1,295 @@
-# Contributing to ScoreKeeper
+# Contributing to Score Keeper
-**TODO:** Add info about the various gradle tasks.
 
-Thank you for your interest in contributing to the ScoreKeeper plugin! This guide will help you set up your development environment and follow best practices for working with the project.
+**Start here to work on Score Keeper.** This guide covers the project structure,
+setup, validation, and publishing. The display name is **Score Keeper**; the
+repository, Gradle project, plugin ID, and jar basename remain `ScoreKeeper`.
 
-# Getting Started
+## Your first contribution
-Pick a folder to hold your minecraft server and this project I'm going to use `$HOME/Projects`. My Minecraft server will be in `$HOME/Projects/MCServer` and this project will be in `$HOME/Projects/ScoreKeeper`.
 
-Setup our project folder.
+1. Read [the project overview](#project-overview-and-source-map) below.
+   Consult [README.md](README.md) if you need user-facing commands and behavior.
+2. Read [AGENTS.md](AGENTS.md) once for the shared rules humans and agents follow.
+   This guide owns onboarding; that file owns change discipline and safety rules.
+3. Follow [prerequisites and checkout](#prerequisites-and-checkout) to build.
+4. Make a scoped change, then use [build and validation tasks](#build-format-and-validation-tasks).
+   Set up a local Paper server only if the affected behavior needs runtime testing.
+5. Run the relevant [manual checks](docs/human-tests.md) and report what you verified.
+
+You do **not** need to read every document before starting. Use these deeper
+references when your task needs them:
+
+- [Domain reference](docs/domain-score-tracking.md): score rules, YAML layout,
+  archives, and ranking.
+- [Integration reference](docs/plugin-integration-and-event-wiring.md): detailed
+  command/lifecycle wiring and API usage, especially for companion-plugin authors.
+- [Modernization plan](docs/Modernize.md) and [TODO.md](TODO.md): planned work,
+  not additional onboarding requirements.
+
+The old `.cursor` plan and rules are historical context, not the current setup
+or validation procedure. In particular, the Maven migration is already complete.
+
+## Project overview and source map
+
+Score Keeper is a command-driven Paper scoring engine: named buckets hold
+UUID-keyed integer scores with custom units, initial values, and reporting.
+It provides eight commands, score archives, high-score runs, and a public Java
+API. Gameplay events do not award scores automatically; companion plugins can
+provide that behavior.
+
+| Source | Responsibility |
+| --- | --- |
+| [ScoreKeeperPlugin.java](src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreKeeperPlugin.java) | Entry point, state, public API, persistence, reporting, ranking, and run completion |
+| [ScoreBucket.java](src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreBucket.java) | Immutable bucket definition and validation |
+| [ScoreReporting.java](src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreReporting.java) | Reporting policy enum and parsing |
+| [commands/](src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/) | Eight executors: arguments, online targets, selected permission guards, and messages |
+| [plugin.yml](src/main/resources/plugin.yml) | Plugin identity, entry point, API version, command declarations, and admin permission |
+| [tools/](tools/) / [PowerShell helpers](tools/powershell/) | Developer/server/release tooling; platform differences are documented below |
+| [.env.example](.env.example) | Bash helper configuration template, not plugin configuration |
+
+### Architecture in one minute
+
+```text
+Paper command -> executor parses/checks permissions/resolves online target
+             -> ScoreKeeperPlugin selects bucket and updates UUID-keyed state
+             -> bucket reporting OR run reporting and target completion
+
+onEnable  -> wire commands -> initialize points -> load scores and archives
+          -> check existing runs -> schedule synchronous checks every 20 ticks
+onDisable -> save scores.yml (version 3) and archives.yml
+```
+
+Most behavior lives in the entry-point class; there is no separate service layer,
+custom scoring event API, ServicesManager registration, or standalone API artifact.
+State uses nested `LinkedHashMap` collections and is not thread-safe. Keep state
+and Paper API calls on the main thread.
+
+There is no plugin `config.yml`: commands/API create buckets and policies,
+which are stored in the plugin's data files. Do not edit generated `build/`,
+`bin/`, or `.gradle/` outputs.
+
+### Behavior to understand before changing it
+
+- Scores, assignments, active runs, and archives save **on disable**, not every
+  mutation. Crashes can lose recent changes; the two YAML writes are not a transaction.
+  Loading supports legacy flat UUID scores but is not comprehensive schema validation.
+- Score get/add/subtract/reset and archive-list are unguarded; players can modify
+  any online player's score. Archive creation, bucket administration, and run
+  management require `scorekeeper.admin`; self bucket selection is open.
+- Named targets are online-only. `/score-get` reads the target's active bucket,
+  lazily creates an entry at its initial value, and shows only the numeric score.
+  An explicit bucket argument is pending SK-13; the API already has that overload.
+- Amounts are signed Java integers; negatives are allowed and overflow wraps.
+  Bucket IDs are case-sensitive.
+- `until-disabled` runs are saved/resumed across clean restarts, not ended by
+  disable. Reset runs restore the pre-run snapshot. Results are announced/logged,
+  not automatically archived; stop a run before archiving its bucket.
+
+The [domain reference](docs/domain-score-tracking.md) explains these rules in
+detail. Treat changes to them as deliberate behavior changes, not incidental cleanup.
+
+## Prerequisites and checkout
+
+The project targets **Paper 26.2 and 26.3 only**, compiles against
+`io.papermc.paper:paper-api:26.2.build.129-stable`, and uses **Java 25** and the
+**Gradle 9.8.0 wrapper**. Bukkit and Spigot servers are not supported.
+
+Install Git and a JDK 25, and set `JAVA_HOME` to the JDK root (not its `bin`
+directory). Confirm `java -version` and `javac -version` report 25. The Gradle
+toolchain resolver can download the compile JDK, but Gradle itself still needs
+a compatible JVM to start. Automatic local JDK detection is disabled in
+[gradle.properties](gradle.properties); `JAVA_HOME` is the configured discovery source.
 
-**Linux, macOS, and WSL**
 ```bash
-PROJECTS_DIR="$HOME/Projects"
-MINECRAFT_SERVER_PATH="$PROJECTS_DIR/MCServer"
-# Set this to the latest download url on the Paper downloads page [https://papermc.io/downloads](https://papermc.io/downloads) and update the jar name.
-MINECRAFT_SERVER_DOWNLOAD_URI="https://fill-data.papermc.io/v1/objects/fb73c7e310215016955617ab957022d9e1d47aeba206df3a98c5ecb43756527c/paper-1.21.8-25.jar"
-MINECRAFT_SERVER_JAR="paper-1.21.8-25.jar"
-mkdir -p "$MINECRAFT_SERVER_PATH"
-# Keep this shell open we will use these variables later.
-```
-
-**Windows**
-```powershell
-$projectsDir="$HOME\Projects"
-$minecraftServerDir="$projectsDir\MCServer"
-# Set this to the latest download url on the Paper downloads page [https://papermc.io/downloads](https://papermc.io/downloads) and update the jar name.
-$minecraftServerDownloadUri="https://fill-data.papermc.io/v1/objects/fb73c7e310215016955617ab957022d9e1d47aeba206df3a98c5ecb43756527c/paper-1.21.8-25.jar"
-$minecraftServerJar="paper-1.21.8-25.jar"
-New-Item -Type Directory $projectsDir
-New-Item -Type Directory $minecraftServerDir
-# Keep this shell open we will use these variables later.
-```
-
-## Install the JDK
-**Linux / WSL**
-```bash
-apt install openjdk-21-jdk
-```
-
-**macOS**
-```zsh
-brew install --cask microsoft-openjdk@21
-```
-
-**Windows**
-From Powershell
-```powershell
-winget install --id Microsoft.OpenJDK.21 --source winget
-```
-
-## Setup a PaperMC Server
-**Linux, macOS, and WSL**
-```bash
-# You're probably still here, but if not go to the server dir.
-cd "$MINECRAFT_SERVER_PATH"
-curl -O "$MINECRAFT_SERVER_DOWNLOAD_URI"
-java -jar "$MINECRAFT_SERVER_JAR"
-nano eula.txt # Change eula=false to eula=true, then save and exit.
-java -jar "$MINECRAFT_SERVER_JAR"
-```
-
-**Windows**
-```powershell
-# You're probably still here, but if not go to the server dir.
-Set-Location $minecraftServerDir
-Invoke-WebRequest -Uri $minecraftServerDownloadUri -OutFile (Split-Path $minecraftServerDownloadUri -Leaf)
-java -jar $minecraftServerJar
-notepad eula.txt
-# Change eula=false to eula=true, then save and close the file.
-java -jar $minecraftServerJar
-```
-
-If you get windows security popups about java with the little java dude allow them. It's because the server is listening on the network. Now you should have the server running and be dropped at a prompt like `> `. Type `stop` and hit enter to kill the server. You can also try CTRL + C.
-
-## Get the Code
-**Linux, macOS, and WSL**
-```bash
-cd "$PROJECTS_DIR"
 git clone https://github.com/headhunter45/ScoreKeeper.git
-code ScoreKeeper
+cd ScoreKeeper
+./gradlew spotlessCheck build
 ```
 
-```powershell
+On Windows, use `.\gradlew.bat spotlessCheck build` from PowerShell instead.
-Set-Location $projectsDir
+No globally installed Gradle or Maven is required.
-git clone https://github.com/headhunter45/ScoreKeeper.git
-# Then to open VSCode
-code ScoreKeeper
-```
 
-## Building the Plugin
+On macOS/Linux, [tools/build-plugin.sh](tools/build-plugin.sh) is an alternative:
-This should download the preferred version of our build tool (gradle) and use it to build the project. Among other intermediate files it will create `build/libs/ScoreKeeper-${Version}.jar`. This is the plugin jar that you copy to the minecraft server to install the plugin. From now on you will use the utility scripts in `tools\powershell\*.ps1` or `tools/bash/*.sh` to build and deploy the plugin to our test server.
+it downloads/caches Temurin 25 under `.gradle/user-home/jdks`, sets `JAVA_HOME`
+for that invocation, and runs `build`. It accepts additional Gradle arguments:
 
-**Linux, macOS, and WSL**
 ```bash
-./gradlew build
+./tools/build-plugin.sh spotlessCheck
 ```
 
-**Windows**
+That JDK selection is local to the script; it does not configure Java for your
-```powershell
+terminal, IDE, Paper server, or later direct wrapper invocations.
-.\gradlew.bat build
-```
 
-## Using the Utility Scripts
+## Build, format, and validation tasks
-Our scripts depend on two environment variables. You can set them each time you open a shell or set them once for every shell your user opens. The variables are `MINECRAFT_SERVER_PATH` and `MINECRAFT_SERVER_JAR`. They are used by the scripts to know where the server is so they can control it and deploy the plugin.
 
-**Linux, macOS, and WSL**
+Run these from the repository root, using the Windows wrapper where applicable.
+
+| Command | Purpose |
+| --- | --- |
+| `./gradlew build` | Compile, package, and run configured checks, including Spotless and `test`. |
+| `./gradlew assemble` | Package without running the full check lifecycle. |
+| `./gradlew spotlessCheck` | Verify Java formatting, imports, and license headers. |
+| `./gradlew spotlessApply` | Apply the configured Java formatting; inspect the diff afterward. |
+| `./gradlew test` | Run the default test task; currently there are no test sources/dependencies, so this is `NO-SOURCE`. |
+| `./gradlew javadoc` | Generate Java API documentation. |
+| `./gradlew properties --property version` | Inspect the Git-derived version. |
+| `./gradlew publishToMavenLocal` | Publish the Java component to your local Maven repository for companion-plugin development. |
+
+Build configuration lives in [build.gradle](build.gradle) (Groovy DSL), with
+`java-library` and `maven-publish`. Paper is a `compileOnly` dependency supplied
+by the server; no third-party runtime dependencies are bundled.
+Spotless 8.10.3 uses google-java-format 1.36.1, import cleanup/order, and
+[the license header](config/license-header.txt). The wrapper version/checksum
+are pinned in [wrapper properties](gradle/wrapper/gradle-wrapper.properties);
+the Foojay toolchain resolver is configured in [settings.gradle](settings.gradle).
+
+The plugin artifact is `build/libs/ScoreKeeper-<version>.jar`. Versioning uses
+`org.danilopianini.git-sensitive-semantic-versioning` version 7.0.24, a minimum
+project version of `0.2.1`, and `v`-prefixed tags. Do not hardcode a release
+version in the manifest:
+[plugin.yml](src/main/resources/plugin.yml) expands `${version}` during resource processing.
+
+There is **no behavioral automated coverage yet** and no `integrationTest` task.
+The test infrastructure and coverage are pending SK-08 through SK-12 in
+[TODO.md](TODO.md). A successful build is not proof that in-game behavior works.
+For code changes, run the smallest relevant existing checks, then exercise the
+affected scenarios in [human-tests.md](docs/human-tests.md). Documentation-only
+changes need link/metadata checks, not a Paper server.
+
+CI in [gradle.yml](.github/workflows/gradle.yml) runs for pushes and pull requests
+to `main` and `develop`, and any `v*` tags. Manual releases are handled via
+[release.yml](.github/workflows/release.yml). It invokes `test`, builds with the
+Bash helper, and uploads jar artifacts (test reports only if present). It does
+not start Paper or verify the two-version runtime compatibility claim.
+
+## Local Paper server: macOS, Linux, or WSL
+
+The Bash server/deploy/backup/restore/publish scripts read a root `.env`:
 
-To set them for the current session run these commands. To set for every new session add these commands to your `.bashrc` or `.zshrc` file.
 ```bash
-MINECRAFT_SERVER_PATH="$HOME/Projects/MCServer"
+cp .env.example .env
-MINECRAFT_SERVER_JAR="paper-1.21.8-25.jar"
 ```
 
-**Windows**
+Edit it using [the example](.env.example) as the configuration reference:
+
+- `PAPER_VERSION`, `PAPER_BUILD`, and `MINECRAFT_SERVER_JAR` must agree.
+  The example pins `26.2`, build `129`, and `paper-26.2-129.jar`. To test 26.3,
+  select a build for that version or clear both build and jar values to resolve
+  the latest stable build.
+- `MINECRAFT_SERVER_PATH` and `MINECRAFT_BACKUP_PATH` accept project-relative
+  paths, absolute paths, or `~/` paths. Defaults in the example are `./server`
+  and `./backups`.
+- Values are literal `KEY=value` data, not shell code. Matching outer quotes
+  are removed, but `$HOME`, variable references, and command substitutions are
+  **not expanded**. Existing nonempty exported environment variables take precedence.
+- Keep `.env` and publishing credentials out of Git.
+
+For server startup, install `curl`, `jq`, `java` (Java 25), and `shasum`.
+[start-server.sh](tools/start-server.sh) downloads missing Paper jars via the
+Fill v3 API, verifies the supplied SHA-256 checksum, and runs Java in the
+foreground with `--nogui`. It does not open a management GUI.
+
+**Process safety:** the Bash start helper calls the stop helper, which matches
+all Java processes running `paper-*.jar`, not just the configured server.
+Backup/restore helpers also check for any such running server. Do not use these
+helpers on a shared host without inspecting the processes and intended paths.
+The safest stop is `stop` in your own server console; do not rely on forced
+termination to save plugin data.
+
+On an isolated development machine:
+
+```bash
+./tools/build-plugin.sh
+./tools/deploy-plugin.sh
+./tools/start-server.sh
+```
+
+Read and accept Minecraft's EULA before setting `eula=true` in the server's
+`eula.txt`. The first launch exits until this is done; rerun the start helper
+after accepting it. Use the matching Minecraft Java Edition client and connect
+to `localhost` (or the server host's address). For WSL, run the client on Windows.
+
+To redeploy, stop the server cleanly, build, copy the jar, and restart. Both
+deploy helpers select the newest jar and **only warn** about stale sources;
+they do not rebuild or reject stale artifacts. Remove older Score Keeper jars
+from the test server's `plugins` directory so only the intended version loads.
+
+### Backup and restore
+
+[backup-server.sh](tools/backup-server.sh) archives plugins, config, world
+directories containing `level.dat`, and top-level settings into a timestamped
+`.tar.bz2`. Stop the server first; `--force` permits a potentially inconsistent
+live backup. Generated Paper remapping caches and world session locks are excluded.
+
+[restore-server.sh](tools/restore-server.sh) defaults to the newest backup,
+asks for confirmation, and takes a pre-restore backup unless `--no-backup` is
+specified. It **replaces** top-level items present in the archive. Inspect the
+archive and resolved paths first, and use only a disposable/test server.
+
+## Windows / PowerShell
+
+The PowerShell helpers are not equivalent to the Bash server tooling: they do
+not parse `.env`, download Paper, or provide backup/restore/publishing helpers.
+Install JDK 25, obtain a Paper 26.2 or 26.3 server jar from
+[Paper downloads](https://papermc.io/downloads/paper), and configure it manually.
+Start it once, read/accept the EULA, and then launch it again.
+
+Set real absolute paths in the current PowerShell session:
 
-To set them for a single session run these commands.
 ```powershell
 $env:MINECRAFT_SERVER_PATH = "$HOME\Projects\MCServer"
-$env:MINECRAFT_SERVER_JAR = "paper-1.21.8-25.jar"
+$env:MINECRAFT_SERVER_JAR = "paper-26.2-129.jar"
+.\tools\powershell\Build-Plugin.ps1
+.\tools\powershell\Deploy-Plugin.ps1
+Set-Location $env:MINECRAFT_SERVER_PATH
+java -jar $env:MINECRAFT_SERVER_JAR --nogui
 ```
 
-If you want them available in all of your powershell sessions you can set them permanently like this.
+Use your actual downloaded jar filename. Build uses the wrapper and your
-```powershell
+configured Java environment. The legacy PowerShell start/stop helpers attempt
-[Environment]::SetEnvironmentVariable("MINECRAFT_SERVER_PATH", "$HOME\Projects\MCServer", "User")
+to discover Java processes by command line and forcibly terminate matches.
-[Environment]::SetEnvironmentVariable("MINECRAFT_SERVER_JAR", "paper-1.21.8-25.jar", "User")
+Prefer starting Java explicitly and typing `stop` in its console for reliable
-```
+shutdown and persistence.
 
-### Start-Server.ps1 and start-server.sh
+## Publishing
-Run `tools\powershell\Start-Server.ps1` or `tools/bash/start-server.sh` to start the server and open a GUI to manage it.
 
-### Stop-Server.ps1 and stop-server.sh
+[tools/publish-local.sh](tools/publish-local.sh) bootstraps a local JDK like the
-Run `tools\powershell\Stop-Server.ps1` or `tools/bash/stop-server.sh` to stop the server. You can also safely close the GUI.
+build helper, then runs `publishToMavenLocal`. Coordinates are
+`com.majinnaibu.minecraft.plugins:ScoreKeeper:<version>`.
 
-### Build-Plugin.ps1 and build-plugin.sh
+[tools/publish-modrinth.sh](tools/publish-modrinth.sh) uploads a jar version to
-Run `tools\powershell\Build-Plugin.ps1` or `tools/bash/build-plugin.sh` to build the plugin. This builds the plugin in `build/libs` as a jar named `ScoreKeeper-${VERSION}.jar`. To install the plugin manually you can copy this to `$env:MINECRAFT_SERVER_PATH\plugins` or `$MINECRAFT_SERVER_PATH/plugins` and restart the server.
+Modrinth. Run it **only when intentionally publishing**, after validation:
 
-### Deploy-Plugin.ps1 and deploy-plugin.sh
+1. Decide whether this is a tagged stable release or a development build.
-Run `tools\powershell\Deploy-Plugin.ps1` or `tools/bash/deploy-plugin.sh` to copy the plugin to the server plugins directory. This checks if the built plugin is up to date with the source code. If it is, then the script copies the plugin to the plugins directory to install it. To use the new plugin restart the server.
+   For a stable release, tag the approved commit with `v<version>` and rebuild
+   from that tag; inspect Gradle's resulting version and jar metadata.
+2. Configure `.env` with `MODRINTH_TOKEN`, project ID, game versions, and loaders.
+   Defaults advertise Paper `26.2,26.3` and the `paper` loader; test both before
+   publishing that compatibility claim.
+3. Build the intended artifact. Optionally set `MODRINTH_FILE` to its exact path;
+   otherwise the newest non-`-all.jar` jar is selected.
+4. Run the publisher with JDK 25 available to the wrapper. It checks the jar's
+   manifest version against Gradle, derives changelog notes from commits unless
+   overridden, and infers `beta` for versions containing `-`, otherwise `release`.
+   `MODRINTH_VERSION_TYPE` can override this with `alpha`, `beta`, or `release`;
+   `MODRINTH_DEPENDENCIES`, if supplied, must be a JSON array.
 
-# Setting up the Minecraft Client
+The publisher needs `curl`, `jq`, and `unzip`; it creates a version, **not** an
-- **macOS / Linux:**
+update to the hosted project description. Keep [modrinth-description.md](docs/modrinth-description.md)
-  - Download and install the official Minecraft Launcher from [minecraft.net](https://www.minecraft.net/en-us/download).
+and [modrinth.json](docs/modrinth.json) current and update the hosted description
-  - Log in with your Mojang/Microsoft account and launch the Java Edition client.
+separately when releasing.
-- **Windows / WSL (Windows Subsystem for Linux):**
-  - For best performance, run the Minecraft client directly under Windows, not inside WSL.
-  - Download and install the official Minecraft Launcher for Windows from [minecraft.net](https://www.minecraft.net/en-us/download).
-  - Use WSL for server and plugin development, and connect to your test server from the Windows client.
 
-# Connecting the Client to Your Server
+## Documentation and scraper metadata
-- Start your Paper server (see above).
-- In the Minecraft client, add a new server with the address:
-  - `localhost` (if running both client and server on the same machine)
-  - Or use your machine's IP address if connecting across devices.
 
-# Notes
+Keep [README.md](README.md), [modrinth-description.md](docs/modrinth-description.md),
-- Always use the provided scripts and environment variables for consistent server management.
+[project-description.md](docs/project-description.md), and
+[project-description.json](docs/project-description.json) consistent with implemented
+features. Do not present planned work or manual checks as completed coverage.
+
+The scraper JSON must validate against [projects.schema.json](docs/projects.schema.json).
+It is a **slug-keyed object**, currently `{ "score-keeper": { ... } }`, not a
+single unwrapped project. Follow [AGENTS.md](AGENTS.md#documentation-and-operational-safety):
+the existing key, `id`, `title`, `docId`, and image URLs are fixed in the
+consuming project and must remain unchanged during routine metadata updates.
+Image paths are relative to that project's root, not this repository.
+Preserve the route, repository links, and filenames unless the consumer contract
+is intentionally changed. Use "Score Keeper" in descriptive prose.

Project.md

@@ -1,280 +0,0 @@
-# ScoreKeeper — Project Reference
-
-> **For a developer joining the team cold.** Read top-to-bottom in ~8 minutes;
-> you'll know where to look and what's real vs. planned on day one.
-
----
-
-## 1. What is ScoreKeeper?
-
-ScoreKeeper is a **Paper Minecraft plugin** (Java 21, Bukkit/Adventure APIs) that manages player
-score tracking. It exposes five in-game/console commands (`/score-get`, `/score-add`,
-`/score-subtract`, `/score-reset`, `/score-archive`) for manual score manipulation — no events,
-no timers, no automation.
-
-**State of the project:** live in-memory scores work today; the \"high-score table\" advertised
-in the README name and `/score-archive` description is **not implemented**. Persistence, ranking,
-and scoring formulas are all **future scope**. See §4 for the gap between *what exists* and
-*what is planned*.
-
----
-
-## 2. Tech Stack & Build
-
-| Item | Value |
-|------|-------|
-| Language | Java 21 (Gradle auto-downloads toolchain) |
-| Runtime target | Paper 1.21.7 (Bukkit + Adventure APIs) |
-| Build tool | Gradle 8.14.3 (`gradlew`) |
-| Linting | Spotless (`googleJavaFormat()` + license header from `config/license-header.txt`) |
-| Release | `net.researchgate.release` plugin; tags `v$version`; rejects snapshot deps except paper-api |
-| External deps | **None at runtime.** `paper-api:1.21.7-R0.1-SNAPSHOT` is `compileOnly` only. |
-| CI/release entry point | `./gradlew spotlessCheck build` then `./gradlew release` |
-
-### Build quickly
-
-```bash
-./gradlew build          # compiles, runs tests (none yet)
-./gradlew spotlessApply  # format to project style
-./gradlew assemble       # produces jar in build/libs/
-```
-
-Drop the resulting jar onto a Paper server's `plugins/` directory.
-
----
-
-## 3. Architecture Overview
-
-### Directory layout
-
-```
-├── src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/
-│   ├── ScoreKeeperPlugin.java        ← entry point, onEnable/onDisable, score CRUD core
-│   └── commands/
-│       ├── ScoreGetCommand.java      → /score-get [player]
-│       ├── ScoreAddCommand.java      → /score-add [player] <amount>
-│       ├── ScoreSubtractCommand.java → /score-subtract [player] <amount>
-│       ├── ScoreResetCommand.java    → /score-reset [player]
-│       └── ScoreArchiveCommand.java  → /score-archive [player] (stub)
-├── src/main/resources/
-│   └── plugin.yml                    ← command manifest + main-class declare
-├── tools/bash/ & tools/powershell/  ← dev helper scripts
-├── config/license-header.txt         ← Spotless license header
-├── build.gradle                      ← Gradle build config (above)
-├── gradle.properties                 ← version, group coordinates
-├── CONTRIBUTING.md                   ← dev env setup
-└── README.md                         ← user-facing command reference + notes
-```
-
-### Data flow (text diagram)
-
-```
-ADMIN / CONSOLE / RCON ──▶ types a /score-* command
-                              │
-                              ▼
-                 ┌──────────────────────┐
-                 │ 5× Score*Command.java│   executors parse args,
-                 │ resolves target      │   resolvePlayerExact(name) (online-only)
-                 └──────────┬───────────┘
-                            │ calls
-                            ▼
-              ┌──────────────────────────────┐
-              │  ScoreKeeperPlugin            │
-              │                                │
-              │  addScore / subtractScore     │  read-modify-write
-              │  resetScore / setScore        │
-              │  getScore (read)              │
-              │  archiveScore (STUB — no-op) │
-              └──────────┬───────────────────┘
-                         │
-                         ▼
-               HashMap<UUID, Integer>   ← in RAM only
-                 _playerScores          ← ScoreKeeperPlugin:38
-```
-
-**Key architectural facts:**
-
-- **Single class owns everything.** `ScoreKeeperPlugin` holds the scores map, score CRUD
-  methods, logging helpers (logWarning/logInfo/logError), and the Adventure component builder
-  for chat color. There is no service layer or boundary separation.
-- **No event listeners.** Zero `@EventHandler`/`Listener` registrations across the codebase.
-  Game events (join, death, kill) do not affect scores. Only manual commands change state.
-- **No scheduler or tick logic.** No periodic tasks, no countdowns, no automated scoring.
-- **No permission nodes.** Every command is available to every sender (player, console, RCON).
-
-### File: ScoreKeeperPlugin.java (`ScoreKeeperPlugin`)
-
-- `main` class in `plugin.yml` (Bukkit plugin entry point)
-- `HashMap<UUID, Integer> _playerScores` at line 38 — the sole score store
-- `onEnable()` (line 52): wires five command executors, logs \"load not implemented\" warning
-- `onDisable()` (line 46): logs \"save not implemented\" warning — scores lost on shutdown
-- Score CRUD methods: `addScore`, `subtractScore`, `resetScore`, `setScore`, `getScore`,
-  `archiveScore` (lines 67–91, 76–86, 72–74)
-- Private helpers: `getPlayerScore(Player)` (get-or-create at 0), `setPlayerScore(Player,int)`
-
----
-
-## 4. Domain Model & Scoring Logic
-
-### 4.1 What exists today (REAL — in code)
-
-| Aspect | Detail | Source |
-|--------|--------|--------|
-| Score model | Single `int` per player, keyed by UUID | `ScoreKeeperPlugin:38` |
-| Storage container | `HashMap<UUID, Integer>` on plugin instance | same file |
-| Default value | `0` — lazy-created on first map access | `getPlayerScore:100-106` |
-| Live only | **No persistence.** Scores erased on server restart | `onEnable:59`, `onDisable:47` |
-| Scoring direction | Any integer (negatives allowed, no floor) | add/subtract are raw `+`/`-` |
-| Recording method | Manual commands only — `/score-add`, `/score-subtract` | command executors |
-| Auto-scoring | **None** — no events, no timers | proven by grep across src/ |
-| Permissions | **None declared.** All commands open to all senders | `plugin.yml`, no permission guard in code |
-
-### 4.2 Open Score Lifecycle (what exists + what is planned)
-
-```
-Stage  1. First access — getPlayerScore() auto-creates key at 0   [REAL]
-         2. Admin runs /score-add player N or /score-subtract       [REAL]
-         3. Player accumulates points over the session             [REAL]
-         4. Read via /score-get (read-only, lazily registers)      [REAL]
-         5. Server restart — scores LOST on shutdown               [REAL]
-         6. Intended: /score-archive freezes score → table        [GAP ✓ not built]
-         7. Intended: high-score table display command            [GAP ✓ not built]
-```
-
-### 4.3 The "high-score table" — status
-
-| Feature | Status | Details |
-|---------|--------|---------|
-| `/score-archive` | **Stub** | Command prints \"archive command unimplemented\"; `archiveScore()` method only logs, never writes a table or resets the player's score |
-| Persistence (save) | **Not built** | `onDisable()` is a TODO stub — map discarded at shutdown |
-| Persistence (load) | **Not built** | `onEnable()` is a TODO stub — map always starts empty `{}` |
-| Sorting / ranking | **Not coded** | No sort, no tie-breaking, no entry cap, no decay logic exists |
-| Scoring formulas | **Not coded** | Scores are plain integer accumulators (`Σ(adds) − Σ(subtracts)`) |
-
-**Design decisions to be made (none answered by code today):**
-
-- Storage format for the table (YAML per Bukkit convention; JSON? SQLite?)
-- What an entry looks like (name + score + timestamp? name is not stored with score today)
-- Sort order and tie-breaking strategy
-- Max entries / leaderboard cap
-- Whether `/score-archive` also resets the live score (README says it does)
-
----
-
-## 5. Plugin Integration & Reference Table
-
-### 5.1 Command → Handler → Effect on score data
-
-| Trigger | Usage | Handler | Effect |
-|---------|-------|---------|--------|
-| `/score-get [player]` | Self or other | `ScoreGetCommand.java:38-84`, delegated to `getScore → getPlayerScore` | **Read-only.** Returns integer. Lazily creates entry at `0` if unseen. |
-| `/score-add [player] <N>` | Self (omit name) or target others | `ScoreAddCommand.java` | `score += N`. Amount must parse as int. No direction validation (negative N still adds). |
-| `/score-subtract [player] <N>` | Same | `ScoreSubtractCommand.java` | `score -= N`. No minimum clamping; negatives freely produced. |
-| `/score-reset [player]` | Same | `ScoreResetCommand.java` | `score = 0`. Key created at `0` if absent. |
-| `/score-archive [player]` | Same | `ScoreArchiveCommand.java` | **No-op.** Prints \"archive command unimplemented\". Does NOT call the `archiveScore()` method. |
-
-### 5.2 Shared behavior details
-
-Every executor follows this pattern:
-
-1. Parse arguments — if `split.length == 1` and sender is a player, target = self (RCON/console
-   requires an explicit `<playerName>` or prints usage).
-2. Resolve target player via `server.getPlayerExact(name)` — **exact, case-sensitive, online-only.**
-3. Call the corresponding `ScoreKeeperPlugin` method.
-4. Echo color-coded result; return `true`.
-
-### 5.3 Inter-plugin / public API surface
-
-`ScoreKeeperPlugin` exposes these public methods that other plugins *could* call if they hold a reference
-(but there is **no formal service registration**):
-
-| Method | Visibility | Called by commands? | Notes |
-|--------|------------|---------------------|-------|
-| `addScore(Player, int)` | `public` | Yes (`/score-add`) | Read-modify-write on `_playerScores` |
-| `subtractScore(Player, int)` | `public` | Yes (`/score-subtract`) | Same pattern |
-| `getScore(Player)` | `public` | Yes (`/score-get`) | Wrapper around `getPlayerScore` |
-| `setScore(Player, int)` | `public` | **No** | Internal write path only; not hooked to any command |
-| `resetScore(Player)` | `public` | Yes (`/score-reset`) | Sets to `0` |
-| `archiveScore(Player)` | `public` | **No** | Only logs a warning; never called by the archive command |
-
-### 5.4 Concurrency note
-
-The map is a plain `HashMap`. Safe because Paper dispatches commands on the server's single main
-thread — but it is **not safe for off-thread use**. Any future event-driven scoring that runs
-asynchronously could corrupt state via non-atomic read-modify-write.
-
----
-
-## 6. Configuration Reference
-
-| File | Format | Purpose |
-|------|--------|---------|
-| `plugin.yml` | YAML (Bukkit manifest) | Declares main class, api-version, five commands + descriptions/usage strings |
-| `build.gradle` | Gradle Kotlin (Groovy DSL) | Dependencies, task config, release/spotless settings |
-| `gradle.properties` | Properties | Project version and group coordinates (for Maven publishing) |
-| **No `config.yml`** | — | ScoreKeeper has **no player-editable configuration**. |
-| **No `permissions:` block** | — | No permission nodes declared; all commands are open. Plans say \"permissions coming after archive works.\" |
-
----
-
-## 7. Running & Testing Locally
-
-### Build
-
-```bash
-./gradlew assemble           # produces ScoreKeeper.jar in build/libs/
-```
-
-### Run locally (Paper server)
-
-1. Download Paper 1.21.7 from `https://papermc.io`
-2. Copy the built jar into `plugins/`
-3. Start the server, verify onEnable logs:
-   ```
-   [ScoreKeeper] ScoreKeeper version X.Y.Z is enabled.
-   [ScoreKeeper] Unable to load scores from file. This feature is not implemented yet.
-   ```
-
-### Commands (in-game or via RCON/console)
-
-| Test scenario | Command | Expected output |
-|--------------|---------|-----------------|
-| Check own score | `/score-get` | \"Your score is 0\" (creates entry at 0) |
-| Add points to self | `/score-add 10` | \"You gained 10 points! Now have 10.\" |
-| Subtract from self | `/score-subtract 5` | \"You lost 5 points! Now have 5.\" |
-| Check another player | `/score-get PlayerName` | \"PlayerName's score is N.\" (must be online) |
-| Reset own score | `/score-reset` | \"Your score has been reset to 0.\" |
-| Archive (stub) | `/score-archive` | \"archive command unimplemented\" |
-
-### Tests
-
-- **No unit/integration tests exist yet.** `./gradlew test` runs an empty suite. Consider
-  adding tests for `ScoreKeeperPlugin`'s private `Player` score state mocking in a future task.
-
----
-
-## 8. Where to Look First
-
-| I want to understand… | Go to |
-|----------------------|-------|
-| The entire live data model | `ScoreKeeperPlugin:38` — one `HashMap<UUID, Integer>` field |
-| How scores change (write path) | `addScore(/:67-70)`, `subtractScore(/:88-91)`, `setPlayerScore(/:108-110)` |
-| How a player is looked up | `getPlayerExact(name)` online only — see any `*Command.java` line ~50 |
-| First-time-player behavior | `getPlayerScore(/:100-106)` — auto-inserts `0` on first access |
-| High-score / archive table | **Does not exist.** See `archiveScore(/:72-74)` stub; design decisions in §4.3 |
-| Persistence (save/load) | `onDisable(/:47)`, `onEnable(/:59)` — both TODO, nothing writes to disk |
-| What's declared/intended but not wired | `plugin.yml:18-20` (`/score-archive`), `README.md:11` and README notes |
-| Command implementations | `commands/Score*Command.java` (all 5 handlers) |
-| Build/runtime config | `build.gradle`, `plugin.yml`, `gradle.properties` |
-| Dev env / CONTRIBUTING | `CONTRIBUTING.md` |
----
-
-## Appendix: Risk Summary
-
-| # | Issue | Impact | Section |
-|---|-------|--------|---------|
-| 1 | **Data loss on restart** — no save/load implemented | Every server boot wipes all scores (§4.1) | §4.1 |
-| 2 | **No permissions** — any player can self-add points | Integrity of scoring is unenforceable today (§5.2) | §5.2 |
-| 3 | **Race condition on add/subtract** — non-atomic read-modify-write on plain `HashMap` | Corrupt state if future event-driven scoring runs async (§5.4) | §5.4 |
-| 4 | **No `int` overflow safety** — Java wrapping semantics apply | Undetectable score corruption near ±2.1 billion | §4.1 |
-| 5 | **Name lookups online-only & case-sensitive** | Can't target offline players; \"Alice\" ≠ \"alice\" (§5.2) | §5.2 |

ProjectDescription.json

@@ -1,23 +0,0 @@
-{
-  "id": "scorekeeper",
-  "title": "ScoreKeeper",
-  "description": "Paper Minecraft plugin for tracking and managing player scores.",
-  "docId": "ScoreKeeper",
-  "image": {
-    "url": "https://image.pollinations.ai/prompt/pixel%20art%20Minecraft%20server%20scoreboard%20with%20a%20glowing%20diamond%20and%20number%20counters%2C%20clean%20square%20game%20plugin%20thumbnail%2C%20no%20text",
-    "alt": "Pixel art scoreboard with a diamond for the ScoreKeeper Minecraft plugin",
-    "prompt": "Pixel art Minecraft server scoreboard with a glowing diamond and number counters, clean square game plugin thumbnail, no text",
-    "width": 1024,
-    "height": 1024,
-    "backgroundClassName": "bg-surface"
-  },
-  "url": "/projects/scorekeeper",
-  "tags": [],
-  "source": {
-    "type": "",
-    "url": ""
-  },
-  "feedback": {
-    "url": ""
-  }
-}

ProjectDescription.md

@@ -1,16 +0,0 @@
-# ScoreKeeper
-
-ScoreKeeper is a Paper Minecraft plugin for tracking player scores during server activities, events, or games. It keeps scores per player in memory and exposes commands for viewing, changing, resetting, and archiving scores.
-
-## Details
-
-- Built for Paper API 1.21.7 with Java 21 and Gradle.
-- Registers `/score-get`, `/score-add`, `/score-subtract`, `/score-reset`, and `/score-archive`.
-- Commands use the executing player when a player name is omitted.
-- Scores are currently held in memory and are not persisted when the server stops.
-- Score archiving is planned, but the current implementation reports that archiving is unavailable.
-- The project is packaged as a Java plugin with a `plugin.yml` descriptor.
-
-## Image
-
-No project image asset is included in the repository. The JSON description includes a prompt-backed image URL for a future project thumbnail.

README.md

@@ -1,23 +1,135 @@
-# ScoreKeeper Plugin
+# Score Keeper
+
+[![Java CI with Gradle](https://github.com/headhunter45/ScoreKeeper/actions/workflows/gradle.yml/badge.svg)](https://github.com/headhunter45/ScoreKeeper/actions/workflows/gradle.yml)
+
+Score Keeper tracks player scores in named buckets for server events, competitions,
+and companion plugins. Buckets support custom units, initial values, reporting,
+archives, and target-based or timed high-score runs. Gameplay does not award points
+automatically: use commands or another plugin calling the public API.
+
+Supports **Paper 26.2 and 26.3 only**, with **Java 25**. Bukkit and Spigot servers
+are not supported. The display name is Score Keeper; the repository and installed
+plugin identifier remain `ScoreKeeper`.
+
+## Installation
+
+1. Obtain a plugin jar from [Modrinth](https://modrinth.com/plugin/scorekeeper)
+   or build it using [CONTRIBUTING.md](CONTRIBUTING.md).
+2. Stop your Paper server cleanly. Back up existing plugin data.
+3. Put `ScoreKeeper-<version>.jar` in the server's `plugins` directory, removing
+   older Score Keeper jars so only one version loads.
+4. Start the server and verify the plugin enables without errors.
+
+Scores, bucket definitions, reporting, player assignments, and active runs load
+from `plugins/ScoreKeeper/scores.yml`; archives load from
+`plugins/ScoreKeeper/archives.yml`. Both are saved **on plugin disable/clean
+shutdown**, not after every command. Crashes or forced termination can lose
+changes since the last successful save. Do not edit these files while running.
 
 ## Running
 
 ### Commands
 
-* `/score-get [playerName]` - Displays the player's score.
+For commands with an optional player name, players can omit it to target themselves.
-* `/score-add [playerName] <amount>` - Add amount points to the player's score.
+Named targets must be online. Console and RCON must provide a player name for
-* `/score-subtract [playerName] <amount>` - Subtracts amount points from the player's score.
+score get/add/subtract/reset; archive also supports `all` and `bucket` scopes.
-* `/score-reset [playerName]` - Resets the player's score to 0.
+Bucket IDs are case-sensitive and allow letters, numbers, `_`, and `-`.
-* `/score-archive [playerName]` - Saves the player's score to a "High Scores" table and resets their current score to 0.
+Command-created singular/plural labels each occupy one argument.
+Add/subtract accept signed 32-bit integers, including zero and negative amounts.
 
-NOTES:
+* `/score-get [playerName]` - Displays the target player's score in their active bucket.
-* All commands will use the executing player in place of [playerName] if it is omitted.
+* `/score-add <amount>` - Adds an amount to your score in your active bucket.
-* Permissions support is coming AFTER I get archive to work.
+* `/score-add <playerName> <amount>` - Adds an amount to the target player's score.
-* The commands aside from get are intended for admins and whatnot as some other plugin should be using the methods instead of letting player's execute commands.
+* `/score-subtract <amount>` - Subtracts an amount from your score in your active bucket.
+* `/score-subtract <playerName> <amount>` - Subtracts an amount from the target player's score.
+* `/score-reset [playerName]` - Resets the target player's score in their active bucket to that bucket's initial value.
+* `/score-archive` - Archives and resets your score in your active bucket.
+* `/score-archive <playerName>` - Archives and resets the target player's score in their active bucket.
+* `/score-archive all` - Archives and resets scores in every bucket.
+* `/score-archive bucket <bucketId>` - Archives and resets every score in one bucket.
+* `/score-archive-list` - Lists saved archive IDs, newest first.
+* `/score-archive-list <archiveId>` - Displays the saved scores in one archive.
+* `/score-bucket` - Displays your active bucket.
+* `/score-bucket <bucketId>` - Switches your active bucket.
+* `/score-bucket create <id> <singular> <plural> <initialValue> [reporting]` - Creates a bucket. Reporting is `admin`, `global`, `player`, or `none` and defaults to `none`.
+* `/score-bucket <playerName> <bucketId>` - Switches a player's active bucket.
+* `/score-bucket all <bucketId>` - Changes the server's default bucket and clears individual bucket assignments.
+* `/score-run start <bucketId> <topN> <true|false> target <score>` - Starts a run that ends when a score reaches the target.
+* `/score-run start <bucketId> <topN> <true|false> duration <time>` - Starts a timed run. Use a positive number followed by lowercase `s`, `m`, `h`, `d`, or `w` (for example, `4h`).
+* `/score-run start <bucketId> <topN> <true|false> until-disabled` - Starts a run with no automatic end, including across clean restarts.
+* `/score-run stop <bucketId>` - Ends an active run.
+
+The reset argument for a run is the literal `true` or `false`, not `reset:true`.
+Top N must be at least 1. For example:
+
+```text
+/score-bucket create event point points 0 player
+/score-bucket event
+/score-run start event 3 true duration 4h
+/score-add 10
+/score-get
+/score-run stop event
+/score-archive bucket event
+```
+
+### Permissions
+
+The `scorekeeper.admin` permission (default: operators) is required for
+`score-archive`, bucket creation, switching another player/all players, and run
+management. Viewing/selecting your own bucket requires no admin permission.
+Score get/add/subtract/reset and archive-list currently have no permission
+checks; add, subtract, and reset can target **any online player**. Restrict command
+access externally if that is inappropriate for your server's scoring rules.
+
+### Reporting, runs, and archives
+
+When a player's active bucket changes, they are told the bucket name and their current score with its singular or plural unit.
+
+Bucket reporting defaults to `none`; `admin` notifies operators and score admins
+and logs the change, `global` notifies all online players, and `player` notifies
+only the scored player. Only changed values produce reports. With `none`, a
+successful add/subtract/reset can be silent; use `/score-get` to inspect the
+numeric score. Scores can go negative and arithmetic overflow is not checked.
+
+Each bucket can have one active run. During it, players receive their own score
+changes regardless of the bucket reporting policy; changes by players in the
+top N after the update are reported globally. Rankings include all recorded
+bucket entries, even offline players. Ties sort by case-insensitive name, then UUID,
+and have consecutive places. Finished runs announce/log the top-N table and each
+online player's place. Reset runs restore the pre-run bucket scores; non-reset
+runs leave earned scores intact. Timed runs use wall-clock time, including time
+offline. An existing target can end a non-reset run immediately.
+
+Run results are not automatically archived. Stop the run before archiving its
+bucket. Archives snapshot the selected recorded scores and reset them to the
+bucket initial value; they become durable at clean shutdown.
+
+## Plugin API
+
+Other plugins can create buckets with
+`createBucket(id, singular, plural, initialValue, ScoreReporting)` and use
+bucket-aware score methods. Existing no-bucket methods use the player's active
+bucket. Runs use `startTargetScoreRun`, `startTimedScoreRun`,
+`startUntilDisabledScoreRun`, and `stopHighScoreRun`.
+
+Declare a dependency on plugin ID `ScoreKeeper`, obtain the enabled
+`ScoreKeeperPlugin` instance, and call it on Paper's main thread. There is no
+separate service registration or automatic gameplay integration. See
+[plugin integration and event wiring](docs/plugin-integration-and-event-wiring.md)
+for setup, overloads, and failure handling.
 
 ## Development
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for development environment setup instructions.
+Start with [CONTRIBUTING.md](CONTRIBUTING.md) and the shared rules in
+[AGENTS.md](AGENTS.md). The project uses Gradle 9.8.0, Java 25 toolchains, and
+Spotless. The compile toolchain can be downloaded automatically, but the wrapper
+still needs a compatible JVM to start.
 
-Tooling note:
+There are currently no automated Java tests; a passing build does not exercise
-* Gradle is configured with Java Toolchains and will automatically download a Java 21 JDK when needed during builds.
+plugin behavior. Use [human-tests.md](docs/human-tests.md) before releases.
+See [the contributor guide's project overview](CONTRIBUTING.md#project-overview-and-source-map) for architecture and
+[the modernization plan](docs/Modernize.md) for remaining work.
+
+## License
+
+Score Keeper is licensed under the [GNU AGPL v3 or later](LICENSE).

TODO.md

@@ -1,17 +1,22 @@
-# Migration TODOs for Paper Modernization
+# Score Keeper Tasks
 
-- [x] Switch all player score storage to use UUID instead of Player as the key
+**Done** means implemented in source, not validated by automated behavioral tests.
-- [x] Update logger usage to use getLogger() from JavaPlugin
+**Ready** means not yet implemented. See [docs/Modernize.md](docs/Modernize.md)
-- [x] Remove or modernize any old/deprecated event registration (use @EventHandler and registerEvents)
+for the broader roadmap and [docs/human-tests.md](docs/human-tests.md) for manual
-- [x] Review and update player lookup logic to use getPlayerExact or handle case sensitivity
+pre-release validation.
-- [x] Ensure all commands are properly defined in plugin.yml
+
-- [x] Initialize Gradle build system
+| ID | Status | Title |
-- [x] Set project metadata in build.gradle
+| --- | --- | --- |
-- [x] Add repositories and dependencies
+| SK-01 | Done | Save scores between clean server launches using enable-time load and disable-time save. Crash-safe/periodic persistence is still future work. |
-- [x] Configure Java version
+| SK-02 | Done | Track independent UUID-keyed scores by named bucket with singular/plural units and initial values; support default and individual assignments. |
-- [x] Ensure resource handling for plugin.yml
+| SK-03 | Done | Add per-bucket `admin`, `global`, `player`, and `none` reporting policies. |
-- [x] Add Gradle plugins as needed (e.g., Shadow)
+| SK-04 | Done | Notify affected online players when their active bucket changes, including current score and units. |
-- [x] Update .gitignore for Gradle
+| SK-05 | Done | Implement target-score, timed, and manually stopped bucket runs with configurable top N, optional initial reset/snapshot restoration, global leader reporting, and final personal standings. Active runs persist across clean restarts. |
-- [x] Remove Maven files
+| SK-06 | Done | Archive player, bucket, or all-bucket scores and reset live entries to initial values; list archive IDs and contents. |
-- [x] Update documentation and scripts
+| SK-07 | Done | Replace the release plugin with Git-sensitive semantic versioning (minimum `0.2.1`, `v` tag prefix) and re-enable Gradle configuration cache. Versions are Git-derived, not a hardcoded snapshot. |
-- [x] Test the Gradle build
+| SK-08 | Ready | Add JUnit 5 test infrastructure and keep the default Gradle `test` task server-free. Use a compatible in-memory Paper harness such as MockBukkit; use Mockito only for narrow boundaries where a harness is unnecessary. |
+| SK-09 | Ready | Add fast score/bucket tests: validation and duplicates, initial values, UUID isolation, lazy entries, default/per-player selection, and signed add/subtract/reset behavior. |
+| SK-10 | Ready | Test YAML round trips, assignments, active runs/snapshots, archive contents/resets, legacy loading, and malformed/unknown entries using temporary data directories. |
+| SK-11 | Ready | Test command validation/dispatch/permissions, reporting/messages, bucket switches, ranking/ties, top-N thresholds, target/duration/manual completion, and restoration. Use controllable time/scheduling where needed. |
+| SK-12 | Ready | Add a separate opt-in `integrationTest` source set/task for real Paper loading, command dispatch, companion API wiring, and restart persistence. Keep it outside normal `test`/`build`. |
+| SK-13 | Ready | Add an option to `/score-get` for a specific bucket, preserving current optional-player syntax. |

build.gradle

@@ -1,12 +1,17 @@
 plugins {
-    id 'com.diffplug.spotless' version '6.22.0'
+    id 'com.diffplug.spotless' version '8.10.3'
     id 'java-library'
     id 'maven-publish'
-    id 'net.researchgate.release' version '3.1.0'
+    id 'org.danilopianini.git-sensitive-semantic-versioning' version '7.0.24'
 }
 
 group = 'com.majinnaibu.minecraft.plugins'
-description = "ScoreKeeper"
+description = "Score Keeper"
+
+gitSemVer {
+    minimumVersion.set('0.2.1')
+    versionPrefix.set('v')
+}
 
 tasks.withType(JavaCompile).configureEach {
 	options.encoding = 'UTF-8'
@@ -18,7 +23,7 @@ tasks.withType(Javadoc).configureEach {
 }
 
 dependencies {
-    compileOnly 'io.papermc.paper:paper-api:1.21.7-R0.1-SNAPSHOT'
+    compileOnly 'io.papermc.paper:paper-api:26.2.build.129-stable'
 }
 
 java {
@@ -41,10 +46,12 @@ tasks.named('updateDaemonJvm') {
     languageVersion = JavaLanguageVersion.of(25)
 }
 
+def pluginVersion = project.version.toString()
+
 processResources {
-    inputs.property "version", project.version
+    inputs.property "version", pluginVersion
     filesMatching('plugin.yml') {
-        expand(project.properties)
+        expand(version: pluginVersion)
     }
 }
 
@@ -56,18 +63,6 @@ publishing {
     }
 }
 
-release {
-//    buildTasks.addAll(['spotlessCheck', 'build'])
-    buildTasks = ['spotlessCheck', 'build']
-    failOnSnapshotDependencies = true
-    ignoredSnapshotDependencies = [
-        "io.papermc.paper:paper-api"
-    ]
-    revertOnFail = true
-    tagTemplate = 'v$version'
-    versionPropertyFile = 'gradle.properties'
-}
-
 repositories {        
      mavenCentral()
      maven { url = 'https://repo.papermc.io/repository/maven-public/' }
@@ -75,7 +70,7 @@ repositories {
 
 spotless {
     java {
-        googleJavaFormat('1.27.0')
+        googleJavaFormat('1.36.1')
         importOrder 'java', 'javax', 'com', 'net', 'org', ''
         licenseHeaderFile 'config/license-header.txt'
         target 'src/**/*.java'

config/license-header.txt

@@ -1,17 +1,17 @@
 /*
-This file is part of ScoreKeeper.
+This file is part of Score Keeper.
 
-ScoreKeeper is free software: you can redistribute it and/or modify
+Score Keeper is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
-ScoreKeeper is distributed in the hope that it will be useful,
+Score Keeper is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 */
 

docs/Modernize.md

@@ -0,0 +1,128 @@
+# Score Keeper Modernization Plan
+
+Current baseline: October 2026. This replaces
+[the historical Cursor plan](../.cursor/plans/Modernize.md) as the maintained
+roadmap. It is a plan, not authorization to change runtime behavior or publish.
+Read [CONTRIBUTING.md](../CONTRIBUTING.md) and [AGENTS.md](../AGENTS.md) first.
+
+## Baseline: already implemented
+
+The old Maven/Java 17/older Minecraft migration is no longer pending.
+
+| Area | Current implementation |
+| --- | --- |
+| Build | Gradle 9.8.0 wrapper, Java 25 toolchain, Foojay resolver, configuration cache, Spotless |
+| Paper target | API `26.2.build.129-stable`, manifest API `26.2`, documented Paper 26.2/26.3 support |
+| Identity and messaging | UUID-based scores, Paper/Adventure messages, plugin logger, online `getPlayerExact` lookup |
+| Domain | Named buckets, initial values, four reporting policies, default/individual assignments |
+| Persistence | Version-3 scores YAML, archives YAML, legacy flat UUID score loading, shutdown save/enable load |
+| Competitions | Target/timed/manual runs, scheduled checks, top-N rankings, score snapshots/restoration |
+| Tooling | Bash build/deploy/server/backup/restore/local and Modrinth publishing; legacy PowerShell subset |
+| Documentation | Contributor entry point, shared agent rules, current domain/integration references, manual release checklist, schema-shaped project metadata |
+
+Implemented is not the same as verified on every advertised server version.
+There are no automated Java tests yet; the CI `test` task is currently `NO-SOURCE`.
+There is no real-server integration task and no automatic publishing workflow.
+
+## Phase 1: reliable regression coverage (SK-08 through SK-11)
+
+These are prerequisites for changing persistence, permissions, arithmetic, or
+run behavior. Keep the default test task server-free.
+
+- [ ] Add JUnit 5 infrastructure and an in-memory Paper harness compatible with
+  the current Java/Paper API (for example, MockBukkit if compatible). Use Mockito
+  only for narrow boundaries where a harness is unnecessary; verify compatibility
+  before choosing/pinning dependencies.
+- [ ] Cover bucket ID/label/reporting validation, duplicates, initial values,
+  UUID isolation, lazy reads, active/default selection, all-player assignment
+  clearing, and signed add/subtract/reset semantics.
+- [ ] Cover YAML round trips in temporary data directories: buckets, scores,
+  assignments, runs/snapshots, archives, and legacy flat scores. Include invalid
+  UUIDs, unknown buckets, malformed values, and empty archive buckets.
+- [ ] Cover all eight command executors: sender/self/online-target resolution,
+  literal reset booleans, duration units/overflow, usage/errors, and existing
+  permission boundaries.
+- [ ] Verify Adventure reporting audiences, changed-vs-unchanged scores, unit
+  labels, self/other bucket notices, and no duplicate run change notifications.
+- [ ] Introduce a small controllable clock/scheduler seam where necessary for
+  deterministic run tests; avoid a wholesale architecture rewrite.
+- [ ] Verify descending/name/UUID run ties, archive UUID ties, offline/unranked
+  entries, top-N boundaries, immediate targets, duration expiration, manual stop,
+  resumed runs, and exact pre-run score restoration (including new run entrants).
+- [ ] Make CI produce real test reports and fail on these regressions once tests
+  exist; do not mistake missing reports for tested coverage.
+
+## Phase 2: explicit real-server validation (SK-12)
+
+- [ ] Add an opt-in `integrationTest` source set/task only for behavior requiring
+  actual Paper. Keep it out of normal `test`/`build`, use disposable directories,
+  and own/stop only the processes it starts.
+- [ ] Load the built jar on both Paper 26.2 and 26.3 with Java 25; verify real
+  command registration/dispatch, Adventure output, scheduler completion, API
+  integration/load order, and persistence across clean restarts.
+- [ ] Run [human-tests.md](human-tests.md) on both versions before release.
+  Record artifact version, Paper build, Java version, observations, and logs.
+- [ ] Review startup/runtime deprecation warnings and unsupported API calls
+  found by builds/runtime tests; update compatibility claims only with evidence.
+
+Do not broaden support to Spigot, Bukkit, Folia, or future Paper versions by
+documentation changes alone.
+
+## Phase 3: persistence and correctness hardening
+
+Choose behavior changes explicitly and add regression tests first.
+
+- [ ] Design safe periodic/dirty-state saves or explicit saves so crashes do not
+  lose all changes since shutdown. Decide save cadence and I/O threading while
+  snapshotting mutable state on the main thread.
+- [ ] Design atomic replacement/recovery and consistency between score resets
+  and archives across the two YAML files. Preserve or migrate legacy data, and
+  ensure save failures are visible to administrators/callers.
+- [ ] Define validation rules for malformed YAML rather than relying on defaulting
+  getters. Cover invalid integer types, assignments, missing archive fields,
+  empty snapshots, and recovery without overwriting good data.
+- [ ] Decide whether integer overflow should fail, clamp, or use a wider score
+  type. Preserve negative-score use cases and provide an explicit data/API
+  migration if the type changes.
+- [ ] Review the misleading `until-disabled` mode name: document current
+  resume-across-disable behavior until any new end-on-disable mode is deliberately
+  designed. Do not silently rename the command or change saved lifetime values.
+
+## Phase 4: command and integration ergonomics
+
+- [ ] Design permission nodes/defaults for score get/add/subtract/reset and archive
+  listing; define self-vs-other access and a migration strategy before restricting
+  currently open commands.
+- [ ] Implement SK-13: explicit bucket selection for `/score-get`, with unambiguous
+  syntax, validation, help, docs, and tests. Preserve existing optional-player usage.
+- [ ] Align manifest/executor help with supported archive scopes, reporting
+  arguments, and literal reset booleans; consider tab completion as a separate
+  tested improvement.
+- [ ] Evaluate a smaller API/domain boundary only where needed for tested
+  behavior or companion integration. Retain public overload compatibility and
+  avoid unnecessary service abstractions.
+
+## Phase 5: safer developer and release tooling
+
+- [ ] Scope Bash start/stop/backup/restore process checks to the configured server
+  or a verified owned PID; never stop another project's Paper process.
+- [ ] Verify the bootstrap helpers select an actual Java 25 JDK, not merely the
+  first cached Java executable, and document supported hosts.
+- [ ] Bring PowerShell setup/configuration/process management to deliberate
+  parity with Bash or clearly retain a reduced supported surface. Prefer graceful
+  shutdown over forced termination.
+- [ ] Make deployment select/verify the intended artifact and version instead of
+  relying only on newest modification time and a stale-source warning.
+- [ ] Add lightweight local-link and JSON Schema checks for docs/metadata to CI,
+  keeping the scraper's slug-keyed contract and existing filenames.
+- [ ] Rehearse a tagged release: rebuild after tagging, verify manifest/version,
+  run manual checks, review changelog and compatibility, upload deliberately, and
+  update hosted Modrinth description separately.
+
+## Completion criteria
+
+A modernization item is done only when its behavior and failure modes have
+appropriate tests or recorded manual evidence, directly related docs are current,
+and existing data/API contracts are preserved or explicitly migrated. Use
+[TODO.md](../TODO.md) for SK feature/task status; this plan organizes the broader
+work and must not mark unchecked tests or future infrastructure as implemented.

docs/domain-score-tracking.md

@@ -1,365 +1,182 @@
-# ScoreKeeper — Score-Tracking & "High-Score Table" Domain Analysis
+# Score Keeper - Score-Tracking Domain
 
-> **Scope of this document:** the domain logic that tracks player scores and (intended) the
+This documents implemented behavior in
-> high-score table. Written for a new team member who must understand the scoring system
+[ScoreKeeperPlugin.java](../src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreKeeperPlugin.java),
-> *without opening the source*. Every claim below is traced to a file/line so it can be
+[ScoreBucket.java](../src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreBucket.java),
-> re-verified.
+and [ScoreReporting.java](../src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreReporting.java).
->
+For command syntax see [README.md](../README.md); for runtime wiring see
-> **Bottom line up front (read this first):** ScoreKeeper currently tracks **live scores
+[the integration reference](plugin-integration-and-event-wiring.md).
-> only, in memory, for the running server session**. It has **no persistence** and **no
-> high-score table**. The high-score table is *described as a planned feature* in the
-> README and is where the `/score-archive` command is *intended* to land scores, but
-> **that code path is an unimplemented stub today.** There is no sorting, no tie-breaking,
-> no entry cap, no decay, and no scoring formula/weighting anywhere in the codebase.
-> This is a greenfield/early-stage domain — the write-up documents the *real* state and
-> flags the gap, because documenting features that don't exist as if they did would mislead
-> the next engineer.
 
----
+## Buckets and live scores
 
-## 0. How to read the rest of this doc against the task's four questions
+- A bucket has an immutable ID, singular label, plural label, initial integer
+  value, and reporting policy. IDs match `[A-Za-z0-9_-]+`, are case-sensitive,
+  and must be unique. Labels must be nonblank; reporting cannot be null.
+- A fresh server has `points` (`point`/`points`, initial value `0`, reporting `none`).
+  Loading bucket data restores this bucket if it is missing.
+- `_bucketScores` maps bucket ID to `UUID -> int`. Players can have independent
+  scores in multiple buckets. Names are not used as identity keys.
+- The server default bucket and optional UUID-specific assignments determine a
+  player's active bucket. Selecting the default removes their override.
+  `switchAllPlayers` changes the default and clears **all** assignments,
+  including offline players' assignments, without deleting scores.
+- `getScore` lazily registers a missing score at the bucket's initial value.
+  Joining alone does not create an entry. Reads therefore affect who appears
+  in a later archive or run ranking.
+- Add/subtract perform ordinary Java integer arithmetic. Zero/negative amounts
+  are allowed, scores can be negative, and overflow wraps. There are no bonuses,
+  weighting, decay, or automatic gameplay scoring.
+- Reset writes the bucket initial value, not necessarily zero. Existing
+  no-bucket API methods use the active bucket; explicit-bucket overloads do not
+  change the player's assignment.
 
-The task asks for (1) the score-entry data model + persistence format, (2) how scores are
+## Reporting and bucket changes
-recorded, (3) the high-score-table algorithm, and (4) scoring formulas/weighting.
-For each question the answer is: **the mechanism that exists vs. the mechanism the project
-intends**, so readers never conflate the two.
 
-| # | Question | Short answer |
+For a changed value written through `setScore`, outside a run:
-|---|----------|--------------|
-| 1 | Score-entry data model & persistence | Live score = `UUID -> int` in a `HashMap`. **No persistence** (load/save are `TODO` stubs). |
-| 2 | How scores are recorded | **Manual, event-free:** the *administrator* runs a command. No game events, no timers. |
-| 3 | High-score-table algorithm | **Not implemented.** No sort/tie-break/cap/decay. Only an aspirational `/score-archive`. |
-| 4 | Scoring formulas / weighting | **None.** Scores are plain integer accumulators; no weighting, no decay, no bonuses. |
 
----
+| Policy | Audience |
+| --- | --- |
+| `none` (default) | Nobody |
+| `player` | Scored player |
+| `global` | All online players |
+| `admin` | Online operators or holders of `scorekeeper.admin`, plus the server log |
 
-## 1. The score-entry data model & persistence  *(task Q1)*
+Writing the same value sends no score-change report. Commands that change scores
+do not independently promise success messages; inspect `/score-get` when reporting
+is `none`. A bucket change tells an affected online player the ID and current score.
+Unit formatting uses the singular label for exactly `1`, plural otherwise.
+`/score-get` itself displays only the number, without bucket or unit labels.
 
-### 1.1 What a "score entry" actually is (current reality)
+Run reporting overrides the bucket policy. Archive resets and run start/restore
+directly update maps and do not send ordinary per-score change reports.
 
-The entire live-score domain is **one field** in the plugin's entry-point class:
+## High-score runs
 
-- **File:** `src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreKeeperPlugin.java:38`
+Each bucket can have at most one active run; different buckets may run concurrently.
-- **Declaration:** `private final HashMap<UUID, Integer> _playerScores = new HashMap<UUID, Integer>();`
+Top N must be at least one. There are three lifetime modes:
 
-That is the whole model:
+- **Target score:** finishes when any recorded score reaches/exceeds the target.
+  With reset enabled, the target must exceed the initial value. Without reset,
+  existing scores can finish a run immediately when it starts.
+- **Duration:** a positive duration, stored as an absolute epoch-millisecond
+  expiration. Time offline counts toward expiration.
+- **Until disabled:** no automatic end; stop explicitly. Plugin disable saves the
+  run rather than finishing it, so it resumes on restart.
 
-| Aspect | Value |
+Starting with reset enabled snapshots existing bucket entries and sets them to
-|--------|-------|
+the initial value. During the run, a changed score is always reported to its
-| Record shape | A single `Integer` (the score), keyed by a player's `UUID`. |
+player. If that player is in the top N **after the change**, the report is sent
-| Key type | `java.util.UUID` — the player's `UniqueId`, *not* the name string. |
+to all other online players too, once per recipient.
-| Value type | `int` (Java `Integer`), autoboxed into the map. |
-| Container | one `java.util.HashMap` on the plugin instance. |
-| Uniqueness | one entry per `UUID`. A player can have exactly one live score at a time. |
-| Default for a new player | `0` — see §3.1 ("first-time player" edge case). |
 
-There is **no `Score`/`ScoreEntry`/`PlayerStats` value class**, no timestamp, no
+Completion is checked immediately at start/load, synchronously every 20 ticks,
-name stored alongside the score (name is looked up from the live server only — see §2.3),
+and on a changed target-run score. Manual stop also completes the run.
-and no secondary index.
+The scheduled check uses wall-clock time; under server lag it need not fire at
+an exact real-time second.
 
-### 1.2 Persistence format: **none exists**
+### Ranking and results
 
-Persistence is *intended* but *not built*. Three concrete stubs prove this:
+Rankings include all recorded entries in that bucket, including offline players
+and entries read/created before the run. The order is:
 
-1. **On disable (server stop):** `ScoreKeeperPlugin.java:46-49` `onDisable()` logs
+1. Descending score.
-   *"Unable to save scores to file. This feature is not implemented yet."* — the map
+2. Case-insensitive player name, using Paper's offline-player lookup.
-   is **discarded** on shutdown; nothing is written.
+3. UUID string to break remaining ties.
-2. **On enable (server start):** `ScoreKeeperPlugin.java:59-60` `onEnable()` logs
-   *"Unable to load scores from file. This feature is not implemented yet."* — the map
-   always starts **empty** `{}` every server start.
-3. **Archive:** `ScoreKeeperPlugin.java:72-74` `archiveScore(Player)` logs
-   *"Unable to archive score for <name>."* and returns — the "save to high-score table"
-   action is a no-op.
 
-So there is **no SQLite, no JSON, no YAML, no flat file, no config.yml**. The only file on
+Unknown/blank names fall back to the UUID string. Ties have distinct consecutive
-disk that concerns scores is `plugin.yml` (the command manifest — it lists the commands but
+places, not shared ranks. Top N limits display/reporting, not stored entries.
-stores no scores). A grep of the whole tree for `sql / json / yaml / saveResource /
+Every online player receives the final top-N table and their own full-ranking
-YamlConfiguration / File / Files. / Gson / Jackson` finds **zero hits** other than the
+place/score, or an unranked result at the initial value. The final table is logged.
-TODO/log strings.
 
-**Persistence format today = "in RAM only, lost on server restart."**
+With reset enabled, completion replaces the bucket map with its pre-run snapshot.
+Players first recorded during the run are removed from that map and get the initial
+value on their next read. Personal results refer to the finished run, not restored
+scores. Without reset, earned scores remain. Run completion does **not** create a
+score archive.
 
-> Implication for a new engineer: any "who's the top player" question answered *across
+## Archives
-> restarts* is impossible today. Scores reset to the map being empty on every server boot.
 
----
+Player, single-bucket, and all-bucket archives create immutable snapshots with a
+random UUID ID, scope text, epoch-millisecond creation time, and nested
+`bucket ID -> UUID -> int` scores. A player archive uses their active bucket;
+bucket/all archives include all recorded entries, even offline players.
 
-## 2. How scores are recorded  *(task Q2)*
+Live archived entries reset to their respective initial values. Archiving fails
+before changing any scores if a selected bucket has an active run; stop the run
+first. Archives do not cap or prune entries.
 
-### 2.1 The recording model is **manual and command-driven — no events, no timers**
+[ScoreArchiveListCommand.java](../src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreArchiveListCommand.java)
+lists archives newest first. Within an archive, scores display descending with
+UUID-string tie-breaking (not the run's name tie-break). Names and unit labels are
+resolved at display time, not captured in the snapshot; missing bucket definitions
+use the generic unit `scores`.
 
-Scores move only when an administrator (or console/RCON) **types a command**. There is:
+## Persistence
 
-- **No** `implements Listener`, no `@EventHandler`, no `registerEvents(...)`, no
+Both files live in `plugins/ScoreKeeper/`. Loading occurs on enable and saving
-  `getServer().getPluginManager().registerEvents(...)`.
+on disable. There is no periodic autosave or immediate archive write despite
-- **No** scheduler: no `getScheduler()`, no `runTask`, no `Timer`.
+the command's "Saved score archive" acknowledgement; a crash can lose recent
-- **No** automatic hook to game events (e.g. a player killing a mob or reaching a goal
+state. Back up only after a successful clean shutdown.
-  awards points automatically — *nothing like that exists*).
 
-A grep for `EventListener|@EventHandler|Listener|Scheduler|runTask` across `src/` returns
+### `scores.yml` (currently writes version 3)
-**zero**.
 
-So "scoring" happens **on demand**, by a person, via one of the four mutating commands:
+```yaml
-
+version: 3
-| Command | Effect on the map | Source |
+default-bucket: points
-|---------|-------------------|--------|
+buckets:
-| `/score-add [player] <amount>` | `score += amount` | `ScoreKeeperPlugin.addScore` `:67-70` |
+  points:
-| `/score-subtract [player] <amount>` | `score -= amount` | `ScoreKeeperPlugin.subtractScore` `:88-91` |
+    singular: point
-| `/score-reset [player]` | `score = 0` | `ScoreKeeperPlugin.resetScore` `:80-82` |
+    plural: points
-| `/score-archive [player]` | **intended** to snapshot to a high-score table and reset to 0; **actually a no-op** | `ScoreKeeperPlugin.archiveScore` `:72-74` |
+    initial-value: 0
-
+    reporting: none
-`/score-get [player]` is read-only (returns the score, §2.4).
+    scores:
-
+      "00000000-0000-0000-0000-000000000001": 10
-### 2.2 The add/subtract primitives (the only real "write" path)
+player-buckets:
-
+  "00000000-0000-0000-0000-000000000002": points
-Both funnel through one private setter:
+high-score-runs:
-
+  points:
-```
+    top-n: 3
-addScore(player, n)    ->  old = getPlayerScore(player); setPlayerScore(player, old + n)   :67-70
+    reset-scores: true
-subtractScore(player,n)->  old = getPlayerScore(player); setPlayerScore(player, old - n)   :88-91
+    lifetime: duration
-setScore(player, s)    ->  setPlayerScore(player, s)                                       :84-86
+    target-score: 0
-resetScore(player)     ->  setPlayerScore(player, 0)                                        :80-82
+    expires-at: 1800000000000
-setPlayerScore(p, v)   ->  _playerScores.put(p.getUniqueId(), v)                            :108-110
+    previous-scores:
+      "00000000-0000-0000-0000-000000000001": 25
 ```
 
-Notes a new engineer must internalize:
+This illustrates field shapes, not a file to install unchanged. Overrides equal
+to the default bucket are normally omitted. Saved lifetime strings are
+`target_score`, `duration`, and `until_disabled`. The loader reads structure,
+not a version-dispatch migration table.
 
-- **Read-modify-write.** `addScore`/`subtractScore` read the current value, compute, write
+If `buckets` is absent, the loader treats top-level UUID/integer entries as legacy
-  back in two map operations. (There is no concurrency control — see §5 risks.)
+`points` scores. Invalid bucket definitions/UUIDs/runs are skipped with warnings;
-- **`int` math.** Values are Java `int`; a score can go **negative** (there is no floor at
+invalid reporting falls back to `none`, and an unknown default falls back to
-  0 — `/score-subtract 50` on a 10-score yields `-40`), and can overflow `int` only after
+`points`. Unknown bucket assignments are ignored. Bukkit YAML getters supply
-  `~2.1e9` points, which is not a practical concern.
+defaults for some missing/wrongly typed values: do not assume every malformed
-- **No validation of the direction.** The only validation is *syntactic*: the amount must
+value is rejected or logged.
-  parse as an integer (see §2.3).
 
-### 2.3 Command surface (who/what is allowed to record a score)
+### `archives.yml`
 
-Every command executor lives in `src/main/java/.../scorekeeper/commands/` and shares one
+```yaml
-shape: parse args, resolve the target player, call the `ScoreKeeperPlugin` method, return
+archives:
-`true` (consumed). Two behavioral details matter:
+  "00000000-0000-0000-0000-000000000003":
-
+    scope: bucket points
-- **Self-target default:** if a *player* runs a command and omits the name, they target
+    created-at: 1800000000000
-  *themselves*: `targetPlayer = (Player) sender`. (e.g. `ScoreGetCommand.java:44`,
+    buckets:
-  `ScoreAddCommand.java:48`, `ScoreResetCommand.java:47-49`.)
+      points:
-- **RCON/console path:** if the sender is **not** a player (console/RCON), a player name
+        scores:
-  is **required** — omitting it prints usage instead of acting
+          "00000000-0000-0000-0000-000000000001": 10
-  (`ScoreGetCommand.java:46-48`, `ScoreAddCommand.java:45-47`,
-  `ScoreResetCommand.java:44-46`).
-- **Name resolution:** `getServer().getPlayerExact(name)` — **exact, case-sensitive**
-  lookup by the *currently online* name (`ScoreGetCommand.java:50`,
-  `ScoreAddCommand.java:57`, `ScoreResetCommand.java:50`). A name that is not online
-  yields `null` → "Can't find a player with that name". Note the *map key is a UUID*, but
-  *lookup by name only works while that player is online* — you cannot change an offline
-  player's score by name today.
-- **No permission nodes anywhere.** `plugin.yml` declares no `permission:`/`permissions:`
-  and the code checks none. The README's note ("the commands aside from get are intended
-  for admins … Permissions support is coming") is **intent, not enforcement** — a vanilla
-  player can run `/score-add` today.
-
-### 2.4 Reading a score (`/score-get`)
-
-`ScoreGetCommand.java:38-84` → `ScoreKeeperPlugin.getScore(player)` → `getPlayerScore(player)`
-(`ScoreKeeperPlugin.java:76-78, 100-106`). It returns the live integer (0 for a known-but-
-unwritten player, which also *materializes* a 0 entry, see §3.1). Output formatting
-("Your score is N" vs. "PLAYER's score is N") depends only on whether the sender is the
-target or not — it carries no ranking or table.
-
----
-
-## 3. The high-score-table algorithm  *(task Q3)*
-
-### 3.1 What exists: **nothing. It is aspirational.**
-
-There is **no high-score table, no ranking structure, no sort, no tie-break rule, no max
-entry count, and no decay/rotation** anywhere in the codebase. The task's premise ("the
-high-score table") reflects the **product intent** in the README, not the **code**. Concretely:
-
-- The README (`README.md:11`) says `/score-archive` *"Saves the player's score to a
-  'High Scores' table and resets their current score to 0."*
-- The manifest (`plugin.yml:18-20`) declares `/score-archive` with that very description.
-- But the command is a stub: `ScoreArchiveCommand.java:37-39` (`onCommand` body) replies
-   *"archive command unimplemented"*, and the underlying `archiveScore`
-  (`ScoreKeeperPlugin.java:72-74`) only logs and returns — it neither writes a table nor
-  resets anything.
-
-Therefore the "algorithm" is: **no-op.** A new engineer asked to "implement the high-score
-table" is starting from zero; the design questions in §3.2 are **open**, not answered by code.
-
-### 3.2 Open design questions the table must settle (no code today decides these)
-
-Since no implementation exists, these are *decisions to be made*, recorded here so the
-implementation task doesn't reinvent the debate:
-
-- **Storage/persistence format.** The load/save TODOs (`:47`, `:59`) say "to file";
-  `plugin.yml`/Bukkit convention favors YAML (`YamlConfiguration`), but JSON/SQLite are all
-  viable. **Unchosen.** Persisting to `data/` via `getDataFolder()` is the idiomatic Bukkit
-  path.
-- **What an entry is.** Today a live score is just `{uuid -> int}`. A high-score entry
-  likely needs **player name + score + (timestamp?) + (date earned?)**. Name is *not*
-  currently stored with the score, so a durable table must capture the name at archive
-  time (a UUID-only entry can't render a leaderboard without the name being resolvable).
-- **Sorting / ordering.** Almost certainly **descending by score**.
-- **Tie-breaking.** Undefined. Candidate rules: by *score only*; by *earliest* archived
-  first (stable, time-ordered); by *name* (alphabetical); or "first to reach that score."
-- **Max entries / cap.** Undefined. A leaderboard needs a cap (e.g. top 10 / top 30);
-  today there is no cap because there is no table.
-- **Decay / rotation / time window.** None, and none described in docs — so the safe
-  default is **"scores are permanent, no decay."**
-- **Reset semantics on archive.** README promises archive *resets to 0* *and* records.
-  `ScoreArchiveCommand` must decide: does archiving also reset? Does it allow multi-entries
-  (a player appearing more than once) or one row per player? All open.
-
-### 3.3 Full lifecycle of a score: creation → (intended) display on the high-score table
-
-This is the acceptance-criterion walk-through. Each stage is marked **[REAL]** (in code now)
-or **[GAP]** (intended, not built).
-
-1. **Player joins / acts** — a score *doesn't* exist yet. First interaction with the map is
-   lazy (see stage 4a). **[REAL]**
-2. **Admin records a score** — `admin: /score-add Alice 10`. Parsed in `ScoreAddCommand`,
-   routed to `addScore`. The first time this runs for Alice, `getPlayerScore` **creates**
-   her entry at 0 and returns it; then `10` is written. **[REAL]**
-3. **Score accumulates** — later `/score-add Alice 5` → 15; `/score-subtract Alice 2` → 13;
-   `/score-reset Alice` → 0. All in the in-memory map, live only. **[REAL]**
-4. **Read** — `/score-get Alice` → "Alice's score is 13". No ranking shown. **[REAL]**
-5. **Server restart** — `onDisable` *cannot* save (stub), `onEnable` *cannot* load (stub);
-   the map is **lost**. Alice's 13 is gone; every score starts empty again. **[REAL] —
-   this is the current data-loss reality.**
-6. **Intended: archive to the high-score table** — `admin: /score-archive Alice` should
-   freeze Alice's 13 into a durable, sorted leaderboard and reset her live score to 0, so
-   it survives restarts. **[GAP]** — currently returns "archive command unimplemented".
-7. **Intended: display on the high-score table** — a command (not yet built) renders the
-   capped, sorted list. **[GAP]** — no such command, no structure to render.
-
-**Edge cases (explicitly, per the acceptance criteria):**
-
-- **First-time player / first write.** A player has no map entry until `getPlayerScore` is
-  called, which **inserts `0` on first access** (`ScoreKeeperPlugin.java:100-106`). So a
-  first `/score-add X 10` yields **10, not** `10 - 0` ambiguity, and a first `/score-subtract
-  X 3` yields **−3** (no minimum-0 clamp). A first `/score-get X` returns **0** and
-  *materializes* the entry at 0. This `get-or-create-0` behavior is the de-facto "first-time
-  player" rule. **[REAL]**
-- **Ties.** **Undefined** because no table exists. When the table is built, decide a
-  tie-break (§3.2). No code today can observe or sort ties — `HashMap` gives no order. **[GAP]**
-- **Table full.** **Undefined** because no cap exists. When a cap is introduced, decide
-  what happens to the displaced entry: drop it, or "rotate" it into overflow. No code
-  today enforces a maximum. **[GAP]**
-- **Offline / unknown name.** `getPlayerExact(name)` returns `null` for anyone not
-  currently online or any misspelling → the command prints "Can't find a player with that
-  name" and changes nothing. You **cannot** archive or reset an *offline* player by name
-  today; by-UUID writes (if a future table stores names+UUIDs) would fix that. **[REAL]**
-- **Negative / large scores.** No clamp; negatives allowed, `int` overflow only near
-  ~2.1 billion. **[REAL]**
-- **Double-spawn / relogin.** Keyed by `UUID`, **not name**, so a name change or two
-  players sharing a name can't collide on the *live* map; but a *name* is never stored,
-  so a future table that only persists the UUID can later fail to render a name.
-
----
-
-## 4. Scoring formulas & weighting  *(task Q4)*
-
-**None.** There is:
-
-- No formula, no multiplier, no combo/bonus/streak logic.
-- No weighting between action types.
-- No time-based decay or "points per game" normalization.
-
-Scores are **pure integer accumulators**: `score = Σ(adds) − Σ(subtracts)` over the session,
-resettable to 0 by `/score-reset` (intended: on `/score-archive`). The only "arithmetic" in
-the code is the `+`/`−` in `addScore`/`subtractScore` and the `0` floor written by
-`resetScore`. `int` semantics apply (wrapping overflow; no checked arithmetic). Any
-formula/weighting is a **future-design** decision, not encoded today.
-
----
-
-## 5. Data-flow diagram (text)
-
-```
-   ADMINISTRATOR / CONSOLE / RCON        (no game events, no scheduler, no auto-scoring)
-        │  types a command
-        ▼
-  ┌─────────────────────────────┐
-  │  command executors          │  commands/Score*Command.java
-  │  parse args + resolve player│  getPlayerExact(name)  ── must be ONLINE (name→UUID)
-  │  (self-target if player)    │  no permission checks
-  └──────────────┬──────────────┘
-                 │ calls
-                 ▼
-  ┌───────────────────────────────────────────────┐
-  │  ScoreKeeperPlugin (entry point; plugin.yml main)│
-  │                                                 │
-  │  addScore / subtractScore / resetScore / setScore │  read-modify-write on...
-  │  getScore (read)               archiveScore (STUB)│
-  └──────────────┬───────────────────────┬──────────┘
-                 │ read-modify-write       │ (intended: snapshot→table, reset 0)
-                 ▼                        ▼
-   live map: HashMap<UUID, int>            ╳ NOT IMPLEMENTED
-   "score entry = one int per UUID"        high-score table:
-   default 0, no clamp, in RAM only       ─ no structure, no sort,
-        │                                  ─ no persistence,
-        ├─ READ: /score-get → "N"          ─ no cap/decay
-        │
-        └─ LIFECYCLE:
-            onEnable  :  load from file  → TODO (stays {} ; lost on restart)
-            onDisable :  save to file    → TODO (map discarded at shutdown)
-
-   PERSISTENCE:  none  │  SCORE FORMULA: none  │  EVENTS/TIMERS: none  │
-   PERMISSIONS: none  │  HIGH-SCORE TABLE: aspirational stub only
 ```
 
----
+This file has no explicit format version. Empty bucket score maps may be omitted
+on serialization because only individual score entries are written.
+The two files are saved separately; there is no cross-file transaction or atomic
+replacement guarantee. Save I/O errors use the plugin logger. Never edit live
+data while the server is running: shutdown can overwrite it.
 
-## 6. Quick reference — "where to look first"
+## Validation status
 
-| I want to understand… | Go to |
+These are source-level behavior descriptions, not claims of passing automated
-|-----------------------|-------|
+tests. Pending coverage is tracked in [TODO.md](../TODO.md). Before release,
-| The entire live data model | `ScoreKeeperPlugin.java:38` (one `HashMap<UUID,Integer>`) |
+use [human-tests.md](human-tests.md), particularly ranking ties, empty buckets,
-| How a score changes | `addScore`/`subtractScore`/`resetScore`/`setScore` `:67-91` |
+restoration, malformed data, and restart/upgrade cases.
-| How a score is read | `getScore` `:76-78` → `getPlayerScore` `:100-106` (note get-or-create-0) |
-| The "high-score table" | **Doesn't exist** — see `archiveScore` stub `:72-74`; design open in §3.2 |
-| Persistence (save/load) | `onDisable` `:46-49`, `onEnable` `:59-60` — both `TODO`, not built |
-| Command behaviors | `commands/Score*Command.java` (self-target default; RCON requires a name; exact online-name lookup) |
-| What's declared/intended but not wired | `plugin.yml:18-20` (`/score-archive`), `README.md:11`, `README.md` notes |
-| Build/runtime target | `build.gradle` (paper-api 1.21.7, Java 21), `plugin.yml` (`api-version: 1.21`) |
-
----
-
-## 7. Risks a new engineer should know (correctness gaps in the *current* live domain)
-
-These are real, not future-work — flagging because the doc's job is to prevent a new
-developer from assuming the system is more mature than it is:
-
-1. **Data loss on restart.** No save/load (`:47`, `:59`). Every server boot wipes all
-   scores. Any "leaderboard across sessions" is broken by design.
-2. **No permissions.** Anyplayer can self-add points. README says this is by intent
-   ("coming after I get archive to work") but it is not enforced.
-3. **Race condition on add/subtract.** `read → compute → write` is not atomic and the
-   `HashMap` is not thread-safe; concurrent command executions could lose an update.
-   (Low likelihood today since commands are serial on one thread, but it's a latent bug for
-   any async/event-driven scoring that gets added.)
-4. **No minimum-0 / no validation of amount sign.** Subtracts produce negatives freely.
-5. **Name lookups are online-only & exact.** Can't target offline players by name;
-   case-sensitive; "Alice" ≠ "alice".
-6. **No high-score table.** The flagship advertised feature (`/score-archive` → "High
-   Scores" table) is a no-op; a new engineer must not expect ranking/persistence to work.
-
----
-
-## 8. Summary for the synthesizer (`Project.md` § "domain model & scoring logic")
-
-Distilled, code-grounded, and honest:
-
-- **Model:** one `int` per player `UUID`, held in `ScoreKeeperPlugin._playerScores`
-  (`HashMap`), default `0`.
-- **Recording:** manual, admin-driven commands; **no events/timers**; no permission guard.
-- **Persistence:** **none** — load/save are `TODO`; scores are lost on restart.
-- **High-score table:** **does not exist** — `/score-archive` is a stub; sorting/tie-break/
-  cap/decay are **undecided design items** (listed in §3.2).
-- **Formula/weighting:** **none** — plain `int` accumulation.
-- **Lifecycle:** create-on-first-access (0) → add/subtract/reset (live only) → read via
-  `/score-get` → *intended* archive+reset + table display **not built** → lost on restart.
-- **Edge cases:** first-time/first-write ⇒ 0-or-delta, no floor; ties/table-full ⇒ undefined
-  (no table yet); offline/unknown name ⇒ "can't find", unchanged.
-
-Everything below the "high-score table" line of the README is **future work**, and the
-write-up's job is to make that boundary explicit so the next team member isn't misled.

docs/human-tests.md

@@ -0,0 +1,72 @@
+# Score Keeper Human Testing
+
+Use this manual pre-release checklist on disposable Paper 26.2 and 26.3 servers
+(test both before advertising both). Score Keeper stores data in its plugin folder
+and interacts with players, command senders, and scheduled runs; a passing build
+alone does not verify these workflows. These are test scenarios, not passing results.
+See [CONTRIBUTING.md](../CONTRIBUTING.md) for setup and helper-script safety, and
+[the domain reference](domain-score-tracking.md) for expected behavior.
+
+## Test Setup
+
+- Use Java 25 and a backed-up test server. Keep the server log available throughout testing.
+- Use at least three test players for rankings: an operator, a non-operator with `scorekeeper.admin`, and an ordinary player. Use a console or RCON session for non-player sender cases.
+- Before each run, preserve `plugins/ScoreKeeper/scores.yml` and `archives.yml`, or use a fresh test server. Archive, reset, and bucket-wide commands intentionally change scores.
+- Record plugin artifact/version, Paper version/build, Java version, command sender, arguments, expected and observed messages, and score values before and after each operation. Save pass/fail notes and relevant logs outside player data committed to the repo.
+- Ensure only the intended Score Keeper jar is installed. Stop with `stop` in the server console so disable-time saves run. Do not use helper scripts that can stop other Paper processes on a shared host.
+
+## Human Checklist
+
+### Startup and score commands
+
+- Start Paper and confirm Score Keeper enables, registers every documented command, and loads existing data without errors.
+- As a player, run `/score-get`, `/score-add 10`, `/score-subtract 3`, and `/score-reset`; inspect `/score-get` after each mutation. Repeat with console/RCON, supplying a player name where required. Missing targets from non-player senders must produce usage, not self-scoring.
+- Try zero and negative amounts: they are valid signed integers (for example, adding `-3` decreases the score). Try missing/non-numeric/out-of-range amounts: these should produce usage/errors without changing scores. At integer boundaries, record the current wrapping behavior; there is no overflow guard.
+- Target offline/unknown names and supply extra arguments; verify errors/usage without unrelated changes. Confirm gameplay such as mob kills does not award points unless a companion plugin is installed.
+- Use two players to verify each player's score is independent. Change a player's Minecraft name if practical, then confirm their score remains associated with their UUID.
+- Check singular/plural labels at 1, 0, negative, and multiple values in reporting, bucket-change, and run/archive messages. `/score-get` only displays a number; it does not show bucket/units.
+
+### Buckets and reporting
+
+- Create a test bucket with a nonzero initial value and distinctive singular/plural labels, for example `/score-bucket create Bread loaf loaves 5 player`. Verify invalid/duplicate IDs, invalid initial values, and unknown reporting policies produce errors. IDs are case-sensitive; command labels each occupy one argument. Use a companion-plugin API test if checking blank/null labels that cannot be supplied naturally as command arguments.
+- Switch one player to the bucket, add and subtract points, and confirm other players remain in their own active bucket. Switch back and verify the original score is unchanged.
+- Change the server-wide default with `/score-bucket all <bucketId>`. Confirm individual assignments are cleared, online players receive the appropriate change notice, and new players use the new default.
+- For each reporting policy (`none`, `player`, `admin`, `global`), change a score and verify exactly the intended audience receives the report. Test with an operator, a `scorekeeper.admin` player, an ordinary player, and the scored player.
+- Exercise authorized/unauthorized bucket creation and switching another/all players: these require `scorekeeper.admin`. An ordinary player must still be able to view/select their own bucket. Selecting the already-active bucket should not produce a bucket-change notice.
+- Set reporting to `none` and verify a successful add/subtract/reset can be silent. Writing the same score should not send a change report under any policy. `admin` reports should also reach the server log.
+- Note that the README says score get/add/subtract/reset currently have no permission checks and can target any online player. Confirm that exposure is acceptable for the server before enabling these commands publicly.
+
+### Archives
+
+- Archive one player's active-bucket score as an admin, then inspect `/score-archive-list` and `/score-archive-list <archiveId>`. Confirm the snapshot value/bucket and the live score returns to that bucket's initial value. Ordinary players must be denied archive creation but can list/view archives.
+- Repeat for `/score-archive bucket <bucketId>` and `/score-archive all`. Confirm only the selected bucket or all buckets are archived and reset as requested.
+- Check archive IDs are listed newest first, then restart and confirm archives and their contents remain available.
+- Try an unknown archive ID or bucket ID and verify a useful failure without unrelated scores being changed.
+- Include recorded offline players and ties: entries sort descending by score then UUID, not run-style name ties. Check empty bucket archives before/after restart and record any omitted empty bucket sections.
+- Attempt player/bucket/all archiving while a selected bucket has an active run. It must fail before changing any selected scores; stop the run and retry. Archive resets should not send normal per-score reporting.
+
+### High-score runs
+
+- Start target/timed runs with at least three players. Use literal booleans, for example `/score-run start Bread 2 true duration 10s`. Top N must be at least 1. Reject invalid booleans, zero/negative/overflowing duration, uppercase time suffixes, unknown buckets, and duplicate runs.
+- A reset target must exceed the initial value. Without reset, a pre-existing score at/above the target may finish immediately; verify this rather than assuming every start remains active.
+- Change scores for players inside and outside the current top-N. Verify individual score-change messages and global reporting for current top-N players match the run behavior.
+- End runs by reaching the target, expiration, and `/score-run stop`. Also start an `until-disabled` run and stop it manually.
+- Check descending score, case-insensitive name then UUID tie-breaking, distinct consecutive places for ties, each online player's place, unranked players, and the top-N cutoff. Include recorded offline players; top N limits display, not stored entries.
+- With reset enabled, verify scores begin at the initial value and pre-run entries are restored exactly. A player first recorded during the run should return to the initial value on the next read after completion. With reset disabled, scores remain as earned. Final personal results must show run scores, not restored scores.
+- Restart cleanly while a run is active. Confirm snapshots survive, timed expiration includes time offline, overdue runs finish on enable, and `until-disabled` resumes until explicitly stopped. Confirm completion happens once and no automatic archive is created.
+- Run two buckets concurrently and confirm independent completion/restoration. Observe timed completion under lag: checks run every 20 ticks, not at an exact wall-clock second.
+
+### Persistence and upgrades
+
+- Restart after changing scores, bucket definitions, reporting policies, the default bucket, and per-player bucket assignments. Verify all values and assignments persist.
+- Test a clean data folder and copies of older files, including flat top-level UUID scores (loaded into `points`). Verify default/reporting fallbacks and invalid UUID/bucket/run warnings. For malformed types/unknown assignments, record actual getter defaults/ignored values; current loading is not comprehensive validation.
+- Check `scores.yml` version 3 and the archive fields after a clean shutdown. Both files save only on disable, not each mutation. On an explicitly authorized disposable server, compare a forced crash with the last clean save: loss of recent changes is a known limitation, not successful durability.
+- If using a companion plugin, verify `depend: [ScoreKeeper]` load order, main-thread awards into an explicit bucket, and visible failure when Score Keeper is absent/disabled. Verify no unintended active-bucket switch.
+
+## Automated Coverage
+
+There are currently no Java test sources or test dependencies in this project,
+and no integration-test source set. Gradle `test` is `NO-SOURCE` and does not
+exercise Score Keeper behavior. Scenarios remain unverified until actually
+tested; SK-08 through SK-12 in [TODO.md](../TODO.md) and
+[the modernization plan](Modernize.md) describe pending automated coverage.

docs/modrinth-description.md

@@ -0,0 +1,95 @@
+**Score Keeper**
+
+Score Keeper tracks player scores in configurable buckets. Use it for event points,
+competitions, or other server-side scoring systems, and integrate it with other
+plugins through the public API. Points are awarded by commands or companion
+plugins, not by built-in gameplay event listeners.
+
+## Installation
+
+Requires Java 25 and Paper 26.2 or 26.3. Stop your server cleanly, back up plugin
+data, and place the downloaded jar in `plugins`, removing older Score Keeper jars.
+Restart and check the server log. The installed plugin ID and data folder remain
+`ScoreKeeper`; the display name is Score Keeper.
+
+## Commands
+
+Players can omit an optional player name to target themselves. Named targets must
+be online. Console and RCON must provide a player name for score get/add/subtract/reset;
+archive also accepts `all` and `bucket` scopes. Add/subtract accept signed 32-bit
+integers, including zero and negative amounts. Bucket IDs are case-sensitive and
+allow letters, numbers, `_`, and `-`; each command-created unit label is one argument.
+
+* `/score-get [playerName]` - Displays the target player's score in their active bucket.
+* `/score-add <amount>` - Adds an amount to your score in your active bucket.
+* `/score-add <playerName> <amount>` - Adds an amount to the target player's score.
+* `/score-subtract <amount>` - Subtracts an amount from your score in your active bucket.
+* `/score-subtract <playerName> <amount>` - Subtracts an amount from the target player's score.
+* `/score-reset [playerName]` - Resets the target player's active-bucket score to that bucket's initial value.
+* `/score-archive` - Archives and resets your score in your active bucket.
+* `/score-archive <playerName>` - Archives and resets the target player's score in their active bucket.
+* `/score-archive all` - Archives and resets scores in every bucket.
+* `/score-archive bucket <bucketId>` - Archives and resets every score in one bucket.
+* `/score-archive-list` - Lists saved archive IDs, newest first.
+* `/score-archive-list <archiveId>` - Displays the saved scores in one archive.
+* `/score-bucket` - Displays your active bucket.
+* `/score-bucket <bucketId>` - Switches your active bucket.
+* `/score-bucket create <id> <singular> <plural> <initialValue> [reporting]` - Creates a bucket. Reporting can be `admin`, `global`, `player`, or `none` (default).
+* `/score-bucket <playerName> <bucketId>` - Switches a player's active bucket.
+* `/score-bucket all <bucketId>` - Changes the server's default bucket and clears individual bucket assignments.
+* `/score-run start <bucketId> <topN> <true|false> target <score>` - Starts a run that ends when a score reaches the target.
+* `/score-run start <bucketId> <topN> <true|false> duration <time>` - Starts a timed run. Use a positive number and lowercase `s`, `m`, `h`, `d`, or `w`, such as `4h`.
+* `/score-run start <bucketId> <topN> <true|false> until-disabled` - Starts a run with no automatic end, including across clean restarts.
+* `/score-run stop <bucketId>` - Ends an active run.
+
+## Permissions
+
+The `scorekeeper.admin` permission (default: operators) is required for
+`score-archive`, bucket creation, switching another player/all players, and run
+management. Viewing/selecting your own bucket is open. Score get/add/subtract/reset
+and archive-list have no permission checks; add, subtract, and reset can target
+**any online player**. Restrict access externally if this does not fit your server.
+
+## Features
+
+* Create score buckets with custom singular/plural labels, initial values, and reporting policies.
+* Reporting can notify operators/admins, everyone online, only the scored player, or nobody.
+* Start target-score, timed, or until-disabled high-score runs with configurable top-N standings and optional score resets.
+* Archive player, bucket, or all-bucket scores; archived scores reset to their bucket's initial value.
+* Persist bucket definitions, assignments, scores, active runs, and archives in the plugin's data folder.
+
+Reporting defaults to `none`, so successful score mutations can be silent; use
+`/score-get` to inspect the number. Changed scores use singular units for exactly
+1, plural otherwise. Scores may be negative and overflow is not checked.
+
+Runs require top N of at least 1 and a literal `true`/`false` reset argument.
+For example, `/score-run start points 3 true duration 4h`. Run reporting overrides
+the bucket policy: the scored player always receives changes, and current top-N
+players' changes are reported globally. Rankings include all recorded bucket
+entries, even offline players; ties use case-insensitive name then UUID and
+consecutive places. Final results include each online player's place. Reset runs
+restore previous scores, while non-reset runs keep earned scores. Timed runs use
+wall-clock time, including time offline; an existing target can finish a non-reset
+run immediately.
+
+Stop a run before archiving its bucket. Final run results are announced/logged,
+not automatically archived. Archives and live state are saved to
+`plugins/ScoreKeeper/archives.yml` and `scores.yml` **on clean shutdown/plugin
+disable**, not after every command. Crashes can lose changes since the last save.
+Do not edit data files while the server is running.
+
+## API
+
+Other plugins can create buckets with
+`createBucket(id, singular, plural, initialValue, ScoreReporting)`, use bucket-aware
+score methods, and manage runs with `startTargetScoreRun`, `startTimedScoreRun`,
+`startUntilDisabledScoreRun`, and `stopHighScoreRun`. Declare a dependency on
+`ScoreKeeper` and call the enabled plugin API on Paper's main thread.
+See the [integration reference](https://github.com/headhunter45/ScoreKeeper/blob/develop/docs/plugin-integration-and-event-wiring.md).
+
+## Compatibility
+
+Built exclusively for Paper 26.2 and 26.3 with the Paper API and Adventure APIs. Bukkit and Spigot servers are not supported.
+
+Source and development instructions are in the
+[repository](https://github.com/headhunter45/ScoreKeeper). Licensed under GNU AGPL v3 or later.

docs/modrinth.json

@@ -0,0 +1,13 @@
+{
+  "name": "Score Keeper",
+  "url": "https://modrinth.com/plugin/scorekeeper",
+  "summary": "A Paper scoring engine with configurable buckets, reporting, high-score runs, shutdown-persisted archives, commands, and a companion-plugin API.",
+  "visibility": "public",
+  "links": {
+    "issueTracker": "https://github.com/headhunter45/ScoreKeeper/issues",
+    "sourceCode": "https://github.com/headhunter45/ScoreKeeper",
+    "wikiPage": null,
+    "discordInvite": null,
+    "donationLinks": []
+  }
+}

docs/plugin-integration-and-event-wiring.md

@@ -1,166 +1,136 @@
-# ScoreKeeper — Plugin Integration & Event/Command Reference
+# Score Keeper - Plugin Integration and Event Wiring
 
-> Analysis for the ScoreKeeper codebase. Scope: how the plugin hooks into the
+New Score Keeper contributors should start with
-> Minecraft (Paper) server runtime — event listeners, command registrations,
+[CONTRIBUTING.md](../CONTRIBUTING.md), which covers architecture, setup, and validation.
-> scheduled/tick logic, and inter-plugin/API surface — with a table mapping each
+This is an optional detailed reference for runtime wiring and companion-plugin
-> trigger → handler class → effect on score data.
+authors, not a second onboarding guide. [domain-score-tracking.md](domain-score-tracking.md)
->
+describes state and [README.md](../README.md) gives full command syntax.
-> Platform: **Paper** (`io.papermc.paper:paper-api:1.21.7-R0.1-SNAPSHOT`), Java 21,
-> Gradle. Main class: `com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin`.
 
----
+## Paper lifecycle
 
-## 1. TL;DR for a new developer
+The entry point is
+[ScoreKeeperPlugin](../src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreKeeperPlugin.java),
+declared in [plugin.yml](../src/main/resources/plugin.yml) under the plugin ID
+`ScoreKeeper`. Compilation targets Paper `26.2.build.129-stable` on Java 25;
+supported server versions are Paper 26.2 and 26.3.
 
-ScoreKeeper is almost entirely **command-driven**. It registers **no Bukkit event
+| Trigger | Handler / effect |
-listeners**, declares **no `@EventHandler` methods, no `Listener` implementations,
+| --- | --- |
-and calls `getPluginManager().registerEvents(...)` nowhere**. It also schedules
+| Plugin enable | Register eight executors, initialize `points`, load scores/archives, check existing runs, schedule synchronous checks every 20 ticks |
-**no timed tasks** (no `BukkitScheduler`/`BukkitRunnable`/tick logic).
+| Scheduled check | `checkHighScoreRuns`: finish expired duration runs or runs whose target is reached |
+| Plugin disable | Serialize bucket definitions, scores, assignments, active runs/snapshots, and archives to two YAML files |
+| Minecraft join/quit/death/kill | No built-in listeners or automatic score awards |
+| Companion-plugin API call | Perform requested score/bucket/archive/run operation |
 
-The only things that touch score state are **five console/chat commands**
+There are no `Listener` implementations, `@EventHandler` methods, custom scoring
-(`score-get`, `score-add`, `score-subtract`, `score-reset`, `score-archive`).
+events, or event registrations. The scheduler manages runs, not gameplay scoring.
-Score state lives in an **in-memory `HashMap<UUID, Integer>`** and is **not
+Expired saved runs finish during enable; `until-disabled` runs persist and resume.
-persisted** — `onEnable`/`onDisable` have `TODO` stubs, so data is lost on restart.
 
-There is a **`highscore` / high-score table in the project name and the task
+## Command wiring
-prompt, but no such command or logic exists yet** — it is unimplemented.
 
----
+Each manifest command is explicitly wired in `onEnable` using `getCommand` and
+`setExecutor`. A missing declaration fails startup via `Objects.requireNonNull`.
 
-## 2. Event listeners (Bukkit/Adventure)
+Handlers are in [commands/](../src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/).
 
-**None.** The plugin listens to no server events. Confirmed by absence of any of:
+| Command | Executor | Delegation / effect | Permission |
-`@EventHandler`, `implements Listener`, `registerEvents(`, `PlayerJoinEvent`,
+| --- | --- | --- | --- |
-`PlayerQuitEvent`, `PlayerDeathEvent`, or any other event import/registration.
+| `score-get` | `ScoreGetCommand` | `getScore`, active bucket, lazy entry creation | None |
+| `score-add` | `ScoreAddCommand` | `addScore`, signed integer addition | None |
+| `score-subtract` | `ScoreSubtractCommand` | `subtractScore`, signed integer subtraction | None |
+| `score-reset` | `ScoreResetCommand` | `resetScore`, active bucket initial value | None |
+| `score-archive` | `ScoreArchiveCommand` | `archivePlayerScore`, `archiveBucketScores`, or `archiveAllScores` | `scorekeeper.admin` |
+| `score-archive-list` | `ScoreArchiveListCommand` | `getScoreArchives` or `getScoreArchive` | None |
+| `score-bucket` | `ScoreBucketCommand` | View/select own bucket, create bucket, switch another/all players | Admin for create/other/all; none for self |
+| `score-run` | `ScoreRunCommand` | Start target/timed/manual run, or stop it | `scorekeeper.admin` |
 
-| Server event | Handler | Effect on score data |
+`scorekeeper.admin` defaults to operators in the manifest. Guards are implemented
-|---|---|---|
+inside selected executors, not per-command manifest permission fields. Public API
-| PlayerJoin | *none* | none |
+calls do not enforce sender permissions; the caller must enforce its own policy.
-| PlayerQuit | *none* | none |
-| PlayerDeath | *none* | none |
-| (all other Bukkit events) | *none* | none |
-| Custom/plugin-injected events | *none* | none |
 
-**Implication:** nothing about a player's score changes as a result of gameplay
+Named player targets use Paper's `getPlayerExact` and must be online. Players
-events (joining, quitting, dying, scoring points in-game, etc.). The only way
+may omit the optional name to target themselves; non-player senders have no
-score data changes is through the commands in §3.
+self context. Console/RCON can use archive `all`/`bucket` forms without a player.
+Bucket IDs are case-sensitive even though command keywords such as `all` are not.
 
----
+Parse/validation failures are returned as Adventure usage/error messages.
+Handlers consume commands by returning `true`. Score mutation commands rely on
+bucket/run reporting instead of unconditional success messages; the default
+`none` policy can make a successful mutation silent.
 
-## 3. Command registrations & permissions
+## Companion-plugin integration
 
-Commands are declared in `src/main/resources/plugin.yml` (no `aliases`, no
+Score Keeper declares no plugin dependencies of its own. A companion that requires
-`permissions:` block, and no per-command `permission:` — so **every command is
+it should compile against the matching jar as a provided/compile-only dependency,
-available to every sender with no permission gating**). Each is wired to an
+and declare `depend: [ScoreKeeper]` in its own Bukkit-style manifest so it loads
-executor in `ScoreKeeperPlugin.onEnable()`.
+after Score Keeper. For optional integration, use `softdepend` and handle absence
+or disabled state explicitly.
 
-Argument-resolution idiom shared by every handler:
+There is no ServicesManager registration or standalone API module. Obtain the
-`boolean rcon = !(sender instanceof Player);` — an RCON caller has no self
+enabled plugin by ID and check its type, for example during the companion's enable:
-context, so the "target = self" shortcut is unavailable and a `<playerName>`
-must be supplied.
 
-`<playerName>` is resolved with `server.getPlayerExact(name)` — an **exact,
+```java
-case-sensitive lookup of currently-online players only**. Score operations
+Plugin candidate = getServer().getPluginManager().getPlugin("ScoreKeeper");
-therefore apply to **online players**, and an unknown/offline name yields a
+if (!(candidate instanceof ScoreKeeperPlugin scoreKeeper) || !candidate.isEnabled()) {
-"Can't find a player with that name" error (except where noted).
+  getLogger().severe("Score Keeper is required but is not enabled.");
+  getServer().getPluginManager().disablePlugin(this);
+  return;
+}
+```
 
-### Reference table — command → handler class → effect on score data
+Imports for this example are `org.bukkit.plugin.Plugin` and
+`com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin`. Keep the
+reference for your integration lifecycle, not as a global singleton.
+Do not shade a second copy of Score Keeper into the companion jar.
 
-| Trigger (command) | Usage | Handler class | Delegates to | Effect on score data |
+### Public operations
-|---|---|---|---|---|
-| `score-get` | `/score-get [player]` | `ScoreGetCommand` | `ScoreKeeperPlugin.getScore(Player)` → `getPlayerScore` | **Read only.** Returns the player's current score. Side effect: lazily registers the player at `0` if unseen. No persistent change. |
-| `score-add` | `/score-add [player] <amount>` | `ScoreAddCommand` | `ScoreKeeperPlugin.addScore(Player,int)` | `score = old + amount` (integer `amount` in `[1..]`). |
-| `score-subtract` | `/score-subtract [player] <amount>` | `ScoreSubtractCommand` | `ScoreKeeperPlugin.subtractScore(Player,int)` | `score = old - amount` (can go negative). |
-| `score-reset` | `/score-reset [player]` | `ScoreResetCommand` | `ScoreKeeperPlugin.resetScore(Player)` | `score = 0` (writes 0; key created if absent). |
-| `score-archive` | `/score-archive [player]` | `ScoreArchiveCommand` | *nothing* | **No state change.** Handler prints `"archive command unimplemented"`. It does **not** call `ScoreKeeperPlugin.archiveScore(...)` — see §5. |
 
-### Command behaviour details
+| Area | Methods |
+| --- | --- |
+| Bucket definition | `createBucket(id, singular, plural, initialValue[, ScoreReporting])`, `getBucket(id)`, `getBuckets()` |
+| Active selection | `getPlayerBucket(Player)`, `switchPlayerBucket(Player, id)`, `switchAllPlayers(id)` |
+| Score CRUD | `getScore(Player[, id])`, `setScore(Player[, id], score)`, `addScore(Player[, id], amount)`, `subtractScore(Player[, id], amount)`, `resetScore(Player[, id])` |
+| Archives | `archivePlayerScore(Player)`, `archiveBucketScores(id)`, `archiveAllScores()`, `getScoreArchives()`, `getScoreArchive(archiveId)` |
+| Compatibility wrapper | `archiveScore(Player)` delegates to player archive creation but discards the returned ID |
+| Runs | `startTargetScoreRun(id, topN, resetScores, targetScore)`, `startTimedScoreRun(id, topN, resetScores, Duration)`, `startUntilDisabledScoreRun(id, topN, resetScores)`, `stopHighScoreRun(id)`, `hasActiveHighScoreRun(id)` |
+| Messaging/logging | `sendMessage(CommandSender, Component)`, `logInfo`, `logWarning`, `logError` |
 
-- **Sender vs. target.** Single-arg form means "operate on the invoking player"
+The bracket notation above describes overloads, not literal Java syntax.
-  (`split.length == 1` → `targetPlayer = sender`). Two-arg form means
+`getBucket` and `getScoreArchive` return null when unknown; mutating/score methods
-  `<playerName> <amount>` (add/subtract) or `<playerName>` (get/reset). For an
+validate bucket existence and throw `IllegalArgumentException` for invalid
-  RCON sender, the single-arg form is treated as missing a target and prints
+operations. Do not swallow errors or report success after a failure.
-  usage instead.
+Bucket maps and archive snapshots exposed by getters are immutable copies/views.
-- **Amount parsing.** `score-add`/`score-subtract` require an integer
-  `amount`; a non-integer prints `"amount must be an integer"`.
-- **Error/usage messaging.** `echoError` (red) and `echoUsage` (colour-coded)
-  differ between player and RCON call sites (`/score-add` vs `score-add`).
-  All handlers `return true` (command handled).
-- **Permissions.** None declared → no operator/permission requirement; any
-  player or RCON can run them.
 
----
+Example explicit-bucket award, with imports for `ScoreReporting` and `Player`:
 
-## 4. Scheduled tasks / tick-based logic
+```java
+if (scoreKeeper.getBucket("event") == null) {
+  scoreKeeper.createBucket("event", "point", "points", 0, ScoreReporting.PLAYER);
+}
+scoreKeeper.addScore(player, "event", 10);
+```
 
-**None.** Confirmed by absence of `getScheduler()`, `runTask`,
+Only create a shared bucket if its existing definition meets your integration's
-`BukkitRunnable`, `BukkitTask`, `scheduleSync*`, or any periodic/repeating
+requirements; duplicate creation throws. Explicit-bucket scoring does not switch
-logic. ScoreKeeper runs no background or tick-driven work.
+the player's active bucket.
 
----
+### Threading and ownership
 
-## 5. Inter-plugin dependencies & API exposure
+All calls touching state, players, or reporting must execute on Paper's main
+server thread. The plugin's `LinkedHashMap` state and read-modify-write operations
+are not synchronized. Marshal asynchronous event/work results to a synchronous
+Paper task before calling this API. Score Keeper does not provide Folia/region
+scheduler support.
 
-- **Declared dependencies:** plugin.yml has no `depend`, `softdepend`, `load`,
+Do not mutate private maps or write the YAML files from another plugin.
-  or `load-before` → **no declared inter-plugin coupling**.
+Use the API so reporting, validation, target completion, and snapshots remain
-- **Build dependency:** the only third-party dependency is
+consistent. API calls change in-memory state; durability is deferred until
-  `io.papermc.paper:paper-api` (marked `compileOnly`, and explicitly ignored as a
+Score Keeper disables successfully.
-  snapshot by the release plugin). No other plugin/API is referenced.
-- **Public API surface.** `ScoreKeeperPlugin` is a plain `JavaPlugin` exposing
-  `public` methods that other plugins *could* call if they hold a reference:
-  - `void addScore(Player, int)`
-  - `void subtractScore(Player, int)`
-  - `int getScore(Player)`
-  - `void setScore(Player, int)` — **public but used by no command** (internal
-    write path; the only writer not reachable via a command).
-  - `void resetScore(Player)`
-  - `void archiveScore(Player)` — **public but called by nothing**; it only logs
-    a warning. The `/score-archive` command does **not** invoke it.
-  - `void sendMessage(CommandSender, Component)`, `logInfo/logWarning/logError`
-- **No formal service registration.** There is no `registerService`/`asService`
-  (ServiceLoader), no dedicated API artifact, and no `api:` block in plugin.yml.
-  Exposure is by **public method surface only** — informal and not discoverable
-  by other plugins.
-- **Persistence (unimplemented).** `onEnable` logs a warning that load-from-file
-  is unimplemented; `onDisable` logs that save-to-file is unimplemented. The
-  `HashMap<UUID,Integer>` is the sole state store and is **forgotten on restart**.
 
----
+## Verification
 
-## 6. Lifecycle
+There is currently no automated plugin harness or real-server test task.
-
+Validate load ordering, command dispatch, messages, run scheduler behavior, and
-| Hook | What it does |
+clean-restart persistence on disposable Paper servers using
-|---|---|
+[human-tests.md](human-tests.md). Do not assume a successful compilation verifies
-| `onEnable()` | Wires the five `score-*` command executors; logs the "load not implemented" warning and an enable log line. |
+companion load order or runtime API compatibility.
-| `onDisable()` | Logs the "save not implemented" warning. **All in-memory scores are lost on shutdown.** |
-
----
-
-## 7. State model (quick reference)
-
-- **Store:** `private HashMap<UUID,Integer> _playerScores` on `ScoreKeeperPlugin`
-  (one map field for the whole plugin).
-- **Keying:** by `Player.getUniqueId()` (UUID), so scores are per-player and
-  survive name changes *within a single server run*; lost on restart.
-- **Lazy init:** any read (including `get`/`score-get`) auto-creates the key at `0`.
-- **Writers:** `addScore`, `subtractScore`, `resetScore`, `setScore`, all funneled
-  through `setPlayerScore(player, value)`.
-- **Concurrency:** plain `HashMap`; safe today only because command dispatch
-  runs on the server's main thread. Not thread-safe for off-thread use.
-
----
-
-## 8. "Which server trigger causes which state change" — summary
-
-| Trigger | State change |
-|---|---|
-| `/score-add [player] <amount>` | `_playerScores[uuid] += amount` |
-| `/score-subtract [player] <amount>` | `_playerScores[uuid] -= amount` |
-| `/score-reset [player]` | `_playerScores[uuid] = 0` |
-| `/score-get [player]` | none (reads; lazily registers at 0) |
-| `/score-archive [player]` | none (not implemented) |
-| Any Minecraft/Bukkit event (join/quit/death/etc.) | **none — no listeners exist** |
-| Server tick / scheduled task | **none — no scheduler exists** |
-| Server enable | no data change (registration + log only) |
-| Server disable | in-memory scores discarded (no persistence) |
-| `addScore`/`subtractScore`/`setScore`/`archiveScore` via the public API | same table where called; only reachable by code holding a plugin reference, not by in-game events or commands (except add/subtract/reset which do have commands) |

docs/project-description.json

@@ -0,0 +1,48 @@
+{
+  "score-keeper": {
+    "id": "score-keeper",
+    "title": "Score Keeper",
+    "description": "A Paper 26.2/26.3 scoring engine with named buckets, custom reporting, shutdown-persisted scores and archives, high-score runs, player commands, and a main-thread API for companion plugins.",
+    "docId": "Score-Keeper",
+    "headerImage": null,
+    "platforms": [
+      {
+        "name": "Paper",
+        "info": "Paper 26.2 and 26.3; Java 25 required. Bukkit and Spigot servers are not supported.",
+        "links": [
+          {
+            "label": "Download on Modrinth",
+            "url": "https://modrinth.com/plugin/scorekeeper"
+          }
+        ]
+      }
+    ],
+    "image": {
+      "url": "/projects/score-keeper/logo.png",
+      "alt": "Score Keeper Minecraft plugin logo",
+      "width": 1024,
+      "height": 1024,
+      "backgroundClassName": "bg-surface"
+    },
+    "url": "/projects/score-keeper",
+    "tags": ["Open-Source", "Game", "Minecraft", "Java"],
+    "source": {
+      "type": "github",
+      "url": "https://github.com/headhunter45/ScoreKeeper"
+    },
+    "feedback": {
+      "type": "github-issues",
+      "url": "https://github.com/headhunter45/ScoreKeeper/issues"
+    },
+    "features": [
+      "Named score buckets with custom units, initial values, and reporting policies",
+      "UUID-keyed integer scores with default and per-player bucket selection",
+      "Player, bucket, and all-bucket archives with score resets",
+      "Target-score, timed, and manually stopped high-score runs with top-N results",
+      "Optional pre-run score snapshots and restoration",
+      "YAML persistence on clean shutdown",
+      "Player commands and a main-thread API for companion plugins"
+    ],
+    "technology": ["Java 25", "Paper API", "Adventure", "Gradle", "YAML"]
+  }
+}

docs/project-description.md

@@ -0,0 +1,31 @@
+# Score Keeper
+
+Score Keeper is a reusable scoring engine for Paper 26.2 and 26.3. It gives events,
+competitions, and companion plugins a shared language for points: named buckets
+can have custom singular/plural labels, initial values, reporting policies,
+archives, and high-score runs.
+
+The plugin is both a player-facing command system and an extension point.
+Administrators can start target-based, timed, or manually stopped score runs,
+while other plugins can create buckets, award points, archive results, and build
+richer game loops through the public API. Gameplay does not automatically award
+scores. Scores, assignments, active runs, and archives persist across clean server
+restarts through shutdown saves. Bukkit and Spigot servers are not supported.
+
+Run standings include deterministic tie-breaking, top-N announcements, personal
+places, and optional restoration of pre-run scores. Separate archives snapshot
+player, bucket, or all-bucket scores and reset the live values.
+
+## Engineering Notes
+
+- Built with Gradle and Java 25 for modern Paper.
+- Uses UUID-based player identity and YAML-backed persistence.
+- Exposes a main-thread Java API for companion plugins; no service registration or built-in gameplay listeners.
+- Has no automated Java test coverage yet; manual pre-release scenarios are documented, with test infrastructure planned.
+- Uses the display name "Score Keeper" while retaining `ScoreKeeper` as the repository and plugin identifier.
+- Licensed under GNU AGPL v3 or later.
+
+Score get/add/subtract/reset commands currently have no permission checks and can
+target online players; archive, bucket administration, and run management use
+`scorekeeper.admin`. Saves happen on disable, not every mutation, so crashes may
+lose recent state.

docs/projects.schema.json

@@ -0,0 +1,114 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Projects",
+  "description": "Project metadata keyed by the project route slug.",
+  "type": "object",
+  "patternProperties": {
+    "^[a-z0-9]+(?:-[a-z0-9]+)*$": { "$ref": "#/definitions/project" }
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "image": {
+      "type": "object",
+      "required": ["url", "width", "height"],
+      "properties": {
+        "url": {
+          "type": "string",
+          "description": "Public asset path or remote image URL. A blank header image URL falls back to image.",
+          "pattern": "^(\\s*|/[^/].*|https?://.+)$"
+        },
+        "alt": { "type": "string" },
+        "prompt": { "type": "string" },
+        "name": { "type": "string" },
+        "width": { "type": "integer", "minimum": 1 },
+        "height": { "type": "integer", "minimum": 1 },
+        "backgroundClassName": { "type": "string" }
+      },
+      "additionalProperties": false
+    },
+    "projectLink": {
+      "type": "object",
+      "required": ["url"],
+      "properties": {
+        "type": { "type": "string" },
+        "url": { "type": "string", "pattern": "^(\\s*|https?://.+)$" }
+      },
+      "additionalProperties": false
+    },
+    "platform": {
+      "type": "object",
+      "required": ["name"],
+      "properties": {
+        "name": { "type": "string", "pattern": "\\S" },
+        "info": { "type": "string" },
+        "links": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["label", "url"],
+            "properties": {
+              "label": { "type": "string", "pattern": "\\S" },
+              "url": {
+                "type": "string",
+                "format": "uri",
+                "pattern": "^https?://.+"
+              }
+            },
+            "additionalProperties": false
+          }
+        }
+      },
+      "additionalProperties": false
+    },
+    "project": {
+      "type": "object",
+      "required": ["id", "title", "description", "tags"],
+      "properties": {
+        "id": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+        "title": { "type": "string", "pattern": "\\S" },
+        "description": { "type": "string", "pattern": "\\S" },
+        "docId": { "type": "string", "minLength": 1 },
+        "image": { "$ref": "#/definitions/image" },
+        "headerImage": {
+          "description": "Optional detail-page logo override. Omit, set to null, or use a blank URL to fall back to image. Listing cards continue to use image.",
+          "anyOf": [{ "$ref": "#/definitions/image" }, { "type": "null" }]
+        },
+        "status": { "type": "string" },
+        "platforms": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/platform" }
+        },
+        "url": {
+          "type": "string",
+          "pattern": "^/projects/[a-z0-9]+(?:-[a-z0-9]+)*$"
+        },
+        "tags": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "uniqueItems": true
+        },
+        "source": {
+          "allOf": [
+            { "$ref": "#/definitions/projectLink" },
+            { "required": ["type"] }
+          ]
+        },
+        "feedback": { "$ref": "#/definitions/projectLink" },
+        "repository": {
+          "type": "string",
+          "format": "uri",
+          "pattern": "^https?://.+"
+        },
+        "features": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 }
+        },
+        "technology": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 }
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+}

gradle.properties

@@ -1,5 +1,5 @@
-version=0.2.2-SNAPSHOT
+org.gradle.configuration-cache=true
+org.gradle.daemon=true
 org.gradle.java.installations.auto-download=true
 org.gradle.java.installations.auto-detect=false
 org.gradle.java.installations.fromEnv=JAVA_HOME
-

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreBucket.java

@@ -0,0 +1,71 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper;
+
+public final class ScoreBucket {
+  private final String _id;
+  private final String _singular;
+  private final String _plural;
+  private final int _initialValue;
+  private final ScoreReporting _reporting;
+
+  public ScoreBucket(String id, String singular, String plural, int initialValue) {
+    this(id, singular, plural, initialValue, ScoreReporting.NONE);
+  }
+
+  public ScoreBucket(
+      String id, String singular, String plural, int initialValue, ScoreReporting reporting) {
+    if (id == null || !id.matches("[A-Za-z0-9_-]+")) {
+      throw new IllegalArgumentException("Bucket ID must contain only letters, numbers, _ or -");
+    }
+    if (singular == null || singular.isBlank()) {
+      throw new IllegalArgumentException("Bucket singular label cannot be blank");
+    }
+    if (plural == null || plural.isBlank()) {
+      throw new IllegalArgumentException("Bucket plural label cannot be blank");
+    }
+    if (reporting == null) {
+      throw new IllegalArgumentException("Bucket reporting policy cannot be null");
+    }
+    _id = id;
+    _singular = singular;
+    _plural = plural;
+    _initialValue = initialValue;
+    _reporting = reporting;
+  }
+
+  public String getId() {
+    return _id;
+  }
+
+  public String getSingular() {
+    return _singular;
+  }
+
+  public String getPlural() {
+    return _plural;
+  }
+
+  public int getInitialValue() {
+    return _initialValue;
+  }
+
+  public ScoreReporting getReporting() {
+    return _reporting;
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreKeeperPlugin.java

@@ -1,63 +1,123 @@
 /*
-This file is part of ScoreKeeper.
+This file is part of Score Keeper.
 
-ScoreKeeper is free software: you can redistribute it and/or modify
+Score Keeper is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
-ScoreKeeper is distributed in the hope that it will be useful,
+Score Keeper is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 */
 
 package com.majinnaibu.minecraft.plugins.scorekeeper;
 
-import java.util.HashMap;
+import java.io.File;
+import java.io.IOException;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
 import java.util.UUID;
 import java.util.logging.Level;
 
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreAddCommand;
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreArchiveCommand;
+import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreArchiveListCommand;
+import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreBucketCommand;
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreGetCommand;
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreResetCommand;
+import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreRunCommand;
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreSubtractCommand;
 
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 
 import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.java.JavaPlugin;
 
 public class ScoreKeeperPlugin extends JavaPlugin {
-  private final HashMap<UUID, Integer> _playerScores = new HashMap<UUID, Integer>();
+  private final Map<String, ScoreBucket> _buckets = new LinkedHashMap<>();
-  public final String _logPrefix = "[ScoreKeeper] ";
+  private final Map<String, Map<UUID, Integer>> _bucketScores = new LinkedHashMap<>();
+  private final Map<UUID, String> _playerBuckets = new LinkedHashMap<>();
+  private final Map<String, HighScoreRun> _highScoreRuns = new LinkedHashMap<>();
+  private final Map<String, ScoreArchive> _scoreArchives = new LinkedHashMap<>();
+  private String _defaultBucketId = "points";
+  public final String _logPrefix = "[Score Keeper] ";
   public final Component _messagePrefix =
       Component.text("[")
-          .append(Component.text("ScoreKeeper").color(NamedTextColor.AQUA))
+          .append(Component.text("Score Keeper").color(NamedTextColor.AQUA))
           .append(Component.text("] ").color(NamedTextColor.WHITE));
 
   @Override
   public void onDisable() {
-    // TODO: save score data to file
+    YamlConfiguration scores = new YamlConfiguration();
-    logWarning("Unable to save scores to file. This feature is not implemented yet.");
+    scores.set("version", 3);
+    scores.set("default-bucket", _defaultBucketId);
+    for (ScoreBucket bucket : _buckets.values()) {
+      String path = "buckets." + bucket.getId();
+      scores.set(path + ".singular", bucket.getSingular());
+      scores.set(path + ".plural", bucket.getPlural());
+      scores.set(path + ".initial-value", bucket.getInitialValue());
+      scores.set(path + ".reporting", bucket.getReporting().name().toLowerCase());
+      for (var entry : _bucketScores.get(bucket.getId()).entrySet()) {
+        scores.set(path + ".scores." + entry.getKey(), entry.getValue());
+      }
+    }
+    for (var entry : _playerBuckets.entrySet()) {
+      scores.set("player-buckets." + entry.getKey(), entry.getValue());
+    }
+    for (HighScoreRun run : _highScoreRuns.values()) {
+      String path = "high-score-runs." + run.bucketId;
+      scores.set(path + ".top-n", run.topN);
+      scores.set(path + ".reset-scores", run.resetScores);
+      scores.set(path + ".lifetime", run.lifetime.name().toLowerCase(Locale.ROOT));
+      scores.set(path + ".target-score", run.targetScore);
+      scores.set(path + ".expires-at", run.expiresAtMillis);
+      for (var entry : run.previousScores.entrySet()) {
+        scores.set(path + ".previous-scores." + entry.getKey(), entry.getValue());
+      }
+    }
+    try {
+      scores.save(new File(getDataFolder(), "scores.yml"));
+    } catch (IOException ex) {
+      logError(ex);
+    }
+    saveArchives();
   }
 
   @Override
   public void onEnable() {
-    getCommand("score-get").setExecutor(new ScoreGetCommand(this));
+    Objects.requireNonNull(getCommand("score-get")).setExecutor(new ScoreGetCommand(this));
-    getCommand("score-add").setExecutor(new ScoreAddCommand(this));
+    Objects.requireNonNull(getCommand("score-add")).setExecutor(new ScoreAddCommand(this));
-    getCommand("score-subtract").setExecutor(new ScoreSubtractCommand(this));
+    Objects.requireNonNull(getCommand("score-subtract"))
-    getCommand("score-reset").setExecutor(new ScoreResetCommand(this));
+        .setExecutor(new ScoreSubtractCommand(this));
-    getCommand("score-archive").setExecutor(new ScoreArchiveCommand(this));
+    Objects.requireNonNull(getCommand("score-reset")).setExecutor(new ScoreResetCommand(this));
+    Objects.requireNonNull(getCommand("score-archive")).setExecutor(new ScoreArchiveCommand(this));
+    Objects.requireNonNull(getCommand("score-archive-list"))
+        .setExecutor(new ScoreArchiveListCommand(this));
+    Objects.requireNonNull(getCommand("score-bucket")).setExecutor(new ScoreBucketCommand(this));
+    Objects.requireNonNull(getCommand("score-run")).setExecutor(new ScoreRunCommand(this));
 
-    // TODO: load score data from file
+    _buckets.put("points", new ScoreBucket("points", "point", "points", 0));
-    logWarning("Unable to load scores from file. This feature is not " + "implemented yet.");
+    _bucketScores.put("points", new LinkedHashMap<>());
+    loadScores();
+    loadArchives();
+    checkHighScoreRuns();
+    getServer().getScheduler().runTaskTimer(this, this::checkHighScoreRuns, 20L, 20L);
 
     logInfo(
         getPluginMeta().getName() + " version " + getPluginMeta().getVersion() + " is enabled.");
@@ -65,48 +125,673 @@ public class ScoreKeeperPlugin extends JavaPlugin {
 
   // region Commands
   public void addScore(Player player, int amount) {
-    int oldScore = getPlayerScore(player);
+    addScore(player, getPlayerBucket(player), amount);
-    setPlayerScore(player, oldScore + amount);
+  }
+
+  public void addScore(Player player, String bucketId, int amount) {
+    setScore(player, bucketId, getScore(player, bucketId) + amount);
   }
 
   public void archiveScore(Player player) {
-    logWarning("Unable to archive score for " + player.getName() + ".");
+    archivePlayerScore(player);
+  }
+
+  public String archivePlayerScore(Player player) {
+    String bucketId = getPlayerBucket(player);
+    return createScoreArchive(
+        "player " + player.getName() + " in " + bucketId, List.of(bucketId), player);
+  }
+
+  public String archiveBucketScores(String bucketId) {
+    requireBucket(bucketId);
+    return createScoreArchive("bucket " + bucketId, List.of(bucketId), null);
+  }
+
+  public String archiveAllScores() {
+    return createScoreArchive("all buckets", new ArrayList<>(_buckets.keySet()), null);
+  }
+
+  public List<ScoreArchive> getScoreArchives() {
+    return List.copyOf(_scoreArchives.values());
+  }
+
+  public ScoreArchive getScoreArchive(String archiveId) {
+    return _scoreArchives.get(archiveId);
   }
 
   public int getScore(Player player) {
-    return getPlayerScore(player);
+    return getScore(player, getPlayerBucket(player));
+  }
+
+  public int getScore(Player player, String bucketId) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    return _bucketScores
+        .get(bucketId)
+        .computeIfAbsent(player.getUniqueId(), uuid -> bucket.getInitialValue());
   }
 
   public void resetScore(Player player) {
-    setPlayerScore(player, 0);
+    resetScore(player, getPlayerBucket(player));
+  }
+
+  public void resetScore(Player player, String bucketId) {
+    setScore(player, bucketId, requireBucket(bucketId).getInitialValue());
   }
 
   public void setScore(Player player, int score) {
-    setPlayerScore(player, score);
+    setScore(player, getPlayerBucket(player), score);
+  }
+
+  public void setScore(Player player, String bucketId, int score) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    int oldScore = getScore(player, bucketId);
+    _bucketScores.get(bucketId).put(player.getUniqueId(), score);
+    if (oldScore != score) {
+      HighScoreRun run = _highScoreRuns.get(bucketId);
+      if (run == null) {
+        reportScoreChange(player, bucket, score);
+      } else {
+        reportHighScoreRunChange(player, bucket, run, score);
+        if (run.lifetime == HighScoreLifetime.TARGET_SCORE && score >= run.targetScore) {
+          finishHighScoreRun(bucketId);
+        }
+      }
+    }
   }
 
   public void subtractScore(Player player, int amount) {
-    int oldScore = getPlayerScore(player);
+    subtractScore(player, getPlayerBucket(player), amount);
-    setPlayerScore(player, oldScore - amount);
+  }
+
+  public void subtractScore(Player player, String bucketId, int amount) {
+    setScore(player, bucketId, getScore(player, bucketId) - amount);
+  }
+
+  public ScoreBucket createBucket(String id, String singular, String plural, int initialValue) {
+    return createBucket(id, singular, plural, initialValue, ScoreReporting.NONE);
+  }
+
+  public ScoreBucket createBucket(
+      String id, String singular, String plural, int initialValue, ScoreReporting reporting) {
+    ScoreBucket bucket = new ScoreBucket(id, singular, plural, initialValue, reporting);
+    if (_buckets.containsKey(id)) {
+      throw new IllegalArgumentException("A score bucket with ID " + id + " already exists");
+    }
+    _buckets.put(id, bucket);
+    _bucketScores.put(id, new LinkedHashMap<>());
+    return bucket;
+  }
+
+  public ScoreBucket getBucket(String bucketId) {
+    return _buckets.get(bucketId);
+  }
+
+  public Map<String, ScoreBucket> getBuckets() {
+    return Map.copyOf(_buckets);
+  }
+
+  public String getPlayerBucket(Player player) {
+    return _playerBuckets.getOrDefault(player.getUniqueId(), _defaultBucketId);
+  }
+
+  public void switchPlayerBucket(Player player, String bucketId) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    UUID playerId = player.getUniqueId();
+    String previousBucketId = getPlayerBucket(player);
+    if (bucketId.equals(_defaultBucketId)) {
+      _playerBuckets.remove(playerId);
+    } else {
+      _playerBuckets.put(playerId, bucketId);
+    }
+    if (!previousBucketId.equals(bucketId)) {
+      sendBucketChangeMessage(player, bucket);
+    }
+  }
+
+  public void switchAllPlayers(String bucketId) {
+    requireBucket(bucketId);
+    Map<UUID, String> previousBuckets = new LinkedHashMap<>();
+    for (Player player : getServer().getOnlinePlayers()) {
+      previousBuckets.put(Objects.requireNonNull(player).getUniqueId(), getPlayerBucket(player));
+    }
+    _defaultBucketId = bucketId;
+    _playerBuckets.clear();
+    ScoreBucket bucket = requireBucket(bucketId);
+    for (Player player : getServer().getOnlinePlayers()) {
+      if (!bucketId.equals(previousBuckets.get(Objects.requireNonNull(player).getUniqueId()))) {
+        sendBucketChangeMessage(player, bucket);
+      }
+    }
+  }
+
+  public void startTargetScoreRun(String bucketId, int topN, boolean resetScores, int targetScore) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    if (resetScores && targetScore <= bucket.getInitialValue()) {
+      throw new IllegalArgumentException("Target score must exceed the bucket's initial value");
+    }
+    startHighScoreRun(bucketId, topN, resetScores, HighScoreLifetime.TARGET_SCORE, targetScore, 0L);
+  }
+
+  public void startTimedScoreRun(
+      String bucketId, int topN, boolean resetScores, Duration duration) {
+    if (duration == null || duration.isNegative() || duration.isZero()) {
+      throw new IllegalArgumentException("Run duration must be positive");
+    }
+    long durationMillis;
+    long expiresAtMillis;
+    try {
+      durationMillis = duration.toMillis();
+      expiresAtMillis = Math.addExact(System.currentTimeMillis(), durationMillis);
+    } catch (ArithmeticException ex) {
+      throw new IllegalArgumentException("Run duration is too large", ex);
+    }
+    if (durationMillis <= 0) {
+      throw new IllegalArgumentException("Run duration must be at least one millisecond");
+    }
+    startHighScoreRun(bucketId, topN, resetScores, HighScoreLifetime.DURATION, 0, expiresAtMillis);
+  }
+
+  public void startUntilDisabledScoreRun(String bucketId, int topN, boolean resetScores) {
+    startHighScoreRun(bucketId, topN, resetScores, HighScoreLifetime.UNTIL_DISABLED, 0, 0L);
+  }
+
+  public void stopHighScoreRun(String bucketId) {
+    if (!_highScoreRuns.containsKey(bucketId)) {
+      throw new IllegalArgumentException("No high-score run is active for bucket " + bucketId);
+    }
+    finishHighScoreRun(bucketId);
+  }
+
+  public boolean hasActiveHighScoreRun(String bucketId) {
+    return _highScoreRuns.containsKey(bucketId);
   }
 
   // endregion
 
   // region Utiilty Methods
   public void sendMessage(CommandSender reciever, Component message) {
-    reciever.sendMessage(_messagePrefix.append(message));
+    reciever.sendMessage(_messagePrefix.append(Objects.requireNonNull(message)));
   }
 
-  private int getPlayerScore(Player player) {
+  private ScoreBucket requireBucket(String bucketId) {
-    UUID uuid = player.getUniqueId();
+    ScoreBucket bucket = _buckets.get(bucketId);
-    if (!_playerScores.containsKey(uuid)) {
+    if (bucket == null) {
-      _playerScores.put(uuid, 0);
+      throw new IllegalArgumentException("Unknown score bucket: " + bucketId);
     }
-    return _playerScores.get(uuid);
+    return bucket;
   }
 
-  private void setPlayerScore(Player player, int score) {
+  private void sendBucketChangeMessage(Player player, ScoreBucket bucket) {
-    _playerScores.put(player.getUniqueId(), score);
+    int score = getScore(player, bucket.getId());
+    String unit = score == 1 ? bucket.getSingular() : bucket.getPlural();
+    sendMessage(
+        player,
+        Component.text(
+            "You are now tracking " + bucket.getId() + ". You have " + score + " " + unit + "."));
+  }
+
+  private String createScoreArchive(String scope, List<String> bucketIds, Player player) {
+    for (String bucketId : bucketIds) {
+      if (_highScoreRuns.containsKey(bucketId)) {
+        throw new IllegalArgumentException(
+            "Stop the active high-score run for " + bucketId + " before archiving it");
+      }
+    }
+
+    Map<String, Map<UUID, Integer>> archivedScores = new LinkedHashMap<>();
+    UUID playerId = player == null ? null : player.getUniqueId();
+    for (String bucketId : bucketIds) {
+      ScoreBucket bucket = requireBucket(bucketId);
+      Map<UUID, Integer> bucketScores = _bucketScores.get(bucketId);
+      if (playerId == null) {
+        archivedScores.put(bucketId, new LinkedHashMap<>(bucketScores));
+        bucketScores.replaceAll((uuid, score) -> bucket.getInitialValue());
+      } else {
+        int score = getScore(player, bucketId);
+        archivedScores.put(bucketId, Map.of(playerId, score));
+        bucketScores.put(playerId, bucket.getInitialValue());
+      }
+    }
+
+    String archiveId = UUID.randomUUID().toString();
+    _scoreArchives.put(
+        archiveId, new ScoreArchive(archiveId, scope, System.currentTimeMillis(), archivedScores));
+    return archiveId;
+  }
+
+  private void startHighScoreRun(
+      String bucketId,
+      int topN,
+      boolean resetScores,
+      HighScoreLifetime lifetime,
+      int targetScore,
+      long expiresAtMillis) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    if (topN < 1) {
+      throw new IllegalArgumentException("Top N must be at least 1");
+    }
+    if (_highScoreRuns.containsKey(bucketId)) {
+      throw new IllegalArgumentException("A high-score run is already active for " + bucketId);
+    }
+
+    Map<UUID, Integer> bucketScores = _bucketScores.get(bucketId);
+    Map<UUID, Integer> previousScores = resetScores ? new LinkedHashMap<>(bucketScores) : Map.of();
+    if (resetScores) {
+      bucketScores.replaceAll((playerId, score) -> bucket.getInitialValue());
+    }
+    _highScoreRuns.put(
+        bucketId,
+        new HighScoreRun(
+            bucketId, topN, resetScores, lifetime, targetScore, expiresAtMillis, previousScores));
+    checkHighScoreRuns();
+  }
+
+  private void checkHighScoreRuns() {
+    long now = System.currentTimeMillis();
+    List<String> finishedRuns = new ArrayList<>();
+    for (HighScoreRun run : _highScoreRuns.values()) {
+      boolean expired = run.lifetime == HighScoreLifetime.DURATION && now >= run.expiresAtMillis;
+      boolean targetReached =
+          run.lifetime == HighScoreLifetime.TARGET_SCORE
+              && _bucketScores.get(run.bucketId).values().stream()
+                  .anyMatch(score -> score >= run.targetScore);
+      if (expired || targetReached) {
+        finishedRuns.add(run.bucketId);
+      }
+    }
+    for (String bucketId : finishedRuns) {
+      finishHighScoreRun(bucketId);
+    }
+  }
+
+  private void reportHighScoreRunChange(
+      Player player, ScoreBucket bucket, HighScoreRun run, int score) {
+    String message = scoreMessage(player.getName(), bucket, score);
+    sendMessage(player, Component.text(Objects.requireNonNull(message)));
+    List<ScoreEntry> standings = getRankedScores(bucket.getId());
+    for (int place = 0; place < Math.min(run.topN, standings.size()); place++) {
+      if (standings.get(place).playerId.equals(player.getUniqueId())) {
+        for (Player recipient : getServer().getOnlinePlayers()) {
+          if (recipient != player) {
+            sendMessage(recipient, Component.text(Objects.requireNonNull(message)));
+          }
+        }
+        return;
+      }
+    }
+  }
+
+  private void finishHighScoreRun(String bucketId) {
+    HighScoreRun run = _highScoreRuns.remove(bucketId);
+    if (run == null) {
+      return;
+    }
+
+    ScoreBucket bucket = requireBucket(bucketId);
+    List<ScoreEntry> standings = getRankedScores(bucketId);
+    StringBuilder table =
+        new StringBuilder("High-score run for ").append(bucketId).append(" finished.");
+    int places = Math.min(run.topN, standings.size());
+    if (places == 0) {
+      table.append("\nNo scores were recorded.");
+    }
+    for (int place = 0; place < places; place++) {
+      ScoreEntry entry = standings.get(place);
+      table
+          .append("\n")
+          .append(place + 1)
+          .append(". ")
+          .append(entry.playerName)
+          .append(" - ")
+          .append(entry.score)
+          .append(" ")
+          .append(scoreUnit(bucket, entry.score));
+    }
+
+    if (run.resetScores) {
+      Map<UUID, Integer> bucketScores = _bucketScores.get(bucketId);
+      bucketScores.clear();
+      bucketScores.putAll(run.previousScores);
+    }
+    logInfo(table.toString().replace('\n', ' '));
+    for (Player player : getServer().getOnlinePlayers()) {
+      ScoreEntry personalEntry = null;
+      int personalPlace = -1;
+      for (int place = 0; place < standings.size(); place++) {
+        if (standings.get(place).playerId.equals(Objects.requireNonNull(player).getUniqueId())) {
+          personalEntry = standings.get(place);
+          personalPlace = place + 1;
+          break;
+        }
+      }
+      int personalScore = personalEntry == null ? bucket.getInitialValue() : personalEntry.score;
+      String personalResult =
+          personalPlace < 0
+              ? "Your place: unranked; score: "
+                  + personalScore
+                  + " "
+                  + scoreUnit(bucket, personalScore)
+              : "Your place: "
+                  + personalPlace
+                  + "; score: "
+                  + personalScore
+                  + " "
+                  + scoreUnit(bucket, personalScore);
+      sendMessage(player, Component.text(table + "\n" + personalResult));
+    }
+  }
+
+  private List<ScoreEntry> getRankedScores(String bucketId) {
+    List<ScoreEntry> standings = new ArrayList<>();
+    for (var entry : _bucketScores.get(bucketId).entrySet()) {
+      String playerName = getServer().getOfflinePlayer(entry.getKey()).getName();
+      if (playerName == null || playerName.isBlank()) {
+        playerName = entry.getKey().toString();
+      }
+      standings.add(new ScoreEntry(entry.getKey(), playerName, entry.getValue()));
+    }
+    standings.sort(
+        Comparator.comparingInt((ScoreEntry entry) -> entry.score)
+            .reversed()
+            .thenComparing(entry -> entry.playerName, String.CASE_INSENSITIVE_ORDER)
+            .thenComparing(entry -> entry.playerId.toString()));
+    return standings;
+  }
+
+  private String scoreMessage(String playerName, ScoreBucket bucket, int score) {
+    return playerName
+        + "'s "
+        + bucket.getId()
+        + " score is now "
+        + score
+        + " "
+        + scoreUnit(bucket, score)
+        + ".";
+  }
+
+  private String scoreUnit(ScoreBucket bucket, int score) {
+    return score == 1 ? bucket.getSingular() : bucket.getPlural();
+  }
+
+  private void loadScores() {
+    File scoreFile = new File(getDataFolder(), "scores.yml");
+    if (!scoreFile.isFile()) {
+      return;
+    }
+
+    YamlConfiguration scores = YamlConfiguration.loadConfiguration(scoreFile);
+    ConfigurationSection bucketSection = scores.getConfigurationSection("buckets");
+    if (bucketSection == null) {
+      loadLegacyScores(scores);
+      return;
+    }
+
+    _buckets.clear();
+    _bucketScores.clear();
+    for (String id : bucketSection.getKeys(false)) {
+      try {
+        ScoreReporting reporting =
+            parseReporting(bucketSection.getString(id + ".reporting", "none"), id);
+        createBucket(
+            id,
+            bucketSection.getString(id + ".singular", id),
+            bucketSection.getString(id + ".plural", id),
+            bucketSection.getInt(id + ".initial-value"),
+            reporting);
+      } catch (IllegalArgumentException ex) {
+        logWarning("Ignoring invalid score bucket " + id + ": " + ex.getMessage());
+      }
+    }
+    if (!_buckets.containsKey("points")) {
+      createBucket("points", "point", "points", 0);
+    }
+    _defaultBucketId = scores.getString("default-bucket", "points");
+    if (!_buckets.containsKey(_defaultBucketId)) {
+      logWarning("Unknown default score bucket; using points instead.");
+      _defaultBucketId = "points";
+    }
+
+    for (String id : _buckets.keySet()) {
+      ConfigurationSection bucketScores =
+          scores.getConfigurationSection("buckets." + id + ".scores");
+      if (bucketScores != null) {
+        loadPlayerScores(bucketScores, _bucketScores.get(id));
+      }
+    }
+    ConfigurationSection playerBuckets = scores.getConfigurationSection("player-buckets");
+    if (playerBuckets != null) {
+      for (String key : playerBuckets.getKeys(false)) {
+        try {
+          UUID playerId = UUID.fromString(key);
+          String bucketId = playerBuckets.getString(key);
+          if (_buckets.containsKey(bucketId) && !bucketId.equals(_defaultBucketId)) {
+            _playerBuckets.put(playerId, bucketId);
+          }
+        } catch (IllegalArgumentException ex) {
+          logWarning("Ignoring invalid player bucket UUID: " + key);
+        }
+      }
+    }
+    loadHighScoreRuns(scores);
+  }
+
+  private void loadArchives() {
+    File archiveFile = new File(getDataFolder(), "archives.yml");
+    if (!archiveFile.isFile()) {
+      return;
+    }
+    YamlConfiguration archives = YamlConfiguration.loadConfiguration(archiveFile);
+    ConfigurationSection archiveSection = archives.getConfigurationSection("archives");
+    if (archiveSection == null) {
+      return;
+    }
+    for (String archiveId : archiveSection.getKeys(false)) {
+      String path = "archives." + archiveId;
+      Map<String, Map<UUID, Integer>> bucketScores = new LinkedHashMap<>();
+      ConfigurationSection buckets = archives.getConfigurationSection(path + ".buckets");
+      if (buckets != null) {
+        for (String bucketId : buckets.getKeys(false)) {
+          Map<UUID, Integer> playerScores = new LinkedHashMap<>();
+          ConfigurationSection savedScores =
+              archives.getConfigurationSection(path + ".buckets." + bucketId + ".scores");
+          if (savedScores != null) {
+            loadPlayerScores(savedScores, playerScores);
+          }
+          bucketScores.put(bucketId, playerScores);
+        }
+      }
+      _scoreArchives.put(
+          archiveId,
+          new ScoreArchive(
+              archiveId,
+              archives.getString(path + ".scope", "unknown"),
+              archives.getLong(path + ".created-at"),
+              bucketScores));
+    }
+  }
+
+  private void saveArchives() {
+    YamlConfiguration archives = new YamlConfiguration();
+    for (ScoreArchive archive : _scoreArchives.values()) {
+      String path = "archives." + archive.getId();
+      archives.set(path + ".scope", archive.getScope());
+      archives.set(path + ".created-at", archive.getCreatedAtMillis());
+      for (var bucketEntry : archive.getBucketScores().entrySet()) {
+        for (var scoreEntry : bucketEntry.getValue().entrySet()) {
+          archives.set(
+              path + ".buckets." + bucketEntry.getKey() + ".scores." + scoreEntry.getKey(),
+              scoreEntry.getValue());
+        }
+      }
+    }
+    try {
+      archives.save(new File(getDataFolder(), "archives.yml"));
+    } catch (IOException ex) {
+      logError(ex);
+    }
+  }
+
+  private void loadLegacyScores(YamlConfiguration scores) {
+    loadPlayerScores(scores, _bucketScores.get("points"));
+  }
+
+  private void loadPlayerScores(ConfigurationSection scores, Map<UUID, Integer> target) {
+    for (String key : scores.getKeys(false)) {
+      try {
+        target.put(UUID.fromString(key), scores.getInt(key));
+      } catch (IllegalArgumentException ex) {
+        logWarning("Ignoring score with invalid player UUID: " + key);
+      }
+    }
+  }
+
+  private ScoreReporting parseReporting(String value, String bucketId) {
+    try {
+      return ScoreReporting.fromString(value);
+    } catch (IllegalArgumentException ex) {
+      logWarning("Ignoring invalid reporting policy for bucket " + bucketId + "; using none.");
+      return ScoreReporting.NONE;
+    }
+  }
+
+  private void loadHighScoreRuns(YamlConfiguration scores) {
+    ConfigurationSection runs = scores.getConfigurationSection("high-score-runs");
+    if (runs == null) {
+      return;
+    }
+    for (String bucketId : runs.getKeys(false)) {
+      if (!_buckets.containsKey(bucketId)) {
+        logWarning("Ignoring high-score run for unknown bucket " + bucketId + ".");
+        continue;
+      }
+      try {
+        String path = "high-score-runs." + bucketId;
+        int topN = scores.getInt(path + ".top-n");
+        if (topN < 1) {
+          throw new IllegalArgumentException("Top N must be at least 1");
+        }
+        HighScoreLifetime lifetime =
+            HighScoreLifetime.valueOf(
+                scores.getString(path + ".lifetime", "until_disabled").toUpperCase(Locale.ROOT));
+        Map<UUID, Integer> previousScores = new LinkedHashMap<>();
+        ConfigurationSection savedScores =
+            scores.getConfigurationSection(path + ".previous-scores");
+        if (savedScores != null) {
+          loadPlayerScores(savedScores, previousScores);
+        }
+        _highScoreRuns.put(
+            bucketId,
+            new HighScoreRun(
+                bucketId,
+                topN,
+                scores.getBoolean(path + ".reset-scores"),
+                lifetime,
+                scores.getInt(path + ".target-score"),
+                scores.getLong(path + ".expires-at"),
+                previousScores));
+      } catch (IllegalArgumentException ex) {
+        logWarning(
+            "Ignoring invalid high-score run for bucket " + bucketId + ": " + ex.getMessage());
+      }
+    }
+  }
+
+  private void reportScoreChange(Player player, ScoreBucket bucket, int score) {
+    ScoreReporting reporting = bucket.getReporting();
+    if (reporting == ScoreReporting.NONE) {
+      return;
+    }
+
+    String text = scoreMessage(player.getName(), bucket, score);
+    Component message = Component.text(Objects.requireNonNull(text));
+    if (reporting == ScoreReporting.PLAYER) {
+      sendMessage(player, message);
+    } else if (reporting == ScoreReporting.GLOBAL) {
+      for (Player recipient : getServer().getOnlinePlayers()) {
+        sendMessage(recipient, message);
+      }
+    } else if (reporting == ScoreReporting.ADMIN) {
+      logInfo(text);
+      for (Player recipient : getServer().getOnlinePlayers()) {
+        if (Objects.requireNonNull(recipient).isOp()
+            || recipient.hasPermission("scorekeeper.admin")) {
+          sendMessage(recipient, message);
+        }
+      }
+    }
+  }
+
+  private enum HighScoreLifetime {
+    TARGET_SCORE,
+    DURATION,
+    UNTIL_DISABLED
+  }
+
+  private static final class HighScoreRun {
+    private final String bucketId;
+    private final int topN;
+    private final boolean resetScores;
+    private final HighScoreLifetime lifetime;
+    private final int targetScore;
+    private final long expiresAtMillis;
+    private final Map<UUID, Integer> previousScores;
+
+    private HighScoreRun(
+        String bucketId,
+        int topN,
+        boolean resetScores,
+        HighScoreLifetime lifetime,
+        int targetScore,
+        long expiresAtMillis,
+        Map<UUID, Integer> previousScores) {
+      this.bucketId = bucketId;
+      this.topN = topN;
+      this.resetScores = resetScores;
+      this.lifetime = lifetime;
+      this.targetScore = targetScore;
+      this.expiresAtMillis = expiresAtMillis;
+      this.previousScores = new LinkedHashMap<>(previousScores);
+    }
+  }
+
+  private record ScoreEntry(UUID playerId, String playerName, int score) {}
+
+  public static final class ScoreArchive {
+    private final String _id;
+    private final String _scope;
+    private final long _createdAtMillis;
+    private final Map<String, Map<UUID, Integer>> _bucketScores;
+
+    private ScoreArchive(
+        String id,
+        String scope,
+        long createdAtMillis,
+        Map<String, Map<UUID, Integer>> bucketScores) {
+      _id = id;
+      _scope = scope;
+      _createdAtMillis = createdAtMillis;
+      Map<String, Map<UUID, Integer>> copiedScores = new LinkedHashMap<>();
+      for (var entry : bucketScores.entrySet()) {
+        copiedScores.put(entry.getKey(), Map.copyOf(entry.getValue()));
+      }
+      _bucketScores = Collections.unmodifiableMap(copiedScores);
+    }
+
+    public String getId() {
+      return _id;
+    }
+
+    public String getScope() {
+      return _scope;
+    }
+
+    public long getCreatedAtMillis() {
+      return _createdAtMillis;
+    }
+
+    public Map<String, Map<UUID, Integer>> getBucketScores() {
+      return _bucketScores;
+    }
   }
 
   // endregion

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreReporting.java

@@ -0,0 +1,38 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper;
+
+import java.util.Locale;
+
+public enum ScoreReporting {
+  ADMIN,
+  GLOBAL,
+  PLAYER,
+  NONE;
+
+  public static ScoreReporting fromString(String value) {
+    if (value == null) {
+      throw new IllegalArgumentException("Reporting policy cannot be null");
+    }
+    try {
+      return valueOf(value.toUpperCase(Locale.ROOT));
+    } catch (IllegalArgumentException ex) {
+      throw new IllegalArgumentException("Reporting must be admin, global, player or none", ex);
+    }
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreAddCommand.java

@@ -1,22 +1,24 @@
 /*
-This file is part of ScoreKeeper.
+This file is part of Score Keeper.
 
-ScoreKeeper is free software: you can redistribute it and/or modify
+Score Keeper is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
-ScoreKeeper is distributed in the hope that it will be useful,
+Score Keeper is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 */
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
@@ -76,7 +78,8 @@ public class ScoreAddCommand implements CommandExecutor {
   }
 
   private void echoError(CommandSender sender, boolean rcon, String string) {
-    _plugin.sendMessage(sender, Component.text(string).color(NamedTextColor.RED));
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(string)).color(NamedTextColor.RED));
   }
 
   private void echoUsage(CommandSender sender, boolean rcon) {

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreArchiveCommand.java

@@ -1,29 +1,33 @@
 /*
-This file is part of ScoreKeeper.
+This file is part of Score Keeper.
 
-ScoreKeeper is free software: you can redistribute it and/or modify
+Score Keeper is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
-ScoreKeeper is distributed in the hope that it will be useful,
+Score Keeper is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 */
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
 public class ScoreArchiveCommand implements CommandExecutor {
   private final ScoreKeeperPlugin _plugin;
@@ -34,7 +38,46 @@ public class ScoreArchiveCommand implements CommandExecutor {
 
   @Override
   public boolean onCommand(CommandSender sender, Command command, String label, String[] split) {
-    _plugin.sendMessage(sender, Component.text("archive command unimplemented"));
+    if (!sender.hasPermission("scorekeeper.admin")) {
+      sendError(sender, "You do not have permission to archive scores");
+      return true;
+    }
+
+    try {
+      String archiveId;
+      if (split.length == 1 && split[0].equalsIgnoreCase("all")) {
+        archiveId = _plugin.archiveAllScores();
+      } else if (split.length == 2 && split[0].equalsIgnoreCase("bucket")) {
+        archiveId = _plugin.archiveBucketScores(split[1]);
+      } else if (split.length == 0 && sender instanceof Player player) {
+        archiveId = _plugin.archivePlayerScore(player);
+      } else if (split.length == 1) {
+        Player target = _plugin.getServer().getPlayerExact(split[0]);
+        if (target == null) {
+          sendError(sender, "Can't find a player with that name");
+          return true;
+        }
+        archiveId = _plugin.archivePlayerScore(target);
+      } else {
+        sendUsage(sender);
+        return true;
+      }
+      _plugin.sendMessage(sender, Component.text("Saved score archive " + archiveId + "."));
+    } catch (IllegalArgumentException ex) {
+      sendError(sender, ex.getMessage());
+    }
     return true;
   }
+
+  private void sendError(CommandSender sender, String message) {
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(message)).color(NamedTextColor.RED));
+  }
+
+  private void sendUsage(CommandSender sender) {
+    _plugin.sendMessage(
+        sender,
+        Component.text("Usage: /score-archive [playerName|all] | /score-archive bucket <bucketId>")
+            .color(NamedTextColor.YELLOW));
+  }
 }

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreArchiveListCommand.java

@@ -0,0 +1,131 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
+
+import java.time.Instant;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.UUID;
+
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreBucket;
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class ScoreArchiveListCommand implements CommandExecutor {
+  private final ScoreKeeperPlugin _plugin;
+
+  public ScoreArchiveListCommand(ScoreKeeperPlugin plugin) {
+    _plugin = plugin;
+  }
+
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+    if (args.length == 0) {
+      var archives = _plugin.getScoreArchives();
+      if (archives.isEmpty()) {
+        _plugin.sendMessage(sender, Component.text("No score archives have been saved."));
+      } else {
+        archives.stream()
+            .sorted(
+                Comparator.comparingLong(
+                        (ScoreKeeperPlugin.ScoreArchive archive) -> archive.getCreatedAtMillis())
+                    .reversed())
+            .forEach(
+                archive ->
+                    _plugin.sendMessage(
+                        sender,
+                        Component.text(
+                            archive.getId()
+                                + " | "
+                                + archive.getScope()
+                                + " | "
+                                + Instant.ofEpochMilli(archive.getCreatedAtMillis()))));
+      }
+      return true;
+    }
+
+    if (args.length != 1) {
+      sendUsage(sender);
+      return true;
+    }
+    ScoreKeeperPlugin.ScoreArchive archive = _plugin.getScoreArchive(args[0]);
+    if (archive == null) {
+      _plugin.sendMessage(
+          sender,
+          Component.text("No score archive exists with ID " + args[0] + ".")
+              .color(NamedTextColor.RED));
+      return true;
+    }
+
+    _plugin.sendMessage(
+        sender,
+        Component.text(
+            "Archive "
+                + archive.getId()
+                + " ("
+                + archive.getScope()
+                + ", "
+                + Instant.ofEpochMilli(archive.getCreatedAtMillis())
+                + ")"));
+    for (var bucketEntry : archive.getBucketScores().entrySet()) {
+      ScoreBucket bucket = _plugin.getBucket(bucketEntry.getKey());
+      _plugin.sendMessage(sender, Component.text("Bucket " + bucketEntry.getKey() + ":"));
+      bucketEntry.getValue().entrySet().stream()
+          .sorted(
+              Map.Entry.<UUID, Integer>comparingByValue()
+                  .reversed()
+                  .thenComparing(entry -> entry.getKey().toString()))
+          .forEach(
+              entry ->
+                  _plugin.sendMessage(
+                      sender,
+                      Component.text(
+                          displayName(entry.getKey())
+                              + " - "
+                              + entry.getValue()
+                              + " "
+                              + scoreUnit(bucket, entry.getValue()))));
+    }
+    return true;
+  }
+
+  private String displayName(UUID playerId) {
+    OfflinePlayer player = _plugin.getServer().getOfflinePlayer(playerId);
+    return player.getName() == null ? playerId.toString() : player.getName();
+  }
+
+  private String scoreUnit(ScoreBucket bucket, int score) {
+    if (bucket == null) {
+      return "scores";
+    }
+    return score == 1 ? bucket.getSingular() : bucket.getPlural();
+  }
+
+  private void sendUsage(CommandSender sender) {
+    _plugin.sendMessage(
+        sender,
+        Component.text("Usage: /score-archive-list [archiveId]").color(NamedTextColor.YELLOW));
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreBucketCommand.java

@@ -0,0 +1,138 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
+
+import java.util.Objects;
+
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreBucket;
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreReporting;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class ScoreBucketCommand implements CommandExecutor {
+  private final ScoreKeeperPlugin _plugin;
+
+  public ScoreBucketCommand(ScoreKeeperPlugin plugin) {
+    _plugin = plugin;
+  }
+
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+    if (args.length == 0) {
+      if (sender instanceof Player player) {
+        String bucketId = _plugin.getPlayerBucket(player);
+        ScoreBucket bucket = _plugin.getBucket(bucketId);
+        _plugin.sendMessage(
+            sender,
+            Component.text(
+                "You are tracking " + bucket.getId() + " (" + bucket.getPlural() + ")."));
+      } else {
+        sendUsage(sender);
+      }
+      return true;
+    }
+
+    if ((args.length == 5 || args.length == 6) && args[0].equalsIgnoreCase("create")) {
+      if (!requireAdmin(sender)) {
+        return true;
+      }
+      try {
+        ScoreReporting reporting =
+            args.length == 6 ? ScoreReporting.fromString(args[5]) : ScoreReporting.NONE;
+        _plugin.createBucket(args[1], args[2], args[3], Integer.parseInt(args[4]), reporting);
+        _plugin.sendMessage(sender, Component.text("Created score bucket " + args[1] + "."));
+      } catch (IllegalArgumentException ex) {
+        sendError(sender, ex.getMessage());
+      }
+      return true;
+    }
+
+    if (args.length == 1 && sender instanceof Player player) {
+      switchPlayerBucket(sender, player, args[0]);
+      return true;
+    }
+
+    if (args.length == 2) {
+      if (!requireAdmin(sender)) {
+        return true;
+      }
+      if (args[0].equalsIgnoreCase("all")) {
+        try {
+          _plugin.switchAllPlayers(args[1]);
+          _plugin.sendMessage(
+              sender, Component.text("All players are now tracking " + args[1] + "."));
+        } catch (IllegalArgumentException ex) {
+          sendError(sender, ex.getMessage());
+        }
+        return true;
+      }
+
+      Player target = _plugin.getServer().getPlayerExact(args[0]);
+      if (target == null) {
+        sendError(sender, "Can't find a player with that name");
+      } else {
+        switchPlayerBucket(sender, target, args[1]);
+      }
+      return true;
+    }
+
+    sendUsage(sender);
+    return true;
+  }
+
+  private void switchPlayerBucket(CommandSender sender, Player target, String bucketId) {
+    try {
+      _plugin.switchPlayerBucket(target, bucketId);
+      if (sender != target) {
+        _plugin.sendMessage(
+            sender, Component.text(target.getName() + " is now tracking " + bucketId + "."));
+      }
+    } catch (IllegalArgumentException ex) {
+      sendError(sender, ex.getMessage());
+    }
+  }
+
+  private boolean requireAdmin(CommandSender sender) {
+    if (sender.hasPermission("scorekeeper.admin")) {
+      return true;
+    }
+    sendError(sender, "You do not have permission to manage score buckets");
+    return false;
+  }
+
+  private void sendError(CommandSender sender, String message) {
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(message)).color(NamedTextColor.RED));
+  }
+
+  private void sendUsage(CommandSender sender) {
+    _plugin.sendMessage(
+        sender,
+        Component.text(
+                "Usage: /score-bucket [bucketId] | create <id> <singular> <plural> <initialValue>"
+                    + " | <player|all> <bucketId>")
+            .color(NamedTextColor.YELLOW));
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreGetCommand.java

@@ -1,22 +1,24 @@
 /*
-This file is part of ScoreKeeper.
+This file is part of Score Keeper.
 
-ScoreKeeper is free software: you can redistribute it and/or modify
+Score Keeper is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
-ScoreKeeper is distributed in the hope that it will be useful,
+Score Keeper is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 */
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
@@ -84,7 +86,8 @@ public class ScoreGetCommand implements CommandExecutor {
   }
 
   private void echoError(CommandSender sender, boolean rcon, String string) {
-    _plugin.sendMessage(sender, Component.text(string).color(NamedTextColor.RED));
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(string)).color(NamedTextColor.RED));
   }
 
   private void echoUsage(CommandSender sender, boolean rcon) {

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreResetCommand.java

@@ -1,22 +1,24 @@
 /*
-This file is part of ScoreKeeper.
+This file is part of Score Keeper.
 
-ScoreKeeper is free software: you can redistribute it and/or modify
+Score Keeper is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
-ScoreKeeper is distributed in the hope that it will be useful,
+Score Keeper is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 */
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
@@ -62,7 +64,8 @@ public class ScoreResetCommand implements CommandExecutor {
   }
 
   private void echoError(CommandSender sender, boolean rcon, String string) {
-    _plugin.sendMessage(sender, Component.text(string).color(NamedTextColor.RED));
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(string)).color(NamedTextColor.RED));
   }
 
   private void echoUsage(CommandSender sender, boolean rcon) {

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreRunCommand.java

@@ -0,0 +1,125 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
+
+import java.time.Duration;
+import java.util.Objects;
+
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class ScoreRunCommand implements CommandExecutor {
+  private final ScoreKeeperPlugin _plugin;
+
+  public ScoreRunCommand(ScoreKeeperPlugin plugin) {
+    _plugin = plugin;
+  }
+
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+    if (!sender.hasPermission("scorekeeper.admin")) {
+      sendError(sender, "You do not have permission to manage high-score runs");
+      return true;
+    }
+
+    if (args.length == 2 && args[0].equalsIgnoreCase("stop")) {
+      try {
+        _plugin.stopHighScoreRun(args[1]);
+      } catch (IllegalArgumentException ex) {
+        sendError(sender, ex.getMessage());
+      }
+      return true;
+    }
+
+    if (args.length < 5 || !args[0].equalsIgnoreCase("start")) {
+      sendUsage(sender);
+      return true;
+    }
+
+    String bucketId = args[1];
+    try {
+      int topN = Integer.parseInt(args[2]);
+      boolean resetScores = parseBoolean(args[3]);
+      String lifetime = args[4].toLowerCase();
+      if (lifetime.equals("target") && args.length == 6) {
+        _plugin.startTargetScoreRun(bucketId, topN, resetScores, Integer.parseInt(args[5]));
+      } else if (lifetime.equals("duration") && args.length == 6) {
+        _plugin.startTimedScoreRun(bucketId, topN, resetScores, parseDuration(args[5]));
+      } else if (lifetime.equals("until-disabled") && args.length == 5) {
+        _plugin.startUntilDisabledScoreRun(bucketId, topN, resetScores);
+      } else {
+        sendUsage(sender);
+        return true;
+      }
+      _plugin.sendMessage(sender, Component.text("Started a high-score run for " + bucketId + "."));
+    } catch (IllegalArgumentException ex) {
+      sendError(sender, ex.getMessage());
+    }
+    return true;
+  }
+
+  private boolean parseBoolean(String value) {
+    if (value.equalsIgnoreCase("true")) {
+      return true;
+    }
+    if (value.equalsIgnoreCase("false")) {
+      return false;
+    }
+    throw new IllegalArgumentException("Reset scores must be true or false");
+  }
+
+  private Duration parseDuration(String value) {
+    if (!value.matches("[0-9]+[smhdw]")) {
+      throw new IllegalArgumentException(
+          "Duration must use seconds, minutes, hours, days or weeks (e.g. 4h)");
+    }
+    long amount = Long.parseLong(value.substring(0, value.length() - 1));
+    try {
+      return switch (value.charAt(value.length() - 1)) {
+        case 's' -> Duration.ofSeconds(amount);
+        case 'm' -> Duration.ofMinutes(amount);
+        case 'h' -> Duration.ofHours(amount);
+        case 'd' -> Duration.ofDays(amount);
+        case 'w' -> Duration.ofDays(Math.multiplyExact(amount, 7));
+        default -> throw new IllegalArgumentException("Unsupported duration unit");
+      };
+    } catch (ArithmeticException ex) {
+      throw new IllegalArgumentException("Duration is too large", ex);
+    }
+  }
+
+  private void sendError(CommandSender sender, String message) {
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(message)).color(NamedTextColor.RED));
+  }
+
+  private void sendUsage(CommandSender sender) {
+    _plugin.sendMessage(
+        sender,
+        Component.text(
+                "Usage: /score-run start <bucket> <topN> <reset:true|false> "
+                    + "<target <score>|duration <time>|until-disabled> | /score-run stop <bucket>")
+            .color(NamedTextColor.YELLOW));
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreSubtractCommand.java

@@ -1,22 +1,24 @@
 /*
-This file is part of ScoreKeeper.
+This file is part of Score Keeper.
 
-ScoreKeeper is free software: you can redistribute it and/or modify
+Score Keeper is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
-ScoreKeeper is distributed in the hope that it will be useful,
+Score Keeper is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 */
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
@@ -76,7 +78,8 @@ public class ScoreSubtractCommand implements CommandExecutor {
   }
 
   private void echoError(CommandSender sender, boolean rcon, String string) {
-    _plugin.sendMessage(sender, Component.text(string).color(NamedTextColor.RED));
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(string)).color(NamedTextColor.RED));
   }
 
   private void echoUsage(CommandSender sender, boolean rcon) {

src/main/resources/plugin.yml

@@ -1,7 +1,7 @@
 name: ScoreKeeper
 main: com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin
 version: ${version}
-api-version: 1.21
+api-version: '26.2'
 commands:
     score-get:
         description: Displays the player's score.
@@ -18,4 +18,17 @@ commands:
     score-archive:
         description: Archives and resets the player's score
         usage: /score-archive [playername]
+    score-archive-list:
+        description: Lists saved score archives or displays one archive.
+        usage: /score-archive-list [archiveId]
+    score-bucket:
+        description: Selects or manages score buckets.
+        usage: /score-bucket [bucketId] | create <id> <singular> <plural> <initialValue> [admin|global|player|none] | <player|all> <bucketId>
+    score-run:
+        description: Starts or stops a high-score run.
+        usage: /score-run start <bucket> <topN> <reset:true|false> <target <score>|duration <time>|until-disabled> | /score-run stop <bucket>
+permissions:
+    scorekeeper.admin:
+        description: Allows managing score buckets.
+        default: op
         

tools/backup-server.sh

@@ -8,8 +8,47 @@
 set -euo pipefail
 
 TOOLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=setup-env.sh
+PROJECT_ROOT="$(cd "$TOOLS_DIR/.." && pwd)"
-source "$TOOLS_DIR/setup-env.sh"
+if [[ ! -r "$PROJECT_ROOT/.env" ]]; then
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
+load_project_env() {
+  local env_line env_key env_value first_char last_char
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
+
+    env_key="${env_line%%=*}"
+    env_value="${env_line#*=}"
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
+
+    if (( ${#env_value} >= 2 )); then
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+load_project_env
+
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH:-MCServer}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_SERVER_PATH" == /* ]] || MINECRAFT_SERVER_PATH="$PROJECT_ROOT/$MINECRAFT_SERVER_PATH"
+MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH:-backups}"
+MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_BACKUP_PATH" == /* ]] || MINECRAFT_BACKUP_PATH="$PROJECT_ROOT/$MINECRAFT_BACKUP_PATH"
 
 FORCE=false
 LABEL=""

tools/deploy-plugin.sh

@@ -4,8 +4,43 @@ set -e
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 
-# shellcheck source=setup-env.sh
+if [[ ! -r "$PROJECT_ROOT/.env" ]]; then
-source "$SCRIPT_DIR/setup-env.sh"
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
+load_project_env() {
+  local env_line env_key env_value first_char last_char
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
+
+    env_key="${env_line%%=*}"
+    env_value="${env_line#*=}"
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
+
+    if (( ${#env_value} >= 2 )); then
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+load_project_env
+
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH:-MCServer}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_SERVER_PATH" == /* ]] || MINECRAFT_SERVER_PATH="$PROJECT_ROOT/$MINECRAFT_SERVER_PATH"
 
 if [[ -z "$MINECRAFT_SERVER_PATH" ]]; then
   echo "Error: MINECRAFT_SERVER_PATH environment variable is not set."

tools/publish-modrinth.sh

@@ -4,32 +4,104 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 
-# Load project config; credentials stay in the project .env.
+load_project_env() {
-# shellcheck source=setup-env.sh
+  local env_line env_key env_value first_char last_char
-source "$SCRIPT_DIR/setup-env.sh"
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
 
-# Required env:
+    env_key="${env_line%%=*}"
-#   MODRINTH_TOKEN
+    env_value="${env_line#*=}"
-#   MODRINTH_PROJECT_ID or MODRINTH_PROJECT_SLUG
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
-#   MODRINTH_VERSION
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
-#   MODRINTH_GAME_VERSIONS (optional, comma-separated list, default from project set)
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
-#   MODRINTH_LOADERS (optional, comma-separated, default paper)
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
-#   MODRINTH_CHANGELOG (optional)
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
-# Optional:
+
-#   MODRINTH_DEPENDENCIES (optional JSON array or a single JSON string)
+    if (( ${#env_value} >= 2 )); then
-#   MODRINTH_FILE (optional path to the jar; defaults to build/libs/*.jar)
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+
+if [[ -r "$PROJECT_ROOT/.env" ]]; then
+  load_project_env
+elif [[ -z "${MODRINTH_TOKEN:-}" ]]; then
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable and MODRINTH_TOKEN is not set. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
 
 MODRINTH_TOKEN="${MODRINTH_TOKEN:-}"
-MODRINTH_PROJECT_ID="${MODRINTH_PROJECT_ID:-${MODRINTH_PROJECT_SLUG:-5NYwxysp}}"
+MODRINTH_PROJECT_ID="${MODRINTH_PROJECT_ID:-5NYwxysp}"
-MODRINTH_VERSION="${MODRINTH_VERSION:-${VERSION:-$(grep -E '^version=' gradle.properties | head -n1 | cut -d= -f2-)}}"
+MODRINTH_VERSION="${MODRINTH_VERSION:-${VERSION:-}}"
-MODRINTH_CHANGELOG="${MODRINTH_CHANGELOG:-Auto release via publish-modrinth.sh}"
+if [[ -z "$MODRINTH_VERSION" ]]; then
-MODRINTH_GAME_VERSIONS="${MODRINTH_GAME_VERSIONS:-1.21,1.21.1,1.21.2,1.21.3,1.21.4,1.21.5,1.21.6,1.21.7}"
+  MODRINTH_VERSION=$(
+    "$PROJECT_ROOT/gradlew" -q -p "$PROJECT_ROOT" properties --property version \
+      | sed -n 's/^version: //p'
+  )
+fi
+
+generate_changelog() {
+  local current_tag previous_tag range commits
+  current_tag="${TAG:-$(git -C "$PROJECT_ROOT" describe --tags --exact-match HEAD 2>/dev/null || true)}"
+  if [[ -n "$current_tag" ]]; then
+    previous_tag=$(git -C "$PROJECT_ROOT" describe --tags --abbrev=0 "${current_tag}^" 2>/dev/null || true)
+    range="${previous_tag:+$previous_tag..}$current_tag"
+  else
+    previous_tag=$(git -C "$PROJECT_ROOT" describe --tags --abbrev=0 2>/dev/null || true)
+    range="${previous_tag:+$previous_tag..}HEAD"
+  fi
+  commits=$(git -C "$PROJECT_ROOT" log --no-merges --format='- %s (%h)' "$range" 2>/dev/null || true)
+  if [[ -z "$commits" ]]; then
+    commits='- No commit messages found for this release.'
+  fi
+  printf '%s\n\n%s\n' "## What's Changed" "$commits"
+}
+
+MODRINTH_CHANGELOG="${MODRINTH_CHANGELOG:-$(generate_changelog)}"
+MODRINTH_GAME_VERSIONS="${MODRINTH_GAME_VERSIONS:-26.2,26.3}"
 MODRINTH_LOADERS="${MODRINTH_LOADERS:-paper}"
+MODRINTH_VERSION_TYPE="${MODRINTH_VERSION_TYPE:-}"
 MODRINTH_FILE="${MODRINTH_FILE:-}"
 MODRINTH_DEPENDENCIES="${MODRINTH_DEPENDENCIES:-}"
+MODRINTH_SYNC_BODY="${MODRINTH_SYNC_BODY:-true}"
+MODRINTH_DESCRIPTION_FILE="${MODRINTH_DESCRIPTION_FILE:-$PROJECT_ROOT/docs/modrinth-description.md}"
+if [[ ! -f "$MODRINTH_DESCRIPTION_FILE" ]]; then
+  MODRINTH_DESCRIPTION_FILE="$PROJECT_ROOT/README.md"
+fi
+
+if [[ -z "$MODRINTH_VERSION" ]]; then
+  echo "Error: could not determine the project version from Gradle." >&2
+  exit 1
+fi
+if [[ -z "$MODRINTH_VERSION_TYPE" ]]; then
+  if [[ "$MODRINTH_VERSION" == *-* ]]; then
+    MODRINTH_VERSION_TYPE="beta"
+  else
+    MODRINTH_VERSION_TYPE="release"
+  fi
+fi
+case "$MODRINTH_VERSION_TYPE" in
+  release|beta|alpha) ;;
+  *) echo "Error: MODRINTH_VERSION_TYPE must be release, beta, or alpha." >&2; exit 1 ;;
+esac
+MODRINTH_VERSION_NAME="Score Keeper $MODRINTH_VERSION"
+
+if [[ -n "$MODRINTH_FILE" && "$MODRINTH_FILE" != /* ]]; then
+  MODRINTH_FILE="$PROJECT_ROOT/$MODRINTH_FILE"
+fi
 
 if [[ -z "$MODRINTH_TOKEN" ]]; then
-  echo "Error: MODRINTH_TOKEN is not set in $PROJECT_ROOT/.env" >&2
+  echo "Error: MODRINTH_TOKEN is not set (check $PROJECT_ROOT/.env or environment variable)." >&2
   exit 1
 fi
 
@@ -40,27 +112,84 @@ if [[ -z "$MODRINTH_FILE" || ! -f "$MODRINTH_FILE" ]]; then
   echo "Error: no jar found for Modrinth upload. Build the project first or set MODRINTH_FILE." >&2
   exit 1
 fi
+if ! command -v unzip >/dev/null; then
+  echo "Error: 'unzip' is required to verify the plugin version in the jar." >&2
+  exit 1
+fi
+JAR_VERSION=$(unzip -p "$MODRINTH_FILE" plugin.yml 2>/dev/null | sed -n 's/^version: //p' | head -n1 || true)
+if [[ -z "$JAR_VERSION" ]]; then
+  echo "Error: could not read the plugin version from $MODRINTH_FILE." >&2
+  exit 1
+fi
+if [[ "$JAR_VERSION" != "$MODRINTH_VERSION" ]]; then
+  echo "Error: jar version $JAR_VERSION does not match Gradle version $MODRINTH_VERSION. Rebuild the plugin and retry." >&2
+  exit 1
+fi
 
 csv_to_json_array() {
   jq -cn --arg csv "$1" '$csv | split(",") | map(gsub("^\\s+|\\s+$"; "")) | map(select(length > 0))'
 }
 MODRINTH_GAME_VERSIONS_JSON=$(csv_to_json_array "$MODRINTH_GAME_VERSIONS")
 MODRINTH_LOADERS_JSON=$(csv_to_json_array "$MODRINTH_LOADERS")
-
 if [[ -n "$MODRINTH_DEPENDENCIES" ]]; then
-  MODRINTH_DEPENDENCIES_ARG=(--form "dependencies=$MODRINTH_DEPENDENCIES")
+  if ! MODRINTH_DEPENDENCIES_JSON=$(jq -ce 'if type == "array" then . else error("dependencies must be a JSON array") end' <<<"$MODRINTH_DEPENDENCIES"); then
+    echo "Error: MODRINTH_DEPENDENCIES must be a JSON array." >&2
+    exit 1
+  fi
 else
-  MODRINTH_DEPENDENCIES_ARG=()
+  MODRINTH_DEPENDENCIES_JSON='[]'
 fi
 
-curl -fsSL \
+MODRINTH_DATA=$(jq -cn \
-  -X POST "https://api.modrinth.com/v2/version" \
+  --arg project_id "$MODRINTH_PROJECT_ID" \
-  -H "Authorization: $MODRINTH_TOKEN" \
+  --arg name "$MODRINTH_VERSION_NAME" \
-  -F "project_id=$MODRINTH_PROJECT_ID" \
+  --arg version_number "$MODRINTH_VERSION" \
-  -F "version_number=$MODRINTH_VERSION" \
+  --arg version_type "$MODRINTH_VERSION_TYPE" \
-  -F "changelog=$MODRINTH_CHANGELOG" \
+  --arg changelog "$MODRINTH_CHANGELOG" \
-  -F "game_versions=${MODRINTH_GAME_VERSIONS_JSON}" \
+  --argjson featured false \
-  -F "loaders=${MODRINTH_LOADERS_JSON}" \
+  --argjson dependencies "$MODRINTH_DEPENDENCIES_JSON" \
-  -F "file=@$MODRINTH_FILE" \
+  --argjson game_versions "$MODRINTH_GAME_VERSIONS_JSON" \
-  "${MODRINTH_DEPENDENCIES_ARG[@]}" \
+  --argjson loaders "$MODRINTH_LOADERS_JSON" \
-  | jq .
+  '{project_id: $project_id, name: $name, version_number: $version_number, version_type: $version_type, featured: $featured, changelog: $changelog, dependencies: $dependencies, game_versions: $game_versions, loaders: $loaders, file_parts: ["file"], primary_file: "file"}')
+
+CURL_ARGS=(
+  -X POST "https://api.modrinth.com/v2/version"
+  -H "Authorization: $MODRINTH_TOKEN"
+  -F "data=$MODRINTH_DATA;type=application/json"
+  -F "file=@$MODRINTH_FILE"
+)
+
+HTTP_RESPONSE=$(curl -sS -w $'\n%{http_code}' "${CURL_ARGS[@]}")
+HTTP_STATUS="${HTTP_RESPONSE##*$'\n'}"
+HTTP_BODY="${HTTP_RESPONSE%$'\n'*}"
+if [[ "$HTTP_STATUS" != 2?? ]]; then
+  echo "Error: Modrinth API returned HTTP $HTTP_STATUS:" >&2
+  if ! printf '%s\n' "$HTTP_BODY" | jq -r '.description // .error // .' >&2; then
+    printf '%s\n' "$HTTP_BODY" >&2
+  fi
+  exit 1
+fi
+printf '%s\n' "$HTTP_BODY" | jq .
+
+if [[ "$MODRINTH_SYNC_BODY" == "true" && -f "$MODRINTH_DESCRIPTION_FILE" ]]; then
+  echo "Syncing project description to Modrinth from $MODRINTH_DESCRIPTION_FILE..."
+  BODY_CONTENT=$(cat "$MODRINTH_DESCRIPTION_FILE")
+  PATCH_DATA=$(jq -cn --arg body "$BODY_CONTENT" '{body: $body}')
+
+  PATCH_RESPONSE=$(curl -sS -w $'\n%{http_code}' \
+    -X PATCH "https://api.modrinth.com/v2/project/$MODRINTH_PROJECT_ID" \
+    -H "Authorization: $MODRINTH_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d "$PATCH_DATA")
+
+  PATCH_STATUS="${PATCH_RESPONSE##*$'\n'}"
+  PATCH_BODY="${PATCH_RESPONSE%$'\n'*}"
+  if [[ "$PATCH_STATUS" != 2?? ]]; then
+    echo "Warning: Modrinth project description update returned HTTP $PATCH_STATUS:" >&2
+    if ! printf '%s\n' "$PATCH_BODY" | jq -r '.description // .error // .' >&2; then
+      printf '%s\n' "$PATCH_BODY" >&2
+    fi
+  else
+    echo "Successfully updated Modrinth project description."
+  fi
+fi

tools/restore-server.sh

@@ -9,8 +9,47 @@
 set -euo pipefail
 
 TOOLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=setup-env.sh
+PROJECT_ROOT="$(cd "$TOOLS_DIR/.." && pwd)"
-source "$TOOLS_DIR/setup-env.sh"
+if [[ ! -r "$PROJECT_ROOT/.env" ]]; then
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
+load_project_env() {
+  local env_line env_key env_value first_char last_char
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
+
+    env_key="${env_line%%=*}"
+    env_value="${env_line#*=}"
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
+
+    if (( ${#env_value} >= 2 )); then
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+load_project_env
+
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH:-MCServer}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_SERVER_PATH" == /* ]] || MINECRAFT_SERVER_PATH="$PROJECT_ROOT/$MINECRAFT_SERVER_PATH"
+MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH:-backups}"
+MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_BACKUP_PATH" == /* ]] || MINECRAFT_BACKUP_PATH="$PROJECT_ROOT/$MINECRAFT_BACKUP_PATH"
 
 ASSUME_YES=false
 SAFETY_BACKUP=true

tools/setup-env.sh

@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-# Source (bash or zsh) to export the shared server config from ../.env
-# (relative to this script):
-#   PAPER_VERSION, PAPER_BUILD, MINECRAFT_SERVER_PATH, MINECRAFT_SERVER_JAR, MINECRAFT_BACKUP_PATH
-
-_setup_env_self="${BASH_SOURCE[0]:-${(%):-%x}}"
-_setup_env_root="$(cd "$(dirname "$_setup_env_self")/.." && pwd)"
-_setup_env_file="${MINECRAFT_ENV_FILE:-$_setup_env_root/.env}"
-
-if [[ -f "$_setup_env_file" ]]; then
-  while IFS= read -r _line || [[ -n "$_line" ]]; do
-    _line="${_line%$'\r'}"
-    [[ "$_line" =~ ^[[:space:]]*(#|$) ]] && continue
-    _key="${_line%%=*}"
-    _value="${_line#*=}"
-    _key="${_key//[[:space:]]/}"
-    [[ "$_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
-    _value="${_value#\"}"; _value="${_value%\"}"
-    _value="${_value#\'}"; _value="${_value%\'}"
-    eval "_current=\"\${$_key:-}\""
-    [[ -z "$_current" ]] && export "$_key=$_value"
-  done < "$_setup_env_file"
-fi
-
-PAPER_VERSION="${PAPER_VERSION:-}"
-PAPER_BUILD="${PAPER_BUILD:-}"
-MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH:-MCServer}"
-MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH/#\~/$HOME}"
-[[ "$MINECRAFT_SERVER_PATH" == /* ]] || MINECRAFT_SERVER_PATH="$_setup_env_root/$MINECRAFT_SERVER_PATH"
-MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH:-backups}"
-MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH/#\~/$HOME}"
-[[ "$MINECRAFT_BACKUP_PATH" == /* ]] || MINECRAFT_BACKUP_PATH="$_setup_env_root/$MINECRAFT_BACKUP_PATH"
-
-if [[ -z "${MINECRAFT_SERVER_JAR:-}" && -n "$PAPER_VERSION" && -n "$PAPER_BUILD" ]]; then
-  MINECRAFT_SERVER_JAR="paper-${PAPER_VERSION}-${PAPER_BUILD}.jar"
-fi
-
-export PAPER_VERSION PAPER_BUILD MINECRAFT_SERVER_PATH MINECRAFT_SERVER_JAR MINECRAFT_BACKUP_PATH
-unset _setup_env_self _setup_env_root _setup_env_file _line _key _value _current

tools/start-server.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Downloads (if missing) and runs a Paper server via the Fill v3 API.
-# Server settings come from ../.env relative to this script (see setup-env.sh).
+# Server settings come from the project .env file.
 #
 # Env vars:
 #   JAVA_OPTS              Extra JVM args (default: -Xms2G -Xmx2G)
@@ -8,8 +8,47 @@
 set -euo pipefail
 
 TOOLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=setup-env.sh
+PROJECT_ROOT="$(cd "$TOOLS_DIR/.." && pwd)"
-source "$TOOLS_DIR/setup-env.sh"
+if [[ ! -r "$PROJECT_ROOT/.env" ]]; then
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
+load_project_env() {
+  local env_line env_key env_value first_char last_char
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
+
+    env_key="${env_line%%=*}"
+    env_value="${env_line#*=}"
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
+
+    if (( ${#env_value} >= 2 )); then
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+load_project_env
+
+PAPER_VERSION="${PAPER_VERSION:-}"
+PAPER_BUILD="${PAPER_BUILD:-}"
+MINECRAFT_SERVER_JAR="${MINECRAFT_SERVER_JAR:-}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH:-MCServer}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_SERVER_PATH" == /* ]] || MINECRAFT_SERVER_PATH="$PROJECT_ROOT/$MINECRAFT_SERVER_PATH"
 
 [[ -n "$PAPER_VERSION" ]] || { echo "Error: PAPER_VERSION is not set (see .env)." >&2; exit 1; }