ππΌββοΈ The blackboard for coding agents - agentic development environment for claude code, codex, cursor, opencode, grok and more.
Rust adeai-agentsclaudeclaude-codecodexcursorgeminigrokopencodespec-driven-developmentvibe-codingvim
feat(benchmark): add report script and docker runtime (#112)
Fynn Flueggeec5e0d9cdba3
diff --git a/benchmark/README.md b/benchmark/README.mdindex cfccb92..448a695 100644--- a/benchmark/README.md+++ b/benchmark/README.md@@ -6,14 +6,80 @@ Runs AI coding agent workflows against [SWE-bench Lite](https://github.com/princ(300 real GitHub bug-fix tasks). Uses agtx as the agent runner, drives it via its MCP server,collects git diff patches, and outputs SWE-bench-compatible results.+> **All commands below assume you are in the `benchmark/` directory.**+> ```bash+> cd benchmark+> ```++### Sandbox Mode (Docker)++In sandbox mode (`--sandbox`), each task runs inside its official SWE-bench Docker image.+The repo is pre-installed in a working conda environment (`testbed`) so agents can run+`pytest` and all dependencies without any setup.++**When to use:** Always recommended. Agents fail on the host because SWE-bench repos require+specific Python versions and C extensions that aren't available outside the containers.++**One-time setup:**+```bash+cd swebench++# Build the tools image (tmux + Node.js + Claude Code)+python prebake_images.py --verbose++# Build the Linux agtx binary (Ubuntu 22.04 / glibc 2.35)+bash build_linux_binary.sh+```++The tools image is the base for the shared Docker named volume `agtx-swebench-tools`.+On the **first benchmark run**, this volume is created automatically and populated from the+tools image β tmux, Node.js, Claude Code, and their shared libraries are copied in once and+then mounted read-only into every instance container. Subsequent runs skip this step.++To force a refresh (e.g. after updating Claude Code):+```bash+docker volume rm agtx-swebench-tools+python prebake_images.py --force --verbose+```++**Run in sandbox mode** (Linux binary required β agents run inside Ubuntu 22.04 containers):+```bash+python swebench/benchmark.py \+ --config swebench/configs/claude-agtx.toml \+ --instance-ids astropy__astropy-12907 \+ --sandbox --verbose \+ --agtx ../target/agtx-linux-x86_64+```++**Attach to a running container** to watch the agent:+```bash+docker exec -it swebench-astropy-astropy-12907 tmux -L agtx attach -t testbed:1+# Ctrl+b 0 β agtx board Ctrl+b 1 β agent session Ctrl+b d β detach+```++**Cleanup** if the benchmark crashes:+```bash+docker rm -f swebench-astropy-astropy-12907+docker volume rm agtx-swebench-tools # only if tools need refreshing+```++---+### Prerequisites-**agtx** (built from source):+**Docker** (required for sandbox mode):+```bash+# macOS β install Docker Desktop from https://docs.docker.com/desktop/mac/install/+# Ubuntu/Debian+apt install docker.io+```++**agtx** (built from repo root):```bashcargo build --release```-**uv** (Python package manager β used both to run the script and to install each benchmark repo):+**uv** (Python package manager):```bashcurl -LsSf https://astral.sh/uv/install.sh | sh```@@ -44,17 +110,18 @@ At least one coding agent CLI must be installed and authenticated:**1. Initialize the Python environment:**```bash-cd benchmarks/swebench+cd swebenchuv sync-cd ../..+cd ..```-This creates a `.venv` inside `benchmarks/swebench/` and installs all dependencies.+This creates a `.venv` inside `swebench/` and installs all dependencies (including `swebench`,+so evaluation can run via `uv run` without a separate swebench install).Only needed once (or after updating `pyproject.toml`).**2. Create a config file** for your benchmark run.-Config files live in `benchmarks/swebench/configs/`. Each file is a standard agtx+Config files live in `swebench/configs/`. Each file is a standard agtx`ProjectConfig` TOML that gets written to `.agtx/config.toml` in every cloned repo.It controls which agent and plugin are used.@@ -71,6 +138,14 @@ workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"```+Sandbox-optimised (agent works directly in `/testbed`, no worktree) β `configs/claude-agtx.toml` with `skip_worktree`:+```toml+default_agent = "claude"+workflow_plugin = "agtx"+worktree_dir = ".agtx/worktrees"+skip_worktree = true # recommended for sandbox: agent works in /testbed directly+```+Mixed agents (different agent per phase) β `configs/gemini-claude-codex-agtx.toml`:```tomldefault_agent = "claude"@@ -82,69 +157,94 @@ running = "claude"review = "codex"```-Available plugins: `void`, `agtx`, `agtx-terse`, `gsd`, `spec-kit`, `bmad`, `openspec`, `superpowers`+Available plugins: `void`, `agtx`, `agtx-terse`, `gsd`, `spec-kit`, `bmad`, `openspec`, `superpowers`, `agent-skills`++Pre-built configs for common single-agent and multi-agent combinations are in [`swebench/configs/`](swebench/configs/).++#### Sandbox-specific config keys-Pre-built configs for common single-agent and multi-agent combinations are in [`benchmarks/swebench/configs/`](swebench/configs/).+These keys are only used in sandbox mode (`--sandbox`) and are ignored otherwise:++| Key | Description |+|-----|-------------|+| `skip_worktree = true` | Agent works directly in `/testbed` instead of a git worktree. Recommended for sandbox runs. |+| `sandbox_init = [...]` | List of shell commands run inside the container (as `/home/bench`) after tools are wired but before the TUI starts. Use for installing per-config tooling (e.g. rtk, caveman). |++Example with `sandbox_init`:+```toml+default_agent = "claude"+workflow_plugin = "agtx"+skip_worktree = true++sandbox_init = [+ # Install rtk token-compression hook+ "curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh",+ "export PATH=$HOME/.local/bin:$PATH && rtk init -g",+]+```++`sandbox_init` commands run with `HOME=/home/bench` and have `PATH` including `/home/bench/.local/bin`.+Each config activates only the tools it explicitly installs β other configs are unaffected.---### Running-All commands are run from the repo root. `uv run` picks up the venv in-`benchmarks/swebench/.venv` via the `--project` flag.+> **Note:** The examples below use `--agtx ../target/release/agtx` (the host binary). For sandbox+> mode (`--sandbox`), the Linux x86_64 binary is required β use `--agtx ../target/agtx-linux-x86_64`+> instead (built via `bash swebench/build_linux_binary.sh`).-**Single task (smoke test):**+**Single task:**```bash-uv run --project benchmarks/swebench \- python benchmarks/swebench/benchmark.py \- --config benchmarks/swebench/configs/claude-void.toml \- --instances 1 --verbose+uv run --project swebench \+ python swebench/benchmark.py \+ --config swebench/configs/claude-void.toml \+ --instances 1 --verbose \+ --agtx ../target/release/agtx```**Specific instance IDs:**```bash-uv run --project benchmarks/swebench \- python benchmarks/swebench/benchmark.py \- --config benchmarks/swebench/configs/claude-void.toml \- --instance-ids sympy__sympy-20590 django__django-11099+uv run --project swebench \+ python swebench/benchmark.py \+ --config swebench/configs/claude-void.toml \+ --instance-ids sympy__sympy-20590 django__django-11099 \+ --agtx ../target/release/agtx```**Full 300-task run:**```bash-uv run --project benchmarks/swebench \- python benchmarks/swebench/benchmark.py \- --config benchmarks/swebench/configs/claude-agtx.toml+uv run --project swebench \+ python swebench/benchmark.py \+ --config swebench/configs/claude-agtx.toml \+ --agtx ../target/release/agtx```**Parallel tasks:**```bash-uv run --project benchmarks/swebench \- python benchmarks/swebench/benchmark.py \- --config benchmarks/swebench/configs/claude-agtx.toml \- --concurrency 4+uv run --project swebench \+ python swebench/benchmark.py \+ --config swebench/configs/claude-agtx.toml \+ --concurrency 4 \+ --agtx ../target/release/agtx```**Resume an interrupted run** (pass the same `--output-dir`):```bash-uv run --project benchmarks/swebench \- python benchmarks/swebench/benchmark.py \- --config benchmarks/swebench/configs/claude-agtx.toml \- --output-dir swebench_output/agtx_claude_20260427_120000+uv run --project swebench \+ python swebench/benchmark.py \+ --config swebench/configs/claude-agtx.toml \+ --output-dir swebench_output/agtx_claude_20260427_120000 \+ --agtx ../target/release/agtx```**Hard mode** (prose only β no code blocks or stack traces):```bash-uv run --project benchmarks/swebench \- python benchmarks/swebench/benchmark.py \- --config benchmarks/swebench/configs/claude-agtx.toml \- --hard-```--Alternatively, activate the venv directly for a shorter prompt:-```bash-source benchmarks/swebench/.venv/bin/activate-python benchmarks/swebench/benchmark.py --config benchmarks/swebench/configs/claude-agtx.toml-deactivate+uv run --project swebench \+ python swebench/benchmark.py \+ --config swebench/configs/claude-agtx.toml \+ --hard \+ --agtx ../target/release/agtx```#### All options@@ -155,11 +255,12 @@ deactivate| `--instances N` | all 300 | Run first N tasks || `--instance-ids ID...` | β | Run specific instance IDs || `--concurrency N` | 1 | Parallel tasks |-| `--output-dir PATH` | `./swebench_output/{plugin}_{agent}_{ts}/` | Output directory |-| `--workdir PATH` | `/tmp/swebench_repos` | Repo clone directory |-| `--agtx PATH` | `./target/release/agtx` | agtx binary |+| `--sandbox` | off | Run each task inside its SWE-bench Docker image (recommended) |+| `--output-dir PATH` | `./swebench_output/{config-name}_{ts}/` | Output directory |+| `--workdir PATH` | `/tmp/swebench_repos` | Repo clone directory (non-sandbox only) |+| `--agtx PATH` | `./target/release/agtx` | agtx binary β must be a Linux x86_64 binary for sandbox mode (use `../target/agtx-linux-x86_64`) || `--phase-timeout SECS` | 1200 | Per-phase max seconds (20 min) |-| `--model-name STRING` | `agtx-{plugin}-{agent}` | Label in predictions.jsonl |+| `--model-name STRING` | `{config-stem}` (e.g. `claude-agtx`) | Label in predictions.jsonl || `--split STRING` | `test` | HuggingFace dataset split || `--verbose` / `-v` | off | Print step-by-step progress to stderr (good for debugging) || `--hard` | off | Strip fenced code blocks and stack traces from the problem statement, keeping prose and inline code. The agent must find and fix the bug from first principles. |@@ -168,7 +269,7 @@ deactivate### Output-Results are written to `./swebench_output/{plugin}_{agent}_{timestamp}/`:+Results are written to `./swebench_output/{config-name}_{timestamp}/`:**`predictions.jsonl`** β SWE-bench format, one line per task:```json@@ -200,22 +301,24 @@ cat swebench_output/*/results.json | \### Cleanup+#### Non-sandbox cleanup+After an interrupted or completed run, stale state (worktrees, tmux sessions, SQLite DBs) can becleaned up with the included script.**Clean all instances:**```bash-./benchmarks/swebench/cleanup.sh+./swebench/cleanup.sh```**Clean a specific instance:**```bash-./benchmarks/swebench/cleanup.sh astropy__astropy-12907+./swebench/cleanup.sh astropy__astropy-12907```**Clean multiple specific instances:**```bash-./benchmarks/swebench/cleanup.sh astropy__astropy-12907 sympy__sympy-20590+./swebench/cleanup.sh astropy__astropy-12907 sympy__sympy-20590```The script removes `.agtx/` dirs, tmux sessions, and central SQLite project DBs.@@ -223,26 +326,69 @@ Repo clones under `/tmp/swebench_repos/` are preserved so the next run skips re-Override the repo clone directory with `SWEBENCH_WORKDIR`:```bash-SWEBENCH_WORKDIR=/my/custom/path ./benchmarks/swebench/cleanup.sh+SWEBENCH_WORKDIR=/my/custom/path ./swebench/cleanup.sh+```++#### Sandbox cleanup++Containers are stopped and removed automatically when a run completes or fails. If the process+is killed mid-run, containers may be left running:++```bash+# Stop and remove a specific container+docker rm -f swebench-astropy-astropy-12907++# Stop and remove all swebench containers+docker ps -a --filter name=swebench- -q | xargs docker rm -f+```++The tools volume is persistent across runs. Remove it only if you want to repopulate it+(e.g. after rebuilding the tools image):+```bash+docker volume rm agtx-swebench-tools```---### Evaluation-After the run, evaluate patches against the SWE-bench test harness-(requires [SWE-bench](https://github.com/princeton-nlp/SWE-bench) installed):+After the run, the benchmark prints exact commands to copy-paste. Evaluate patches against the+SWE-bench test harness (requires Docker running):```bash-python -m swebench.harness.run_evaluation \+uv run python -m swebench.harness.run_evaluation \--dataset_name princeton-nlp/SWE-bench_Lite \- --predictions_path swebench_output/agtx_claude_20260427_120000/predictions.jsonl \- --run_id agtx-claude-1+ --predictions_path swebench_output/claude-agtx_20260427_120000/predictions.jsonl \+ --run_id claude-agtx-1746345600```The harness runs tests in Docker containers β each task gets a fresh repo checkout-and the patch is applied and tested in isolation. The benchmark script's output-directory is not used during evaluation.+and the patch is applied and tested in isolation.++### Report++After evaluation, print a summary table with resolved status, duration, cost, and token usage:++```bash+uv run python swebench/report.py \+ --results swebench_output/claude-agtx_20260427_120000/results.json \+ --logs logs/run_evaluation/claude-agtx-1746345600/+```++Example output:+```+βββββββββββββββββββββββββ¬ββββββββββββββ¬βββββββββββ¬ββββββββ¬βββββββββ+β Instance β Status β Duration β Cost β Tokens β+βββββββββββββββββββββββββΌββββββββββββββΌβββββββββββΌββββββββΌβββββββββ€+β astropy/astropy-12907 β β resolved β 4m 57s β $0.95 β 1.9M β+βββββββββββββββββββββββββΌββββββββββββββΌβββββββββββΌββββββββΌβββββββββ€+β astropy/astropy-14182 β β failed β 5m 57s β $1.66 β 5.3M β+βββββββββββββββββββββββββ΄ββββββββββββββ΄βββββββββββ΄ββββββββ΄βββββββββ++1/2 resolved Β· 10m 54s total Β· $2.60 total Β· 7.3M tokens+```++The exact commands (with correct paths and run_id) are printed at the end of every benchmark run.---@@ -250,9 +396,11 @@ directory is not used during evaluation.```benchmark.py- βββ Clones each repo at base_commit β /tmp/swebench_repos/{instance_id}/- βββ Writes .agtx/config.toml (your config file) into each clone- βββ Starts agtx TUI per task in detached tmux (tmux -L swebench)+ βββ [sandbox] Pulls SWE-bench Docker image, starts container with tools volume mounted+ βββ [sandbox] Copies credentials, wires tools (tmux/node/claude via symlinks), runs sandbox_init+ βββ [non-sandbox] Clones each repo at base_commit β /tmp/swebench_repos/{instance_id}/+ βββ Writes .agtx/config.toml (your config file) into each repo/container+ βββ Starts agtx TUI per task in detached tmux (tmux -L agtx, inside container in sandbox mode)βββ Spawns agtx mcp-serve as subprocess (JSON-RPC 2.0 over stdio)βββ Drives task via MCP:β create_task β move_forward (Planning)@@ -267,5 +415,9 @@ Phase completion detection (per phase, in priority order):1. **Artifact file** β if the plugin defines an artifact for that phase (e.g. `.agtx/plan.md`,`.agtx/execute.md`, `.agtx/review.md` for the `agtx`/`agtx-terse` plugins), polls for itsexistence every 5 seconds-2. **Pane stability** β fallback for plugins without artifacts (e.g. `void`): two- consecutive unchanged pane reads at 30-second intervals (β₯60s stable)+2. **Claude finish marker** β detects `β» [Word] for Xs` followed by a `β―` prompt in the pane;+ confirmed within 5 seconds of the marker appearing+3. **Pane stability** β fallback for plugins without artifacts when no finish marker is seen: pane+ content identical for 2 consecutive 5-second checks (10s stable). If stability is reached+ without a finish marker, a warning is emitted β the agent may be stuck, errored, or waiting+ for manual approvaldiff --git a/benchmark/RESULTS.md b/benchmark/RESULTS.mdnew file mode 100644index 0000000..bb8b850--- /dev/null+++ b/benchmark/RESULTS.md@@ -0,0 +1,62 @@+# Benchmark Results++Tracks agtx benchmark runs against [SWE-bench Lite](https://github.com/princeton-nlp/SWE-bench).+All runs use Claude Sonnet as the agent, sandbox mode (`--sandbox`).++> **Note on tokens vs cost:** Token count is a simple sum of all token types (input + output + cache read + cache write). Since cache reads are 10Γ cheaper than regular input ($0.30 vs $3.00/MTok on Sonnet 4.6), a run with more tokens can have lower cost if those extra tokens are mostly cache reads.+>+> **Resolution icons:** β Resolved β π‘ Fix correct but incomplete (missing tests, spurious changes) β β Fix wrong or no patch++---++## `claude-agtx`++| Instance | Date | Duration | Tokens | Cost | Result | Notes |+|----------|------|----------|--------|------|--------|-------|+| `astropy__astropy-12907` | 2026-06-29 | 2m 38s | 1,514K | $1.00 | π‘ | Correct fix in `separable.py`; missing test cases |+| `astropy__astropy-14182` | 2026-06-29 | 3m 17s | 1,400K | $1.11 | β | Fix attempted but tests still fail |++## `claude-rtk-caveman-agtx`++| Instance | Date | Duration | Tokens | Cost | Result | Notes |+|----------|------|----------|--------|------|--------|-------|+| `astropy__astropy-12907` | 2026-06-29 | 2m 14s | 1,149K | $0.92 | π‘ | Correct fix in `separable.py`; missing test cases |+| `astropy__astropy-14182` | 2026-06-29 | 3m 31s | 1,800K | $1.18 | β | Fix attempted but tests still fail |++## `claude-rtk-ponytail-agtx`++| Instance | Date | Duration | Tokens | Cost | Result | Notes |+|----------|------|----------|--------|------|--------|-------|+| `astropy__astropy-12907` | 2026-06-30 | 2m 27s | 1,314K | $1.02 | π‘ | Correct fix in `separable.py`; missing test cases |+| `astropy__astropy-14182` | 2026-06-30 | 5m 21s | 2,586K | $1.21 | β | Fix attempted but tests still fail |++## `claude-rtk-caveman-ponytail-agtx`++| Instance | Date | Duration | Tokens | Cost | Result | Notes |+|----------|------|----------|--------|------|--------|-------|+| `astropy__astropy-12907` | 2026-06-29 | 2m 09s | 1,006K | $0.55 | π‘ | Correct fix in `separable.py`; missing test cases |+| `astropy__astropy-14182` | 2026-06-29 | 6m 07s | 2,500K | $1.15 | β | Fix attempted but tests still fail |++## `claude-superpowers`++| Instance | Date | Duration | Tokens | Cost | Result | Notes |+|----------|------|----------|--------|------|--------|-------|+| `astropy__astropy-12907` | 2026-06-30 | 15m 46s | 5,400K | $2.64 | β | Correct fix + test case added; |++## `claude-spec-kit`++| Instance | Date | Duration | Tokens | Cost | Result | Notes |+|----------|------|----------|--------|------|--------|-------|+| `astropy__astropy-12907` | 2026-06-30 | 4m 48s | 926K | $0.40 | π‘ | Correct fix in `separable.py`; no test case added |++## `claude-openspec`++| Instance | Date | Duration | Tokens | Cost | Result | Notes |+|----------|------|----------|--------|------|--------|-------|+| `astropy__astropy-12907` | 2026-06-30 | 2m 15s | 468K | $0.48 | π‘ | Correct fix in `separable.py`; no test case added; `/opsx:verify` command didn't exist (fixed) |++## `claude-agent-skills`++| Instance | Date | Duration | Tokens | Cost | Result | Notes |+|----------|------|----------|--------|------|--------|-------|+| `astropy__astropy-12907` | 2026-07-01 | 3m 30s | 2,680K | $1.04 | π‘ | Correct fix in `separable.py`; no test case added; spurious `setuptools==68.0.0` pin |diff --git a/benchmark/swebench/benchmark.py b/benchmark/swebench/benchmark.pyindex e8ab9cd..1a1dd0d 100755--- a/benchmark/swebench/benchmark.py+++ b/benchmark/swebench/benchmark.py@@ -21,6 +21,7 @@ Usage:python benchmark.py --config my_config.toml --instances 1python benchmark.py --config my_config.toml --concurrency 2 --instances 10python benchmark.py --config my_config.toml --instance-ids sympy__sympy-20590+ python benchmark.py --config my_config.toml --instance-ids astropy__astropy-12907 --sandbox --verbose --agtx ../../target/release/agtxExample config.toml:default_agent = "claude"@@ -32,9 +33,11 @@ from __future__ import annotationsimport argparseimport json+import osimport reimport subprocessimport sys+import tempfileimport threadingimport timefrom concurrent.futures import ThreadPoolExecutor, as_completed@@ -112,11 +115,21 @@ class McpError(Exception):class McpClient:"""Raw JSON-RPC 2.0 MCP client over subprocess stdin/stdout."""- def __init__(self, agtx_bin: str, repo_path: str):+ def __init__(self, agtx_bin: str, repo_path: str, container_id: str | None = None):self._seq = 0self._lock = threading.Lock()+ if container_id:+ cmd = [+ "docker", "exec", "-i", container_id,+ "/bin/bash", "-c",+ "export HOME=/home/bench"+ " && source /opt/miniconda3/bin/activate && conda activate testbed"+ " && agtx mcp-serve /testbed",+ ]+ else:+ cmd = [agtx_bin, "mcp-serve", repo_path]self._proc = subprocess.Popen(- [agtx_bin, "mcp-serve", repo_path],+ cmd,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.DEVNULL,@@ -241,19 +254,32 @@ def setup_repo(instance: dict, workdir: str, config_path: Path, verbose: bool =head_ok = head_result.returncode == 0 and head_result.stdout.strip() == base_commitno_task_branches = branch_result.returncode != 0 or not branch_result.stdout.strip()- if head_ok and no_task_branches:- if verbose:- print(f" [setup] Using cached repo at {repo_path}", file=sys.stderr)- _write_agtx_config(repo_path, config_path, base_commit)- return repo_path- else:+ if not head_ok:+ # Wrong commit β need a clean cloneif verbose:print(- f" [setup] Contaminated clone (head_ok={head_ok}, "- f"task_branches={not no_task_branches}), removing {repo_path}",+ f" [setup] Stale clone (wrong commit), removing {repo_path}",file=sys.stderr,)subprocess.run(["rm", "-rf", str(repo_path)], check=True)+ else:+ if not no_task_branches:+ # Just delete leftover task branches, no need to re-clone+ for branch in branch_result.stdout.strip().splitlines():+ branch = branch.strip()+ if branch:+ subprocess.run(+ ["git", "branch", "-D", branch],+ cwd=repo_path,+ capture_output=True,+ )+ if verbose:+ print(f" [setup] Cleaned stale task branches, reusing {repo_path}", file=sys.stderr)+ else:+ if verbose:+ print(f" [setup] Using cached repo at {repo_path}", file=sys.stderr)+ _write_agtx_config(repo_path, config_path, base_commit)+ return repo_pathif verbose:print(f" [setup] Cloning {repo_url} β {repo_path}", file=sys.stderr)@@ -387,6 +413,413 @@ def kill_tmux_session(slug: str, repo_path: Path | None = None) -> None:)+# ---------------------------------------------------------------------------+# Docker helpers+# ---------------------------------------------------------------------------++def docker_image_name(instance_id: str) -> str:+ """Convert an instance_id to its SWE-bench Docker image name.++ e.g. astropy__astropy-12907 β swebench/sweb.eval.x86_64.astropy_1776_astropy-12907:latest+ """+ image_slug = instance_id.replace("__", "_1776_")+ return f"swebench/sweb.eval.x86_64.{image_slug}:latest"+++TOOLS_IMAGE = "agtx/swebench-tools:latest"+TOOLS_CONTAINER = "agtx-swebench-tools"+TOOLS_VOLUME = "agtx-swebench-tools"+++def _tools_image_exists() -> bool:+ """Return True if the shared tools image has been built by prebake_images.py."""+ result = subprocess.run(+ ["docker", "image", "inspect", TOOLS_IMAGE],+ capture_output=True,+ )+ return result.returncode == 0+++def _tools_volume_exists() -> bool:+ result = subprocess.run(+ ["docker", "volume", "inspect", TOOLS_VOLUME],+ capture_output=True,+ )+ return result.returncode == 0+++def ensure_tools_volume(verbose: bool = False) -> None:+ """Create and populate the tools volume from the tools image if it doesn't exist.++ The volume contains tmux + libutempter (so SWE-bench containers don't need apt),+ node, node_modules, and rtk. Mounting read-only at /tools avoids copying the large+ Node stack into instance containers' writable layers.+ """+ if _tools_volume_exists():+ if verbose:+ print(f" [docker] Tools volume '{TOOLS_VOLUME}' already exists.", file=sys.stderr)+ return+ if verbose:+ print(f" [docker] Creating tools volume '{TOOLS_VOLUME}'...", file=sys.stderr)+ subprocess.run(["docker", "volume", "create", TOOLS_VOLUME], check=True, capture_output=True)+ # Populate volume by running a one-shot container that copies from the image into the volume.+ # libutempter is copied alongside tmux because SWE-bench containers don't have it.+ subprocess.run(+ [+ "docker", "run", "--rm", "--platform", "linux/amd64",+ "-v", f"{TOOLS_VOLUME}:/tools",+ TOOLS_IMAGE,+ "/bin/bash", "-c",+ "cp -a /usr/bin/tmux /usr/bin/node /usr/lib/node_modules /tools/"+ " && mkdir -p /tools/lib/x86_64-linux-gnu"+ " && cp /lib/x86_64-linux-gnu/libutempter.so.* /tools/lib/x86_64-linux-gnu/"+ " && cp /lib/x86_64-linux-gnu/libevent_core-2.1.so.* /tools/lib/x86_64-linux-gnu/",+ ],+ check=True, capture_output=not verbose,+ )+ if verbose:+ print(f" [docker] Tools volume ready.", file=sys.stderr)+++def start_tools_container(verbose: bool = False) -> str:+ """Start the shared tools container and return its container ID.++ The tools container is a long-running instance of agtx/swebench-tools:latest+ used as a source to copy tmux/Node/Claude Code binaries into benchmark containers.+ Starting it once and sharing it across all concurrent runs avoids redundant installs.+ """+ # Kill any stale tools container+ subprocess.run(["docker", "rm", "-f", TOOLS_CONTAINER], capture_output=True)+ result = subprocess.run(+ ["docker", "run", "-d", "--platform", "linux/amd64",+ "--name", TOOLS_CONTAINER, TOOLS_IMAGE, "sleep", "infinity"],+ check=True, capture_output=True, text=True,+ )+ container_id = result.stdout.strip()+ if verbose:+ print(f" [docker] Started tools container {container_id[:12]}", file=sys.stderr)+ return container_id+++def stop_tools_container(verbose: bool = False) -> None:+ subprocess.run(["docker", "rm", "-f", TOOLS_CONTAINER], capture_output=True)+++def _agtx_db_dir() -> str:+ """Return the host path to the agtx database directory."""+ if sys.platform == "darwin":+ return str(Path.home() / "Library" / "Application Support" / "agtx")+ return str(Path.home() / ".config" / "agtx")+++def _docker_env_overrides() -> list[str]:+ """Build -e flags for docker run to fix localhost URLs in Claude env settings.++ Reads ~/.claude/settings.json env overrides (read-only, never modified) and+ replaces http://localhost: with http://host.docker.internal: so proxies running+ on the macOS host are reachable from inside the container.+ Returns a flat list of ["-e", "KEY=VALUE", ...] suitable for subprocess args.+ """+ settings_path = Path.home() / ".claude" / "settings.json"+ if not settings_path.exists():+ return []+ try:+ data = json.loads(settings_path.read_text())+ env_overrides = data.get("env", {})+ except Exception:+ return []+ result = []+ for key, val in env_overrides.items():+ if isinstance(val, str) and "localhost" in val:+ val = val.replace("http://localhost:", "http://host.docker.internal:")+ val = val.replace("https://localhost:", "https://host.docker.internal:")+ result += ["-e", f"{key}={val}"]+ return result+++def start_docker_container(+ instance_id: str, slug: str, agtx_bin: str, verbose: bool = False+) -> str:+ """Pull the SWE-bench image and start a long-running container. Returns container_id."""+ container_name = f"swebench-{slug}"+ image = docker_image_name(instance_id)++ # Kill any stale container with the same name+ subprocess.run(["docker", "rm", "-f", container_name], capture_output=True)++ if verbose:+ print(f" [docker] Pulling {image}...", file=sys.stderr)+ subprocess.run(+ ["docker", "pull", "--platform", "linux/amd64", image],+ check=True,+ capture_output=not verbose,+ )++ if verbose:+ print(f" [docker] Starting container {container_name}...", file=sys.stderr)++ # Mount the tools volume if available β provides tmux, node, node_modules, rtk+ # without consuming writable layer space in the instance container.+ extra_mounts = []+ if _tools_volume_exists():+ extra_mounts = ["-v", f"{TOOLS_VOLUME}:/tools:ro"]+ if verbose:+ print(f" [docker] Mounting tools volume.", file=sys.stderr)++ run_result = subprocess.run(+ [+ "docker", "run", "-d",+ "--platform", "linux/amd64",+ "--name", container_name,+ "-v", f"{agtx_bin}:/usr/local/bin/agtx",+ ] + extra_mounts + [+ image,+ "sleep", "infinity",+ ],+ capture_output=True,+ text=True,+ check=True,+ )+ container_id = run_result.stdout.strip()+ if verbose:+ print(f" [docker] Container id: {container_id[:12]}", file=sys.stderr)+ return container_id+++def setup_container(+ container_id: str, config_path: Path, base_commit: str, verbose: bool = False,+ tools_container_id: str | None = None,+ extra_dirs: list[tuple[Path, str]] | None = None,+ sandbox_init: list[str] | None = None,+) -> None:+ """Write agtx config into the container and install tmux + Node + Claude Code.++ If tools_container_id is provided, binaries are copied from the shared tools+ container instead of being installed from the network (~3-5 min saved).++ extra_dirs is an optional list of (host_path, container_dest) pairs for copying+ additional files into the container (e.g. third-party plugin skill directories).++ sandbox_init is an optional list of shell commands to run inside the container+ after setup (e.g. ["rtk init -g"] to activate rtk hooks).+ """+ # Parse default_agent from the benchmark config so we can write a global agtx config+ # inside the container. Without it agtx shows the agent-selection wizard on startup.+ bench_config = load_config_toml(config_path)+ default_agent = bench_config.get("default_agent", "claude")++ # Copy Claude credentials into the container as snapshots (not mounts).+ # This avoids writing back to host files and lets us patch localhost URLs.+ # We only copy the credential/config files β NOT ~/.claude/projects/ which can be+ # gigabytes of conversation history and would exhaust the container's disk space.+ home = Path.home()+ subprocess.run(+ ["docker", "exec", container_id, "/bin/bash", "-c",+ "mkdir -p /home/bench/.config/claude /home/bench/.claude"],+ check=True, capture_output=not verbose,+ )+ # ~/.config/claude/ β API key and auth tokens+ config_claude = home / ".config" / "claude"+ if config_claude.exists():+ subprocess.run(+ ["docker", "cp", f"{config_claude}/.", f"{container_id}:/home/bench/.config/claude"],+ check=True, capture_output=not verbose,+ )+ # ~/.claude/ β copy only top-level files (settings.json, credentials), skip subdirs+ # (projects/, worktrees/, etc.) which contain large conversation history+ claude_dir = home / ".claude"+ if claude_dir.exists():+ for item in claude_dir.iterdir():+ if item.is_file():+ subprocess.run(+ ["docker", "cp", str(item), f"{container_id}:/home/bench/.claude/{item.name}"],+ check=True, capture_output=not verbose,+ )++ # Copy ~/.claude.json as a snapshot so Claude skips the first-launch welcome screen.+ claude_json = home / ".claude.json"+ if claude_json.exists():+ subprocess.run(+ ["docker", "cp", str(claude_json), f"{container_id}:/home/bench/.claude.json"],+ check=True, capture_output=not verbose,+ )++ # Copy extra directories into the container (e.g. third-party plugin skill dirs).+ for src, dst in (extra_dirs or []):+ if not src.exists():+ print(f" [docker] Warning: extra_dir source not found, skipping: {src}", file=sys.stderr)+ continue+ if verbose:+ print(f" [docker] Copying {src} β container:{dst}", file=sys.stderr)+ subprocess.run(+ ["docker", "exec", container_id, "/bin/bash", "-c", f"mkdir -p {dst}"],+ capture_output=True,+ )+ subprocess.run(+ ["docker", "cp", f"{src}/.", f"{container_id}:{dst}"],+ check=True, capture_output=not verbose,+ )++ # Patch localhost β host.docker.internal in settings.json inside the container.+ # Claude reads ANTHROPIC_BASE_URL from settings.json["env"] which overrides process env,+ # so we must fix it in the file itself (container-local copy only, host file untouched).+ subprocess.run(+ ["docker", "exec", container_id, "/bin/bash", "-c",+ r"sed -i 's|http://localhost:|http://host.docker.internal:|g'"+ r" /home/bench/.claude/settings.json 2>/dev/null || true"],+ capture_output=True,+ )++ # Write global agtx config for bench user so the TUI skips the agent-selection wizard+ global_config_content = f'default_agent = "{default_agent}"\n'+ if verbose:+ print(f" [docker] Writing global agtx config (default_agent={default_agent})...", file=sys.stderr)+ subprocess.run(+ ["docker", "exec", container_id,+ "/bin/bash", "-c",+ f"mkdir -p /home/bench/.config/agtx && cat > /home/bench/.config/agtx/config.toml << 'ENDOFCONFIG'\n{global_config_content}\nENDOFCONFIG"],+ check=True,+ capture_output=not verbose,+ )++ # Write .agtx/config.toml into /testbed inside the container+ # Build the config content (with base_branch injected) in memory+ content = config_path.read_text()+ base_branch_line = f'base_branch = "{base_commit}"\n'+ lines = [l for l in content.splitlines(keepends=True) if not l.startswith("base_branch =")]+ insert_at = next((i for i, l in enumerate(lines) if l.startswith("[")), len(lines))+ lines.insert(insert_at, base_branch_line)+ config_content = "".join(lines)++ if verbose:+ print(f" [docker] Writing .agtx/config.toml into container...", file=sys.stderr)+ subprocess.run(+ ["docker", "exec", container_id,+ "/bin/bash", "-c",+ f"mkdir -p /testbed/.agtx && cat > /testbed/.agtx/config.toml << 'ENDOFCONFIG'\n{config_content}\nENDOFCONFIG"],+ check=True,+ capture_output=not verbose,+ )++ # Clean stale agtx state (worktrees, project DB) β same as _write_agtx_config+ subprocess.run(+ ["docker", "exec", container_id,+ "/bin/bash", "-c",+ "rm -rf /testbed/.agtx/worktrees /testbed/.agtx/db"],+ capture_output=True,+ )++ # Activate the conda 'testbed' environment for all new shells.+ # SWE-bench images ship with repo dependencies pre-installed in conda env 'testbed'.+ # Without this, Claude uses the system python/pip and tries to reinstall everything.+ subprocess.run(+ ["docker", "exec", container_id, "/bin/bash", "-c",+ "echo 'source /opt/miniconda3/etc/profile.d/conda.sh && conda activate testbed'"+ " >> /root/.bashrc"],+ check=True, capture_output=not verbose,+ )++ if tools_container_id:+ # Tools volume is mounted at /tools (read-only). Symlink everything from there β+ # zero writable-layer usage. libutempter is included in the volume because+ # SWE-bench containers don't have it (tmux needs it).+ if verbose:+ print(f" [docker] Wiring tools from volume...", file=sys.stderr)+ subprocess.run(+ ["docker", "exec", container_id, "/bin/bash", "-c",+ "ln -sf /tools/tmux /usr/bin/tmux"+ " && ln -sf /tools/node /usr/bin/node"+ " && ln -sf /tools/node_modules/npm/bin/npm-cli.js /usr/bin/npm"+ " && ln -sf /tools/node_modules/npm/bin/npx-cli.js /usr/bin/npx"+ " && ln -sf /tools/node_modules/@anthropic-ai/claude-code/bin/claude.exe /usr/bin/claude"+ " && mkdir -p /usr/lib/node_modules"+ " && ln -sf /tools/node_modules/@anthropic-ai /usr/lib/node_modules/@anthropic-ai"+ " && ln -sf /tools/node_modules/npm /usr/lib/node_modules/npm"+ " && test -f /tools/node_modules/.bin/caveman && ln -sf /tools/node_modules/.bin/caveman /usr/bin/caveman || true"+ " && mkdir -p /usr/lib/x86_64-linux-gnu"+ " && ln -sf /tools/lib/x86_64-linux-gnu/libutempter.so.0 /usr/lib/x86_64-linux-gnu/libutempter.so.0"+ " && ln -sf /tools/lib/x86_64-linux-gnu/libutempter.so.1.2.1 /usr/lib/x86_64-linux-gnu/libutempter.so.1.2.1"+ " && ln -sf /tools/lib/x86_64-linux-gnu/libevent_core-2.1.so.7 /usr/lib/x86_64-linux-gnu/libevent_core-2.1.so.7"],+ check=True, capture_output=not verbose,+ )+ else:+ if verbose:+ print(f" [docker] Installing tmux, Node.js 22, Claude Code...", file=sys.stderr)+ subprocess.run(+ ["docker", "exec", container_id,+ "/bin/bash", "-c",+ "apt-get update -qq && apt-get install -y -qq tmux curl ca-certificates "+ "&& curl -fsSL https://deb.nodesource.com/setup_22.x | bash - "+ "&& apt-get install -y -qq nodejs "+ "&& npm install -g @anthropic-ai/claude-code"],+ check=True,+ capture_output=not verbose,+ )++ # Run optional sandbox init commands (e.g. "rtk init -g").+ # These run after credentials are in place so tools can write into ~/.claude/.+ # Prepend ~/.local/bin to PATH so tools installed there (e.g. rtk) are found.+ for cmd in (sandbox_init or []):+ if verbose:+ print(f" [docker] sandbox_init: {cmd}", file=sys.stderr)+ subprocess.run(+ ["docker", "exec", container_id, "/bin/bash", "-c",+ f"HOME=/home/bench && export HOME PATH=$HOME/.local/bin:$PATH && {cmd}"],+ check=True, capture_output=not verbose,+ )+++def start_tui_in_container(slug: str, container_id: str, verbose: bool = False) -> None:+ """Start the agtx TUI inside the container's tmux session."""+ if verbose:+ print(f" [docker] Starting agtx TUI in container tmux session '{slug}'...", file=sys.stderr)+ # Launch agtx with all required env vars baked into the command so every tmux+ # window it spawns (agent sessions) inherits them from the start β no race.+ # HOME=/home/bench β agtx reads ~/.config/agtx/config.toml+ # IS_SANDBOX=1 β bypasses Claude's root check (--dangerously-skip-permissions)+ # PATH/CONDA vars β activate conda 'testbed' env so pre-installed deps are used+ testbed_bin = "/opt/miniconda3/envs/testbed/bin"+ env_prefix = (+ f"HOME=/home/bench "+ f"IS_SANDBOX=1 "+ f"CONDA_DEFAULT_ENV=testbed "+ f"CONDA_PREFIX=/opt/miniconda3/envs/testbed "+ f"PATH={testbed_bin}:/opt/miniconda3/bin:/home/bench/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"+ )+ subprocess.run(+ ["docker", "exec", "-d", container_id,+ "tmux", "new-session", "-d", "-s", slug,+ f"env {env_prefix} agtx /testbed"],+ check=True,+ capture_output=not verbose,+ )+ # Also set them in the agtx tmux server global env so windows created later+ # (e.g. after a phase transition) also inherit the correct PATH.+ time.sleep(3)+ for key, val in [+ ("HOME", "/home/bench"),+ ("IS_SANDBOX", "1"),+ ("CONDA_DEFAULT_ENV", "testbed"),+ ("CONDA_PREFIX", "/opt/miniconda3/envs/testbed"),+ ("PATH", f"{testbed_bin}:/opt/miniconda3/bin:/home/bench/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"),+ ]:+ subprocess.run(+ ["docker", "exec", container_id,+ "tmux", "-L", "agtx", "set-environment", "-g", key, val],+ capture_output=True,+ )+ # Give the TUI time to fully start before the caller proceeds+ time.sleep(5)+++def stop_docker_container(container_id: str, verbose: bool = False) -> None:+ """Stop and remove the container."""+ if verbose:+ print(f" [docker] Stopping container {container_id[:12]}...", file=sys.stderr)+ subprocess.run(["docker", "stop", container_id], capture_output=True)+ subprocess.run(["docker", "rm", container_id], capture_output=True)++# ---------------------------------------------------------------------------# Token/cost tracking via tokscale# ---------------------------------------------------------------------------@@ -472,9 +905,63 @@ def tokscale_diff(before: dict, after: dict) -> dict:}-# ----------------------------------------------------------------------------# Results store-# ---------------------------------------------------------------------------+def tokscale_from_container(container_id: str, agent: str) -> dict:+ """+ Read token/cost usage from a sandbox container by copying /home/bench/.claude+ to a temp dir and running tokscale --home against it.+ Returns the standard cost_data dict {cost_usd, cost_tokens}, or nulls on failure.+ """+ tokscale = _find_tokscale()+ if not tokscale:+ return {"cost_usd": None, "cost_tokens": None}++ flag = _TOKSCALE_FLAG.get(agent)+ if not flag:+ return {"cost_usd": None, "cost_tokens": None}++ try:+ with tempfile.TemporaryDirectory() as tmpdir:+ # Copy /home/bench/.claude out of the container+ result = subprocess.run(+ ["docker", "cp", f"{container_id}:/home/bench/.claude", tmpdir],+ capture_output=True,+ )+ if result.returncode != 0:+ return {"cost_usd": None, "cost_tokens": None}++ # tokscale --home expects the home dir (parent of .claude)+ result = subprocess.run(+ [tokscale, "--home", tmpdir, "--json", flag],+ capture_output=True,+ text=True,+ timeout=15,+ )+ if result.returncode != 0 or not result.stdout.strip():+ return {"cost_usd": None, "cost_tokens": None}++ data = json.loads(result.stdout)+ entries = data.get("entries", [])++ inp = out = cr = cw = reasoning = 0+ cost = 0.0+ for entry in entries:+ inp += entry.get("input", 0)+ out += entry.get("output", 0)+ cr += entry.get("cacheRead", 0)+ cw += entry.get("cacheWrite", 0)+ reasoning += entry.get("reasoning", 0)+ cost += entry.get("cost", 0.0)++ total = inp + out + cr + cw + reasoning+ return {+ "cost_usd": round(cost, 6) if cost > 0 else None,+ "cost_tokens": total if total > 0 else None,+ }+ except Exception:+ return {"cost_usd": None, "cost_tokens": None}+++class ResultsStore:"""Thread-safe, resumable persistence for benchmark results."""@@ -554,7 +1041,8 @@ PLUGIN_PLANNING_ARTIFACTS: dict[str, str | None] = {"spec-kit": None,"bmad": None,"openspec": None,- "superpowers": None,+ "agent-skills": None,+ "superpowers": "docs/superpowers/plans/*.md","oh-my-claudecode": None,"void": None,}@@ -567,7 +1055,8 @@ PLUGIN_RUNNING_ARTIFACTS: dict[str, str | None] = {"gsd": ".planning/phases/*/{phase}-SUMMARY.md","spec-kit": None,"bmad": "_bmad-output/implementation-artifacts/*.md",- "openspec": "openspec/changes/*/tasks.md",+ "openspec": None,+ "agent-skills": None,"superpowers": None,"oh-my-claudecode": None,"void": None,@@ -582,20 +1071,33 @@ PLUGIN_REVIEW_ARTIFACTS: dict[str, str | None] = {"spec-kit": None,"bmad": None,"openspec": None,+ "agent-skills": None,"superpowers": None,"oh-my-claudecode": None,"void": None,}-def _artifact_exists(worktree: Path, pattern: str) -> bool:- """Return True if the artifact path (possibly with * or {phase} placeholders) exists."""+def _artifact_exists(worktree: Path, pattern: str, container_id: str | None = None) -> bool:+ """Return True if the artifact path (possibly with * or {phase} placeholders) exists.++ In Docker mode (container_id provided), checks inside the container via docker exec+ instead of the local filesystem (the worktree lives inside the container).+ """if "{phase}" in pattern:for n in range(1, 21):for fmt in (f"{n:02d}", str(n)):- if _artifact_exists(worktree, pattern.replace("{phase}", fmt)):+ if _artifact_exists(worktree, pattern.replace("{phase}", fmt), container_id):return Truereturn False+ if container_id:+ # In Docker: use shell glob via docker exec so * patterns work+ path = str(worktree / pattern)+ result = subprocess.run(+ ["docker", "exec", container_id, "/bin/bash", "-c", f"ls {path} 2>/dev/null | head -1"],+ capture_output=True, text=True,+ )+ return bool(result.stdout.strip())if "*" not in pattern:return (worktree / pattern).exists()parts = Path(pattern).parts@@ -627,10 +1129,12 @@ class TaskRunner:)NOTE = (- "Note: the repo may not be fully installable in this environment. "- "Do not attempt to build, install, or run tests. "- "Do not run any git commands (no fetch, pull, merge, or commit). "- "Read the source code, understand the bug, and fix it by editing the relevant files directly."+ "IMPORTANT CONSTRAINTS β these apply to all phases including review:\n"+ "- NEVER install packages, dependencies, or build the project.\n"+ "- NEVER run tests under any circumstances.\n"+ "- Do not run any git commands (no fetch, pull, merge, or commit).\n"+ "- The repo may not be installable in this environment β do not attempt it.\n"+ "- Read the source code, understand the bug, and fix it by editing the relevant files directly.")@staticmethod@@ -660,6 +1164,7 @@ class TaskRunner:verbose: bool = False,smoke_test: bool = False,hard: bool = False,+ container_id: str | None = None,):self.instance = instanceself.instance_id = instance["instance_id"]@@ -673,6 +1178,7 @@ class TaskRunner:self.verbose = verboseself.smoke_test = smoke_testself.hard = hard+ self.container_id = container_idself.mcp: McpClient | None = Nonedef _poll_transition(self, request_id: str, timeout: int = 120) -> None:@@ -721,36 +1227,95 @@ class TaskRunner:worktree = Path(worktree_path)deadline = time.monotonic() + timeoutwhile time.monotonic() < deadline:- if _artifact_exists(worktree, artifact_pattern):+ if _artifact_exists(worktree, artifact_pattern, self.container_id):return Truetime.sleep(5)return False+ # Patterns that indicate a shell command run by the agent is waiting for input,+ # blocking Claude from finishing. Only used in the stability fallback path.+ _INTERACTIVE_PROMPT_PATTERNS = [+ r"\[y/N\]",+ r"\[Y/n\]",+ r"\[y/n\]",+ r"\[Y/N\]",+ r"Press Enter to continue",+ r"Press any key",+ ]++ def _check_interactive_prompt(self, content: str) -> str | None:+ """Return the matching line if pane content looks like an interactive prompt, else None."""+ for line in content.splitlines()[-20:]:+ for pattern in self._INTERACTIVE_PROMPT_PATTERNS:+ if re.search(pattern, line, re.IGNORECASE):+ return line.strip()+ return None++ # Claude always prints one of these lines when it finishes a response.+ # Detecting this (plus the β― prompt) is more reliable than pure pane stability.+ _CLAUDE_FINISHED_RE = re.compile(r"β»\s+[A-Z][a-z]+ for \d+s")++ def _is_claude_idle(self, content: str) -> bool:+ """Return True when Claude has finished its last response and shows the β― prompt."""+ lines = content.splitlines()+ has_finish_marker = any(self._CLAUDE_FINISHED_RE.search(l) for l in lines)+ has_prompt = any(l.strip() == "β―" or l.strip().startswith("β― ") for l in lines[-10:])+ return has_finish_marker and has_prompt+def _wait_for_pane_stable(self, task_id: str, timeout: int) -> None:- """Wait for pane content to be stable for 2 consecutive 30s checks (no artifact available)."""+ """Wait until Claude has finished its last response (no artifact available).++ Primary signal: Claude prints 'β» Cooked/Worked/Crunched for Xs' + β― prompt.+ Fallback: pane content identical for 2 consecutive 10s checks.++ If an interactive prompt is detected while stable, prints a warning so the user+ can attach to the session and answer it.+ """prev_content: str | None = Nonestable_count = 0+ prompt_warned = Falsedeadline = time.monotonic() + timeoutwhile time.monotonic() < deadline:- time.sleep(30)+ time.sleep(5)try:result = self.mcp.call("read_pane_content", task_id=task_id, lines=80)content = result.get("content", "")except McpError:content = ""+ # Primary: Claude idle signal+ if self._is_claude_idle(content):+ return+ # Interactive prompt check (even when not yet stable)if content == prev_content:stable_count += 1- if stable_count >= 2:- return+ prompt_line = self._check_interactive_prompt(content)+ if prompt_line:+ if not prompt_warned:+ print(f"\n[{self.instance_id}] β Agent is waiting for input: \"{prompt_line}\"", file=sys.stderr)+ slug = self.instance_id.replace("__", "-").replace("_", "-")+ print(f" Attach to answer: docker exec -it swebench-{slug} tmux -L agtx attach -t testbed:1", file=sys.stderr)+ prompt_warned = True+ stable_count = 0 # Reset β not actually done+ elif stable_count >= 2:+ # Pane stable but no Claude finish marker β needs attention.+ # Possible causes: agent error, waiting for user approval (e.g. superpowers brainstorm),+ # or genuinely stuck. Warn once and keep polling; do NOT advance.+ if not prompt_warned:+ slug = self.instance_id.replace("__", "-").replace("_", "-")+ print(f"\n[{self.instance_id}] β Pane stable but no finish marker β agent may be stuck, hit an error, or requires manual approval.", file=sys.stderr)+ print(f" Attach to inspect or interact: docker exec -it swebench-{slug} tmux -L agtx attach -t testbed:1", file=sys.stderr)+ prompt_warned = True+ stable_count = 0 # Keep polling, don't advanceelse:stable_count = 0+ prompt_warned = Falseprev_content = contentdef run(self) -> dict:start = time.monotonic()if self.verbose:print(f" [{self.instance_id}] Starting MCP handshake...", file=sys.stderr)- self.mcp = McpClient(self.agtx_bin, str(self.repo_path))+ self.mcp = McpClient(self.agtx_bin, str(self.repo_path), container_id=self.container_id)task_id = Nonetry:@@ -781,8 +1346,8 @@ class TaskRunner:planning_task = self._wait_for_worktree(task_id, timeout=180)worktree_path = planning_task.get("worktree_path", "")- # Snapshot tokscale before agent starts working- cost_before = _tokscale_snapshot(self.running_agent)+ # Snapshot tokscale before agent starts working (non-sandbox only)+ cost_before = _tokscale_snapshot(self.running_agent) if not self.container_id else None# Wait for planning phase artifact (.agtx/plan.md for agtx/agtx-terse plugins)planning_artifact = PLUGIN_PLANNING_ARTIFACTS.get(self.plugin)@@ -820,8 +1385,13 @@ class TaskRunner:print(f" [{self.instance_id}] Waiting for running phase (pane stability)...", file=sys.stderr)self._wait_for_pane_stable(task_id, self.phase_timeout)- # Snapshot again and diff to get this task's usage- cost_data = tokscale_diff(cost_before, _tokscale_snapshot(self.running_agent))+ # Collect token/cost usage:+ # - sandbox: read directly from container's /home/bench/.claude via tokscale --home+ # - non-sandbox: diff host tokscale snapshots taken before/after running phase+ if self.container_id:+ cost_data = tokscale_from_container(self.container_id, self.running_agent)+ else:+ cost_data = tokscale_diff(cost_before, _tokscale_snapshot(self.running_agent))if self.verbose:print(f" [{self.instance_id}] Running done, moving to Review...", file=sys.stderr)@@ -872,10 +1442,25 @@ class TaskRunner:self.mcp.close()def _collect_patch(self, task: dict) -> str:+ base_commit = self.instance["base_commit"]++ if self.container_id:+ # In Docker mode, diff /testbed directly inside the container+ result = subprocess.run(+ [+ "docker", "exec", self.container_id,+ "git", "-C", "/testbed", "diff", base_commit,+ "--", ".", ":!.agtx/",+ ],+ capture_output=True,+ )+ if result.returncode != 0:+ return ""+ return result.stdout.decode("utf-8", errors="replace")+worktree_path = task.get("worktree_path")if not worktree_path:return ""- base_commit = self.instance["base_commit"]# Diff the worktree's actual files against the base commit.# Using the worktree path directly avoids picking up any extra commits# the agent may have merged/fetched onto the branch β we only care about@@ -932,6 +1517,9 @@ class BenchmarkOrchestrator:verbose: bool = False,smoke_test: bool = False,hard: bool = False,+ docker: bool = False,+ extra_dirs: list[tuple[Path, str]] | None = None,+ sandbox_init: list[str] | None = None,):self.instances = instancesself.agtx_bin = agtx_bin@@ -947,6 +1535,10 @@ class BenchmarkOrchestrator:self.verbose = verboseself.smoke_test = smoke_testself.hard = hard+ self.docker = docker+ self.extra_dirs = extra_dirs or []+ self.sandbox_init = sandbox_init or []+ self.tools_container_id: str | None = None # set in run() when --sandbox is activedef _run_one(self, instance: dict, progress: tqdm) -> None:instance_id = instance["instance_id"]@@ -958,36 +1550,92 @@ class BenchmarkOrchestrator:slug = re.sub(r"[^a-z0-9]+", "-", instance_id.lower()).strip("-")[:50]start = time.monotonic()- if self.verbose:- print(f"\n[{instance_id}] Setting up repo...", file=sys.stderr)- try:- repo_path = setup_repo(instance, self.workdir, self.config_path, verbose=self.verbose, smoke_test=self.smoke_test)- except Exception as e:- self.store.save_result(- instance_id=instance_id,- status="setup_error",- duration_seconds=time.monotonic() - start,- model_name=self.model_name,- error=str(e),- )- progress.update(1)- return+ container_id: str | None = None+ repo_path: Path | None = None- if self.verbose:- print(f"[{instance_id}] Starting TUI...", file=sys.stderr)- try:- start_tui_in_tmux(slug, repo_path, self.agtx_bin, verbose=self.verbose)- time.sleep(8) # Wait for TUI startup + project registration- except Exception as e:- self.store.save_result(- instance_id=instance_id,- status="setup_error",- duration_seconds=time.monotonic() - start,- model_name=self.model_name,- error=f"TUI startup failed: {e}",- )- progress.update(1)- return+ if self.docker:+ if self.verbose:+ print(f"\n[{instance_id}] Starting Docker container...", file=sys.stderr)+ try:+ container_id = start_docker_container(+ instance_id, slug, self.agtx_bin, verbose=self.verbose+ )+ setup_container(+ container_id, self.config_path, instance["base_commit"],+ verbose=self.verbose, tools_container_id=self.tools_container_id,+ extra_dirs=self.extra_dirs or None,+ sandbox_init=self.sandbox_init or None,+ )+ except Exception as e:+ if container_id:+ stop_docker_container(container_id, verbose=self.verbose)+ self.store.save_result(+ instance_id=instance_id,+ status="setup_error",+ duration_seconds=time.monotonic() - start,+ model_name=self.model_name,+ error=str(e),+ )+ progress.update(1)+ return++ if self.verbose:+ print(f"[{instance_id}] Starting TUI inside container...", file=sys.stderr)+ print(f" [docker] To watch the agent:", file=sys.stderr)+ print(f" docker exec -it swebench-{slug} tmux -L agtx attach -t testbed:1", file=sys.stderr)+ try:+ start_tui_in_container(slug, container_id, verbose=self.verbose)+ # start_tui_in_container already waits for TUI startup internally+ except Exception as e:+ stop_docker_container(container_id, verbose=self.verbose)+ self.store.save_result(+ instance_id=instance_id,+ status="setup_error",+ duration_seconds=time.monotonic() - start,+ model_name=self.model_name,+ error=f"TUI startup failed: {e}",+ )+ progress.update(1)+ return++ # In Docker mode, repo_path is unused by McpClient/patch collection+ # but TaskRunner still needs a Path object (used as identifier).+ repo_path = Path("/testbed")++ else:+ if self.verbose:+ print(f"\n[{instance_id}] Setting up repo...", file=sys.stderr)+ try:+ repo_path = setup_repo(+ instance, self.workdir, self.config_path,+ verbose=self.verbose, smoke_test=self.smoke_test,+ )+ except Exception as e:+ self.store.save_result(+ instance_id=instance_id,+ status="setup_error",+ duration_seconds=time.monotonic() - start,+ model_name=self.model_name,+ error=str(e),+ )+ progress.update(1)+ return++ if self.verbose:+ print(f"[{instance_id}] Starting TUI...", file=sys.stderr)+ try:+ start_tui_in_tmux(slug, repo_path, self.agtx_bin, verbose=self.verbose)+ time.sleep(8) # Wait for TUI startup + project registration+ except Exception as e:+ self.store.save_result(+ instance_id=instance_id,+ status="setup_error",+ duration_seconds=time.monotonic() - start,+ model_name=self.model_name,+ error=f"TUI startup failed: {e}",+ )+ progress.update(1)+ returnif self.verbose:print(f"[{instance_id}] Connecting MCP client...", file=sys.stderr)@@ -1003,9 +1651,14 @@ class BenchmarkOrchestrator:verbose=self.verbose,smoke_test=self.smoke_test,hard=self.hard,+ container_id=container_id,)result = runner.run()- kill_tmux_session(slug, repo_path)++ if self.docker:+ stop_docker_container(container_id, verbose=self.verbose)+ else:+ kill_tmux_session(slug, repo_path)self.store.save_result(instance_id=instance_id,@@ -1023,21 +1676,31 @@ class BenchmarkOrchestrator:print(f"Agent: {self.agent} | Plugin: {self.plugin} | Tasks: {len(pending)} | Concurrency: {self.concurrency}")print(f"Output: {self.store.output_dir}")- with tqdm(total=total, initial=already_done, unit="task") as progress:- if self.concurrency == 1:- for instance in pending:- self._run_one(instance, progress)- else:- with ThreadPoolExecutor(max_workers=self.concurrency) as pool:- futures = {- pool.submit(self._run_one, instance, progress): instance- for instance in pending- }- for future in as_completed(futures):- exc = future.exception()- if exc:- inst = futures[future]- print(f"\nUnhandled error for {inst['instance_id']}: {exc}", file=sys.stderr)+ if self.docker and _tools_image_exists():+ if self.verbose:+ print("[docker] Ensuring tools volume is ready...", file=sys.stderr)+ ensure_tools_volume(verbose=self.verbose)+ self.tools_container_id = "volume" # sentinel: volume is mounted, no container needed++ try:+ with tqdm(total=total, initial=already_done, unit="task") as progress:+ if self.concurrency == 1:+ for instance in pending:+ self._run_one(instance, progress)+ else:+ with ThreadPoolExecutor(max_workers=self.concurrency) as pool:+ futures = {+ pool.submit(self._run_one, instance, progress): instance+ for instance in pending+ }+ for future in as_completed(futures):+ exc = future.exception()+ if exc:+ inst = futures[future]+ print(f"\nUnhandled error for {inst['instance_id']}: {exc}", file=sys.stderr)+ finally:+ if self.tools_container_id and self.tools_container_id != "volume":+ stop_tools_container(verbose=self.verbose)statuses: dict[str, int] = {}for r in self.store._results:@@ -1115,7 +1778,7 @@ other agtx project settings. Example:parser.add_argument("--agtx",default="./target/release/agtx",- help="Path to agtx binary (default: ./target/release/agtx)",+ help="Path to agtx binary (default: ../target/release/agtx relative to benchmark/)",)parser.add_argument("--phase-timeout",@@ -1154,6 +1817,17 @@ other agtx project settings. Example:help="Strip code blocks and stack traces from the problem statement, keeping only the prose. ""The agent must find and fix the bug from first principles.",)+ parser.add_argument(+ "--sandbox",+ action="store_true",+ dest="docker",+ help=(+ "Run each task inside its SWE-bench Docker image "+ "(swebench/sweb.eval.x86_64.*). Gives agents a working test "+ "environment with pre-installed dependencies. "+ "Requires Docker with Rosetta on Apple Silicon."+ ),+ )args = parser.parse_args()# Load and validate config@@ -1166,6 +1840,16 @@ other agtx project settings. Example:agent = config.get("default_agent", "claude")run_agent = running_agent(config)+ # Resolve sandbox_copy_dirs β paths relative to the config file's directory+ extra_dirs: list[tuple[Path, str]] = []+ for entry in config.get("sandbox_copy_dirs", []):+ src = (config_path.parent / entry["src"]).resolve()+ dst = entry["dst"]+ extra_dirs.append((src, dst))++ # Resolve sandbox_init β shell commands to run inside the container after setup+ sandbox_init: list[str] = config.get("sandbox_init", [])+# Resolve agtx binaryagtx_bin = str(Path(args.agtx).resolve())if not Path(agtx_bin).exists():@@ -1173,11 +1857,12 @@ other agtx project settings. Example:print("Build with: cargo build --release", file=sys.stderr)sys.exit(1)- model_name = args.model_name or f"agtx-{plugin}-{agent}"+ model_name = args.model_name or config_path.stemif args.output_dir is None:ts = datetime.now().strftime("%Y%m%d_%H%M%S")- output_dir = Path(f"./swebench_output/{plugin}_{agent}_{ts}").resolve()+ config_stem = config_path.stem # e.g. "claude-rtk-caveman-ponytail-agtx"+ output_dir = Path(f"./swebench_output/{config_stem}_{ts}").resolve()else:output_dir = Path(args.output_dir).resolve()@@ -1211,16 +1896,24 @@ other agtx project settings. Example:verbose=args.verbose,smoke_test=args.smoke_test,hard=args.hard,+ docker=args.docker,+ extra_dirs=extra_dirs or None,+ sandbox_init=sandbox_init or None,)orchestrator.run()print(f"\nPredictions: {orchestrator.store.predictions_path}")print(f"Results: {orchestrator.store.results_path}")+ run_id = f"{config_path.stem}-{int(time.time())}"print("\nTo evaluate:")- print(f" python -m swebench.harness.run_evaluation \\")+ print(f" uv run python -m swebench.harness.run_evaluation \\")print(f" --dataset_name princeton-nlp/SWE-bench_Lite \\")print(f" --predictions_path {orchestrator.store.predictions_path} \\")- print(f" --run_id {plugin}-{agent}-$(date +%s)")+ print(f" --run_id {run_id}")+ print("\nTo report (after evaluation):")+ print(f" uv run python swebench/report.py \\")+ print(f" --results {orchestrator.store.results_path} \\")+ print(f" --logs logs/run_evaluation/{run_id}/")if __name__ == "__main__":diff --git a/benchmark/swebench/build_linux_binary.sh b/benchmark/swebench/build_linux_binary.shnew file mode 100755index 0000000..6f64527--- /dev/null+++ b/benchmark/swebench/build_linux_binary.sh@@ -0,0 +1,52 @@+#!/usr/bin/env bash+# Build the agtx Linux x86_64 binary inside a Ubuntu 22.04 container.+# Output: ../../target/agtx-linux-x86_64+#+# Must be run from the repo root or benchmark/swebench/ directory.+# Requires Docker.++set -euo pipefail++# Resolve repo root (two levels up from this script)+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"+REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"+OUTPUT="$REPO_ROOT/target/agtx-linux-x86_64"++echo "Building agtx Linux x86_64 binary..."+echo "Repo root: $REPO_ROOT"+echo "Output: $OUTPUT"++# Clean up any stale builder container+docker rm -f agtx-builder 2>/dev/null || true++# Start Ubuntu 22.04 builder (matches glibc 2.35 of SWE-bench images)+docker run -d --name agtx-builder ubuntu:22.04 sleep infinity++# Install build dependencies+docker exec agtx-builder apt-get update -qq+docker exec agtx-builder apt-get install -y curl gcc pkg-config libssl-dev++# Install Rust+docker exec agtx-builder bash -c "curl -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal"++# Copy source into container+docker exec agtx-builder mkdir -p /build+docker cp "$REPO_ROOT/src" agtx-builder:/build/src+docker cp "$REPO_ROOT/Cargo.toml" agtx-builder:/build/Cargo.toml+docker cp "$REPO_ROOT/Cargo.lock" agtx-builder:/build/Cargo.lock+docker cp "$REPO_ROOT/plugins" agtx-builder:/build/plugins+docker cp "$REPO_ROOT/skills" agtx-builder:/build/skills++# Build+docker exec agtx-builder bash -c "source /root/.cargo/env && cd /build && cargo build --release"++# Copy binary out+mkdir -p "$REPO_ROOT/target"+docker cp agtx-builder:/build/target/release/agtx "$OUTPUT"++# Clean up+docker rm -f agtx-builder++echo ""+echo "Done: $OUTPUT"+file "$OUTPUT"diff --git a/benchmark/swebench/configs/claude-agent-skills.toml b/benchmark/swebench/configs/claude-agent-skills.tomlnew file mode 100644index 0000000..bf4537e--- /dev/null+++ b/benchmark/swebench/configs/claude-agent-skills.toml@@ -0,0 +1,15 @@+default_agent = "claude"+workflow_plugin = "agent-skills"+worktree_dir = ".agtx/worktrees"+skip_worktree = true++sandbox_init = [+ # Register the agent-skills marketplace and install the plugin+ "HOME=/home/bench claude plugin marketplace add addyosmani/agent-skills 2>/dev/null || true",+ "HOME=/home/bench claude plugin install agent-skills@addy-agent-skills --scope local 2>/dev/null || true",+]++[agents]+planning = "claude"+running = "claude"+review = "claude"diff --git a/benchmark/swebench/configs/claude-agtx-terse.toml b/benchmark/swebench/configs/claude-agtx-terse.tomlindex 2e04c3b..8e773e8 100644--- a/benchmark/swebench/configs/claude-agtx-terse.toml+++ b/benchmark/swebench/configs/claude-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "claude"diff --git a/benchmark/swebench/configs/claude-agtx.toml b/benchmark/swebench/configs/claude-agtx.tomlindex f094a00..589be93 100644--- a/benchmark/swebench/configs/claude-agtx.toml+++ b/benchmark/swebench/configs/claude-agtx.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "claude"diff --git a/benchmark/swebench/configs/claude-claude-opencode-agtx-terse.toml b/benchmark/swebench/configs/claude-claude-opencode-agtx-terse.tomlindex 7936933..7efd4e7 100644--- a/benchmark/swebench/configs/claude-claude-opencode-agtx-terse.toml+++ b/benchmark/swebench/configs/claude-claude-opencode-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "claude"diff --git a/benchmark/swebench/configs/claude-claude-opencode-agtx.toml b/benchmark/swebench/configs/claude-claude-opencode-agtx.tomlindex 72dd088..6a35d4d 100644--- a/benchmark/swebench/configs/claude-claude-opencode-agtx.toml+++ b/benchmark/swebench/configs/claude-claude-opencode-agtx.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "claude"diff --git a/benchmark/swebench/configs/claude-codex-claude-agtx-terse.toml b/benchmark/swebench/configs/claude-codex-claude-agtx-terse.tomlindex b3157af..b635e30 100644--- a/benchmark/swebench/configs/claude-codex-claude-agtx-terse.toml+++ b/benchmark/swebench/configs/claude-codex-claude-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "claude"diff --git a/benchmark/swebench/configs/claude-codex-claude-agtx.toml b/benchmark/swebench/configs/claude-codex-claude-agtx.tomlindex 3562f10..06fcd63 100644--- a/benchmark/swebench/configs/claude-codex-claude-agtx.toml+++ b/benchmark/swebench/configs/claude-codex-claude-agtx.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "claude"diff --git a/benchmark/swebench/configs/claude-codex-gemini-agtx.toml b/benchmark/swebench/configs/claude-codex-gemini-agtx.tomlindex 701f9e0..298b434 100644--- a/benchmark/swebench/configs/claude-codex-gemini-agtx.toml+++ b/benchmark/swebench/configs/claude-codex-gemini-agtx.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "claude"diff --git a/benchmark/swebench/configs/claude-opencode-claude-agtx-terse.toml b/benchmark/swebench/configs/claude-opencode-claude-agtx-terse.tomlindex d27e12f..523bd9c 100644--- a/benchmark/swebench/configs/claude-opencode-claude-agtx-terse.toml+++ b/benchmark/swebench/configs/claude-opencode-claude-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "claude"diff --git a/benchmark/swebench/configs/claude-opencode-claude-agtx.toml b/benchmark/swebench/configs/claude-opencode-claude-agtx.tomlindex a395a46..f87592d 100644--- a/benchmark/swebench/configs/claude-opencode-claude-agtx.toml+++ b/benchmark/swebench/configs/claude-opencode-claude-agtx.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "claude"diff --git a/benchmark/swebench/configs/claude-openspec.toml b/benchmark/swebench/configs/claude-openspec.tomlnew file mode 100644index 0000000..79cd7a8--- /dev/null+++ b/benchmark/swebench/configs/claude-openspec.toml@@ -0,0 +1,16 @@+default_agent = "claude"+workflow_plugin = "openspec"+worktree_dir = ".agtx/worktrees"+skip_worktree = true++sandbox_init = [+ # Install openspec CLI+ "npm install -g @fission-ai/openspec@latest 2>&1 || true",+ # Initialize openspec in testbed with claude tools (non-interactive)+ "cd /testbed && openspec init --tools claude 2>&1 || true",+]++[agents]+planning = "claude"+running = "claude"+review = "claude"diff --git a/benchmark/swebench/configs/claude-rtk-caveman-agtx.toml b/benchmark/swebench/configs/claude-rtk-caveman-agtx.tomlnew file mode 100644index 0000000..5796a02--- /dev/null+++ b/benchmark/swebench/configs/claude-rtk-caveman-agtx.toml@@ -0,0 +1,25 @@+default_agent = "claude"+workflow_plugin = "agtx"+worktree_dir = ".agtx/worktrees"+skip_worktree = true++# Install rtk and activate caveman inside the container (config-specific).+# caveman is pre-installed in the tools image; rtk is downloaded at runtime (small binary).+# Both are inert unless activated here β other configs are unaffected.+sandbox_init = [+ # Install rtk binary+ "curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh",+ # Register rtk global hook (writes RTK.md + CLAUDE.md reference)+ "export PATH=$HOME/.local/bin:$PATH && rtk init -g",+ # Patch settings.json to add rtk PreToolUse hook (rtk init can't do it non-interactively)+ # Use full path to rtk so it works regardless of Claude Code's PATH+ "python3 -c \"import json,pathlib; p=pathlib.Path('/home/bench/.claude/settings.json'); d=json.loads(p.read_text()); h={'matcher':'Bash','hooks':[{'type':'command','command':'/home/bench/.local/bin/rtk hook claude'}]}; d.setdefault('hooks',{}).setdefault('PreToolUse',[]).append(h); p.write_text(json.dumps(d,indent=2))\"",+ # Activate caveman (pre-installed in tools image once apt is fixed; falls back to curl install)+ # Must run with HOME=/home/bench so the plugin is registered in the correct Claude config+ "HOME=/home/bench curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash 2>/dev/null || true",+]++[agents]+planning = "claude"+running = "claude"+review = "claude"diff --git a/benchmark/swebench/configs/claude-rtk-caveman-ponytail-agtx.toml b/benchmark/swebench/configs/claude-rtk-caveman-ponytail-agtx.tomlnew file mode 100644index 0000000..7be7746--- /dev/null+++ b/benchmark/swebench/configs/claude-rtk-caveman-ponytail-agtx.toml@@ -0,0 +1,26 @@+default_agent = "claude"+workflow_plugin = "agtx"+worktree_dir = ".agtx/worktrees"+skip_worktree = true++# Install rtk, caveman, and ponytail inside the container (config-specific).+# All three are inert unless activated here β other configs are unaffected.+sandbox_init = [+ # Install rtk binary+ "curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh",+ # Register rtk global hook (writes RTK.md + CLAUDE.md reference)+ "export PATH=$HOME/.local/bin:$PATH && rtk init -g",+ # Patch settings.json to add rtk PreToolUse hook (rtk init can't do it non-interactively)+ # Use full path to rtk so it works regardless of Claude Code's PATH+ "python3 -c \"import json,pathlib; p=pathlib.Path('/home/bench/.claude/settings.json'); d=json.loads(p.read_text()); h={'matcher':'Bash','hooks':[{'type':'command','command':'/home/bench/.local/bin/rtk hook claude'}]}; d.setdefault('hooks',{}).setdefault('PreToolUse',[]).append(h); p.write_text(json.dumps(d,indent=2))\"",+ # Activate caveman β must run with HOME=/home/bench so the plugin is registered correctly+ "HOME=/home/bench curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash 2>/dev/null || true",+ # Activate ponytail β same CLI pattern as caveman (direct subcommands, not slash commands)+ "HOME=/home/bench claude plugin marketplace add DietrichGebert/ponytail 2>/dev/null || true",+ "HOME=/home/bench claude plugin install ponytail@ponytail 2>/dev/null || true",+]++[agents]+planning = "claude"+running = "claude"+review = "claude"diff --git a/benchmark/swebench/configs/claude-rtk-caveman-superpowers.toml b/benchmark/swebench/configs/claude-rtk-caveman-superpowers.tomlnew file mode 100644index 0000000..8eef9ac--- /dev/null+++ b/benchmark/swebench/configs/claude-rtk-caveman-superpowers.toml@@ -0,0 +1,23 @@+default_agent = "claude"+workflow_plugin = "superpowers"+worktree_dir = ".agtx/worktrees"+skip_worktree = true++sandbox_init = [+ # Register the official Claude plugins marketplace and install superpowers+ "HOME=/home/bench claude plugin marketplace add anthropics/claude-plugins-official 2>/dev/null || true",+ "HOME=/home/bench claude plugin install superpowers@claude-plugins-official --scope local 2>/dev/null || true",+ # Install rtk binary+ "curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh",+ # Register rtk global hook (writes RTK.md + CLAUDE.md reference)+ "export PATH=$HOME/.local/bin:$PATH && rtk init -g",+ # Patch settings.json to add rtk PreToolUse hook+ "python3 -c \"import json,pathlib; p=pathlib.Path('/home/bench/.claude/settings.json'); d=json.loads(p.read_text()); h={'matcher':'Bash','hooks':[{'type':'command','command':'/home/bench/.local/bin/rtk hook claude'}]}; d.setdefault('hooks',{}).setdefault('PreToolUse',[]).append(h); p.write_text(json.dumps(d,indent=2))\"",+ # Install caveman plugin+ "HOME=/home/bench curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash 2>/dev/null || true",+]++[agents]+planning = "claude"+running = "claude"+review = "claude"diff --git a/benchmark/swebench/configs/claude-rtk-ponytail-agtx.toml b/benchmark/swebench/configs/claude-rtk-ponytail-agtx.tomlnew file mode 100644index 0000000..1e2ed91--- /dev/null+++ b/benchmark/swebench/configs/claude-rtk-ponytail-agtx.toml@@ -0,0 +1,24 @@+default_agent = "claude"+workflow_plugin = "agtx"+worktree_dir = ".agtx/worktrees"+skip_worktree = true++# Install rtk and ponytail inside the container (config-specific).+# Both are inert unless activated here β other configs are unaffected.+sandbox_init = [+ # Install rtk binary+ "curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh",+ # Register rtk global hook (writes RTK.md + CLAUDE.md reference)+ "export PATH=$HOME/.local/bin:$PATH && rtk init -g",+ # Patch settings.json to add rtk PreToolUse hook (rtk init can't do it non-interactively)+ # Use full path to rtk so it works regardless of Claude Code's PATH+ "python3 -c \"import json,pathlib; p=pathlib.Path('/home/bench/.claude/settings.json'); d=json.loads(p.read_text()); h={'matcher':'Bash','hooks':[{'type':'command','command':'/home/bench/.local/bin/rtk hook claude'}]}; d.setdefault('hooks',{}).setdefault('PreToolUse',[]).append(h); p.write_text(json.dumps(d,indent=2))\"",+ # Activate ponytail β same CLI pattern as caveman (direct subcommands, not slash commands)+ "HOME=/home/bench claude plugin marketplace add DietrichGebert/ponytail 2>/dev/null || true",+ "HOME=/home/bench claude plugin install ponytail@ponytail 2>/dev/null || true",+]++[agents]+planning = "claude"+running = "claude"+review = "claude"diff --git a/benchmark/swebench/configs/claude-spec-kit.toml b/benchmark/swebench/configs/claude-spec-kit.tomlnew file mode 100644index 0000000..e8b7ba0--- /dev/null+++ b/benchmark/swebench/configs/claude-spec-kit.toml@@ -0,0 +1,18 @@+default_agent = "claude"+workflow_plugin = "spec-kit"+worktree_dir = ".agtx/worktrees"+skip_worktree = true++sandbox_init = [+ # Install uv (needed for spec-kit)+ "curl -LsSf https://astral.sh/uv/install.sh | sh 2>/dev/null",+ # Install specify-cli+ "/home/bench/.local/bin/uv tool install specify-cli --from git+https://github.com/github/[email protected] 2>&1 || true",+ # Initialize spec-kit in testbed with claude integration (deploys /speckit.* commands)+ "cd /testbed && /home/bench/.local/bin/specify init . --here --force --integration claude 2>&1 || true",+]++[agents]+planning = "claude"+running = "claude"+review = "claude"diff --git a/benchmark/swebench/configs/claude-superpowers.toml b/benchmark/swebench/configs/claude-superpowers.tomlnew file mode 100644index 0000000..e30a65f--- /dev/null+++ b/benchmark/swebench/configs/claude-superpowers.toml@@ -0,0 +1,19 @@+default_agent = "claude"+workflow_plugin = "superpowers"+worktree_dir = ".agtx/worktrees"+skip_worktree = true++# Install the superpowers plugin inside the container before the TUI starts.+# init_script runs inside the worktree which doesn't exist in skip_worktree mode,+# so we install it here via sandbox_init instead.+sandbox_init = [+ # Register the official Claude plugins marketplace (not present in container by default)+ "HOME=/home/bench claude plugin marketplace add anthropics/claude-plugins-official 2>/dev/null || true",+ # Install superpowers plugin from the marketplace+ "HOME=/home/bench claude plugin install superpowers@claude-plugins-official --scope local 2>/dev/null || true",+]++[agents]+planning = "claude"+running = "claude"+review = "claude"diff --git a/benchmark/swebench/configs/codex-agtx-terse.toml b/benchmark/swebench/configs/codex-agtx-terse.tomlindex 4d38198..1dce697 100644--- a/benchmark/swebench/configs/codex-agtx-terse.toml+++ b/benchmark/swebench/configs/codex-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "codex"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "codex"diff --git a/benchmark/swebench/configs/codex-agtx.toml b/benchmark/swebench/configs/codex-agtx.tomlindex 07cd7bc..51859ea 100644--- a/benchmark/swebench/configs/codex-agtx.toml+++ b/benchmark/swebench/configs/codex-agtx.toml@@ -1,6 +1,7 @@default_agent = "codex"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "codex"diff --git a/benchmark/swebench/configs/codex-claude-codex-agtx.toml b/benchmark/swebench/configs/codex-claude-codex-agtx.tomlindex a755d48..041491b 100644--- a/benchmark/swebench/configs/codex-claude-codex-agtx.toml+++ b/benchmark/swebench/configs/codex-claude-codex-agtx.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "codex"diff --git a/benchmark/swebench/configs/cursor-agtx.toml b/benchmark/swebench/configs/cursor-agtx.tomlindex b882063..9e33afc 100644--- a/benchmark/swebench/configs/cursor-agtx.toml+++ b/benchmark/swebench/configs/cursor-agtx.toml@@ -1,6 +1,7 @@default_agent = "cursor"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "cursor"diff --git a/benchmark/swebench/configs/gemini-agtx-terse.toml b/benchmark/swebench/configs/gemini-agtx-terse.tomlindex ff509b1..82923c1 100644--- a/benchmark/swebench/configs/gemini-agtx-terse.toml+++ b/benchmark/swebench/configs/gemini-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "gemini"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "gemini"diff --git a/benchmark/swebench/configs/gemini-agtx.toml b/benchmark/swebench/configs/gemini-agtx.tomlindex dc96dc4..08b0ff0 100644--- a/benchmark/swebench/configs/gemini-agtx.toml+++ b/benchmark/swebench/configs/gemini-agtx.toml@@ -1,6 +1,7 @@default_agent = "gemini"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "gemini"diff --git a/benchmark/swebench/configs/gemini-claude-codex-agtx-terse.toml b/benchmark/swebench/configs/gemini-claude-codex-agtx-terse.tomlindex 4f512da..a45f096 100644--- a/benchmark/swebench/configs/gemini-claude-codex-agtx-terse.toml+++ b/benchmark/swebench/configs/gemini-claude-codex-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "gemini"diff --git a/benchmark/swebench/configs/gemini-claude-codex-agtx.toml b/benchmark/swebench/configs/gemini-claude-codex-agtx.tomlindex b1395ab..42a18cd 100644--- a/benchmark/swebench/configs/gemini-claude-codex-agtx.toml+++ b/benchmark/swebench/configs/gemini-claude-codex-agtx.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "gemini"diff --git a/benchmark/swebench/configs/gemini-codex-claude-agtx-terse.toml b/benchmark/swebench/configs/gemini-codex-claude-agtx-terse.tomlindex 76b2f06..17d3980 100644--- a/benchmark/swebench/configs/gemini-codex-claude-agtx-terse.toml+++ b/benchmark/swebench/configs/gemini-codex-claude-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "gemini"diff --git a/benchmark/swebench/configs/gemini-codex-claude-agtx.toml b/benchmark/swebench/configs/gemini-codex-claude-agtx.tomlindex 7f2da2b..e0daa9e 100644--- a/benchmark/swebench/configs/gemini-codex-claude-agtx.toml+++ b/benchmark/swebench/configs/gemini-codex-claude-agtx.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "gemini"diff --git a/benchmark/swebench/configs/opencode-agtx-terse.toml b/benchmark/swebench/configs/opencode-agtx-terse.tomlindex dffb40b..a631910 100644--- a/benchmark/swebench/configs/opencode-agtx-terse.toml+++ b/benchmark/swebench/configs/opencode-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "opencode"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "opencode"diff --git a/benchmark/swebench/configs/opencode-agtx.toml b/benchmark/swebench/configs/opencode-agtx.tomlindex d8b354c..268adcb 100644--- a/benchmark/swebench/configs/opencode-agtx.toml+++ b/benchmark/swebench/configs/opencode-agtx.toml@@ -1,6 +1,7 @@default_agent = "opencode"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "opencode"diff --git a/benchmark/swebench/configs/opencode-claude-claude-agtx-terse.toml b/benchmark/swebench/configs/opencode-claude-claude-agtx-terse.tomlindex 5160209..c04f315 100644--- a/benchmark/swebench/configs/opencode-claude-claude-agtx-terse.toml+++ b/benchmark/swebench/configs/opencode-claude-claude-agtx-terse.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx-terse"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "opencode"diff --git a/benchmark/swebench/configs/opencode-claude-claude-agtx.toml b/benchmark/swebench/configs/opencode-claude-claude-agtx.tomlindex f7a6845..12ca3e6 100644--- a/benchmark/swebench/configs/opencode-claude-claude-agtx.toml+++ b/benchmark/swebench/configs/opencode-claude-claude-agtx.toml@@ -1,6 +1,7 @@default_agent = "claude"workflow_plugin = "agtx"worktree_dir = ".agtx/worktrees"+skip_worktree = true[agents]planning = "opencode"diff --git a/benchmark/swebench/prebake_images.py b/benchmark/swebench/prebake_images.pynew file mode 100644index 0000000..1e5cc92--- /dev/null+++ b/benchmark/swebench/prebake_images.py@@ -0,0 +1,91 @@+#!/usr/bin/env python3+"""+Build the shared agtx/swebench-tools:latest image with tmux, Node.js, and Claude Code.++This single image is used by all benchmark sandbox runs β the benchmark runner copies+the installed binaries from a running tools container into each SWE-bench instance+container at startup, saving ~3-5 min per instance compared to installing from scratch.++The tools image is based on Ubuntu 22.04 (matching SWE-bench images) and contains only+the agent tooling layer. SWE-bench instance images are used as-is from Docker Hub.++Usage:+ # Build the tools image (run once, or after updating Claude Code)+ python prebake_images.py++ # Force rebuild even if image already exists+ python prebake_images.py --force++ # Show docker build output+ python prebake_images.py --verbose+"""++from __future__ import annotations++import argparse+import subprocess+import sys++TOOLS_IMAGE = "agtx/swebench-tools:latest"++DOCKERFILE = """\+FROM --platform=linux/amd64 ubuntu:22.04+ENV DEBIAN_FRONTEND=noninteractive+RUN apt-get update -qq \\+ && apt-get install -y -qq tmux curl ca-certificates \\+ && curl -fsSL https://deb.nodesource.com/setup_22.x | bash - \\+ && apt-get install -y -qq nodejs \\+ && npm install -g @anthropic-ai/claude-code \\+ && apt-get clean \\+ && rm -rf /var/lib/apt/lists/*+"""+++def tools_image_exists() -> bool:+ result = subprocess.run(+ ["docker", "image", "inspect", TOOLS_IMAGE],+ capture_output=True,+ )+ return result.returncode == 0+++def build_tools_image(force: bool = False, verbose: bool = False) -> None:+ if not force and tools_image_exists():+ print(f"Tools image already exists: {TOOLS_IMAGE}")+ print("Use --force to rebuild.")+ return++ print(f"Building {TOOLS_IMAGE}...")+ capture = not verbose+ subprocess.run(+ ["docker", "build", "--platform", "linux/amd64", "-t", TOOLS_IMAGE, "-"],+ input=DOCKERFILE,+ text=True,+ capture_output=capture,+ check=True,+ )+ print(f"Done: {TOOLS_IMAGE}")+++def main() -> None:+ parser = argparse.ArgumentParser(+ description="Build the shared agtx/swebench-tools image for sandbox benchmark runs.",+ formatter_class=argparse.RawDescriptionHelpFormatter,+ epilog=__doc__,+ )+ parser.add_argument(+ "--force",+ action="store_true",+ help="Rebuild even if the tools image already exists",+ )+ parser.add_argument(+ "--verbose", "-v",+ action="store_true",+ help="Show docker build output",+ )+ args = parser.parse_args()+ build_tools_image(force=args.force, verbose=args.verbose)+++if __name__ == "__main__":+ main()diff --git a/benchmark/swebench/pyproject.toml b/benchmark/swebench/pyproject.tomlindex e646f92..d3260e6 100644--- a/benchmark/swebench/pyproject.toml+++ b/benchmark/swebench/pyproject.toml@@ -4,5 +4,6 @@ version = "0.1.0"requires-python = ">=3.10"dependencies = ["datasets>=2.18.0",+ "swebench>=4.1.0","tqdm>=4.66.0",]diff --git a/benchmark/swebench/report.py b/benchmark/swebench/report.pynew file mode 100644index 0000000..f477ba7--- /dev/null+++ b/benchmark/swebench/report.py@@ -0,0 +1,136 @@+#!/usr/bin/env python3+"""+Print a summary table for a completed benchmark + evaluation run.++Usage:+ python report.py --results swebench_output/agtx_claude_.../results.json \+ --logs ../../logs/run_evaluation/<run_id>/+"""++from __future__ import annotations++import argparse+import json+from pathlib import Path+++def find_resolved(logs_dir: Path) -> dict[str, bool]:+ """Walk logs dir and collect resolved status per instance_id."""+ resolved = {}+ for report_file in logs_dir.rglob("report.json"):+ data = json.loads(report_file.read_text())+ for instance_id, info in data.items():+ resolved[instance_id] = info.get("resolved", False)+ return resolved+++def fmt_duration(seconds: float) -> str:+ m = int(seconds) // 60+ s = int(seconds) % 60+ return f"{m}m {s:02d}s" if m else f"{s}s"+++def fmt_tokens(n: int | None) -> str:+ if n is None:+ return "n/a"+ if n >= 1_000_000:+ return f"{n / 1_000_000:.1f}M"+ if n >= 1_000:+ return f"{n / 1_000:.0f}K"+ return str(n)+++def fmt_cost(usd: float | None) -> str:+ if usd is None:+ return "n/a"+ return f"${usd:.2f}"+++def print_table(rows: list[dict], resolved: dict[str, bool]) -> None:+ # Build display rows+ display = []+ totals = {"duration": 0.0, "cost": 0.0, "tokens": 0, "resolved": 0}++ for r in rows:+ iid = r["instance_id"]+ short = iid.replace("__", "/")+ is_resolved = resolved.get(iid)++ if is_resolved is None:+ status = "β³ pending"+ elif is_resolved:+ status = "β resolved"+ totals["resolved"] += 1+ else:+ status = "β failed"++ dur = r.get("duration_seconds") or 0.0+ cost = r.get("cost_usd")+ tokens = r.get("cost_tokens")++ totals["duration"] += dur+ if cost is not None:+ totals["cost"] += cost+ if tokens is not None:+ totals["tokens"] += tokens++ display.append((short, status, fmt_duration(dur), fmt_cost(cost), fmt_tokens(tokens)))++ # Column widths+ headers = ("Instance", "Status", "Duration", "Cost", "Tokens")+ widths = [len(h) for h in headers]+ for row in display:+ for i, cell in enumerate(row):+ widths[i] = max(widths[i], len(cell))++ def sep(left, mid, right, fill="β"):+ parts = [fill * (w + 2) for w in widths]+ return left + mid.join(parts) + right++ def row_line(cells):+ parts = [f" {c:<{widths[i]}} " for i, c in enumerate(cells)]+ return "β" + "β".join(parts) + "β"++ print(sep("β", "β¬", "β"))+ print(row_line(headers))+ print(sep("β", "βΌ", "β€"))+ for i, row in enumerate(display):+ print(row_line(row))+ if i < len(display) - 1:+ print(sep("β", "βΌ", "β€"))+ print(sep("β", "β΄", "β"))++ # Summary line+ n = len(rows)+ cost_str = fmt_cost(totals["cost"] if totals["cost"] else None)+ tokens_str = fmt_tokens(totals["tokens"] if totals["tokens"] else None)+ print(+ f"\n{totals['resolved']}/{n} resolved Β· "+ f"{fmt_duration(totals['duration'])} total Β· "+ f"{cost_str} total Β· {tokens_str} tokens"+ )+++def main() -> None:+ parser = argparse.ArgumentParser(description="Print benchmark + evaluation summary table.")+ parser.add_argument("--results", required=True, help="Path to results.json from benchmark run")+ parser.add_argument("--logs", required=True, help="Path to evaluation logs dir (contains report.json files)")+ args = parser.parse_args()++ results_path = Path(args.results)+ logs_path = Path(args.logs)++ if not results_path.exists():+ print(f"results.json not found: {results_path}")+ raise SystemExit(1)+ if not logs_path.exists():+ print(f"Logs dir not found: {logs_path}")+ raise SystemExit(1)++ rows = json.loads(results_path.read_text())+ resolved = find_resolved(logs_path)+ print_table(rows, resolved)+++if __name__ == "__main__":+ main()diff --git a/benchmark/swebench/uv.lock b/benchmark/swebench/uv.lockindex 9440f80..86d176d 100644--- a/benchmark/swebench/uv.lock+++ b/benchmark/swebench/uv.lock@@ -211,6 +211,75 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },]+[[package]]+name = "beautifulsoup4"+version = "4.15.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "soupsieve" },+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/88/c6/92fcd42f1ba33e1184263f25bfabf3d27c383410470f169e4b8163bf9c17/beautifulsoup4-4.15.0-py3-none-any.whl", hash = "sha256:d6f88de62e1d4e38ecb1077eb9724cd0eff29d2a08ca16a401e9b9e93f117cf9", size = 109924, upload-time = "2026-06-07T16:44:21.566Z" },+]++[[package]]+name = "cbor2"+version = "6.1.2"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/75/af/473c241e41c142ea06ebef8d1f660fa6ff928fb97210e7bec8ee5974f8cd/cbor2-6.1.2.tar.gz", hash = "sha256:6b43037a66947dee5af0abb1a4c3a13b3abac5a4a3f32f9771efbbcd030fd909", size = 86760, upload-time = "2026-06-02T19:01:29.333Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/52/3f/37771defcae022510d640df8e420b7968c01804c084ff8cd2b9021c8873b/cbor2-6.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8ffda338fe434d8d37e92e0d2e8f66432f0aa983f769dd2417f1eb6dfce634d3", size = 412096, upload-time = "2026-06-02T19:00:21.183Z" },+ { url = "https://files.pythonhosted.org/packages/13/ab/a10563c43a937a5fc0c5c52ee14f8380c7ba66634294759cc3dd3697d521/cbor2-6.1.2-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:715112c1087bc65f26d50ed4ffaaa214cbd398fbfb0d1a45f7edf555e77c7ca6", size = 457955, upload-time = "2026-06-02T19:00:22.989Z" },+ { url = "https://files.pythonhosted.org/packages/c7/a9/443cb3f0b086cbb78e3df098bce6f8fb6cabc39b9ea5b46bca27b7adf4ad/cbor2-6.1.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:86b030a6accec1b4a58387e27edb656921c4b6d5d36d60f05d19915526233402", size = 468656, upload-time = "2026-06-02T19:00:24.549Z" },+ { url = "https://files.pythonhosted.org/packages/6b/ed/2b2446767225078c023fd32523f84dceecb2a94e7ac7259b27d1527a5eac/cbor2-6.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fe007e47f6edb828cc97af256ce3452f57431cb8841302c3c28543efc7c9e037", size = 523323, upload-time = "2026-06-02T19:00:25.851Z" },+ { url = "https://files.pythonhosted.org/packages/b2/71/cfe388abc06d59e8393a1a5fa260d5412b5a68963de0ef0e79f6395a3cb7/cbor2-6.1.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:95e3d99160f105b8b6bccb1033c9c14e8ca7c450d8999363882d87357313b78e", size = 534929, upload-time = "2026-06-02T19:00:27.61Z" },+ { url = "https://files.pythonhosted.org/packages/a0/e8/8b454b8d405d9a66935b47bf5d9b045147bcf86f7747161598a32e5169ad/cbor2-6.1.2-cp310-cp310-win32.whl", hash = "sha256:464abc44b6863f888c9e263078e52395bddc03f20a3bd59f58fff581788fea51", size = 284490, upload-time = "2026-06-02T19:00:29.347Z" },+ { url = "https://files.pythonhosted.org/packages/d2/3e/ecce89144cd820ba6f528debedff4948b6022996d3fcc4715e69f6acb483/cbor2-6.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:a3d1699de84d8aec4e9c6c3fdd450d86fac183a542733f0cac36a4317db2375a", size = 301090, upload-time = "2026-06-02T19:00:30.619Z" },+ { url = "https://files.pythonhosted.org/packages/cb/cd/92f77e8bdfef427c6617cd4b02898e9d88861db8dcc973cc8b2c29a51582/cbor2-6.1.2-cp310-cp310-win_arm64.whl", hash = "sha256:925ebc6d26a0d3aa81377bdcfd8d44d166f4f6a5ee77467a9d6f3ed1487fc499", size = 292330, upload-time = "2026-06-02T19:00:31.946Z" },+ { url = "https://files.pythonhosted.org/packages/c0/1e/687d7a712755c84a4b823ca79622dceef7ddfb0a3387b6ac1cad10835e07/cbor2-6.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6ce8f6d9e234bdf36b5300bf3da98fafc198b253f8dfe77747327806bdb37d97", size = 411738, upload-time = "2026-06-02T19:00:33.396Z" },+ { url = "https://files.pythonhosted.org/packages/3f/d3/a96162ac244e074f9c188ffd29c086c51466e71c7c360189f6204900db3d/cbor2-6.1.2-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9f81ab0e74671b0ff9b7e30386e2ab8d40ee1049d13c1680b57ab1b1cd95c81a", size = 457945, upload-time = "2026-06-02T19:00:34.729Z" },+ { url = "https://files.pythonhosted.org/packages/3a/f3/7fed7cee8456932d38e7b11d5034470ee9e91378d16f762c552e78df34fa/cbor2-6.1.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:5a429fc61db768c3b4739eb8532556eed86913ad64fe6ebbc1f3a646fb9a4f22", size = 468758, upload-time = "2026-06-02T19:00:35.882Z" },+ { url = "https://files.pythonhosted.org/packages/a1/e9/bb31f04c5afa53eb55927da1399cc596d7e84e7053de7abf2c3aba0ea3a9/cbor2-6.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:511999bf3310c6641d3d15ee3853daa7ebd6ef3130bb0d63b9a7e2fd720a3714", size = 523169, upload-time = "2026-06-02T19:00:37.422Z" },+ { url = "https://files.pythonhosted.org/packages/fe/7f/90faf18c280abb49428ed2e78f672ef0c7f6eb1b9b685bc4fe810f2e5e95/cbor2-6.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3099e678283efd2d3cabd6ddcb770da6e2102c0d265f98bca38aa4e720e247cf", size = 534885, upload-time = "2026-06-02T19:00:38.972Z" },+ { url = "https://files.pythonhosted.org/packages/b8/8a/447aea5da80847bb17ca4718cd4909a2dc8dfe6f68ede4fe29f94b4ca12c/cbor2-6.1.2-cp311-cp311-win32.whl", hash = "sha256:0ef832ac8152ca76a69c184fe401329629b7dfd5fdddd713121bf1ff6d21660f", size = 284601, upload-time = "2026-06-02T19:00:40.426Z" },+ { url = "https://files.pythonhosted.org/packages/55/95/6239187639a875eb83b924c16f4938d3d735c9c45474008c8b962bd55da2/cbor2-6.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:08cdc03d65e965aafd04c3bf9cb54b8cba55041756bd39d0ba6cd62bd060f959", size = 301284, upload-time = "2026-06-02T19:00:41.693Z" },+ { url = "https://files.pythonhosted.org/packages/76/cb/e5f92271747a0331ca9151fac4098f8e245f1b09623ddff1258967a35b01/cbor2-6.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:0e2cfd25a395d454990d67148103107293c6506c3b0b15952a6e97f53d23deda", size = 292228, upload-time = "2026-06-02T19:00:43.27Z" },+ { url = "https://files.pythonhosted.org/packages/5e/0c/a857b6ca032282b564cf25de18ad92fe0614e8b3fa3422eb10e32a873939/cbor2-6.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:92b158d3ff9d9dce70eeb09786a6e518e3cb0ecb927fd23e9a0f7fc4b175c01a", size = 409592, upload-time = "2026-06-02T19:00:44.556Z" },+ { url = "https://files.pythonhosted.org/packages/29/db/e0518153b3228159d9373f3b5785d7ea2d68898e27ee1bce7d03f0b5f7aa/cbor2-6.1.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:d29a11044b07048e19f39a87fe8fea7ea865eb0ace50dc4c29513d52d40e2ddf", size = 454598, upload-time = "2026-06-02T19:00:45.784Z" },+ { url = "https://files.pythonhosted.org/packages/29/67/62127b22edc6011ba55b76a28ab7c2219a45d01871a8199532e0978b26d1/cbor2-6.1.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:a106f174eda34d8937a621c7f3e6044586cb209170cdc8da0ffbea89d1d6e385", size = 467380, upload-time = "2026-06-02T19:00:47.196Z" },+ { url = "https://files.pythonhosted.org/packages/7c/95/7992d8ec904c116ad547abb4960cc3fde695d5853c66596b1465d14d2f7b/cbor2-6.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2ea16a25cc457a92879ff7a36cc50b587bddba09d8176bf1a94803eec5aa27eb", size = 521672, upload-time = "2026-06-02T19:00:48.656Z" },+ { url = "https://files.pythonhosted.org/packages/cb/cf/80cc4be132a523f0c92fb4c71813577bb393abea9e27990ca74605e0e930/cbor2-6.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2652a94224980d47f2a3866dd35b1afe532ecdfaf91f8cfcec39a026c457a844", size = 534402, upload-time = "2026-06-02T19:00:50.064Z" },+ { url = "https://files.pythonhosted.org/packages/b1/ea/99e466d8bef61a0775a1d8538ae6c9d95f4533fadc01f8f7814cb7ab80ad/cbor2-6.1.2-cp312-cp312-win32.whl", hash = "sha256:618666292900487db4a5abcade3150105c9c9fdd22576e6ff297c9a72eef0c6a", size = 283225, upload-time = "2026-06-02T19:00:51.406Z" },+ { url = "https://files.pythonhosted.org/packages/14/13/e6a677bdc499e43049006cb54fe605b0f7aef621402d31354cc42ef293c9/cbor2-6.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:c61c0b2e2cee64497e6c62d1976bc212f62ac0cd2b5b903613610d79b8b06b60", size = 300844, upload-time = "2026-06-02T19:00:52.628Z" },+ { url = "https://files.pythonhosted.org/packages/77/4a/08bd8461f8e2e1ce1de5ae2768f2b7ca39a090e3156c1ee0d9b5fd86e70d/cbor2-6.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:c871e7266ddc545b258e6f8e5300396985dc485d7ccf8bb4777385782f302153", size = 289040, upload-time = "2026-06-02T19:00:53.971Z" },+ { url = "https://files.pythonhosted.org/packages/2b/dc/bc045c8f36317e4e5f7a60d94b36833139909fc32e3a65f44bc61a36def0/cbor2-6.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f1aa38c422d87ea61849b2a823b10b64053fb4da8763f19ac78ea9a69d682b2a", size = 408846, upload-time = "2026-06-02T19:00:55.476Z" },+ { url = "https://files.pythonhosted.org/packages/2b/36/d66f5f0dd98ecbdcfc7da1fbd423f7b3782a27719f0062a560476f00b334/cbor2-6.1.2-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ff7d0bd8ff432832338a8d2430aee34f8a082342480ff537c0ba90e2b8ff7894", size = 454624, upload-time = "2026-06-02T19:00:56.744Z" },+ { url = "https://files.pythonhosted.org/packages/38/6b/4884b9cf03db14dc5007825d5d1bf8678a75c49d4268d8e0c1c6e9580104/cbor2-6.1.2-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c1eedf3290d88a5f663bd8b4b8f0f0e2103d0594c293fa5f4e62e53100972309", size = 466585, upload-time = "2026-06-02T19:00:58.209Z" },+ { url = "https://files.pythonhosted.org/packages/50/f6/36a15beb3915f56a79d6e9213c6d40c0f5cb90cd3462923f555d78068847/cbor2-6.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3049b04bddf9a5a2d0e5bb25dccdaf4552fcaf607b404e249d4f78f010fcc7d0", size = 521678, upload-time = "2026-06-02T19:00:59.524Z" },+ { url = "https://files.pythonhosted.org/packages/c6/3f/e899313371ebeb7a191d751de97ccd8242abc24bbc9d8e2c58e04475cfb0/cbor2-6.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:96eb687a62040401668f06a85de8f47361ef44574de1493899e0ec678109fc04", size = 534044, upload-time = "2026-06-02T19:01:00.875Z" },+ { url = "https://files.pythonhosted.org/packages/1e/5e/1a872acdeb1ab9a884ec3460f73a43e02154dc20d8ccb627bbd60f4c0ea1/cbor2-6.1.2-cp313-cp313-win32.whl", hash = "sha256:03440b505882280023db1fedcee6844804e9968bb50f9eb4ff12aaf27777fcfe", size = 282328, upload-time = "2026-06-02T19:01:02.347Z" },+ { url = "https://files.pythonhosted.org/packages/70/79/29721bc15d38889e7bec214ede2346ee15970bedcc5e6ce1fa30f21e9a4e/cbor2-6.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:d2c8da2c0f821827dcc9eb59a5c9351791a8aa3b389a2ea7ca64c4f97bcb94cf", size = 300313, upload-time = "2026-06-02T19:01:03.69Z" },+ { url = "https://files.pythonhosted.org/packages/07/98/a13b424fb2f14fe332b57f71f479953b2f291a051f797d42ddab9fcd2027/cbor2-6.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:8e1478d3b980ddfcaf56e27cecbfe13057e0f67d5e8240fe8a398815acb9c4bf", size = 288725, upload-time = "2026-06-02T19:01:04.933Z" },+ { url = "https://files.pythonhosted.org/packages/62/72/949bdc7422acd868a2355ae032561a104973fb5de284b36a237b85780dc9/cbor2-6.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b0b65314a0b18c47651e17792447171a858dd77e3f161c451ad850d63f8718a9", size = 407436, upload-time = "2026-06-02T19:01:06.259Z" },+ { url = "https://files.pythonhosted.org/packages/2f/bd/5969f9263102d1c15aa370b39802e4a87b1d1703fdb51588daf38b5fbe7e/cbor2-6.1.2-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:8904deb2849bae40cea970e114398a19da371e1048ae1409e64f167a1205daf6", size = 453507, upload-time = "2026-06-02T19:01:07.795Z" },+ { url = "https://files.pythonhosted.org/packages/93/a5/227b785692a8374e3dbdf1fe76d1a9af48239855abd68a4111a1458fd81b/cbor2-6.1.2-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:b29d58d8ce00535354d873df170a3e9f0f0a02af65d12102d2552e2129c65dc8", size = 464875, upload-time = "2026-06-02T19:01:09.222Z" },+ { url = "https://files.pythonhosted.org/packages/6d/48/a06527c3fbed4c32816abba4540e432fe9cd7e739a37fef0f205bd0f1e44/cbor2-6.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:27be1cc0abc42f154a48a315c92feb2bfb50397e51c70860460438ea172198a5", size = 519940, upload-time = "2026-06-02T19:01:10.795Z" },+ { url = "https://files.pythonhosted.org/packages/31/1b/0e3f0dac7140d4b94ffbcef765fa4cce0caa1d942060101149de998fa7be/cbor2-6.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b8d87fb8a33ff1971cb01511e74b044767cbba1ba536d3dc0b0c48f0d1b62237", size = 532612, upload-time = "2026-06-02T19:01:12.363Z" },+ { url = "https://files.pythonhosted.org/packages/35/2f/5af245e7667b65c6e4a714bb5d89c84de5573b857eba9137533d54bc2e4f/cbor2-6.1.2-cp314-cp314-win32.whl", hash = "sha256:72ba0ea913ca1a8d916867f1b7d414f140982d2873e5d92f8f51de437e08979e", size = 285886, upload-time = "2026-06-02T19:01:13.658Z" },+ { url = "https://files.pythonhosted.org/packages/d9/0a/6303f3e19730450c5a82b97cd2c0ed54855f9108502041305b4c641116cd/cbor2-6.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:c02b7d94fe9914798a346a2f089f0f7f85be71d120d40080916d131fa0bd0442", size = 308808, upload-time = "2026-06-02T19:01:14.944Z" },+ { url = "https://files.pythonhosted.org/packages/cd/61/48f9c5545223dad9d2ea2061a76da739b4047a461297b621fc80ce0f65c0/cbor2-6.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:2af1309865000c401755fd4fdd5550f74ac34c3f79eb7db15f3956714769a5a9", size = 299522, upload-time = "2026-06-02T19:01:16.393Z" },+ { url = "https://files.pythonhosted.org/packages/b2/2b/efcc6578b4e6142fb8ec9212c0dee5030345db2092f26aa960236067e717/cbor2-6.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9f26e08dd78ee77d103065543a65cfb838948fa8735180ad4d81d939950a1420", size = 402925, upload-time = "2026-06-02T19:01:17.979Z" },+ { url = "https://files.pythonhosted.org/packages/58/f6/58c86aa6246b3e7de473d8ff79ac8cc986e95cafe208899a70d6916012d7/cbor2-6.1.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:596e238f24bf9ede11a1ad08d2115fe78105ed6dda42ce1dd35872e7e91974fd", size = 446201, upload-time = "2026-06-02T19:01:19.481Z" },+ { url = "https://files.pythonhosted.org/packages/c8/12/3b90820583e9860e35cb5e91f3b2cd2ab1bbdf1c57fc63aa572952f5f75f/cbor2-6.1.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:08a62f69fe0f0ee1428d901423853b56bb5c775430f798401f8fac4b9affdecc", size = 460193, upload-time = "2026-06-02T19:01:20.876Z" },+ { url = "https://files.pythonhosted.org/packages/ed/88/c1e841ffb39a8e7163d7d432f7ea0e59b812c5134a449c75b6b8eb8aad08/cbor2-6.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6ca0080e4d8ab0d67c0518ac995d03151a1274b5c295c9e619fb6057c91ae49e", size = 511446, upload-time = "2026-06-02T19:01:22.18Z" },+ { url = "https://files.pythonhosted.org/packages/db/0a/f1ede587a388f127b9fc3d8ecb2f5d948654fed9fc7698f8b05fd90986bf/cbor2-6.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b44eb2f3ea1c8d9cb3e39c345204ec4d9489f8149b78eb5e058b13b14a8c7b07", size = 527683, upload-time = "2026-06-02T19:01:23.639Z" },+ { url = "https://files.pythonhosted.org/packages/1a/89/e3210ea45855a8d6173821f712a71a90d23dea0c134c4017c6f666a04fdf/cbor2-6.1.2-cp314-cp314t-win32.whl", hash = "sha256:f93179b4b1ba958b5c37b56969b8f07b4fcf44a83319f47559c59f28a1c564a4", size = 280419, upload-time = "2026-06-02T19:01:25.365Z" },+ { url = "https://files.pythonhosted.org/packages/96/84/b555de26cc01108a72ed1df8eb7ca1d63495a3727045f0f93318dc5f99a8/cbor2-6.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:3c6c3d6598c268abf7068ae75b23b19f708e7a4aa294341b356deb65cb2664f1", size = 302514, upload-time = "2026-06-02T19:01:26.782Z" },+ { url = "https://files.pythonhosted.org/packages/d4/6e/5556939414c0d2bffed7c7a53cf2b32181b55a795944d19835d513a7bc88/cbor2-6.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:8c2202fd1906f978bff3f97b21351815753dd9a8fcf4612a5113b6b257089059", size = 290058, upload-time = "2026-06-02T19:01:28.077Z" },+]+[[package]]name = "certifi"version = "2026.4.22"@@ -220,6 +289,58 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" },]+[[package]]+name = "cfgv"+version = "3.5.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },+]++[[package]]+name = "chardet"+version = "7.4.3"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/19/b6/9df434a8eeba2e6628c465a1dfa31034228ef79b26f76f46278f4ef7e49d/chardet-7.4.3.tar.gz", hash = "sha256:cc1d4eb92a4ec1c2df3b490836ffa46922e599d34ce0bb75cf41fd2bf6303d56", size = 784800, upload-time = "2026-04-13T21:33:39.803Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/6b/1b/7f73766c119a1344eb69e31890ede7c5825ce03d69a9d29292d1bd1cfa1b/chardet-7.4.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c0c79b13c9908ac7dfe0a74116ebc9a0f28b2319d23c32f3dfcdfbe1279c7eaf", size = 874121, upload-time = "2026-04-13T21:32:47.065Z" },+ { url = "https://files.pythonhosted.org/packages/8b/02/b677c8203d34dad6c2af48287bb1f8c5dff63db2094636fbe634b555b7fb/chardet-7.4.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bba8bea1b28d927b3e99e47deafe53658d34497c0a891d95ff1ba8ff6663f01c", size = 856900, upload-time = "2026-04-13T21:32:48.893Z" },+ { url = "https://files.pythonhosted.org/packages/c4/4b/1361a485a999d97cac4c895e615326f69a639532a52ef365a468bd09bad1/chardet-7.4.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23163921dccf3103ce59540b0443c106d2c0a0ff2e0503e05196f5e6fdea453f", size = 876634, upload-time = "2026-04-13T21:32:50.238Z" },+ { url = "https://files.pythonhosted.org/packages/87/23/e31c8ad33aa448f0845fd58af5fc22da1626407616d09df4973b2b34f477/chardet-7.4.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cfb54563fe5f130da17c44c6a4e2e8052ba628e5ab4eab7ef8190f736f0f8f72", size = 886497, upload-time = "2026-04-13T21:32:52.111Z" },+ { url = "https://files.pythonhosted.org/packages/18/ef/ea4edec8c87f7e6eda02673acc68fe48725e564fc5a1865782efb53d5598/chardet-7.4.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3990fffcc6a6045f2234ab72752ad037e3b2d48c72037f244d42738db397eb75", size = 881061, upload-time = "2026-04-13T21:32:53.755Z" },+ { url = "https://files.pythonhosted.org/packages/f2/11/fc10600da98541777d720ad9e6bc040c0e0af1adb92e27142e35158957cb/chardet-7.4.3-cp310-cp310-win_amd64.whl", hash = "sha256:c7116b0452994734ccff35e154b44240090eb0f4f74b9106292668133557c175", size = 942533, upload-time = "2026-04-13T21:32:55.134Z" },+ { url = "https://files.pythonhosted.org/packages/19/52/505c207f334d51e937cbaa27ff95776e16e2d120e13cbe491cd7b3a70b50/chardet-7.4.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:25a862cddc6a9ac07023e808aedd297115345fbaabc2690479481ddc0f980e09", size = 870747, upload-time = "2026-04-13T21:32:56.916Z" },+ { url = "https://files.pythonhosted.org/packages/14/4b/d3c79495dee4831b8bebca2790e72cb90f0c5849c940570a7c7e5b70b952/chardet-7.4.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7005c88da26fd95d8abb8acbe6281d833e9a9181b03cf49b4546c4555389bd97", size = 853210, upload-time = "2026-04-13T21:32:58.309Z" },+ { url = "https://files.pythonhosted.org/packages/b9/99/f6a822ad1bde25a4c38dc3e770485e78e0893dfd871cd6e18ed3ea3a795e/chardet-7.4.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc50f28bad067393cce0af9091052c3b8df7a23115afd8ba7b2e0947f0cef1f8", size = 873625, upload-time = "2026-04-13T21:32:59.606Z" },+ { url = "https://files.pythonhosted.org/packages/b1/10/31932775c94a86814f76b41c4a772b52abfb0e6125324f32c6da1196c297/chardet-7.4.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3da294de1a681097848ab58bd3f2771a674f8039d2d87a5538b28856b815e9", size = 883436, upload-time = "2026-04-13T21:33:01.351Z" },+ { url = "https://files.pythonhosted.org/packages/6c/63/0f43e3acf2c436fdb32a0f904aeb03a2904d2126eed34a042a194d235926/chardet-7.4.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:93c45e116dd51b66226a53ade3f9f635e870de5399b90e00ce45dcc311093bf4", size = 876589, upload-time = "2026-04-13T21:33:02.636Z" },+ { url = "https://files.pythonhosted.org/packages/5d/a6/e9b8f8a3e99602792b01fa7d0a731737615ab56d8bfd0b52935a0ef88b85/chardet-7.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:ccc1f83ab4bcfb901cf39e0c4ba6bc6e726fc6264735f10e24ceb5cb47387578", size = 941866, upload-time = "2026-04-13T21:33:04.282Z" },+ { url = "https://files.pythonhosted.org/packages/61/33/29de185079e6675c3f375546e30a559b7ddc75ce972f18d6e566cd9ea4eb/chardet-7.4.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:75d3c65cc16bddf40b8da1fd25ba84fca5f8070f2b14e86083653c1c85aee971", size = 874870, upload-time = "2026-04-13T21:33:05.977Z" },+ { url = "https://files.pythonhosted.org/packages/9c/2f/4c5af01fd1a7506a1d5375403d68925eac70289229492db5aa68b58103d8/chardet-7.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:29af5999f654e8729d251f1724a62b538b1262d9292cccaefddf8a02aae1ef6a", size = 854859, upload-time = "2026-04-13T21:33:07.381Z" },+ { url = "https://files.pythonhosted.org/packages/36/21/edb36ad5dfa48d7f8eed97ab43931ecdaa8c15166c21b1d614967e49d681/chardet-7.4.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:626f00299ad62dfe937058a09572beed442ccc7b58f87aa667949b20fd3db235", size = 875032, upload-time = "2026-04-13T21:33:08.741Z" },+ { url = "https://files.pythonhosted.org/packages/e5/59/a32a241d861cf180853a11c8e5a67641cb1b2af13c3a5ccce83ec07e2c9f/chardet-7.4.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9a4904dd5f071b7a7d7f50b4a67a86db3c902d243bf31708f1d5cde2f68239cb", size = 888283, upload-time = "2026-04-13T21:33:10.213Z" },+ { url = "https://files.pythonhosted.org/packages/87/2e/e1ee6a77abf3782c00e05b89c4d4328c8353bf9500661c4348df1dd68614/chardet-7.4.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5d2879598bc220689e8ce509fe9c3f37ad2fca53a36be9c9bd91abdd91dd364f", size = 879974, upload-time = "2026-04-13T21:33:11.448Z" },+ { url = "https://files.pythonhosted.org/packages/32/60/fca69c534602a7ced04280c952a246ad1edde2a6ca3a164f65d32ac41fe7/chardet-7.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:4b2799bd58e7245cfa8d4ab2e8ad1d76a5c3a5b1f32318eb6acca4c69a3e7101", size = 943973, upload-time = "2026-04-13T21:33:12.756Z" },+ { url = "https://files.pythonhosted.org/packages/7c/43/79ac9b4db5bc87020c9dbc419125371d80882d1d197e9c4765ba8682b605/chardet-7.4.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a9e4486df251b8962e86ea9f139ca235aa6e0542a00f7844c9a04160afb99aa9", size = 873769, upload-time = "2026-04-13T21:33:14.002Z" },+ { url = "https://files.pythonhosted.org/packages/55/5f/25bdec773905bff0ff6cf35ca73b17bd05593b4f87bd8c5fa43705f7167d/chardet-7.4.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4fbff1907925b0c5a1064cffb5e040cd5e338585c9c552625f30de6bc2f3107a", size = 853991, upload-time = "2026-04-13T21:33:15.564Z" },+ { url = "https://files.pythonhosted.org/packages/b4/07/a29380ee0b215d23d77733b5ad60c5c0c7969650e080c667acdf9462040d/chardet-7.4.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:365135eaf37ba65a828f8e668eb0a8c38c479dcbec724dc25f4dfd781049c357", size = 874024, upload-time = "2026-04-13T21:33:16.915Z" },+ { url = "https://files.pythonhosted.org/packages/a8/b1/3338e121cbd4c8a126b8ccb1061170c2ce51a53f678c502793ea49c6fd6d/chardet-7.4.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfc134b70c846c21ead8e43ada3ae1a805fff732f6922f8abcf2ff27b8f6493d", size = 887410, upload-time = "2026-04-13T21:33:18.368Z" },+ { url = "https://files.pythonhosted.org/packages/63/1c/44a9a9e0c59c185a5d307ceaeee8768afa1558f0a24f7a4b5fa11b67586b/chardet-7.4.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9acd9988a93e09390f3cd231201ea7166c415eb8da1b735928990ffc05cb9fbb", size = 879269, upload-time = "2026-04-13T21:33:20.377Z" },+ { url = "https://files.pythonhosted.org/packages/1b/b3/5d0e77ea774bd3224321c248880ea0c0379000ac5c2bb6d77609549de247/chardet-7.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:e1b98790c284ff813f18f7cf7de5f05ea2435a080030c7f1a8318f3a4f80b131", size = 944155, upload-time = "2026-04-13T21:33:21.694Z" },+ { url = "https://files.pythonhosted.org/packages/70/a8/bf0811d859e13801279a2ae64f37a408027b282f2047bc0001c75dd356ad/chardet-7.4.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d892d3dcd652fdef53e3d6327d39b17c0df40a899dfc919abaeb64c974497531", size = 872887, upload-time = "2026-04-13T21:33:23.328Z" },+ { url = "https://files.pythonhosted.org/packages/51/ac/b9d68ebddfe1b02c77af5bf81120e12b036b4432dc6af7a303d90e2bc38b/chardet-7.4.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:acc46d1b8b7d5783216afe15db56d1c179b9a40e5a1558bc13164c4fd20674c4", size = 853964, upload-time = "2026-04-13T21:33:24.724Z" },+ { url = "https://files.pythonhosted.org/packages/2a/81/17fa103ea9caf5d325a5e4051ab2ba65996fd66baa60b81ee41af1f54e10/chardet-7.4.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ac3bf11c645734a1701a3804e43eabd98851838192267d08c353a834ab79fea", size = 876006, upload-time = "2026-04-13T21:33:26.098Z" },+ { url = "https://files.pythonhosted.org/packages/c2/20/193faab46a68ea550587331a698c3dca8099f8901d10937c4443135c7ed9/chardet-7.4.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6e3bd9f936e04bae89c254262af08d9e5b98f805175ba1e29d454e6cba3107b7", size = 887680, upload-time = "2026-04-13T21:33:27.49Z" },+ { url = "https://files.pythonhosted.org/packages/40/c6/94a3c673327392652ee8bdea9a45bc8a5f5365197a7387d68f0eed007115/chardet-7.4.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:27cc23da03630cdecc9aa81a895aa86629c211f995cd57651f0fbc280717bf93", size = 879865, upload-time = "2026-04-13T21:33:29.052Z" },+ { url = "https://files.pythonhosted.org/packages/b1/2c/cad8b5e3623a987f3c930b68e2bdd06cfc388cd91cd42ed05f1227701b73/chardet-7.4.3-cp314-cp314-win_amd64.whl", hash = "sha256:b95c934b9ad59e2ba8abb9be49df70d3ad1b0d95d864b9fdb7588d4fa8bd921c", size = 939594, upload-time = "2026-04-13T21:33:31.391Z" },+ { url = "https://files.pythonhosted.org/packages/33/e0/d06e42fd6f02a58e5e227e5106587751cb38adcff0aaf949add744b78b6e/chardet-7.4.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c77867f0c1cb8bd819502249fcdc500364aedb07881e11b743726fa2148e7b6e", size = 889714, upload-time = "2026-04-13T21:33:32.772Z" },+ { url = "https://files.pythonhosted.org/packages/d4/ed/40d091954d48abea037baae6be8fb79905e5f78d34d12ea955132c7d8011/chardet-7.4.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cf1efeaf65a6ef2f5b9cc3a1df6f08ba2831b369ccaa4c7018eaf90aa757bb11", size = 872319, upload-time = "2026-04-13T21:33:34.427Z" },+ { url = "https://files.pythonhosted.org/packages/bb/77/82a46821dbfbdfe062710d2bf2ede13426304e3567a23c57d919c0c31630/chardet-7.4.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9f3504c139a2ad544077dd2d9e412cd08b01786843d76997cd43bb6de311723c", size = 892021, upload-time = "2026-04-13T21:33:35.766Z" },+ { url = "https://files.pythonhosted.org/packages/49/57/42d30c562bda5b4a839766c1aad8d5856b798ad2a1c3247b72a679afec94/chardet-7.4.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457f619882ba66327d4d8d14c6c342269bdb1e4e1c38e8117df941d14d351b04", size = 902509, upload-time = "2026-04-13T21:33:37.096Z" },+ { url = "https://files.pythonhosted.org/packages/8c/6c/0a40afdb50a0fe041ab95553b835a8160b6cf0e81edf2ae2fe9f5224cbf9/chardet-7.4.3-py3-none-any.whl", hash = "sha256:1173b74051570cf08099d7429d92e4882d375ad4217f92a6e5240ccfb26f231e", size = 626562, upload-time = "2026-04-13T21:33:38.559Z" },+]+[[package]]name = "charset-normalizer"version = "3.4.7"@@ -382,6 +503,29 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/1e/77/dc8c558f7593132cf8fefec57c4f60c83b16941c574ac5f619abb3ae7933/dill-0.4.1-py3-none-any.whl", hash = "sha256:1e1ce33e978ae97fcfcff5638477032b801c46c7c65cf717f95fbc2248f79a9d", size = 120019, upload-time = "2026-01-19T02:36:55.663Z" },]+[[package]]+name = "distlib"+version = "0.4.3"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/c9/02/bd72be9134d25ed783ecbbc38a539ffaefbf90c78418c7fb7229600dbac7/distlib-0.4.3.tar.gz", hash = "sha256:f152097224a0ae24be5a0f6bae1b9359af82133bce63f98a95f86cae1aede9ed", size = 615141, upload-time = "2026-06-12T08:04:52.847Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/02/08/9c41fb51ab5b43eb21674aff13df270e8ba6c4b29c8624e328dc7a9482af/distlib-0.4.3-py2.py3-none-any.whl", hash = "sha256:4b0ce306c966eb73bc3a7b6abad017c556dadd92c44701562cd528ac7fde4d5b", size = 470628, upload-time = "2026-06-12T08:04:50.506Z" },+]++[[package]]+name = "docker"+version = "7.1.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pywin32", marker = "sys_platform == 'win32'" },+ { name = "requests" },+ { name = "urllib3" },+]+sdist = { url = "https://files.pythonhosted.org/packages/91/9b/4a2ea29aeba62471211598dac5d96825bb49348fa07e906ea930394a83ce/docker-7.1.0.tar.gz", hash = "sha256:ad8c70e6e3f8926cb8a92619b832b4ea5299e2831c14284663184e200546fa6c", size = 117834, upload-time = "2024-05-23T11:13:57.216Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/e3/26/57c6fb270950d476074c087527a558ccb6f4436657314bfb6cdf484114c4/docker-7.1.0-py3-none-any.whl", hash = "sha256:c96b93b7f0a746f9e77d325bcfb87422a3d8bd4f03136ae8a85b37f1898d5fc0", size = 147774, upload-time = "2024-05-23T11:13:55.01Z" },+]+[[package]]name = "exceptiongroup"version = "1.3.1"@@ -394,6 +538,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },]+[[package]]+name = "fastcore"+version = "1.13.9"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/d7/20/c2a99b1735adedd7cfd007f923db9100a8a69224622dba83803ad1887a09/fastcore-1.13.9.tar.gz", hash = "sha256:28620775e800397dab2986f217eae6e430ba7570e5f7523ba40d4f186d55f212", size = 100843, upload-time = "2026-07-01T01:05:57.664Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/51/4d/411fae078134890c53b9659887ffe19a85e30b7f6e2530b33ccc2665399a/fastcore-1.13.9-py3-none-any.whl", hash = "sha256:b3e58f798dcafef31e2331b60b9f85aa56c292f93683683ef37a9801a97a6af4", size = 105897, upload-time = "2026-07-01T01:05:56.036Z" },+]+[[package]]name = "filelock"version = "3.29.0"@@ -538,6 +691,55 @@ http = [{ name = "aiohttp" },]+[[package]]+name = "ghapi"+version = "1.0.14"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "fastcore" },+]+sdist = { url = "https://files.pythonhosted.org/packages/79/e3/133eb1edbbf07e1ef65cbfdd37d1d64078d406d713bb2a77213c95f92960/ghapi-1.0.14.tar.gz", hash = "sha256:5752ff78a48b965522b9f3d41a8953efc469c9535b9fd0ac8be15000b6c99aa9", size = 76904, upload-time = "2026-06-22T03:57:43.514Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/54/36/3475841d207b73f45fddfac827201919a8cbf7d75fcdf79ff1d9c1216375/ghapi-1.0.14-py3-none-any.whl", hash = "sha256:b92e4187d7a85f73a667c7ce6bda7a4c421e64306af6b9fb112cc58bbbd92b5e", size = 75381, upload-time = "2026-06-22T03:57:41.999Z" },+]++[[package]]+name = "gitdb"+version = "4.0.12"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "smmap" },+]+sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" },+]++[[package]]+name = "gitpython"+version = "3.1.50"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "gitdb" },+]+sdist = { url = "https://files.pythonhosted.org/packages/33/f6/354ae6491228b5eb40e10d89c4d13c651fe1cf7556e35ebdded50cff57ce/gitpython-3.1.50.tar.gz", hash = "sha256:80da2d12504d52e1f998772dc5baf6e553f8d2fcfe1fcc226c9d9a2ee3372dcc", size = 219798, upload-time = "2026-05-06T04:01:26.571Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/20/7a/1c6e3562dfd8950adbb11ffbc65d21e7c89d01a6e4f137fa981056de25c5/gitpython-3.1.50-py3-none-any.whl", hash = "sha256:d352abe2908d07355014abdd21ddf798c2a961469239afec4962e9da884858f9", size = 212507, upload-time = "2026-05-06T04:01:23.799Z" },+]++[[package]]+name = "grpclib"+version = "0.4.9"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "h2" },+ { name = "multidict" },+]+sdist = { url = "https://files.pythonhosted.org/packages/5b/28/5a2c299ec82a876a252c5919aa895a6f1d1d35c96417c5ce4a4660dc3a80/grpclib-0.4.9.tar.gz", hash = "sha256:cc589c330fa81004c6400a52a566407574498cb5b055fa927013361e21466c46", size = 84798, upload-time = "2025-12-14T22:23:14.349Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/5c/90/b0cbbd9efcc82816c58f31a34963071aa19fb792a212a5d9caf8e0fc3097/grpclib-0.4.9-py3-none-any.whl", hash = "sha256:7762ec1c8ed94dfad597475152dd35cbd11aecaaca2f243e29702435ca24cf0e", size = 77063, upload-time = "2025-12-14T22:23:13.224Z" },+]+[[package]]name = "h11"version = "0.16.0"@@ -547,6 +749,19 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },]+[[package]]+name = "h2"+version = "4.3.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "hpack" },+ { name = "hyperframe" },+]+sdist = { url = "https://files.pythonhosted.org/packages/1d/17/afa56379f94ad0fe8defd37d6eb3f89a25404ffc71d4d848893d270325fc/h2-4.3.0.tar.gz", hash = "sha256:6c59efe4323fa18b47a632221a1888bd7fde6249819beda254aeca909f221bf1", size = 2152026, upload-time = "2025-08-23T18:12:19.778Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/69/b2/119f6e6dcbd96f9069ce9a2665e0146588dc9f88f29549711853645e736a/h2-4.3.0-py3-none-any.whl", hash = "sha256:c438f029a25f7945c69e0ccf0fb951dc3f73a5f6412981daee861431b70e2bdd", size = 61779, upload-time = "2025-08-23T18:12:17.779Z" },+]+[[package]]name = "hf-xet"version = "1.4.3"@@ -579,6 +794,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/8a/7c/44314ecd0e89f8b2b51c9d9e5e7a60a9c1c82024ac471d415860557d3cd8/hf_xet-1.4.3-cp37-abi3-win_arm64.whl", hash = "sha256:7c2c7e20bcfcc946dc67187c203463f5e932e395845d098cc2a93f5b67ca0b47", size = 3533664, upload-time = "2026-03-31T22:40:12.152Z" },]+[[package]]+name = "hpack"+version = "4.2.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/26/5b/fcabf6028144a8723726318b07a32c2f3314acdff6265743cf08a344b18e/hpack-4.2.0.tar.gz", hash = "sha256:0895cfa3b5531fc65fe439c05eb65144f123bf7a394fcaa56aa423548d8e45c0", size = 51300, upload-time = "2026-06-23T18:34:46.667Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/71/b4/4a9fcfb2aef6ba44d9073ecd301443aa00b3dac95de5619f2a7de7ec8a91/hpack-4.2.0-py3-none-any.whl", hash = "sha256:858ac0b02280fa582b5080d68db0899c62a80375e0e5413a74970c5e518b6986", size = 34246, upload-time = "2026-06-23T18:34:45.472Z" },+]+[[package]]name = "httpcore"version = "1.0.9"@@ -627,6 +851,24 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/7e/2b/ef03ddb96bd1123503c2bd6932001020292deea649e9bf4caa2cb65a85bf/huggingface_hub-1.12.0-py3-none-any.whl", hash = "sha256:d74939969585ee35748bd66de09baf84099d461bda7287cd9043bfb99b0e424d", size = 646806, upload-time = "2026-04-24T13:32:06.717Z" },]+[[package]]+name = "hyperframe"+version = "6.1.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/02/e7/94f8232d4a74cc99514c13a9f995811485a6903d48e5d952771ef6322e30/hyperframe-6.1.0.tar.gz", hash = "sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08", size = 26566, upload-time = "2025-01-22T21:41:49.302Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/48/30/47d0bf6072f7252e6521f3447ccfa40b421b6824517f82854703d0f5a98b/hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5", size = 13007, upload-time = "2025-01-22T21:41:47.295Z" },+]++[[package]]+name = "identify"+version = "2.6.19"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/52/63/51723b5f116cc04b061cb6f5a561790abf249d25931d515cd375e063e0f4/identify-2.6.19.tar.gz", hash = "sha256:6be5020c38fcb07da56c53733538a3081ea5aa70d36a156f83044bfbf9173842", size = 99567, upload-time = "2026-04-17T18:39:50.265Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/94/84/d9273cd09688070a6523c4aee4663a8538721b2b755c4962aafae0011e72/identify-2.6.19-py2.py3-none-any.whl", hash = "sha256:20e6a87f786f768c092a721ad107fc9df0eb89347be9396cadf3f4abbd1fb78a", size = 99397, upload-time = "2026-04-17T18:39:49.221Z" },+]+[[package]]name = "idna"version = "3.15"@@ -657,6 +899,30 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },]+[[package]]+name = "modal"+version = "1.5.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "aiohttp" },+ { name = "cbor2" },+ { name = "certifi" },+ { name = "click" },+ { name = "grpclib" },+ { name = "protobuf" },+ { name = "rich" },+ { name = "synchronicity" },+ { name = "toml" },+ { name = "types-certifi" },+ { name = "types-toml" },+ { name = "typing-extensions" },+ { name = "watchfiles" },+]+sdist = { url = "https://files.pythonhosted.org/packages/54/56/a8d1a1dd705044e0c3534642361e8586db98908b683f8231b9fd39a86209/modal-1.5.1.tar.gz", hash = "sha256:f8fb7f4d3ccc5b774370704b1aabb79e629ea7e6681a7f9671af5cf77161be12", size = 801962, upload-time = "2026-06-23T15:44:18.853Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/85/67/c91cb2ee6cbae523ae051f5ecfebd9fc24518fb84b9e92859d32fbbe3a71/modal-1.5.1-py3-none-any.whl", hash = "sha256:49aeda1a4fafc71994c3aa63d3e2321419b586de0303113fa5bfc68f31ad5c95", size = 915761, upload-time = "2026-06-23T15:44:16.48Z" },+]+[[package]]name = "multidict"version = "6.7.1"@@ -818,6 +1084,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/7e/82/69e539c4c2027f1e1697e09aaa2449243085a0edf81ae2c6341e84d769b6/multiprocess-0.70.19-py39-none-any.whl", hash = "sha256:0d4b4397ed669d371c81dcd1ef33fd384a44d6c3de1bd0ca7ac06d837720d3c5", size = 133477, upload-time = "2026-01-19T06:47:38.619Z" },]+[[package]]+name = "nodeenv"+version = "1.10.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },+]+[[package]]name = "numpy"version = "2.2.6"@@ -1111,6 +1386,31 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/cb/2b/f8434233fab2bd66a02ec014febe4e5adced20e2693e0e90a07d118ed30e/pandas-3.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:5371b72c2d4d415d08765f32d689217a43227484e81b2305b52076e328f6f482", size = 9455341, upload-time = "2026-03-31T06:48:28.418Z" },]+[[package]]+name = "platformdirs"+version = "4.10.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/d7/47/e4501f49c178ae1d9f4a75073fda4204f52647993f075a9db4d14930e0c5/platformdirs-4.10.0.tar.gz", hash = "sha256:31e761a6a0ca04faf7353ea759bdba55652be214725111e5aac52dfa29d4bef7", size = 31224, upload-time = "2026-05-28T03:32:53.587Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/81/e6/cd9575ac904136b3cbf7aa7ee819ef86eedb7274e46f230e94ea4342e729/platformdirs-4.10.0-py3-none-any.whl", hash = "sha256:fb516cdb12eb0d857d0cd85a7c57cea4d060bee4578d6cf5a14dfdf8cbf8784a", size = 22743, upload-time = "2026-05-28T03:32:52.175Z" },+]++[[package]]+name = "pre-commit"+version = "4.6.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "cfgv" },+ { name = "identify" },+ { name = "nodeenv" },+ { name = "pyyaml" },+ { name = "virtualenv" },+]+sdist = { url = "https://files.pythonhosted.org/packages/8e/22/2de9408ac81acbb8a7d05d4cc064a152ccf33b3d480ebe0cd292153db239/pre_commit-4.6.0.tar.gz", hash = "sha256:718d2208cef53fdc38206e40524a6d4d9576d103eb16f0fec11c875e7716e9d9", size = 198525, upload-time = "2026-04-21T20:31:41.613Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/80/6e/4b28b62ecb6aae56769c34a8ff1d661473ec1e9519e2d5f8b2c150086b26/pre_commit-4.6.0-py2.py3-none-any.whl", hash = "sha256:e2cf246f7299edcabcf15f9b0571fdce06058527f0a06535068a86d38089f29b", size = 226472, upload-time = "2026-04-21T20:31:40.092Z" },+]+[[package]]name = "propcache"version = "0.4.1"@@ -1225,6 +1525,21 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },]+[[package]]+name = "protobuf"+version = "6.33.6"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/fc/9f/2f509339e89cfa6f6a4c4ff50438db9ca488dec341f7e454adad60150b00/protobuf-6.33.6-cp310-abi3-win32.whl", hash = "sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3", size = 425739, upload-time = "2026-03-18T19:04:48.373Z" },+ { url = "https://files.pythonhosted.org/packages/76/5d/683efcd4798e0030c1bab27374fd13a89f7c2515fb1f3123efdfaa5eab57/protobuf-6.33.6-cp310-abi3-win_amd64.whl", hash = "sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326", size = 437089, upload-time = "2026-03-18T19:04:50.381Z" },+ { url = "https://files.pythonhosted.org/packages/5c/01/a3c3ed5cd186f39e7880f8303cc51385a198a81469d53d0fdecf1f64d929/protobuf-6.33.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a", size = 427737, upload-time = "2026-03-18T19:04:51.866Z" },+ { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" },+ { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" },+ { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" },+ { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" },+]+[[package]]name = "pyarrow"version = "24.0.0"@@ -1303,6 +1618,28 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },]+[[package]]+name = "python-discovery"+version = "1.4.2"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "filelock" },+ { name = "platformdirs" },+]+sdist = { url = "https://files.pythonhosted.org/packages/0b/1a/cbbaf13b730abb0a16b964d984e19f2fe520c21a4dc664051359a3f5a9e7/python_discovery-1.4.2.tar.gz", hash = "sha256:8f3746c4b4968d22afbb97d36e1a0e5b66e6c0f297290f2e95f05b9b8bf18690", size = 70277, upload-time = "2026-06-11T16:10:42.383Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/1a/82/a70006589557f267f15bd384c0642ad49f0d97b690c3a05b166b9dcbad3b/python_discovery-1.4.2-py3-none-any.whl", hash = "sha256:475803f53b7b2ed6e490e27373f9d8340f7d2eebf9acdaf645d7d714c97bb500", size = 33886, upload-time = "2026-06-11T16:10:41.192Z" },+]++[[package]]+name = "python-dotenv"+version = "1.2.2"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },+]+[[package]]name = "pytz"version = "2026.1.post1"@@ -1312,6 +1649,31 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", hash = "sha256:f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a", size = 510489, upload-time = "2026-03-03T07:47:49.167Z" },]+[[package]]+name = "pywin32"+version = "312"+source = { registry = "https://pypi.org/simple" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/fe/1b/9cfdeac80ee45bebbbcb31f1b7b99a0d81a1c72de48d837be984e0e88b1d/pywin32-312-cp310-cp310-win32.whl", hash = "sha256:772235332b5d1024c696f11cea1ae4be7930f0a8b894bb43db14e3f435f1ff7e", size = 6361387, upload-time = "2026-06-04T07:49:14.329Z" },+ { url = "https://files.pythonhosted.org/packages/33/b1/7afc96d041d982c27bc2df6f853d43f01fd273e3d39d04be3647ddeb533d/pywin32-312-cp310-cp310-win_amd64.whl", hash = "sha256:5dbc35d2b5320dc07f25fa31269cfb767471002b17de5eb067d03da68c7cb2db", size = 6926780, upload-time = "2026-06-04T07:49:16.881Z" },+ { url = "https://files.pythonhosted.org/packages/ce/3a/4140da9ad54108e517f4a16b2d83da3033e08662144623e1239587cb7db6/pywin32-312-cp310-cp310-win_arm64.whl", hash = "sha256:3020656e34f1cf7faeb7bccd2b84653a607c6ff0c55ada85e6487d61716deabd", size = 4307203, upload-time = "2026-06-04T07:49:18.993Z" },+ { url = "https://files.pythonhosted.org/packages/1f/f5/10a6e845a00fc5e7afd0a988b744f403d4d57162a28d160a093c4d9322f0/pywin32-312-cp311-cp311-win32.whl", hash = "sha256:17948aeadbdb091f0ced6ef0841620794e68327b94ee415571c1203594b7215c", size = 6362659, upload-time = "2026-06-04T07:49:21.349Z" },+ { url = "https://files.pythonhosted.org/packages/35/c4/dcd2d62b5944b6d5db53413a5899016ccd57ffcb7278f3f81655d25d2027/pywin32-312-cp311-cp311-win_amd64.whl", hash = "sha256:d11417d84412f859b722fad0841b3614459ed0047f7542d8362e77884f6b6e8a", size = 6928825, upload-time = "2026-06-04T07:49:23.934Z" },+ { url = "https://files.pythonhosted.org/packages/b7/56/3cbb433fe4501cdba2eb9040f56a4e1a8243faa4186b25295564d1a7a79d/pywin32-312-cp311-cp311-win_arm64.whl", hash = "sha256:b2200a054ca6d6625c4842fc56a4976a4b47f96b73dbe5538c3f813a80359f47", size = 6721875, upload-time = "2026-06-04T07:49:26.416Z" },+ { url = "https://files.pythonhosted.org/packages/83/ff/32aa7d2ed0ab12b323aaa64f9b75e6ad4f8fd09f9ccfc28c79414d46838d/pywin32-312-cp312-cp312-win32.whl", hash = "sha256:dab4f65ac9c4e48400a2a0530c46c3c579cd5905ecd11b80692373915269208b", size = 6371877, upload-time = "2026-06-04T07:49:28.836Z" },+ { url = "https://files.pythonhosted.org/packages/03/d9/77040d3b43df3f3be32ea289433d660d2727f5ba327bc73be835127d9d60/pywin32-312-cp312-cp312-win_amd64.whl", hash = "sha256:b457f6d628a47e8a7346ce22acb7e1a46a4a78b52e1d17e1af56871bd19a93bc", size = 6914841, upload-time = "2026-06-04T07:49:31.85Z" },+ { url = "https://files.pythonhosted.org/packages/e3/cc/7b1ec671775756020a0ee7f4feeaf3c568f0ab86bd3900088cf986937a92/pywin32-312-cp312-cp312-win_arm64.whl", hash = "sha256:6017c58e12f6809fbb0555b75df144c2922a9ffd18e4b9b5afa863b6c1a9d950", size = 6727901, upload-time = "2026-06-04T07:49:34.244Z" },+ { url = "https://files.pythonhosted.org/packages/2d/41/12fbfd7f36ed2146d8bc9de96c2741296bf0d490b98508496cff322e274c/pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c", size = 6370184, upload-time = "2026-06-04T07:49:36.253Z" },+ { url = "https://files.pythonhosted.org/packages/ba/db/36a78e3403099d31d9746d13fdcde5accc43c1155f375a34d15983a479a7/pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9", size = 6914298, upload-time = "2026-06-04T07:49:38.876Z" },+ { url = "https://files.pythonhosted.org/packages/84/37/c1697194092b76de9ed47ca124323f02c57ffc8a45c06f88a3d5acaf01eb/pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831", size = 6727640, upload-time = "2026-06-04T07:49:41.083Z" },+ { url = "https://files.pythonhosted.org/packages/fc/2b/1f3cded5822fd49c02f40544cbb5f58c7cfd6b1694869fd476cb6170ee97/pywin32-312-cp314-cp314-win32.whl", hash = "sha256:a77a90fbb6881238d2ca9c6fd797b25817f3768fe78d214a90137ff055a75f5b", size = 6468928, upload-time = "2026-06-04T07:49:43.188Z" },+ { url = "https://files.pythonhosted.org/packages/21/82/3bf86d2e2808902013132e1ce905a7da0da53790f3836c64bf44d55e24f3/pywin32-312-cp314-cp314-win_amd64.whl", hash = "sha256:a4dd3a848290ef724347b19f301045831d8e802fa4464f491b98b1e0a081432e", size = 7024157, upload-time = "2026-06-04T07:49:45.34Z" },+ { url = "https://files.pythonhosted.org/packages/a4/0e/73f6d6800b4f27655abd9e9f6aaeaefcddb2b946e4674efa2bab184a7f7b/pywin32-312-cp314-cp314-win_arm64.whl", hash = "sha256:9fce94568364e0155e6dfb781ac5d95903be8baf28670632beab1b523f300daa", size = 6839598, upload-time = "2026-06-04T07:49:47.613Z" },+ { url = "https://files.pythonhosted.org/packages/eb/61/caa39686032d2ebdd04ff0ab5cbe163126c0066d98e00c9018646e42393b/pywin32-312-cp315-cp315-win32.whl", hash = "sha256:5c1fbe4a937a73ae9297384a3da38518cbc694c68ad8a809b2e19acd350f03ed", size = 6471159, upload-time = "2026-06-04T07:49:50.035Z" },+ { url = "https://files.pythonhosted.org/packages/0f/cd/7e1de64a4a6f69c04214169657ccab0d93a670ea50e35eb8f489d7378249/pywin32-312-cp315-cp315-win_amd64.whl", hash = "sha256:c2f03a0f73f804a13c2735b99392b0cd426bb4f2c4d0178e5ac966a0f21618d5", size = 7025293, upload-time = "2026-06-04T07:49:54.857Z" },+ { url = "https://files.pythonhosted.org/packages/23/ed/4532e9388e65fa16b46776ef47ad631a64eda1631884488af707666350ed/pywin32-312-cp315-cp315-win_arm64.whl", hash = "sha256:a8597d28f267b39074aef51fa593530082b39cbe5a074226096857b1fed2dfb9", size = 6840337, upload-time = "2026-06-04T07:49:57.531Z" },+]+[[package]]name = "pyyaml"version = "6.0.3"@@ -1422,21 +1784,96 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },]+[[package]]+name = "smmap"+version = "5.0.3"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/1f/ea/49c993d6dfdd7338c9b1000a0f36817ed7ec84577ae2e52f890d1a4ff909/smmap-5.0.3.tar.gz", hash = "sha256:4d9debb8b99007ae47165abc08670bd74cb74b5227dda7f643eccc4e9eb5642c", size = 22506, upload-time = "2026-03-09T03:43:26.1Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/c1/d4/59e74daffcb57a07668852eeeb6035af9f32cbfd7a1d2511f17d2fe6a738/smmap-5.0.3-py3-none-any.whl", hash = "sha256:c106e05d5a61449cf6ba9a1e650227ecfb141590d2a98412103ff35d89fc7b2f", size = 24390, upload-time = "2026-03-09T03:43:24.361Z" },+]++[[package]]+name = "soupsieve"+version = "2.8.4"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/47/2c/0a5f6f8ee0d5589e48c7640213ed5175d52cf540a06725b628cc1a45d6ce/soupsieve-2.8.4.tar.gz", hash = "sha256:e121fd02e975c695e4e9e8774a5ee35d74714b59307868dcc5319ad2d9e3328e", size = 121110, upload-time = "2026-05-24T13:55:57.154Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/5e/f5/0c41cb68dcae6b7de4fac4188a3a9589e21fb31df21ea3a2e888db95e6c9/soupsieve-2.8.4-py3-none-any.whl", hash = "sha256:e7e6b0769c8f51ed59acab6e994b00621096cfb1c640a7509295987388fbaf65", size = 37304, upload-time = "2026-05-24T13:55:55.406Z" },+]++[[package]]+name = "swebench"+version = "4.1.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "beautifulsoup4" },+ { name = "chardet" },+ { name = "datasets" },+ { name = "docker" },+ { name = "ghapi" },+ { name = "gitpython" },+ { name = "modal" },+ { name = "pre-commit" },+ { name = "python-dotenv" },+ { name = "requests" },+ { name = "rich" },+ { name = "tenacity" },+ { name = "tqdm" },+ { name = "unidiff" },+]+sdist = { url = "https://files.pythonhosted.org/packages/24/e1/c997299ad7bf088876d30398203aa1eed7dec897670dc1aa35b1d748ffcc/swebench-4.1.0.tar.gz", hash = "sha256:5aaa6a92c2db1aa64892d28a47483ca46a45a15cf1d2df673d7744f71811dc9a", size = 134341, upload-time = "2025-09-11T02:58:00.447Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/36/67/981d8b642ac3eac7c8a7b7832ff8b2fb74f96b28b5fcd9a8979879e5c46d/swebench-4.1.0-py3-none-any.whl", hash = "sha256:1243776f720047cc9e20a427f7a52b75c13a07abda6154fb60fe77f82ec8af57", size = 157231, upload-time = "2025-09-11T02:57:58.953Z" },+]+[[package]]name = "swebench-agtx"version = "0.1.0"source = { virtual = "." }dependencies = [{ name = "datasets" },+ { name = "swebench" },{ name = "tqdm" },][package.metadata]requires-dist = [{ name = "datasets", specifier = ">=2.18.0" },+ { name = "swebench", specifier = ">=4.1.0" },{ name = "tqdm", specifier = ">=4.66.0" },]+[[package]]+name = "synchronicity"+version = "0.12.5"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/5d/1c/f51dc54bbd302991026a53f9790735540e0e9e1184e9d5939f02446aa5bc/synchronicity-0.12.5.tar.gz", hash = "sha256:94d96b1d85698e3056b96a793b8c0949af6584e4a7d877fabdeb5385efe230aa", size = 60745, upload-time = "2026-06-18T21:06:23.545Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/06/74/ad9b99520f70c0bc3318e582e359d360cfc0f7afd7bf368a7f24013cece7/synchronicity-0.12.5-py3-none-any.whl", hash = "sha256:fdbbb10d437bc08a6b0f814fc66fddd1b58ffed314533d42f1ab555801e781af", size = 41107, upload-time = "2026-06-18T21:06:22.505Z" },+]++[[package]]+name = "tenacity"+version = "9.1.4"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },+]++[[package]]+name = "toml"+version = "0.10.2"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" },+]+[[package]]name = "tqdm"version = "4.67.3"@@ -1464,6 +1901,24 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/9a/72/193d4e586ec5a4db834a36bbeb47641a62f951f114ffd0fe5b1b46e8d56f/typer-0.25.0-py3-none-any.whl", hash = "sha256:ac01b48823d3db9a83c9e164338057eadbb1c9957a2a6b4eeb486669c560b5dc", size = 55993, upload-time = "2026-04-26T08:46:15.889Z" },]+[[package]]+name = "types-certifi"+version = "2021.10.8.3"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/52/68/943c3aeaf14624712a0357c4a67814dba5cea36d194f5c764dad7959a00c/types-certifi-2021.10.8.3.tar.gz", hash = "sha256:72cf7798d165bc0b76e1c10dd1ea3097c7063c42c21d664523b928e88b554a4f", size = 2095, upload-time = "2022-06-09T15:19:05.244Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/b5/63/2463d89481e811f007b0e1cd0a91e52e141b47f9de724d20db7b861dcfec/types_certifi-2021.10.8.3-py3-none-any.whl", hash = "sha256:b2d1e325e69f71f7c78e5943d410e650b4707bb0ef32e4ddf3da37f54176e88a", size = 2136, upload-time = "2022-06-09T15:19:03.127Z" },+]++[[package]]+name = "types-toml"+version = "0.10.8.20260518"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/4b/11/6ece999e91f2ccb848ab4420f3f4816e78ac0541f739e6864affdaaa5737/types_toml-0.10.8.20260518.tar.gz", hash = "sha256:80e10facd24fdeda9d5c672187d72be3ac284843788d67f5aae59e3e016db6fe", size = 9419, upload-time = "2026-05-18T06:02:16.719Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/91/25/489751806bf5c95e4007f8e17409199c54d31e49ffbea07c5729b1286c8e/types_toml-0.10.8.20260518-py3-none-any.whl", hash = "sha256:0e564ab05f6fde62a315b3b5a9b6624fda569399795d30a37e64705a70459303", size = 9669, upload-time = "2026-05-18T06:02:15.86Z" },+]+[[package]]name = "typing-extensions"version = "4.15.0"@@ -1482,6 +1937,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" },]+[[package]]+name = "unidiff"+version = "0.7.5"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/a3/48/81be0ac96e423a877754153699731ef439fd7b80b4c8b5425c94ed079ebd/unidiff-0.7.5.tar.gz", hash = "sha256:2e5f0162052248946b9f0970a40e9e124236bf86c82b70821143a6fc1dea2574", size = 20931, upload-time = "2023-03-10T01:05:39.185Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/8a/54/57c411a6e8f7bd7848c8b66e4dcaffa586bf4c02e63f2280db0327a4e6eb/unidiff-0.7.5-py2.py3-none-any.whl", hash = "sha256:c93bf2265cc1ba2a520e415ab05da587370bc2a3ae9e0414329f54f0c2fc09e8", size = 14386, upload-time = "2023-03-10T01:05:36.594Z" },+]+[[package]]name = "urllib3"version = "2.7.0"@@ -1491,6 +1955,139 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },]+[[package]]+name = "virtualenv"+version = "21.5.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "distlib" },+ { name = "filelock" },+ { name = "platformdirs" },+ { name = "python-discovery" },+ { name = "typing-extensions", marker = "python_full_version < '3.11'" },+]+sdist = { url = "https://files.pythonhosted.org/packages/f1/a5/81f987504738e6defeed61ec1c47e2aefab3c35d8eeb87e1b3f38cf28254/virtualenv-21.5.1.tar.gz", hash = "sha256:dca3bf98275a59c652b69d68e73433e597d977c2da9198882479d1a7188009c8", size = 4578798, upload-time = "2026-06-16T16:23:58.603Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/2c/02/3623e6169bed617ed1e2d372f7c69f92ec28d54c4dfc997055c8578ec148/virtualenv-21.5.1-py3-none-any.whl", hash = "sha256:55aa670b67bbfb991b03fda39bd3276d92c419d702376e98c5df1c9989a26783", size = 4558820, upload-time = "2026-06-16T16:23:56.963Z" },+]++[[package]]+name = "watchfiles"+version = "1.2.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "anyio" },+]+sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/0d/5a/2bf22ecb24916983bf1cc0095e7dea2741d14d6553b0d6a2ac8bc96eca93/watchfiles-1.2.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:bb68bf4df85abebe5efddc53cf2075520f243a59868d9b3973278b23e76962a9", size = 400471, upload-time = "2026-05-18T04:31:08.908Z" },+ { url = "https://files.pythonhosted.org/packages/55/70/dea1f6a0e76607841a60fb51af150e70124864673f61704abb62b90cdcc7/watchfiles-1.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c16cb06dd17d43b9d185094268459eac92c9538356f050e55b54e82cf700e1d4", size = 394599, upload-time = "2026-05-18T04:30:19.845Z" },+ { url = "https://files.pythonhosted.org/packages/18/52/752dcc7dc817baef5e89518732925795ce52e36a683a9a3c9fb68b21504e/watchfiles-1.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77a0feab9af4c021c581f695258c642b3d10c5fd4c676e33a0d8606425d82631", size = 455458, upload-time = "2026-05-18T04:30:29.126Z" },+ { url = "https://files.pythonhosted.org/packages/12/48/366ebbb22fcc504c2f72b45f0b7e72f40a18795cc01752c16066d597b67a/watchfiles-1.2.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a16ffe19bf5cf9f5edaa1ad1dd830c5a816e8feec430c522302ab55483a4b994", size = 460513, upload-time = "2026-05-18T04:31:40.85Z" },+ { url = "https://files.pythonhosted.org/packages/ad/44/1f9e1b15e7a729062e0d0c3d0d7225ea4ab98b2267ef87287153be2495fc/watchfiles-1.2.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:204f299afcbd65918ab78dbc52626b0ae45e9d8cef403fdbf33ecf9e40eac66e", size = 493616, upload-time = "2026-05-18T04:30:58.47Z" },+ { url = "https://files.pythonhosted.org/packages/7e/55/8b1086dcc8a1d6a697a62767bd7ea368e74c61c6fd171683cfe24a3fe5d2/watchfiles-1.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11743adfa510bfffebe97659fb280182b5c9b238708f667e866f308c3430dc19", size = 573154, upload-time = "2026-05-18T04:30:37.903Z" },+ { url = "https://files.pythonhosted.org/packages/14/7a/242f400cc77fafa7b18d53d19d9cb64fc6a6f61f28c55913bae7c674d92a/watchfiles-1.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb72919d93e3a16fc451d3aa3d4b1698423daca1b382d3d959c9ac51297c12a8", size = 467046, upload-time = "2026-05-18T04:30:41.869Z" },+ { url = "https://files.pythonhosted.org/packages/02/c8/79eee650c62d2c186598489814468e389b5def0ebe755399ff645b35b1b2/watchfiles-1.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62f042afde2dde21ec1d2c1a74361e804673df86f51e418a999c9acfe671b07", size = 457100, upload-time = "2026-05-18T04:31:13.064Z" },+ { url = "https://files.pythonhosted.org/packages/81/36/519f6dbb7a95e4fe7c1513ed25b1520295ef9905a27f1f2226a73892bfb7/watchfiles-1.2.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:027ae72bfdfd254862065d8b3e2a815c6ab9b1853ce41e6648ece84afd34a551", size = 467038, upload-time = "2026-05-18T04:30:32.915Z" },+ { url = "https://files.pythonhosted.org/packages/2f/12/951af6b9f89097e02511122258402cb3578443021930b70cf968d6310dc0/watchfiles-1.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e1cfd51e97e13ff3bd047c140764d277fc9b95b7cb5da59e46a47d167adab310", size = 632563, upload-time = "2026-05-18T04:30:11.539Z" },+ { url = "https://files.pythonhosted.org/packages/28/cc/0cba1f0a6117b7ec117271bdc3cb3a5a252005959755a2c09a745e0942cc/watchfiles-1.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:24b2405c0a46738dd9e1cf7135aa5dbdb9d42d024628651b3b13d5117e99f8df", size = 660851, upload-time = "2026-05-18T04:31:53.186Z" },+ { url = "https://files.pythonhosted.org/packages/d0/f2/26347558cc8bf6877845e66b315f644d03c173906aa09e233a3f4fd23928/watchfiles-1.2.0-cp310-cp310-win32.whl", hash = "sha256:8c520725602756229f045b032a1ff33d7ef0f7404189d62f6c2438cb6d8ef6a1", size = 277023, upload-time = "2026-05-18T04:30:18.825Z" },+ { url = "https://files.pythonhosted.org/packages/6d/68/a5e67b6b68e94f4c1511d61c46c55eba0737583620b6febf194c7b9cc23f/watchfiles-1.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:03b14855c6f35539e2d95c442ae9530a75762f1e26567152b9ed05f96534a74d", size = 290107, upload-time = "2026-05-18T04:32:09.677Z" },+ { url = "https://files.pythonhosted.org/packages/fc/3d/8024c801df84d1587740d0359e7fdd80afeae3d159011f3d5376dd82f18e/watchfiles-1.2.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:704fd259e332e01f9b9c178f4bce9e49027e5587cc2600eeeaf8e76e1c846201", size = 400242, upload-time = "2026-05-18T04:31:19.014Z" },+ { url = "https://files.pythonhosted.org/packages/87/5b/f4dfd45323e949984a3a7f9dc31d1cbb049921e7d98253488dda72ccdaa9/watchfiles-1.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6543cf55d170003296d185c0af981f3e1311564907e1f4e08671fc7693a890a5", size = 394562, upload-time = "2026-05-18T04:30:08.46Z" },+ { url = "https://files.pythonhosted.org/packages/98/d8/19483ef075d601c409bce8bcbb5c0f81a10876fff870400568f08ce484a1/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89d8c2394a065ca86f5d2910ff263ae67c127e1376ccc4f9fc35c71db879f80a", size = 456611, upload-time = "2026-05-18T04:30:45.723Z" },+ { url = "https://files.pythonhosted.org/packages/b1/6a/cc81fbe7ee42f2f22e661a6e12def7807e01b14b2f39e0ff83fd373fd307/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:772b80df316480d894a0e3165fdd19cf77f5d17f9a787f94029465ad0e3529d1", size = 461379, upload-time = "2026-05-18T04:31:29.292Z" },+ { url = "https://files.pythonhosted.org/packages/b1/57/7e669002082c0a0f4fb5113bb70125f7110124b846b0a11bc5ae8e90eac1/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d158cd89df6053823533e06fb1d73c549133bff5f0396170c0e53d9559340717", size = 493556, upload-time = "2026-05-18T04:30:05.44Z" },+ { url = "https://files.pythonhosted.org/packages/45/7d/f60a2b19807b21fe8281f3a8da4f59eef0d5f96825ac4680ba2d4f2ebf91/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d516b3283a758e087841aedb8031549fb41ced08f3db10aa6d2bf32dc042525b", size = 575255, upload-time = "2026-05-18T04:30:40.568Z" },+ { url = "https://files.pythonhosted.org/packages/bd/49/77f5b5e6efbcd57482f74948ebb1b97e5c0046d6b61475042d830c84b3ff/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:53b2290c92e0506d102cd448fbc610d87079553f86caa39d67440856a8b8bba5", size = 467052, upload-time = "2026-05-18T04:31:17.942Z" },+ { url = "https://files.pythonhosted.org/packages/ee/5a/73e2959af1b97fd5d556f9a8bdba017be23ceeef731869d5eaa0a753d5a3/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a711b51aec4370d0dcda5b6c09463206f133a5759341d7744b953a7b62e1100e", size = 456858, upload-time = "2026-05-18T04:30:30.182Z" },+ { url = "https://files.pythonhosted.org/packages/50/57/1bc8c27fad7e6c19bddee15d276dbb6ab72480ec01c127afff1673aee417/watchfiles-1.2.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:e2ca07fa7d89195ec0865d3d285666286740bfa83d83e5cee204043a31ecc165", size = 467579, upload-time = "2026-05-18T04:32:15.897Z" },+ { url = "https://files.pythonhosted.org/packages/09/6c/3c2e44edba3553c5e3c3b8c8a2a6dee6b9e12ae2cf4bd2378bebf9dc3038/watchfiles-1.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e0618518f282c4ebff60f5e5b1247b6d91bb8b9f4476947563a1e74acc66f3c6", size = 633253, upload-time = "2026-05-18T04:31:37.123Z" },+ { url = "https://files.pythonhosted.org/packages/30/c2/d8c84a882ab39bbefcc4915ab3e91830b7a7e990c5570b0b69075aba3faf/watchfiles-1.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0d191c054d0715c3c95c99df9b8dbf6fd096d8c1e021e8f212e1bd8bc444ccb5", size = 660713, upload-time = "2026-05-18T04:31:24.62Z" },+ { url = "https://files.pythonhosted.org/packages/a9/07/f97736a5fc605364fe67b25e9fa4a6965dfd4840d50c406ada507e9d735f/watchfiles-1.2.0-cp311-cp311-win32.whl", hash = "sha256:9342472aff9b093c5acd4f6d8f70ae0937964ab56542502bcf5579782da69ae8", size = 277222, upload-time = "2026-05-18T04:31:21.131Z" },+ { url = "https://files.pythonhosted.org/packages/cf/99/2b04981977fc2608afd60360d928c6aecf6b950292ca221d98f4005f6694/watchfiles-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:dbd6c97045dad81227c8d040173da044c1de08de64a5ea8b555da4aee1d5fa22", size = 290274, upload-time = "2026-05-18T04:31:45.966Z" },+ { url = "https://files.pythonhosted.org/packages/3c/74/f7f58a7075ee9cf612b0cfcddb78b8cd8234f0742d6f0075cf0da2dde1c6/watchfiles-1.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:57a2d9fa4fb4c2ecae57b13dfff2c7ab53e21a2ba674fe9f05506680fcdcc0d7", size = 283460, upload-time = "2026-05-18T04:31:39.126Z" },+ { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115, upload-time = "2026-05-18T04:32:02.06Z" },+ { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659, upload-time = "2026-05-18T04:30:50.951Z" },+ { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207, upload-time = "2026-05-18T04:31:04.231Z" },+ { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273, upload-time = "2026-05-18T04:31:50.377Z" },+ { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927, upload-time = "2026-05-18T04:31:42.485Z" },+ { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476, upload-time = "2026-05-18T04:31:03.071Z" },+ { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650, upload-time = "2026-05-18T04:30:12.701Z" },+ { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398, upload-time = "2026-05-18T04:30:13.784Z" },+ { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140, upload-time = "2026-05-18T04:31:52.111Z" },+ { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259, upload-time = "2026-05-18T04:31:25.676Z" },+ { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859, upload-time = "2026-05-18T04:30:24.333Z" },+ { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480, upload-time = "2026-05-18T04:30:31.307Z" },+ { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718, upload-time = "2026-05-18T04:32:10.745Z" },+ { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026, upload-time = "2026-05-18T04:30:22.23Z" },+ { url = "https://files.pythonhosted.org/packages/d1/4d/70a7feced9f87e2ff26dba42667290f41694fc64646c67261fbb8cab5d5c/watchfiles-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98", size = 399730, upload-time = "2026-05-18T04:31:38.162Z" },+ { url = "https://files.pythonhosted.org/packages/31/3a/0da302f2307aee316922806ebd5726c542cbd787c938271cf14a074c7daf/watchfiles-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44", size = 392842, upload-time = "2026-05-18T04:30:27.051Z" },+ { url = "https://files.pythonhosted.org/packages/db/ef/d5bdb705c224dbc256aa0c1ec47bf4e61ec52558f2afb44a71a1fe4d7015/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658", size = 452989, upload-time = "2026-05-18T04:31:11.945Z" },+ { url = "https://files.pythonhosted.org/packages/71/29/5495f2c1661949ef7a35e4d71111d129cfe7606414a26887a919d0a55406/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b4e77f6a55f858504069abd35d336a637555c09bca453dde1ee1e5ada8a6a1fb", size = 458978, upload-time = "2026-05-18T04:30:52.606Z" },+ { url = "https://files.pythonhosted.org/packages/d5/8c/7f9c07c433811c2fffd93e13fdfb7135de9aab5f2ae41be08960fa0047dc/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0cb4d80e212f116474a545c21c912b445f16bb0cef9e6a73a498164223e14e2f", size = 490248, upload-time = "2026-05-18T04:31:36.003Z" },+ { url = "https://files.pythonhosted.org/packages/3c/11/d93632febc52fbc21be90231bb7c17fd5387f46c9076fd40a5f9c2ae6910/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b974946a10af379d425e2eef5b62f5c6ebeaccf91d45eaad6f5b27ecd4f91aa0", size = 571847, upload-time = "2026-05-18T04:31:10.862Z" },+ { url = "https://files.pythonhosted.org/packages/55/b4/383173e73aabb07ad1d9c7aa859d95437ac46a6d6a1e11005facda0c9d19/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86bc13c25a8d1fcd70b51d0ce7c9b65e90de5666fcbfd3e34957cc73ee19aeb5", size = 465974, upload-time = "2026-05-18T04:30:17.006Z" },+ { url = "https://files.pythonhosted.org/packages/a7/6c/89b1a230a78f57c52dd8893adb1f92f94411721b6ec12596c56d98c74356/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca148d73dea36c9763aaa351e4d7a51780ec1584217c45276f4fe8239c768b71", size = 454782, upload-time = "2026-05-18T04:30:35.656Z" },+ { url = "https://files.pythonhosted.org/packages/24/62/1732118367cfff0a9fce3bf62ff4bfded09ef5df21d9d446b858b3f70a96/watchfiles-1.2.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:c525543d91961c6955b2636b308569e84a1d1c5f5f2932041ab9ef46422f43e3", size = 465182, upload-time = "2026-05-18T04:30:20.846Z" },+ { url = "https://files.pythonhosted.org/packages/28/96/716f7e5f51339bf22963f3345f9f27d7f3b30e2eadc597e257c881dd3c53/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:a204794696ffb8f9b10fba6f7cb5216d42f3b2b71860ccac6b6e42f5f10973b0", size = 629841, upload-time = "2026-05-18T04:31:05.397Z" },+ { url = "https://files.pythonhosted.org/packages/4c/fe/c40783950fd771ccf66ab3ec2722d188a9af1c7f96c6e811f36e40c6e03f/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:10d86db20695afe7997ac9e1717637d6714a8d0220458c33f3d2061f54cec427", size = 658028, upload-time = "2026-05-18T04:31:48.22Z" },+ { url = "https://files.pythonhosted.org/packages/71/72/4508db1856d1d87fcbb3b63f4839bab1b5682cb0e8d224d122263c09654a/watchfiles-1.2.0-cp313-cp313-win32.whl", hash = "sha256:eb283ee99e21ad6443c8cdb06ac5b34b1308c329cbdf03fa02b445363714c799", size = 275183, upload-time = "2026-05-18T04:30:59.57Z" },+ { url = "https://files.pythonhosted.org/packages/f9/36/14b76ca57652e5cc5fd1c11f32a261292c08a0d19a00351013c2549cbfb2/watchfiles-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a0f27f01bee51861392bb6b7c4fdb290b27d1eb194e9e28788d68102a0e898d9", size = 288059, upload-time = "2026-05-18T04:32:07.937Z" },+ { url = "https://files.pythonhosted.org/packages/1b/8d/0a85e395398d8d20fadfe5c5d32c726eee17a519e78fb356f2cf7531bffe/watchfiles-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:3651aa7058595e9cfb75d35dd5ada2bf9f48a5b8a0f3562821d3e210c507e077", size = 280186, upload-time = "2026-05-18T04:31:54.484Z" },+ { url = "https://files.pythonhosted.org/packages/37/68/36db056f1fdcc5f07302f56e631774d6835bcd6fa3ace402304621d5f9e5/watchfiles-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:faea288b6f0ab1902ef08f4ca6de005dccf856c4e0c4f21b8c5fce02d90a1b08", size = 399031, upload-time = "2026-05-18T04:30:44.576Z" },+ { url = "https://files.pythonhosted.org/packages/c1/64/01a9d6f66a82a5c101ce939274106cc72759d62427e153f01edd2b9f87c2/watchfiles-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01859b11fd9fbca670f4d5da00fbac282cfea9bd67a2125d8b2833a3b5617ea9", size = 391205, upload-time = "2026-05-18T04:30:25.413Z" },+ { url = "https://files.pythonhosted.org/packages/84/2c/0a44fe058cb4bb7b8ede6b6670698bbb7c0400740e378d00022189b7b31d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fff610d7bb2256a317bb1e96f0d7862c7aa8076733ee5df0fd41bbe76a24a4f4", size = 451892, upload-time = "2026-05-18T04:32:14.005Z" },+ { url = "https://files.pythonhosted.org/packages/67/a1/351e0d56cd35e6488b5c8b4fb11a809a5bc923e8fe8fed9faf8920be0c89/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b141a4891c995a039cd89e9a49e62df1dc8a559a5d1a6e4c7106d16c12777a55", size = 458867, upload-time = "2026-05-18T04:31:22.279Z" },+ { url = "https://files.pythonhosted.org/packages/d5/7d/9d09605187f1b838998624049fcf8bf47b73c1a3b76901fcac1782f62277/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f22943b7770483f6ea0721c6b11d022947a98eb0acae14694de034f4d0d38925", size = 490217, upload-time = "2026-05-18T04:31:43.657Z" },+ { url = "https://files.pythonhosted.org/packages/60/5d/a17a16eccb182f04188cd308ec24b1a71a9b5c4e7098269cf35d9fa56d02/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1bc6195825b7dcd217968bb1f801a60fd4c16e8eeab5bedc7fe917d7d5995ab4", size = 571458, upload-time = "2026-05-18T04:32:11.875Z" },+ { url = "https://files.pythonhosted.org/packages/d3/3d/4dd457062083ab1938e5dfd45032eb425cee2ac817287ca8ff4356183e5d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4a4b147f5dca2a5d325a06a832fb43f345751adfbc63204aec30e0d9ca965a2", size = 464707, upload-time = "2026-05-18T04:30:43.492Z" },+ { url = "https://files.pythonhosted.org/packages/c6/71/ea8c57b128f5383de74d0c7d2d9c57ad7c9a65a930c451bd25d524b295b7/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4543579a9bdb0c9560039b4ffddbdb39545707659fbc430ce4c10f3f68d557f9", size = 454663, upload-time = "2026-05-18T04:30:16.061Z" },+ { url = "https://files.pythonhosted.org/packages/53/fd/2e812bf938406d7db351f0703ddd3fc6c061cf30d96153a77bc79a943a44/watchfiles-1.2.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:20aa0e708b920bde876a4aa82dc7dd6ebea228a63a67cda6632c2fc87b787efa", size = 463537, upload-time = "2026-05-18T04:31:44.9Z" },+ { url = "https://files.pythonhosted.org/packages/86/56/d17a7f1dd1bc3035f1072694a551301272f1739c2d8e319c927cb9e29b38/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:d413349d565dab74297f2a63e84a097936be69bf8f3b3801f27f380e32040f44", size = 629194, upload-time = "2026-05-18T04:31:14.141Z" },+ { url = "https://files.pythonhosted.org/packages/be/06/f1ff66bf5cae50aa4062779a0ecd0bbaf15e466195719074078947d9a17d/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f28b2725eb8cce327b9b3ab02415c853011dc55c95832fe90de6bc56f5315f72", size = 656194, upload-time = "2026-05-18T04:31:47.14Z" },+ { url = "https://files.pythonhosted.org/packages/e7/54/a9c7ea9a82a4ac65e7004c0a03920b5cdd2f9c3b678757d9cd425aa51d53/watchfiles-1.2.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b8c8358484d5fa12ef34f05b7f4168eaf1932f408725ff6d023c33ec17bd79d4", size = 400205, upload-time = "2026-05-18T04:32:05.153Z" },+ { url = "https://files.pythonhosted.org/packages/aa/5d/c9ab3534374a4a67450696905d6ef16a04405448b8dc52bd752ae50423d4/watchfiles-1.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f04b092229ad2c50126dd3c922c8822e51e605993764a33058d4a791ab42281", size = 392508, upload-time = "2026-05-18T04:30:54.849Z" },+ { url = "https://files.pythonhosted.org/packages/26/ca/1ad30103535cf0cecd7b993e8d50edc5351b1820e38f2d22e3df58962feb/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a7ce236284f002a156f70add88efe5c70879cccbb658be0822c54b1306fc09d", size = 452448, upload-time = "2026-05-18T04:30:53.727Z" },+ { url = "https://files.pythonhosted.org/packages/37/a1/ceee2cdf2afbd715fa07758d39c9859513eae411b23196f7fd039e5feedd/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b9909cc2b48468b575eefa944919e1fe8a36c5849d5c7c168f80a8c1db69398e", size = 459605, upload-time = "2026-05-18T04:30:23.312Z" },+ { url = "https://files.pythonhosted.org/packages/e8/f6/421e30fd1cb3907a84ed92ab3f1983e37ba2dca015e9a894a048418417a2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a37faaed405c67e28e6be45a1fa4f206ef5a2860f27c237db9fa30704c38242", size = 490757, upload-time = "2026-05-18T04:30:47.358Z" },+ { url = "https://files.pythonhosted.org/packages/41/b0/55ed1b97ed08be7bba6f9a541cac15f2a858e1d74d2b07b6da70a82aab00/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9649193aa27bd9ff2e80ff29bfaa93085496c7a3a377592823cc58b77ee88add", size = 568672, upload-time = "2026-05-18T04:30:38.915Z" },+ { url = "https://files.pythonhosted.org/packages/d1/cf/d8ae8a80dd7bafab395ea7681c10237311bbf34d37704a8c744e7cf31fc7/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e4ff8e37f99cf1da89e255e07c9c4b37c214038c4283707bdec308cb1b0ea1f", size = 464197, upload-time = "2026-05-18T04:30:09.914Z" },+ { url = "https://files.pythonhosted.org/packages/7c/8a/3076c496ca8dafe0e8cd03fcebdfc47be4b1174b4e5b24ff6e396e6b3af2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:054dc20fd2e3132b4c3883b4a00d72fd6e1f56fdaf89fccd12e8057d74cd74d7", size = 453181, upload-time = "2026-05-18T04:30:14.829Z" },+ { url = "https://files.pythonhosted.org/packages/e5/10/9745e17c98e7b8a86454df0a3c7b5686bd650383f1e9f26e4ebcbd6cc0c0/watchfiles-1.2.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e140ed30ebde76796b686e67c182cff10ea2fbab186fafd1560f74bb5a473a6e", size = 465109, upload-time = "2026-05-18T04:30:28.123Z" },+ { url = "https://files.pythonhosted.org/packages/8f/95/8ef4a95481d3e0cb52d62a06fa6e972e81424be2d9698b91a2fecca9904c/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:bb7e52ecf68ba46d22df23467b87cffeb2146908aa523ebfe803019618cfda06", size = 630653, upload-time = "2026-05-18T04:31:49.304Z" },+ { url = "https://files.pythonhosted.org/packages/fd/e4/3b3bf36b0f829b50c6ebcb8d031583863c59f923d6a6af3d485e470d0fac/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:23282a321c8baf9b3a3c4afff673f9fe65eb7fdc2338d765ccad9d3d1916a5ba", size = 657838, upload-time = "2026-05-18T04:31:06.497Z" },+ { url = "https://files.pythonhosted.org/packages/21/b1/6cbbb50c1f3002ab568777d44aa21206dfb8807a840990c4037523b51812/watchfiles-1.2.0-cp314-cp314-win32.whl", hash = "sha256:c0db965c5f79aa49fe672d297cf1febc5ad149b658594944f49a54a2b96270a7", size = 275108, upload-time = "2026-05-18T04:30:06.891Z" },+ { url = "https://files.pythonhosted.org/packages/92/45/190ce6db8dcb4536682cf75d3889ff1a27182a58cb519d343cb6d9ea63d8/watchfiles-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:71283b39fd17e5408eb123bd37aeecfd9d54c81fc184421943208aadb879d103", size = 288441, upload-time = "2026-05-18T04:32:12.901Z" },+ { url = "https://files.pythonhosted.org/packages/74/0d/3eae1c2313ab08378431d907c3f8095ecca00f3eda33111cf4f0f2591799/watchfiles-1.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:c5c19526f4e54a00f2666a6c0e9e40d582c09e865055ea7378bf0009aab857b3", size = 280684, upload-time = "2026-05-18T04:31:26.902Z" },+ { url = "https://files.pythonhosted.org/packages/b1/75/fb64e6c25d6b5ca636d03df34ffb1c6e9873303e76d27967e045f8df088f/watchfiles-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d73a585accffa5ae39c17264c36ec3166d2fad7000c780f5ef83b2722afb9dd2", size = 398857, upload-time = "2026-05-18T04:32:17.108Z" },+ { url = "https://files.pythonhosted.org/packages/73/4e/9f7adf01754cbf81843722ccfec169d8f26c69778281a302855cecd2ee08/watchfiles-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ae99b14c5f21e026e0e9d96f40e07d8570ebee6cafd9d8fc318354606daa7a28", size = 392413, upload-time = "2026-05-18T04:31:07.911Z" },+ { url = "https://files.pythonhosted.org/packages/47/c8/bec626bcc2d69f44b9acb24ce7d60ed7b16b73628eea747fcbd169d8edda/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4429f3b105524a10b72c3a819b091c495d2811d419c1e1e8df773a5a5974f831", size = 452409, upload-time = "2026-05-18T04:31:20.142Z" },+ { url = "https://files.pythonhosted.org/packages/00/b7/b6362068e81e7c556d155a34c35d40ac3ef42d747b06d7f6e5bf58e359c2/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43d818978d06062d9b22c4fab2ebe44cf5213d42dc8e62bda8c2760cfa2eeb33", size = 458827, upload-time = "2026-05-18T04:32:06.219Z" },+ { url = "https://files.pythonhosted.org/packages/67/f8/9a813fa42afb1e0b4625e75f0479826644d3ee8dc287e093799bc01f390c/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9f732dc58b2dbe69e464ccf8fff7a03b0dd0be439da4c0720d3558527d3d6b4", size = 490104, upload-time = "2026-05-18T04:31:56.034Z" },+ { url = "https://files.pythonhosted.org/packages/2f/bf/27dfb6094ca4c9aad21298b5525b6c53cb36121ee454331d05161e58d130/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f200104103feb097de4cab8fe4f5dd18a2026934c7dea98c55a2f5fd6d5a33b", size = 571360, upload-time = "2026-05-18T04:31:57.133Z" },+ { url = "https://files.pythonhosted.org/packages/fb/39/44a096d67270ea93df91d33877dbe91fbda3aa4f8ec2edf799d93eda8736/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:63ac26eefbf4af1741247d6fb68b11c49a25b2f7413fbd318a83a12aaa9cf666", size = 464644, upload-time = "2026-05-18T04:30:57.33Z" },+ { url = "https://files.pythonhosted.org/packages/0e/80/c7472203bad6268e3ef1ad260739704847898938ad7ea8b63a5131f46b50/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c4997d4e4a55f0d02b6cde327322daf3a0400e5df6c6b15948994bf72497925", size = 454771, upload-time = "2026-05-18T04:30:48.736Z" },+ { url = "https://files.pythonhosted.org/packages/51/cf/3b10b268b4b7f0fc26e9debb5eef1998b515887840f444cd3ec80c688755/watchfiles-1.2.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4c887eba18b7945ac73067a8b4a66f21cd46c2539b2bc68588f7be6c7eb6d26b", size = 463494, upload-time = "2026-05-18T04:31:33.826Z" },+ { url = "https://files.pythonhosted.org/packages/3d/3e/a4302545cd589262a0dc7d140e86f7688eba3f9c72776c27f7e23b8864c4/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3416ff151bb6b5a8d8d11664974fbef4d9305b9b2957839ab5a270468fd8df30", size = 629383, upload-time = "2026-05-18T04:31:15.596Z" },+ { url = "https://files.pythonhosted.org/packages/db/99/d5649df0a9a410d45b7c882304d0b790903ac9b6e8f2cfd12114e0c6b9f2/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:0e831a271c035d89789cffc386b6aa1375f39f1cd25eb7ca0997e4970d152fc5", size = 656093, upload-time = "2026-05-18T04:31:58.707Z" },+ { url = "https://files.pythonhosted.org/packages/92/b9/362702539275019a54dd2e94511b31a9b89c5f9e6a21966de7eb692549fc/watchfiles-1.2.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:37a6721cdf3f65dbb13aa9503510ccb4451603ac837e44d265d7992a597e1374", size = 400109, upload-time = "2026-05-18T04:31:16.879Z" },+ { url = "https://files.pythonhosted.org/packages/8f/75/71d5ba62db781e5587bded1d944c675374bc4aa37ff33d5018d98e8b6538/watchfiles-1.2.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2b37d10b5a63bd4d87e18472d80fa525bd670586fae62e5dd580452764879b65", size = 392167, upload-time = "2026-05-18T04:31:28.058Z" },+ { url = "https://files.pythonhosted.org/packages/3c/01/c66dd95d0423fe30d31820e2d1d5bda773764131bbb6ac0cb1cf303ac328/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a105bc2283f67e8fbec74253ec2d94925de92ed72c0393f1206bf326b7b7b69", size = 452372, upload-time = "2026-05-18T04:31:00.836Z" },+ { url = "https://files.pythonhosted.org/packages/91/15/2fe99557e72f85627c6a8eed50d889e8d101623e060a22ad75b875cb932d/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5327989a465505f05cfe06f04fa9d0c2fd5432bb243e10e6f012b1bdca3c8579", size = 459596, upload-time = "2026-05-18T04:31:34.96Z" },+ { url = "https://files.pythonhosted.org/packages/ed/23/d4acfa0023367428ed48351b3b9b267893037b6cadae55620c61c24bcfd4/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ecb47f183a8025b2aa18b546725c3657e542112ae9c0613a2af79b4fa8d04ad7", size = 490869, upload-time = "2026-05-18T04:31:59.923Z" },+ { url = "https://files.pythonhosted.org/packages/a4/5f/3164cbdce06c9fb95c4f7b9e2f9760b5e2797af43a9ecc317ef42a23a278/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8520a4ab0e37f770afc34459c4f8f7019e153f9124dc101c15538365875d1ab2", size = 571641, upload-time = "2026-05-18T04:32:00.948Z" },+ { url = "https://files.pythonhosted.org/packages/41/e6/85d3731c55e65cd7690f3f803d24c139588aaf863e4bf2148fe7a7fa1a19/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:71cd71740ed2c15211ebb237ced4e39a1cdf6f80566e5fe95428da1626f4fde6", size = 464444, upload-time = "2026-05-18T04:30:34.298Z" },+ { url = "https://files.pythonhosted.org/packages/f4/7d/562641012b8b09872742c3b8adf9629ec479fd78f8d68ae4a0c13da8add6/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f88af53d6ddaf72179ef613ddc905e6f4785f712b49b80b3bef9f3525e6194b4", size = 453593, upload-time = "2026-05-18T04:31:23.464Z" },+ { url = "https://files.pythonhosted.org/packages/56/fe/cb8ef3d6f929d14158fdaaad9925985b7310abc9384dcd4d82dd0016fb59/watchfiles-1.2.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:cee9d5efd929efdac5f7e58f72b3376f676b64050a91c5b99a7094c5b2317488", size = 465096, upload-time = "2026-05-18T04:31:30.384Z" },+ { url = "https://files.pythonhosted.org/packages/25/91/80908e835e100527a9267147b08c0eee1fa6ab0ffec15edc04d1d44885f7/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:b718bf356bbc15e559bd8ef41782b573b8ae0e3f177ab244b440568d7ea02cfb", size = 630638, upload-time = "2026-05-18T04:30:49.89Z" },+ { url = "https://files.pythonhosted.org/packages/46/4b/95ab2f256bb4af3cb2eb23b9317bda984ee6e0f11733a5c004a6c95b06e3/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:922c0e019fe68b3ae392965a766b02a71ba1168c932cebc3733cd52c5fe5b377", size = 657684, upload-time = "2026-05-18T04:31:32.027Z" },+ { url = "https://files.pythonhosted.org/packages/23/f4/7513ef1e85fc4c6331b59479d6d72661fc391fbe543678052ac72c8b6c19/watchfiles-1.2.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4674d49eb94706dfe666c069fc0a1b646ffcf920473492e209f6d5f60d3f0cc2", size = 403050, upload-time = "2026-05-18T04:30:36.753Z" },+ { url = "https://files.pythonhosted.org/packages/27/0b/a54103cfd732bb703c7a749222011a0483ef3705948dae3b203158601119/watchfiles-1.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:094b9b70103d4e963499bdea001ee3c2697b144cd9ae6218a62c0f89ec9e31db", size = 396629, upload-time = "2026-05-18T04:32:03.268Z" },+ { url = "https://files.pythonhosted.org/packages/5e/2c/73f31a3b893886206c3f54d73e8ad8dee58cdb2f69ad2622e0a8a9e07f4e/watchfiles-1.2.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0ef001f8c25ad0fa9529f914c1600647ecd0f542d11c19b7894768c67b6acb7", size = 457318, upload-time = "2026-05-18T04:31:01.932Z" },+ { url = "https://files.pythonhosted.org/packages/e9/f9/45d021e4a5cc7b9dd567f7cbb06d3b75f751a690063fb6cc7ec60f4e46b7/watchfiles-1.2.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a88fc94e647bc4eec523f1caa540258eb71d14278b9daf72fa1e2658a98df0f0", size = 457771, upload-time = "2026-05-18T04:30:56.331Z" },+]+[[package]]name = "xxhash"version = "3.7.0"diff --git a/plugins/openspec/plugin.toml b/plugins/openspec/plugin.tomlindex 5923cb5..231bba0 100644--- a/plugins/openspec/plugin.toml+++ b/plugins/openspec/plugin.toml@@ -6,15 +6,14 @@ copy_dirs = ["openspec"][artifacts]planning = "openspec/changes/*/proposal.md"-running = "openspec/changes/*/tasks.md"[commands]planning = "/opsx:propose {task}"running = "/opsx:apply"-review = "/opsx:verify"[prompts]# propose takes {task} inline in the command β no separate prompt needed+review = "Review the implementation: run the relevant tests, verify the fix is correct and complete, and confirm no regressions. Report results."[copy_back]planning = ["openspec"]diff --git a/src/config/mod.rs b/src/config/mod.rsindex f3fead8..d2f55d2 100644--- a/src/config/mod.rs+++ b/src/config/mod.rs@@ -237,6 +237,10 @@ pub struct ProjectConfig {/// Override branch prefix for this project (e.g. "user/name")pub branch_prefix: Option<String>,++ /// Skip git worktree creation β agent works directly in the project root.+ /// Useful when the repo is already an isolated environment (e.g. Docker container).+ pub skip_worktree: Option<bool>,}impl GlobalConfig {@@ -352,6 +356,7 @@ pub struct MergedConfig {pub default_agent: String,pub phase_agents: PhaseAgentsConfig,pub worktree_enabled: bool,+ pub skip_worktree: bool,pub auto_cleanup: bool,pub base_branch: String,pub worktree_dir: String,@@ -381,6 +386,7 @@ impl MergedConfig {review: project_agents.review.or(global.agents.review.clone()),},worktree_enabled: global.worktree.enabled,+ skip_worktree: project.skip_worktree.unwrap_or(!global.worktree.enabled),auto_cleanup: global.worktree.auto_cleanup,base_branch: project.base_branchdiff --git a/src/tui/app.rs b/src/tui/app.rsindex e936c3d..c7d3470 100644--- a/src/tui/app.rs+++ b/src/tui/app.rs@@ -4891,6 +4891,7 @@ impl App {self.state.config.init_script.clone()};let skip_init_scripts = self.state.flags.no_init_scripts;+ let skip_worktree = self.state.config.skip_worktree;let tmux_ops = Arc::clone(&self.state.tmux_ops);let git_ops = Arc::clone(&self.state.git_ops);let agent_ops = self.state.agent_registry.get(&planning_agent);@@ -4952,6 +4953,7 @@ impl App {agent_ops.as_ref(),&referenced_tasks,skip_init_scripts,+ skip_worktree,);match result {@@ -5260,6 +5262,7 @@ impl App {self.state.config.init_script.clone()};let skip_init_scripts = self.state.flags.no_init_scripts;+ let skip_worktree = self.state.config.skip_worktree;let tmux_ops = Arc::clone(&self.state.tmux_ops);let git_ops = Arc::clone(&self.state.git_ops);@@ -5301,6 +5304,7 @@ impl App {agent_ops.as_ref(),&[],skip_init_scripts,+ skip_worktree,);match result {@@ -5750,6 +5754,7 @@ impl App {self.state.config.init_script.clone()};let skip_init_scripts = self.state.flags.no_init_scripts;+ let skip_worktree = self.state.config.skip_worktree;let tmux_ops = Arc::clone(&self.state.tmux_ops);let git_ops = Arc::clone(&self.state.git_ops);let agent_ops = self.state.agent_registry.get(&running_agent);@@ -5783,6 +5788,7 @@ impl App {agent_ops.as_ref(),&[],skip_init_scripts,+ skip_worktree,);match result {@@ -7456,13 +7462,18 @@ fn setup_task_worktree(agent_ops: &dyn AgentOperations,referenced_tasks: &[ReferencedTaskInfo],skip_init_scripts: bool,+ skip_worktree: bool,) -> Result<String> {let unique_slug = generate_task_slug(&task.id, &task.title);let window_name = format!("task-{}", unique_slug);let target = format!("{}:{}", tmux_project_name, window_name);- // Create git worktree from the configured base branch- let worktree_path_str =+ // When skip_worktree is set, use the project root directly instead of creating a git worktree.+ // Useful for isolated environments (e.g. Docker) where the repo is already the working copy.+ let worktree_path_str = if skip_worktree {+ project_path.to_string_lossy().to_string()+ } else {+ // Create git worktree from the configured base branchmatch git_ops.create_worktree(project_path, &unique_slug, base_branch, worktree_dir, branch_prefix) {Ok(path) => path,Err(e) => {@@ -7473,7 +7484,8 @@ fn setup_task_worktree(.to_string_lossy().to_string()}- };+ }+ };// Initialize worktree: copy files and run init script// Merge plugin-level copy_files with project-level copy_files@@ -9610,6 +9622,15 @@ fn write_skills_to_worktree(Path::new(worktree_path).join(".mcp.json"),serde_json::to_string_pretty(&cfg).unwrap_or_default(),);+ // Pre-trust the agtx MCP server so Claude doesn't show an interactive+ // trust dialog when the agent window opens for the first time.+ let settings = serde_json::json!({ "enableAllProjectMcpServers": true });+ let claude_dir = Path::new(worktree_path).join(".claude");+ let _ = std::fs::create_dir_all(&claude_dir);+ let _ = std::fs::write(+ claude_dir.join("settings.local.json"),+ serde_json::to_string_pretty(&settings).unwrap_or_default(),+ );}"codex" => {let toml = format!(diff --git a/src/tui/app_tests.rs b/src/tui/app_tests.rsindex ac7a486..fb42f3d 100644--- a/src/tui/app_tests.rs+++ b/src/tui/app_tests.rs@@ -1546,6 +1546,7 @@ fn test_setup_task_worktree_success() {&mock_agent,&[],false,+ false,);assert!(result.is_ok());@@ -1601,6 +1602,7 @@ fn test_setup_task_worktree_sets_task_fields() {&mock_agent,&[],false,+ false,).unwrap();@@ -1664,6 +1666,7 @@ fn test_setup_task_worktree_worktree_creation_fails() {&mock_agent,&[],false,+ false,);// Should succeed despite worktree creation failure (uses fallback path)@@ -1722,6 +1725,7 @@ fn test_setup_task_worktree_tmux_window_fails() {&mock_agent,&[],false,+ false,);// Should propagate the error@@ -1776,6 +1780,7 @@ fn test_setup_task_worktree_creates_session_when_missing() {&mock_agent,&[],false,+ false,);assert!(result.is_ok());@@ -1833,6 +1838,7 @@ fn test_setup_task_worktree_passes_init_config() {&mock_agent,&[],false,+ false,);assert!(result.is_ok());diff --git a/tests/config_tests.rs b/tests/config_tests.rsindex 866708c..6aef2b9 100644--- a/tests/config_tests.rs+++ b/tests/config_tests.rs@@ -114,6 +114,7 @@ fn test_merged_config_project_overrides() {cleanup_script: Some("scripts/cleanup.sh".to_string()),branch_prefix: None,workflow_plugin: None,+ skip_worktree: None,};let merged = MergedConfig::merge(&global, &project);