peakstone 0.1.0__tar.gz

peakstone-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

peakstone-0.1.0/NOTICE

@@ -0,0 +1,15 @@
+Peakstone
+Copyright 2026 The Peakstone Authors
+
+This product includes software developed by the Peakstone project and its contributors,
+licensed under the Apache License, Version 2.0 (see LICENSE).
+
+Peakstone — a public, reproducible benchmark platform that tracks the evolution of open-model
+capabilities, from simple verifiable assignments to complex iterated projects.
+https://peakstone.ai
+
+Submitted benchmark result data is published under CC-BY-4.0 (see DATA-LICENSE.md), separate from
+the Apache-2.0 software license above.
+
+Portions of this repository originated as a local coding-LLM benchmarking harness; see the git
+history for provenance.

peakstone-0.1.0/PKG-INFO

@@ -0,0 +1,276 @@
+Metadata-Version: 2.4
+Name: peakstone
+Version: 0.1.0
+Summary: A public, reproducible benchmark platform tracking the capability frontier of open models (coding, agentic, planning).
+Author: The Peakstone Authors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://peakstone.ai
+Project-URL: Source, https://github.com/peakstone-ai/peakstone
+Keywords: llm,benchmark,evaluation,reproducibility,coding,agents,gpu
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: jsonschema>=4
+Requires-Dist: cryptography>=41
+Provides-Extra: dashboard
+Requires-Dist: textual>=0.60; extra == "dashboard"
+Requires-Dist: huggingface_hub>=0.20; extra == "dashboard"
+Requires-Dist: fastapi>=0.110; extra == "dashboard"
+Requires-Dist: uvicorn>=0.27; extra == "dashboard"
+Requires-Dist: httpx>=0.27; extra == "dashboard"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Dynamic: license-file
+
+# Peakstone
+
+**A public, reproducible benchmark platform for the capabilities of open models** — from solving
+simple verifiable assignments to (eventually) iterating their way through complex, multi-machine
+projects. Community-run, community-authored, independently reproducible.
+
+> *Tsunami "high-water-mark" stones record how far the wave reached. Peakstone records how far the
+> open-model capability frontier has reached — permanent, reproducible markers ("set in stone") of a
+> moving peak.*
+
+See **[PLAN.md](./PLAN.md)** for the full vision, architecture, and roadmap.
+
+## Status
+
+Early. **P1 (reproducible coding leaderboard)** is in progress. What exists today:
+
+- **`engine/`** — the test harness: serves a model over an OpenAI-compatible API, runs a suite of
+  **verifiable** challenges (deterministic tests), scores them, and (soon) emits a signed
+  **result bundle**. Also supports LLM-judge grading, self-repair (`--retries`), a global-rules
+  output contract (`--agents-md`), tool-calling/agentic/injection modes, and a planner eval. Ships
+  the **result-bundle JSON Schema** (the reproducibility contract) + capability taxonomy as packaged
+  data in `engine/schema/`, so a bare `pip install` can produce and validate bundles.
+- **`challenges/`** — the challenge corpus (`spec.md` + `tests/` + `reference/` per challenge). Part
+  of the repo workspace, not the PyPI wheel; running the suite needs a checkout (set `PEAKSTONE_REPO`
+  if the package and corpus live apart).
+- **`serve/`** — local model-serving helpers (run your own GGUF models to test).
+- **`gateway/`** — `peakstone serve`: a standing, **llama-swap-style OpenAI-compatible gateway** on one
+  port. It picks (and hot-swaps) the backend `llama-server` from the `model` field of each request, so
+  it doubles as a local OpenAI endpoint for everyday use — not just benchmarking. It also owns the
+  **benchmark job queue** (sqlite-persisted), so the TUI/CLI are thin clients: runs survive quitting
+  the dashboard.
+
+- **`api/`** — the submission/leaderboard API (FastAPI + Postgres) that runs on peakstone.ai. Validates
+  signed result bundles, serves faceted leaderboards, and moderates the open challenge corpus.
+  Deployed from this repo via Docker (see **Running the server** below); not part of the PyPI client.
+- **`web/`** — the Next.js leaderboard frontend.
+
+## Quickstart — run the engine against a local model
+
+```bash
+# 0. Sanity-check the suite itself (no model needed): reference solutions must all pass
+python -m peakstone.engine.runner --reference --models reference
+
+# 1. Serve a model over an OpenAI-compatible API (any engine works; helper for llama.cpp GGUFs):
+./serve/serve.sh <model-name>          # see serve/models.toml for the local registry
+# …or run the model gateway, which hot-swaps models per request (see "Model gateway" below):
+peakstone serve                        # then add `--gateway http://localhost:12434` to step 2
+
+# 2. Evaluate it
+export PATH="$HOME/opt/node/bin:$PATH"   # JS/TS test runners need this Node
+python -m peakstone.engine.runner --models <model-name>
+python -m peakstone.engine.runner --models <model-name> --retries 2 --agents-md   # self-repair + output contract
+```
+
+Scoring: `final = pass_rate` for `tests` challenges; `0.7*pass_rate + 0.3*judge` for `both`.
+Each run records full per-challenge transcripts and the model/environment metadata needed to
+reproduce it. See `peakstone/engine/runner.py --help` for filters (`--lang`, `--type`, `--difficulty`,
+`--ids`) and modes (judge, retries, agents-md, planner eval).
+
+### Offline test sandbox (Linux)
+
+Each test runs **offline**, in a throwaway network namespace (loopback only). This keeps a solution
+that does real network I/O — e.g. a BigCodeBench task that `wget`/HTTP/FTPs past the test's mocks —
+from hanging to the per-challenge timeout: the call fails fast instead.
+
+It uses unprivileged user namespaces, which **Ubuntu's AppArmor disables by default**. Enable them:
+
+```bash
+sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0          # this boot
+echo 'kernel.apparmor_restrict_unprivileged_userns=0' | sudo tee /etc/sysctl.d/99-peakstone.conf   # persist
+# older kernels: kernel.unprivileged_userns_clone=1
+```
+
+Without it the harness still works — it just falls back to a plain subprocess (no network isolation),
+so a runaway network call can burn the full challenge timeout. Verify it's active:
+`unshare -rn -- true` should exit 0. (No-op on macOS, which mocks-or-Docker-isolates instead.)
+
+### Running on macOS (Apple Silicon)
+
+The harness, dashboard, and serving all run on macOS. The engine auto-detects the platform —
+hardware stats come from `sysctl`/`ioreg`/`vm_stat` (the dashboard shows the unified-memory GPU
+live), and it uses GNU `time` only when present. One-time toolchain setup:
+
+```bash
+# Work in an isolated venv — don't install into system / conda-base Python:
+python -m venv ~/.peakstone/venv && source ~/.peakstone/venv/bin/activate
+
+# Python: engine deps + the optional library-challenge references + the dashboard TUI
+pip install jsonschema cryptography pytest numpy pandas pydantic networkx more-itertools \
+            python-dateutil sortedcontainers "textual>=0.60" "huggingface_hub>=0.20"
+
+# JS/TS challenges: install the jsenv libs, plus tsx + typescript on PATH (the TS runner needs them)
+( cd peakstone/engine/jsenv && npm install )
+npm install -g tsx typescript
+
+# Serving (optional — only to run a model): a Metal build of llama.cpp
+brew install llama.cpp        # serve.sh finds `llama-server` on PATH automatically
+```
+
+On Apple Silicon, memory is **unified** (weights + KV share system RAM), so pick a model that fits
+your RAM with headroom — on a 16 GB Mac, `vibethinker-3b` (3.3 GB) or `phi-4-mini` (~9 GB) rather
+than the 22 GB roster tuned for a 24 GB NVIDIA card.
+
+For the multi-machine agentic env challenges, the **local** provider works everywhere, and the
+**docker** provider gives full isolation *plus network shaping* (`tc` latency / `iptables` link
+partitions) on macOS too — those run inside Docker Desktop's Linux VM, so start Docker Desktop and
+use `--env-provider docker`. Only **firecracker** is genuinely Linux-only (it needs `/dev/kvm`,
+which Apple Silicon does not provide).
+
+## Dashboard (TUI)
+
+A Textual terminal UI shows your **local GPU/CPU/RAM** live, next to the leaderboard **filtered to
+what fits your hardware** — so you can see how models that actually run on your machine compare:
+
+Install into an **isolated environment** so Peakstone's dependencies never touch your system or
+conda-base Python (they'd otherwise clobber whatever `requests`/`urllib3`/etc. you already have):
+
+```bash
+pipx install "peakstone[dashboard]"          # recommended — pipx gives it its own venv + a PATH shim
+# …or a plain venv:
+python -m venv ~/.peakstone/venv && ~/.peakstone/venv/bin/pip install "peakstone[dashboard]"
+
+peakstone --api https://peakstone.ai/api     # public API is under /api; default http://localhost:8000
+peakstone login --api https://peakstone.ai/api   # link your signing key to GitHub (one browser round-trip)
+```
+
+`peakstone login` binds your local ed25519 signing key to a GitHub handle: it opens the OAuth consent
+page, catches the redirect on a loopback callback, and proves key ownership by signing a server nonce —
+the private key never leaves your machine. Optional, but it attributes your runs and lets your
+reproductions count toward the community-verified (ranked) tier.
+
+The published package is the **client**: the engine and the dashboard, nothing server-side. The
+submission API (`api/`) is the *server* and is deployed from this repo, never installed from PyPI —
+see **Running the server** below.
+
+See **[peakstone/dashboard/README.md](./peakstone/dashboard/README.md)**.
+
+## Model gateway (`peakstone serve`)
+
+A standing, **llama-swap-style** OpenAI-compatible gateway on a single port (default `:12434`). The
+`model` field of each request selects the backend — the gateway loads/swaps the right `llama-server`
+on demand — so it's a drop-in local OpenAI endpoint for editors, scripts, and agents, *and* the
+serving layer the benchmark harness runs on.
+
+```bash
+peakstone serve                              # foreground; or `peakstone serve --detach`
+# point any OpenAI client at it:
+curl http://localhost:12434/v1/chat/completions \
+  -d '{"model": "<model-name>", "messages": [{"role":"user","content":"hi"}]}'
+```
+
+**Browser chat UI.** The gateway also serves a single-file chat app at **`http://localhost:12434/chat`**
+(root `/` redirects there). It's a multi-conversation UI with editable system prompts, image input,
+streaming + reasoning, and a **model selector** populated live from `GET /v1/models` — picking a model
+just puts its name in the request body, so the gateway loads/swaps it into VRAM on demand. Because it's
+served from the gateway origin it shares `/v1` (no CORS) and is reachable on the LAN at the gateway's
+host:port. On a trusted network, `peakstone serve --host 0.0.0.0 --open` drops auth so any device can
+use it tokenlessly; otherwise paste the token into the chat's ⚙ Settings (see auth below).
+
+The gateway also owns the **benchmark job queue** (persisted to `results/jobs.db`), so the TUI/CLI are
+thin clients over it — **runs keep going after you quit the dashboard**, and reconnecting shows their
+state. Drive it headless with the `jobs` CLI:
+
+```bash
+peakstone jobs add <model-name> --level standard   # queue a run on the daemon
+peakstone jobs list                                # queued / running / done
+peakstone jobs logs <id>                            # stream a job's log
+peakstone jobs cancel <id>
+```
+
+`peakstone` (the TUI) auto-spawns the gateway detached on startup; disable with `--no-gateway` or
+`PEAKSTONE_NO_GATEWAY=1`. Config lives under `[gateway]` in `peakstone/engine/config.toml`
+(host/port/`idle_timeout_s` — unload the model and free VRAM after a quiet spell; `0` = never).
+
+**Use it from another machine (auth).** Loopback requests (`127.0.0.1`) need no token, so the TUI, the
+CLI, and anything on the box just work. To reach it over a LAN — e.g. an editor on your laptop driving
+the GPU box — bind it publicly and present the token; non-loopback requests without a valid one get
+`401`:
+
+```bash
+peakstone serve --host 0.0.0.0          # prints the token; also saved to ~/.peakstone/gateway_token (0600)
+# from the laptop — OpenAI base URL http://<gpu-box>:12434/v1, API key = that token:
+curl http://<gpu-box>:12434/v1/chat/completions \
+  -H "Authorization: Bearer $TOKEN" \
+  -d '{"model": "<model-name>", "messages": [{"role":"user","content":"hi"}]}'
+```
+
+The token is generated on first run; override it with `PEAKSTONE_GATEWAY_TOKEN`. On a trusted LAN you
+can skip tokens entirely with `peakstone serve --host 0.0.0.0 --open` (auth disabled — any reachable
+device can drive the GPU, so use it only at home).
+
+**Sharing one GPU.** Only one model is resident at a time. While a benchmark job runs it *pins* the GPU
+to that model: chat requests for the same model are served, but a request for a *different* model gets
+`503 busy` rather than evicting the run mid-flight. With no job running, any model loads/swaps on demand.
+
+## Running the server (peakstone.ai)
+
+The website + leaderboard API + Postgres + automatic-HTTPS proxy run as one Docker stack (`infra/`).
+Caddy serves the Next.js site at `/` and the API under `/api/*` on the same domain (so
+`https://<domain>/` is the leaderboard and `https://<domain>/api/...` is the API). On a Linux box
+reachable on a public IP:
+
+```bash
+git clone https://github.com/peakstone-ai/peakstone && cd peakstone
+cp infra/.env.example infra/.env        # set PEAKSTONE_DOMAIN + a strong POSTGRES_PASSWORD
+./infra/deploy.sh                        # build, migrate (alembic), start db + api + web + caddy
+```
+
+[Caddy](https://caddyserver.com) provisions and renews the TLS cert for `PEAKSTONE_DOMAIN`
+automatically — point its DNS A record at the box and open ports 80 + 443; there's no certbot to
+manage. **To update:** `git pull && ./infra/deploy.sh`. Migrations (`alembic upgrade head`) run on
+every deploy before the app starts. Postgres is internal-only (not published to the host); only the
+proxy is exposed. For a local self-signed smoke test, leave `PEAKSTONE_DOMAIN=localhost` and run
+`docker compose -f infra/docker-compose.yml up --build`.
+
+**Running the API directly (dev / LAN).** Outside Docker, `python -m peakstone.api` starts uvicorn
+with host/port from the `[api]` block in `engine/config.toml`. It's local-only by default; to reach it
+from your phone or another machine on the LAN, expose it without editing the tracked config by dropping
+this in `~/.peakstone/config.toml` (or pass `--host 0.0.0.0`, or set `PEAKSTONE_API_HOST=0.0.0.0`):
+
+```toml
+[api]
+host = "0.0.0.0"
+```
+
+Ingest is signature-verified, but account/admin endpoints are reachable too — only bind `0.0.0.0` on a
+trusted network.
+
+## Add a challenge
+
+Create `challenges/<lang-or-category>/NN-slug/` with `meta.toml`, `spec.md`, `tests/`, and a
+`reference/` solution, then verify it passes its own tests:
+
+```bash
+python -m peakstone.engine.runner --reference --models reference --ids <id>
+```
+
+See **[CONTRIBUTING.md](./CONTRIBUTING.md)** for the challenge schema, the corpus → admin-canonized
+suite lifecycle, and the DCO sign-off. Several challenges test **library fluency** with offline-safe
+libs (Python: numpy/pandas/pydantic/networkx/...; JS/TS: lodash/date-fns/zod/mathjs in `peakstone/engine/jsenv`).
+
+## License
+
+- **Code & challenges:** Apache-2.0 ([LICENSE](./LICENSE)), via DCO ([CONTRIBUTING.md](./CONTRIBUTING.md)).
+- **Submitted result data:** CC-BY-4.0 ([DATA-LICENSE.md](./DATA-LICENSE.md)).
+- The **Peakstone** name and "official"/"verified" designations are reserved ([TRADEMARK.md](./TRADEMARK.md)).