researchloop 0.1.0__tar.gz → 0.3.0__tar.gz

{researchloop-0.1.0 → researchloop-0.3.0}/.github/workflows/ci.yml

@@ -67,7 +67,11 @@ jobs:
       - name: Build SLURM test container
         run: docker build -t researchloop-slurm-test tests/docker/slurm/
 
+      - name: Build SGE test container
+        run: docker build -t researchloop-sge-test tests/docker/sge/
+
       - name: Run integration tests
-        run: uv run pytest tests/integration/ -v --tb=short -x --timeout=120
+        run: uv run pytest tests/integration/ -v --tb=short -x --timeout=180
         env:
           SLURM_TEST_IMAGE: researchloop-slurm-test
+          SGE_TEST_IMAGE: researchloop-sge-test

{researchloop-0.1.0 → researchloop-0.3.0}/CLAUDE.md

@@ -8,18 +8,19 @@ ResearchLoop is an automated research sprint platform for HPC clusters. It orche
 
 Two processes:
 
-1. **Orchestrator** (`researchloop serve`) — FastAPI server that manages studies/sprints in SQLite, submits jobs via SSH, receives webhooks from runners, stores artifacts. Also serves the web dashboard and handles Slack events.
+1. **Orchestrator** (`researchloop serve`) — FastAPI server that manages studies/sprints in SQLite, submits jobs via SSH, receives webhooks from runners, stores artifacts. Also serves the web dashboard and handles Slack events. Has no Claude CLI dependency.
 2. **Sprint Runner** — runs inside each SLURM/SGE job on HPC. Self-contained bash scripts chain `claude -p` calls through a pipeline (research → red-team → fix → report → summarize), then upload artifacts and send a completion webhook.
 
 Key design decisions:
 
-- All AI work runs on HPC, never on the orchestrator (except Slack conversations and auto-loop idea generation, which use `claude -p` locally with restricted tools)
-- `claude -p --output-format stream-json` for sprint steps (enables live progress), `--output-format json` for conversations
+- All AI work runs on HPC; the orchestrator never invokes `claude`
+- `claude -p --output-format stream-json` for sprint steps (enables live progress)
 - SSH to HPC login nodes for sbatch/squeue/scancel/qsub/qdel
 - Job completion via per-sprint webhook tokens (runner → orchestrator), SSH polling as fallback
 - SQLite (aiosqlite, WAL mode) for metadata, with a `settings` table for persistent config (signing key, password hash)
 - Jinja2 templates for all prompts and job scripts — prompts are pre-rendered by the orchestrator and embedded as base64 in the job script
 - Auto-loop sprints generate their own ideas on the cluster (where Claude is authenticated) rather than on the orchestrator
+- Slack integration is notification + structured slash-style commands only (`sprint run`, `sprint list`, `loop start`, `help`); free-form Q&A was removed
 - Context hierarchy: global → cluster → study (inline text + file paths at each level)
 
 ## Tech stack
@@ -30,7 +31,7 @@ Python 3.10+, uv, asyncio throughout. Key deps: click (CLI), FastAPI (API + dash
 
 ```bash
 uv sync                              # install deps
-uv run pytest tests/ -v -m "not integration"  # unit tests (339 tests, ~3s)
+uv run pytest tests/ -v -m "not integration"  # unit tests (374 tests, ~3s)
 uv run pytest tests/integration/ -v --timeout=120  # integration tests (needs Docker)
 uv run ruff check .                  # lint
 uv run ruff format .                 # format
@@ -51,11 +52,10 @@ researchloop/
     models.py           — SprintStatus enum, Sprint/Study/AutoLoop dataclasses, generate_sprint_id(), format_sprint_dirname()
     orchestrator.py     — Orchestrator class + create_app() FastAPI factory (API + Slack + dashboard)
     credentials.py      — CLI credential storage (~/.config/researchloop/credentials.json) for remote orchestrator auth
-    auth.py             — check_claude_auth_async() helper for verifying Claude CLI auth status
   db/
     __init__.py
     database.py         — async SQLite wrapper (WAL mode, auto-migrations, fetch_one/fetch_all/execute)
-    migrations.py       — CREATE TABLE statements (7 tables: studies, sprints, auto_loops, artifacts, slack_sessions, events, settings) + indexes + incremental column migrations
+    migrations.py       — CREATE TABLE statements (7 tables: studies, sprints, tweaks, auto_loops, artifacts, events, settings) + indexes + incremental column migrations
     queries.py          — async CRUD functions (all take Database as first arg, return dicts)
   clusters/
     __init__.py
@@ -95,7 +95,6 @@ researchloop/
     base.py             — BaseNotifier ABC (notify_sprint_started/completed/failed)
     ntfy.py             — NtfyNotifier (ntfy.sh push notifications)
     slack.py            — SlackNotifier (chat:write + files:write) + verify_slack_signature()
-    conversation.py     — ConversationManager (Slack threads → Claude sessions via --resume, action execution, markdown→Slack conversion)
     router.py           — NotificationRouter (fan-out to all configured notifiers)
   dashboard/
     __init__.py
@@ -116,7 +115,7 @@ researchloop/
 
 ## Database
 
-SQLite with 7 tables: `studies`, `sprints`, `auto_loops`, `artifacts`, `slack_sessions`, `events`, `settings`. Schema in `db/migrations.py`. All queries in `db/queries.py` use parameterized SQL and return plain dicts.
+SQLite with 7 tables: `studies`, `sprints`, `tweaks`, `auto_loops`, `artifacts`, `events`, `settings`. Schema in `db/migrations.py`. All queries in `db/queries.py` use parameterized SQL and return plain dicts. (An older `slack_sessions` table is dropped by the migration if present.)
 
 Key columns:
 - `sprints.webhook_token` — per-sprint token for webhook auth (generated at creation)
@@ -124,6 +123,8 @@ Key columns:
 - `sprints.metadata_json` — stores report text, has_pdf flag, heartbeat info
 - `sprints.error` — stores live progress (progress.md + output.log + tool log) during running sprints
 - `auto_loops.metadata_json` — stores loop context and job_options
+- `tweaks.sprint_id` — links tweak to parent sprint (one sprint can have many tweaks)
+- `tweaks.instruction` — the user's tweak request text
 - `settings` — key/value store for signing_key and dashboard_password_hash
 
 ## Key patterns
@@ -146,7 +147,7 @@ Key columns:
 - CSRF protection: HMAC-based tokens derived from session token + signing secret, checked on all mutating dashboard POST routes
 - Dashboard refresh: pulls live status from cluster via SSH (reads logs, progress.md, output.log, report.md, findings.md, summary.txt, idea.txt, checks for PDF)
 - Slack events: deduplication via event_id set, signature verification, background task processing (return 200 immediately), bot message filtering
-- Slack conversation: thread → session mapping in DB, context building with study/sprint info, action execution via [ACTION: ...] tags
+- Slack commands: `sprint run`, `sprint list`, `loop start`, `help` (no free-form chat — orchestrator does not run Claude locally)
 - Auto-loop: sprint idea=None → job script generates idea on cluster → idea.txt read back via SSH/webhook
 - CLI auth: `researchloop connect` gets a bearer token via /api/auth, stored in ~/.config/researchloop/credentials.json with 600 permissions
 - CLI auto-reauth: on 401, prompts for password, gets new token, saves it
@@ -154,7 +155,7 @@ Key columns:
 
 ## Testing
 
-339 unit tests covering: models, config parsing, database operations, all query functions, SLURM scheduler (mock SSH), SGE scheduler (mock SSH), local scheduler (real subprocesses), study/sprint managers, auto-loop controller (with mock claude), notification router, Slack notifier + signature verification + conversation manager + Slack events API, FastAPI API endpoints (TestClient), dashboard routes + auth + setup + CSRF, CLI commands (CliRunner), runner output parsing, and template rendering.
+Unit tests cover: models, config parsing, database operations, all query functions, SLURM scheduler (mock SSH), SGE scheduler (mock SSH), local scheduler (real subprocesses), study/sprint managers, auto-loop controller, notification router, Slack notifier + signature verification + Slack events API, FastAPI API endpoints (TestClient), dashboard routes + auth + setup + CSRF, CLI commands (CliRunner), runner output parsing, and template rendering.
 
 Integration tests (in tests/integration/) use a Docker SLURM container to test real job submission.
 

researchloop-0.3.0/PKG-INFO

@@ -0,0 +1,213 @@
+Metadata-Version: 2.4
+Name: researchloop
+Version: 0.3.0
+Summary: Automated research sprint platform for HPC clusters
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: aiosqlite<1,>=0.19
+Requires-Dist: asyncssh<3,>=2.14
+Requires-Dist: bcrypt<5,>=4.0
+Requires-Dist: click<9,>=8.0
+Requires-Dist: fastapi>=0.100
+Requires-Dist: httpx<1,>=0.24
+Requires-Dist: itsdangerous<3,>=2.1
+Requires-Dist: jinja2<4,>=3.1
+Requires-Dist: markdown<4,>=3.4
+Requires-Dist: python-multipart<1,>=0.0.6
+Requires-Dist: starlette<1
+Requires-Dist: tomli<3,>=2.0; python_version < '3.11'
+Requires-Dist: uvicorn[standard]<1,>=0.20
+Description-Content-Type: text/markdown
+
+# ResearchLoop
+
+**Run AI-automated research experiments on your HPC cluster. Monitor from anywhere.**
+
+[![CI](https://github.com/researchloop/researchloop/actions/workflows/ci.yml/badge.svg)](https://github.com/researchloop/researchloop/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/researchloop.svg)](https://pypi.org/project/researchloop/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+<img width="720" height="456" alt="mmlu-combined" src="https://github.com/user-attachments/assets/6d1d495f-1078-4f81-9f8a-bb1792ea3905" />
+
+---
+
+ResearchLoop submits AI-powered research experiments to your SLURM or SGE cluster, then reports back the results. You describe a research idea in natural language, it handles the rest: submitting the job, running a multi-step pipeline with [Claude Code](https://docs.anthropic.com/en/docs/claude-code), red-teaming the results, generating a report, and notifying you when it's done.
+
+```bash
+pip install researchloop
+
+# Submit an experiment to your cluster
+researchloop sprint run "Investigate whether batch normalization improves convergence" --study my-project
+
+# Start an auto-loop: 5 experiments, each building on the last
+researchloop loop start --study my-project --count 5 --context "Focus on improving F1 score"
+```
+
+Monitor everything from a web dashboard, Slack, or the CLI -- no need to SSH in and check on jobs.
+
+## Why ResearchLoop?
+
+If you run experiments on shared HPC clusters, you know the pain: SSH in, write a script, submit with sbatch, wait, check logs, repeat. ResearchLoop automates this loop:
+
+1. **You describe what to investigate** (via CLI, dashboard, or Slack)
+2. **ResearchLoop submits a job** to your cluster via SSH
+3. **Claude runs the full experiment** -- writes code, runs it, analyzes results
+4. **A red-team step critiques the work** and Claude fixes any issues
+5. **You get a report** with a summary, PDF, and all artifacts
+
+The **auto-loop** feature takes this further: after each experiment, Claude analyzes the results and proposes the next one. You set how many iterations, and walk away.
+
+## Get started in 5 minutes
+
+**Prerequisites:** Python 3.10+, SSH access to an HPC cluster, [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed on the cluster.
+
+### 1. Install and initialize
+
+```bash
+pip install researchloop
+researchloop init
+```
+
+### 2. Edit `researchloop.toml`
+
+```toml
+shared_secret = "pick-a-secret"
+orchestrator_url = "http://localhost:8080"
+
+[[cluster]]
+name = "my-cluster"
+host = "login.cluster.example.com"
+user = "researcher"
+key_path = "~/.ssh/id_ed25519"
+scheduler_type = "slurm"
+working_dir = "/scratch/researcher/researchloop"
+
+[cluster.job_options]
+gres = "gpu:1"
+mem = "64G"
+cpus-per-task = "8"
+
+[[study]]
+name = "my-project"
+cluster = "my-cluster"
+description = "Investigating X"
+```
+
+### 3. Start the server and run your first sprint
+
+```bash
+researchloop serve &
+researchloop connect http://localhost:8080
+researchloop sprint run "Try approach X on dataset Y" --study my-project
+```
+
+That's it. ResearchLoop SSHes to your cluster, submits the job, and you can monitor progress from the dashboard at `http://localhost:8080/dashboard/`.
+
+## Three ways to interact
+
+### Web dashboard
+
+Browse to `/dashboard/` to see all your studies, sprints, and loops. Submit new sprints, start loops with custom GPU/memory settings, refresh live status from the cluster, and read reports -- all from the browser.
+
+### Slack bot
+
+Get sprint notifications in your Slack channel and run commands from a thread:
+
+```
+sprint run my-project "investigate feature X under condition Y"
+sprint list
+loop start my-project 5
+help
+```
+
+See the [Slack setup guide](https://researchloop.github.io/researchloop/slack/) for configuration.
+
+### CLI
+
+```bash
+researchloop sprint run "idea" --study my-project   # Submit a sprint
+researchloop sprint list                             # List recent sprints
+researchloop sprint show sp-a3f7b2                   # View details
+researchloop loop start --study my-project --count 5 # Auto-loop
+researchloop loop stop loop-b4e1c9                   # Stop a loop
+```
+
+## Customizing your studies
+
+Each study can have its own context, cluster settings, and configuration:
+
+```toml
+[[study]]
+name = "sae-research"
+cluster = "my-cluster"
+max_sprint_duration_hours = 12
+red_team_max_rounds = 2
+allow_loop = true
+
+# Tell Claude what this study is about and how to approach it
+context = """
+You are researching sparse autoencoder architectures.
+Always train for 200M samples. Use batch size 1024.
+Validate on the variation models listed in ~/reference/models.txt.
+"""
+
+# Or point to a file with detailed instructions
+claude_md_path = "./studies/sae-research/CLAUDE.md"
+
+# Override GPU/memory for this study
+[study.job_options]
+gres = "gpu:a100:2"
+mem = "128G"
+```
+
+The context hierarchy is: **global** > **cluster** > **study**. All levels are merged and included in every sprint's prompt.
+
+## Deployment
+
+For production, deploy the orchestrator as a Docker container on Fly.io, Railway, or any platform that supports persistent volumes:
+
+```bash
+pip install researchloop
+# See deployment guide for Docker/Fly.io setup
+```
+
+Full deployment guide: [researchloop.github.io/researchloop/deployment](https://researchloop.github.io/researchloop/deployment/)
+
+## Documentation
+
+Full docs at **[researchloop.github.io/researchloop](https://researchloop.github.io/researchloop/)**, including:
+
+- [Configuration reference](https://researchloop.github.io/researchloop/configuration/) -- all TOML options and environment variables
+- [Deployment guide](https://researchloop.github.io/researchloop/deployment/) -- Docker, Fly.io, SSH key setup
+- [Dashboard guide](https://researchloop.github.io/researchloop/dashboard/) -- web UI features and authentication
+- [Slack integration](https://researchloop.github.io/researchloop/slack/) -- setup, commands, notifications
+- [CLI reference](https://researchloop.github.io/researchloop/cli/) -- all commands with examples
+- [Security](https://researchloop.github.io/researchloop/security/) -- authentication, CSRF, webhook tokens
+- [Development](https://researchloop.github.io/researchloop/development/) -- contributing, testing, architecture
+
+## Contributing
+
+```bash
+git clone https://github.com/researchloop/researchloop.git
+cd researchloop
+uv sync
+uv run pytest tests/ -m "not integration"   # Unit tests
+uv run ruff check . && uv run pyright researchloop/  # Lint + type check
+```
+
+Integration tests run against a real SLURM scheduler in Docker -- see [development guide](https://researchloop.github.io/researchloop/development/).
+
+## License
+
+MIT

researchloop-0.3.0/README.md

@@ -0,0 +1,182 @@
+# ResearchLoop
+
+**Run AI-automated research experiments on your HPC cluster. Monitor from anywhere.**
+
+[![CI](https://github.com/researchloop/researchloop/actions/workflows/ci.yml/badge.svg)](https://github.com/researchloop/researchloop/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/researchloop.svg)](https://pypi.org/project/researchloop/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+<img width="720" height="456" alt="mmlu-combined" src="https://github.com/user-attachments/assets/6d1d495f-1078-4f81-9f8a-bb1792ea3905" />
+
+---
+
+ResearchLoop submits AI-powered research experiments to your SLURM or SGE cluster, then reports back the results. You describe a research idea in natural language, it handles the rest: submitting the job, running a multi-step pipeline with [Claude Code](https://docs.anthropic.com/en/docs/claude-code), red-teaming the results, generating a report, and notifying you when it's done.
+
+```bash
+pip install researchloop
+
+# Submit an experiment to your cluster
+researchloop sprint run "Investigate whether batch normalization improves convergence" --study my-project
+
+# Start an auto-loop: 5 experiments, each building on the last
+researchloop loop start --study my-project --count 5 --context "Focus on improving F1 score"
+```
+
+Monitor everything from a web dashboard, Slack, or the CLI -- no need to SSH in and check on jobs.
+
+## Why ResearchLoop?
+
+If you run experiments on shared HPC clusters, you know the pain: SSH in, write a script, submit with sbatch, wait, check logs, repeat. ResearchLoop automates this loop:
+
+1. **You describe what to investigate** (via CLI, dashboard, or Slack)
+2. **ResearchLoop submits a job** to your cluster via SSH
+3. **Claude runs the full experiment** -- writes code, runs it, analyzes results
+4. **A red-team step critiques the work** and Claude fixes any issues
+5. **You get a report** with a summary, PDF, and all artifacts
+
+The **auto-loop** feature takes this further: after each experiment, Claude analyzes the results and proposes the next one. You set how many iterations, and walk away.
+
+## Get started in 5 minutes
+
+**Prerequisites:** Python 3.10+, SSH access to an HPC cluster, [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed on the cluster.
+
+### 1. Install and initialize
+
+```bash
+pip install researchloop
+researchloop init
+```
+
+### 2. Edit `researchloop.toml`
+
+```toml
+shared_secret = "pick-a-secret"
+orchestrator_url = "http://localhost:8080"
+
+[[cluster]]
+name = "my-cluster"
+host = "login.cluster.example.com"
+user = "researcher"
+key_path = "~/.ssh/id_ed25519"
+scheduler_type = "slurm"
+working_dir = "/scratch/researcher/researchloop"
+
+[cluster.job_options]
+gres = "gpu:1"
+mem = "64G"
+cpus-per-task = "8"
+
+[[study]]
+name = "my-project"
+cluster = "my-cluster"
+description = "Investigating X"
+```
+
+### 3. Start the server and run your first sprint
+
+```bash
+researchloop serve &
+researchloop connect http://localhost:8080
+researchloop sprint run "Try approach X on dataset Y" --study my-project
+```
+
+That's it. ResearchLoop SSHes to your cluster, submits the job, and you can monitor progress from the dashboard at `http://localhost:8080/dashboard/`.
+
+## Three ways to interact
+
+### Web dashboard
+
+Browse to `/dashboard/` to see all your studies, sprints, and loops. Submit new sprints, start loops with custom GPU/memory settings, refresh live status from the cluster, and read reports -- all from the browser.
+
+### Slack bot
+
+Get sprint notifications in your Slack channel and run commands from a thread:
+
+```
+sprint run my-project "investigate feature X under condition Y"
+sprint list
+loop start my-project 5
+help
+```
+
+See the [Slack setup guide](https://researchloop.github.io/researchloop/slack/) for configuration.
+
+### CLI
+
+```bash
+researchloop sprint run "idea" --study my-project   # Submit a sprint
+researchloop sprint list                             # List recent sprints
+researchloop sprint show sp-a3f7b2                   # View details
+researchloop loop start --study my-project --count 5 # Auto-loop
+researchloop loop stop loop-b4e1c9                   # Stop a loop
+```
+
+## Customizing your studies
+
+Each study can have its own context, cluster settings, and configuration:
+
+```toml
+[[study]]
+name = "sae-research"
+cluster = "my-cluster"
+max_sprint_duration_hours = 12
+red_team_max_rounds = 2
+allow_loop = true
+
+# Tell Claude what this study is about and how to approach it
+context = """
+You are researching sparse autoencoder architectures.
+Always train for 200M samples. Use batch size 1024.
+Validate on the variation models listed in ~/reference/models.txt.
+"""
+
+# Or point to a file with detailed instructions
+claude_md_path = "./studies/sae-research/CLAUDE.md"
+
+# Override GPU/memory for this study
+[study.job_options]
+gres = "gpu:a100:2"
+mem = "128G"
+```
+
+The context hierarchy is: **global** > **cluster** > **study**. All levels are merged and included in every sprint's prompt.
+
+## Deployment
+
+For production, deploy the orchestrator as a Docker container on Fly.io, Railway, or any platform that supports persistent volumes:
+
+```bash
+pip install researchloop
+# See deployment guide for Docker/Fly.io setup
+```
+
+Full deployment guide: [researchloop.github.io/researchloop/deployment](https://researchloop.github.io/researchloop/deployment/)
+
+## Documentation
+
+Full docs at **[researchloop.github.io/researchloop](https://researchloop.github.io/researchloop/)**, including:
+
+- [Configuration reference](https://researchloop.github.io/researchloop/configuration/) -- all TOML options and environment variables
+- [Deployment guide](https://researchloop.github.io/researchloop/deployment/) -- Docker, Fly.io, SSH key setup
+- [Dashboard guide](https://researchloop.github.io/researchloop/dashboard/) -- web UI features and authentication
+- [Slack integration](https://researchloop.github.io/researchloop/slack/) -- setup, commands, notifications
+- [CLI reference](https://researchloop.github.io/researchloop/cli/) -- all commands with examples
+- [Security](https://researchloop.github.io/researchloop/security/) -- authentication, CSRF, webhook tokens
+- [Development](https://researchloop.github.io/researchloop/development/) -- contributing, testing, architecture
+
+## Contributing
+
+```bash
+git clone https://github.com/researchloop/researchloop.git
+cd researchloop
+uv sync
+uv run pytest tests/ -m "not integration"   # Unit tests
+uv run ruff check . && uv run pyright researchloop/  # Lint + type check
+```
+
+Integration tests run against a real SLURM scheduler in Docker -- see [development guide](https://researchloop.github.io/researchloop/development/).
+
+## License
+
+MIT

{researchloop-0.1.0 → researchloop-0.3.0}/docs/deployment.md

@@ -20,8 +20,7 @@ RUN curl -fsSL https://claude.ai/install.sh | bash
 # Install researchloop
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 RUN uv venv /app/.venv && \
-    uv pip install --python /app/.venv/bin/python --no-cache \
-    "researchloop @ git+https://github.com/chanind/researchloop.git"
+    uv pip install --python /app/.venv/bin/python --no-cache researchloop
 
 WORKDIR /app
 

{researchloop-0.1.0 → researchloop-0.3.0}/docs/development.md

@@ -3,7 +3,7 @@
 ## Setup
 
 ```bash
-git clone https://github.com/chanind/researchloop.git
+git clone https://github.com/researchloop/researchloop.git
 cd researchloop
 uv sync
 ```

{researchloop-0.1.0 → researchloop-0.3.0}/docs/getting-started.md

@@ -3,24 +3,13 @@
 ## Prerequisites
 
 - **Python 3.10+**
-- **[uv](https://docs.astral.sh/uv/)** (recommended) or pip
 - **SSH access** to an HPC cluster with SLURM or SGE
 - **[Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)** installed and authenticated on the HPC cluster
 
 ## Installation
 
-### From GitHub
-
-```bash
-pip install git+https://github.com/chanind/researchloop.git
-```
-
-### For development
-
 ```bash
-git clone https://github.com/chanind/researchloop.git
-cd researchloop
-uv sync
+pip install researchloop
 ```
 
 ## Initialize a project

{researchloop-0.1.0 → researchloop-0.3.0}/docs/index.md

@@ -2,6 +2,10 @@
 
 **Automated AI research sprints on HPC clusters.**
 
+<video autoplay muted loop playsinline width="720" style="max-width:100%;height:auto;border-radius:6px">
+  <source src="assets/mmlu-combined.mp4" type="video/mp4">
+</video>
+
 ---
 
 ResearchLoop automates multi-step AI research pipelines on SLURM and SGE clusters. You describe a research idea, and ResearchLoop submits it to your HPC cluster where [Claude Code](https://docs.anthropic.com/en/docs/claude-code) executes a full research pipeline -- coding, red-teaming, fixing, reporting -- inside a single job. Results are reported back via webhooks, Slack, or push notifications, and you can monitor everything from a web dashboard or the CLI.

{researchloop-0.1.0 → researchloop-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "researchloop"
-version = "0.1.0"
+version = "0.3.0"
 description = "Automated research sprint platform for HPC clusters"
 readme = "README.md"
 license = {text = "MIT"}
@@ -18,7 +18,8 @@ classifiers = [
 ]
 dependencies = [
     "click>=8.0,<9",
-    "fastapi>=0.100,<1",
+    "fastapi>=0.100",
+    "starlette<1",
     "uvicorn[standard]>=0.20,<1",
     "jinja2>=3.1,<4",
     "aiosqlite>=0.19,<1",

researchloop-0.3.0/researchloop/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"