Remove replicated code

.agents/skills

@@ -1 +0,0 @@
-../.claude/skills

.branchlet.json

@@ -1,36 +0,0 @@
-{
-  "worktreeCopyPatterns": [
-    ".env*",
-    ".vscode/**",
-    ".auth/**",
-    ".claude/**",
-    "autogpt_platform/.env*",
-    "autogpt_platform/backend/.env*",
-    "autogpt_platform/frontend/.env*",
-    "autogpt_platform/frontend/.auth/**",
-    "autogpt_platform/db/docker/.env*"
-  ],
-  "worktreeCopyIgnores": [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/.git/**",
-    "**/Thumbs.db",
-    "**/.DS_Store",
-    "**/.next/**",
-    "**/__pycache__/**",
-    "**/.ruff_cache/**",
-    "**/.pytest_cache/**",
-    "**/*.pyc",
-    "**/playwright-report/**",
-    "**/logs/**",
-    "**/site/**"
-  ],
-  "worktreePathTemplate": "$BASE_PATH.worktree",
-  "postCreateCmd": [
-    "cd autogpt_platform/autogpt_libs && poetry install",
-    "cd autogpt_platform/backend && poetry install && poetry run prisma generate",
-    "cd autogpt_platform/frontend && pnpm install"
-  ],
-  "terminalCommand": "code .",
-  "deleteBranchWithWorktree": false
-}

.claude/settings.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allowedTools": [
-      "Read", "Grep", "Glob",
-      "Bash(ls:*)", "Bash(cat:*)", "Bash(grep:*)", "Bash(find:*)",
-      "Bash(git status:*)", "Bash(git diff:*)", "Bash(git log:*)", "Bash(git worktree:*)",
-      "Bash(tmux:*)", "Bash(sleep:*)", "Bash(branchlet:*)"
-    ]
-  }
-}

.claude/skills/open-pr/SKILL.md

@@ -1,106 +0,0 @@
----
-name: open-pr
-description: Open a pull request with proper PR template, test coverage, and review workflow. Guides agents through creating a PR that follows repo conventions, ensures existing behaviors aren't broken, covers new behaviors with tests, and handles review via bot when local testing isn't possible. TRIGGER when user asks to "open a PR", "create a PR", "make a PR", "submit a PR", "open pull request", "push and create PR", or any variation of opening/submitting a pull request.
-user-invocable: true
-args: "[base-branch] — optional target branch (defaults to dev)."
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
----
-
-# Open a Pull Request
-
-## Step 1: Pre-flight checks
-
-Before opening the PR:
-
-1. Ensure all changes are committed
-2. Ensure the branch is pushed to the remote (`git push -u origin <branch>`)
-3. Run linters/formatters across the whole repo (not just changed files) and commit any fixes
-
-## Step 2: Test coverage
-
-**This is critical.** Before opening the PR, verify:
-
-### Existing behavior is not broken
-- Identify which modules/components your changes touch
-- Run the existing test suites for those areas
-- If tests fail, fix them before opening the PR — do not open a PR with known regressions
-
-### New behavior has test coverage
-- Every new feature, endpoint, or behavior change needs tests
-- If you added a new block, add tests for that block
-- If you changed API behavior, add or update API tests
-- If you changed frontend behavior, verify it doesn't break existing flows
-
-If you cannot run the full test suite locally, note which tests you ran and which you couldn't in the test plan.
-
-## Step 3: Create the PR using the repo template
-
-Read the canonical PR template at `.github/PULL_REQUEST_TEMPLATE.md` and use it **verbatim** as your PR body:
-
-1. Read the template: `cat .github/PULL_REQUEST_TEMPLATE.md`
-2. Preserve the exact section titles and formatting, including:
-   - `### Why / What / How`
-   - `### Changes 🏗️`
-   - `### Checklist 📋`
-3. Replace HTML comment prompts (`<!-- ... -->`) with actual content; do not leave them in
-4. **Do not pre-check boxes** — leave all checkboxes as `- [ ]` until each step is actually completed
-5. Do not alter the template structure, rename sections, or remove any checklist items
-
-**PR title must use conventional commit format** (e.g., `feat(backend): add new block`, `fix(frontend): resolve routing bug`, `dx(skills): update PR workflow`). See CLAUDE.md for the full list of scopes.
-
-Use `gh pr create` with the base branch (defaults to `dev` if no `[base-branch]` was provided). Use `--body-file` to avoid shell interpretation of backticks and special characters:
-
-```bash
-BASE_BRANCH="${BASE_BRANCH:-dev}"
-PR_BODY=$(mktemp)
-cat > "$PR_BODY" << 'PREOF'
-<filled-in template from .github/PULL_REQUEST_TEMPLATE.md>
-PREOF
-gh pr create --base "$BASE_BRANCH" --title "<type>(scope): short description" --body-file "$PR_BODY"
-rm "$PR_BODY"
-```
-
-## Step 4: Review workflow
-
-### If you have a workspace that allows testing (docker, running backend, etc.)
-- Run `/pr-test` to do E2E manual testing of the PR using docker compose, agent-browser, and API calls. This is the most thorough way to validate your changes before review.
-- After testing, run `/pr-review` to self-review the PR for correctness, security, code quality, and testing gaps before requesting human review.
-
-### If you do NOT have a workspace that allows testing
-This is common for agents running in worktrees without a full stack. In this case:
-
-1. Run `/pr-review` locally to catch obvious issues before pushing
-2. **Comment `/review` on the PR** after creating it to trigger the review bot
-3. **Poll for the review** rather than blindly waiting — check for new review comments every 30 seconds using `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews --paginate` and the GraphQL inline threads query. The bot typically responds within 30 minutes, but polling lets the agent react as soon as it arrives.
-4. Do NOT proceed or merge until the bot review comes back
-5. Address any issues the bot raises — use `/pr-address` which has a full polling loop with CI + comment tracking
-
-```bash
-# After creating the PR:
-PR_NUMBER=$(gh pr view --json number -q .number)
-gh pr comment "$PR_NUMBER" --body "/review"
-# Then use /pr-address to poll for and address the review when it arrives
-```
-
-## Step 5: Address review feedback
-
-Once the review bot or human reviewers leave comments:
-- Run `/pr-address` to address review comments. It will loop until CI is green and all comments are resolved.
-- Do not merge without human approval.
-
-## Related skills
-
-| Skill | When to use |
-|---|---|
-| `/pr-test` | E2E testing with docker compose, agent-browser, API calls — use when you have a running workspace |
-| `/pr-review` | Review for correctness, security, code quality — use before requesting human review |
-| `/pr-address` | Address reviewer comments and loop until CI green — use after reviews come in |
-
-## Step 6: Post-creation
-
-After the PR is created and review is triggered:
-- Share the PR URL with the user
-- If waiting on the review bot, let the user know the expected wait time (~30 min)
-- Do not merge without human approval

.claude/skills/orchestrate/SKILL.md

@@ -1,509 +0,0 @@
----
-name: orchestrate
-description: "Meta-agent supervisor that manages a fleet of Claude Code agents running in tmux windows. Auto-discovers spare worktrees, spawns agents, monitors state, kicks idle agents, approves safe confirmations, and recycles worktrees when done. TRIGGER when user asks to supervise agents, run parallel tasks, manage worktrees, check agent status, or orchestrate parallel work."
-user-invocable: true
-argument-hint: "any free text — e.g. 'start 3 agents on X Y Z', 'show status', 'add task: implement feature A', 'stop', 'how many are free?'"
-metadata:
-  author: autogpt-team
-  version: "6.0.0"
----
-
-# Orchestrate — Agent Fleet Supervisor
-
-One tmux session, N windows — each window is one agent working in its own worktree. Speak naturally; Claude maps your intent to the right scripts.
-
-## Scripts
-
-```bash
-SKILLS_DIR=$(git rev-parse --show-toplevel)/.claude/skills/orchestrate/scripts
-STATE_FILE=~/.claude/orchestrator-state.json
-```
-
-| Script | Purpose |
-|---|---|
-| `find-spare.sh [REPO_ROOT]` | List free worktrees — one `PATH BRANCH` per line |
-| `spawn-agent.sh SESSION PATH SPARE NEW_BRANCH OBJECTIVE [PR_NUMBER] [STEPS...]` | Create window + checkout branch + launch claude + send task. **Stdout: `SESSION:WIN` only** |
-| `recycle-agent.sh WINDOW PATH SPARE_BRANCH` | Kill window + restore spare branch |
-| `run-loop.sh` | **Mechanical babysitter** — idle restart + dialog approval + recycle on ORCHESTRATOR:DONE + supervisor health check + all-done notification |
-| `verify-complete.sh WINDOW` | Verify PR is done: checkpoints ✓ + 0 unresolved threads + CI green. Repo auto-derived from state file `.repo` or git remote. |
-| `notify.sh MESSAGE` | Send notification via Discord webhook (env `DISCORD_WEBHOOK_URL` or state `.discord_webhook`), macOS notification center, and stdout |
-| `capacity.sh [REPO_ROOT]` | Print available + in-use worktrees |
-| `status.sh` | Print fleet status + live pane commands |
-| `poll-cycle.sh` | One monitoring cycle — classifies panes, tracks checkpoints, returns JSON action array |
-| `classify-pane.sh WINDOW` | Classify one pane state |
-
-## Supervision model
-
-```
-Orchestrating Claude (this Claude session — IS the supervisor)
-  └── Reads pane output, checks CI, intervenes with targeted guidance
-        run-loop.sh (separate tmux window, every 30s)
-          └── Mechanical only: idle restart, dialog approval, recycle on ORCHESTRATOR:DONE
-```
-
-**You (the orchestrating Claude)** are the supervisor. After spawning agents, stay in this conversation and actively monitor: poll each agent's pane every 2-3 minutes, check CI, nudge stalled agents, and verify completions. Do not spawn a separate supervisor Claude window — it loses context, is hard to observe, and compounds context compression problems.
-
-**run-loop.sh** is the mechanical layer — zero tokens, handles things that need no judgment: restart crashed agents, press Enter on dialogs, recycle completed worktrees (only after `verify-complete.sh` passes).
-
-## Checkpoint protocol
-
-Agents output checkpoints as they complete each required step:
-
-```
-CHECKPOINT:<step-name>
-```
-
-Required steps are passed as args to `spawn-agent.sh` (e.g. `pr-address pr-test`). `run-loop.sh` will not recycle a window until all required checkpoints are found in the pane output. If `verify-complete.sh` fails, the agent is re-briefed automatically.
-
-## Worktree lifecycle
-
-```text
-spare/N branch  →  spawn-agent.sh (--session-id UUID)  →  window + feat/branch + claude running
-                                                                 ↓
-                                               CHECKPOINT:<step> (as steps complete)
-                                                                 ↓
-                                                        ORCHESTRATOR:DONE
-                                                                 ↓
-                                    verify-complete.sh: checkpoints ✓ + 0 threads + CI green
-                                                                 ↓
-                                              state → "done", notify, window KEPT OPEN
-                                                                 ↓
-                              user/orchestrator explicitly requests recycle
-                                                                 ↓
-                                         recycle-agent.sh → spare/N (free again)
-```
-
-**Windows are never auto-killed.** The worktree stays on its branch, the session stays alive. The agent is done working but the window, git state, and Claude session are all preserved until you choose to recycle.
-
-**To resume a done or crashed session:**
-```bash
-# Resume by stored session ID (preferred — exact session, full context)
-claude --resume SESSION_ID --permission-mode bypassPermissions
-
-# Or resume most recent session in that worktree directory
-cd /path/to/worktree && claude --continue --permission-mode bypassPermissions
-```
-
-**To manually recycle when ready:**
-```bash
-bash ~/.claude/orchestrator/scripts/recycle-agent.sh SESSION:WIN WORKTREE_PATH spare/N
-# Then update state:
-jq --arg w "SESSION:WIN" '.agents |= map(if .window == $w then .state = "recycled" else . end)' \
-  ~/.claude/orchestrator-state.json > /tmp/orch.tmp && mv /tmp/orch.tmp ~/.claude/orchestrator-state.json
-```
-
-## State file (`~/.claude/orchestrator-state.json`)
-
-Never committed to git. You maintain this file directly using `jq` + atomic writes (`.tmp` → `mv`).
-
-```json
-{
-  "active": true,
-  "tmux_session": "autogpt1",
-  "idle_threshold_seconds": 300,
-  "loop_window": "autogpt1:5",
-  "repo": "Significant-Gravitas/AutoGPT",
-  "discord_webhook": "https://discord.com/api/webhooks/...",
-  "last_poll_at": 0,
-  "agents": [
-    {
-      "window": "autogpt1:3",
-      "worktree": "AutoGPT6",
-      "worktree_path": "/path/to/AutoGPT6",
-      "spare_branch": "spare/6",
-      "branch": "feat/my-feature",
-      "objective": "Implement X and open a PR",
-      "pr_number": "12345",
-      "session_id": "550e8400-e29b-41d4-a716-446655440000",
-      "steps": ["pr-address", "pr-test"],
-      "checkpoints": ["pr-address"],
-      "state": "running",
-      "last_output_hash": "",
-      "last_seen_at": 0,
-      "spawned_at": 0,
-      "idle_since": 0,
-      "revision_count": 0,
-      "last_rebriefed_at": 0
-    }
-  ]
-}
-```
-
-Top-level optional fields:
-- `repo` — GitHub `owner/repo` for CI/thread checks. Auto-derived from git remote if omitted.
-- `discord_webhook` — Discord webhook URL for completion notifications. Also reads `DISCORD_WEBHOOK_URL` env var.
-
-Per-agent fields:
-- `session_id` — UUID passed to `claude --session-id` at spawn; use with `claude --resume UUID` to restore exact session context after a crash or window close.
-- `last_rebriefed_at` — Unix timestamp of last re-brief; enforces 5-min cooldown to prevent spam.
-
-Agent states: `running` | `idle` | `stuck` | `waiting_approval` | `complete` | `done` | `escalated`
-
-`done` means verified complete — window is still open, session still alive, worktree still on task branch. Not recycled yet.
-
-## Serial /pr-test rule
-
-`/pr-test` and `/pr-test --fix` run local Docker + integration tests that use shared ports, a shared database, and shared build caches. **Running two `/pr-test` jobs simultaneously will cause port conflicts and database corruption.**
-
-**Rule: only one `/pr-test` runs at a time. The orchestrator serializes them.**
-
-You (the orchestrating Claude) own the test queue:
-1. Agents do `pr-review` and `pr-address` in parallel — that's safe (they only push code and reply to GitHub).
-2. When a PR needs local testing, add it to your mental queue — don't give agents a `pr-test` step.
-3. Run `/pr-test https://github.com/OWNER/REPO/pull/PR_NUMBER --fix` yourself, sequentially.
-4. Feed results back to the relevant agent via `tmux send-keys`:
-   ```bash
-   tmux send-keys -t SESSION:WIN "Local tests for PR #N: <paste failure output or 'all passed'>. Fix any failures and push, then output ORCHESTRATOR:DONE."
-   sleep 0.3
-   tmux send-keys -t SESSION:WIN Enter
-   ```
-5. Wait for CI to confirm green before marking the agent done.
-
-If multiple PRs need testing at the same time, pick the one furthest along (fewest pending CI checks) and test it first. Only start the next test after the previous one completes.
-
-## Session restore (tested and confirmed)
-
-Agent sessions are saved to disk. To restore a closed or crashed session:
-
-```bash
-# If session_id is in state (preferred):
-NEW_WIN=$(tmux new-window -t SESSION -n WORKTREE_NAME -P -F '#{window_index}')
-tmux send-keys -t "SESSION:${NEW_WIN}" "cd /path/to/worktree && claude --resume SESSION_ID --permission-mode bypassPermissions" Enter
-
-# If no session_id (use --continue for most recent session in that directory):
-tmux send-keys -t "SESSION:${NEW_WIN}" "cd /path/to/worktree && claude --continue --permission-mode bypassPermissions" Enter
-```
-
-`--continue` restores the full conversation history including all tool calls, file edits, and context. The agent resumes exactly where it left off. After restoring, update the window address in the state file:
-
-```bash
-jq --arg old "SESSION:OLD_WIN" --arg new "SESSION:NEW_WIN" \
-  '(.agents[] | select(.window == $old)).window = $new' \
-  ~/.claude/orchestrator-state.json > /tmp/orch.tmp && mv /tmp/orch.tmp ~/.claude/orchestrator-state.json
-```
-
-## Intent → action mapping
-
-Match the user's message to one of these intents:
-
-| The user says something like… | What to do |
-|---|---|
-| "status", "what's running", "show agents" | Run `status.sh` + `capacity.sh`, show output |
-| "how many free", "capacity", "available worktrees" | Run `capacity.sh`, show output |
-| "start N agents on X, Y, Z" or "run these tasks: …" | See **Spawning agents** below |
-| "add task: …", "add one more agent for …" | See **Adding an agent** below |
-| "stop", "shut down", "pause the fleet" | See **Stopping** below |
-| "poll", "check now", "run a cycle" | Run `poll-cycle.sh`, process actions |
-| "recycle window X", "free up autogpt3" | Run `recycle-agent.sh` directly |
-
-When the intent is ambiguous, show capacity first and ask what tasks to run.
-
-## Spawning agents
-
-### 1. Resolve tmux session
-
-```bash
-tmux list-sessions -F "#{session_name}: #{session_windows} windows" 2>/dev/null
-```
-
-Use an existing session. **Never create a tmux session from within Claude** — it becomes a child of Claude's process and dies when the session ends. If no session exists, tell the user to run `tmux new-session -d -s autogpt1` in their terminal first, then re-invoke `/orchestrate`.
-
-### 2. Show available capacity
-
-```bash
-bash $SKILLS_DIR/capacity.sh $(git rev-parse --show-toplevel)
-```
-
-### 3. Collect tasks from the user
-
-For each task, gather:
-- **objective** — what to do (e.g. "implement feature X and open a PR")
-- **branch name** — e.g. `feat/my-feature` (derive from objective if not given)
-- **pr_number** — GitHub PR number if working on an existing PR (for verification)
-- **steps** — required checkpoint names in order (e.g. `pr-address pr-test`) — derive from objective
-
-Ask for `idle_threshold_seconds` only if the user mentions it (default: 300).
-
-Never ask the user to specify a worktree — auto-assign from `find-spare.sh`.
-
-### 4. Spawn one agent per task
-
-```bash
-# Get ordered list of spare worktrees
-SPARE_LIST=$(bash $SKILLS_DIR/find-spare.sh $(git rev-parse --show-toplevel))
-
-# For each task, take the next spare line:
-WORKTREE_PATH=$(echo "$SPARE_LINE" | awk '{print $1}')
-SPARE_BRANCH=$(echo "$SPARE_LINE" | awk '{print $2}')
-
-# With PR number and required steps:
-WINDOW=$(bash $SKILLS_DIR/spawn-agent.sh "$SESSION" "$WORKTREE_PATH" "$SPARE_BRANCH" "$NEW_BRANCH" "$OBJECTIVE" "$PR_NUMBER" "pr-address" "pr-test")
-
-# Without PR (new work):
-WINDOW=$(bash $SKILLS_DIR/spawn-agent.sh "$SESSION" "$WORKTREE_PATH" "$SPARE_BRANCH" "$NEW_BRANCH" "$OBJECTIVE")
-```
-
-Build an agent record and append it to the state file. If the state file doesn't exist yet, initialize it:
-
-```bash
-# Derive repo from git remote (used by verify-complete.sh + supervisor)
-REPO=$(git remote get-url origin 2>/dev/null | sed 's|.*github\.com[:/]||; s|\.git$||' || echo "")
-
-jq -n \
-  --arg session "$SESSION" \
-  --arg repo "$REPO" \
-  --argjson threshold 300 \
-  '{active:true, tmux_session:$session, idle_threshold_seconds:$threshold,
-    repo:$repo, loop_window:null, supervisor_window:null, last_poll_at:0, agents:[]}' \
-  > ~/.claude/orchestrator-state.json
-```
-
-Optionally add a Discord webhook for completion notifications:
-```bash
-jq --arg hook "$DISCORD_WEBHOOK_URL" '.discord_webhook = $hook' ~/.claude/orchestrator-state.json \
-  > /tmp/orch.tmp && mv /tmp/orch.tmp ~/.claude/orchestrator-state.json
-```
-
-`spawn-agent.sh` writes the initial agent record (window, worktree_path, branch, objective, state, etc.) to the state file automatically — **do not append the record again after calling it.** The record already exists and `pr_number`/`steps` are patched in by the script itself.
-
-### 5. Start the mechanical babysitter
-
-```bash
-LOOP_WIN=$(tmux new-window -t "$SESSION" -n "orchestrator" -P -F '#{window_index}')
-LOOP_WINDOW="${SESSION}:${LOOP_WIN}"
-tmux send-keys -t "$LOOP_WINDOW" "bash $SKILLS_DIR/run-loop.sh" Enter
-
-jq --arg w "$LOOP_WINDOW" '.loop_window = $w' ~/.claude/orchestrator-state.json \
-  > /tmp/orch.tmp && mv /tmp/orch.tmp ~/.claude/orchestrator-state.json
-```
-
-### 6. Begin supervising directly in this conversation
-
-You are the supervisor. After spawning, immediately start your first poll loop (see **Supervisor duties** below) and continue every 2-3 minutes. Do NOT spawn a separate supervisor Claude window.
-
-## Adding an agent
-
-Find the next spare worktree, then spawn and append to state — same as steps 2–4 above but for a single task. If no spare worktrees are available, tell the user.
-
-## Supervisor duties (YOUR job, every 2-3 min in this conversation)
-
-You are the supervisor. Run this poll loop directly in your Claude session — not in a separate window.
-
-### Poll loop mechanism
-
-You are reactive — you only act when a tool completes or the user sends a message. To create a self-sustaining poll loop without user involvement:
-
-1. Start each poll with `run_in_background: true` + a sleep before the work:
-   ```bash
-   sleep 120 && tmux capture-pane -t autogpt1:0 -p -S -200 | tail -40
-   # + similar for each active window
-   ```
-2. When the background job notifies you, read the pane output and take action.
-3. Immediately schedule the next background poll — this keeps the loop alive.
-4. Stop scheduling when all agents are done/escalated.
-
-**Never tell the user "I'll poll every 2-3 minutes"** — that does nothing without a trigger. Start the background job instead.
-
-### Each poll: what to check
-
-```bash
-# 1. Read state
-cat ~/.claude/orchestrator-state.json | jq '.agents[] | {window, worktree, branch, state, pr_number, checkpoints}'
-
-# 2. For each running/stuck/idle agent, capture pane
-tmux capture-pane -t SESSION:WIN -p -S -200 | tail -60
-```
-
-For each agent, decide:
-
-| What you see | Action |
-|---|---|
-| Spinner / tools running | Do nothing — agent is working |
-| Idle `❯` prompt, no `ORCHESTRATOR:DONE` | Stalled — send specific nudge with objective from state |
-| Stuck in error loop | Send targeted fix with exact error + solution |
-| Waiting for input / question | Answer and unblock via `tmux send-keys` |
-| CI red | `gh pr checks PR_NUMBER --repo REPO` → tell agent exactly what's failing |
-| Context compacted / agent lost | Send recovery: `cat ~/.claude/orchestrator-state.json | jq '.agents[] | select(.window=="WIN")'` + `gh pr view PR_NUMBER --json title,body` |
-| `ORCHESTRATOR:DONE` in output | Run `verify-complete.sh` — if it fails, re-brief with specific reason |
-
-### Strict ORCHESTRATOR:DONE gate
-
-`verify-complete.sh` handles the main checks automatically (checkpoints, threads, CHANGES_REQUESTED, CI green, spawned_at). Run it:
-
-```bash
-SKILLS_DIR=~/.claude/orchestrator/scripts
-bash $SKILLS_DIR/verify-complete.sh SESSION:WIN
-```
-
-If it passes → run-loop.sh will recycle the window automatically. No manual action needed.
-If it fails → re-brief the agent with the failure reason. Never manually mark state `done` to bypass this.
-
-### Re-brief a stalled agent
-
-```bash
-OBJ=$(jq -r --arg w SESSION:WIN '.agents[] | select(.window==$w) | .objective' ~/.claude/orchestrator-state.json)
-PR=$(jq -r --arg w SESSION:WIN '.agents[] | select(.window==$w) | .pr_number' ~/.claude/orchestrator-state.json)
-tmux send-keys -t SESSION:WIN "You appear stalled. Your objective: $OBJ. Check: gh pr view $PR --json title,body,headRefName to reorient."
-sleep 0.3
-tmux send-keys -t SESSION:WIN Enter
-```
-
-If `image_path` is set on the agent record, include: "Re-read context at IMAGE_PATH with the Read tool."
-
-## Self-recovery protocol (agents)
-
-spawn-agent.sh automatically includes this instruction in every objective:
-
-> If your context compacts and you lose track of what to do, run:
-> `cat ~/.claude/orchestrator-state.json | jq '.agents[] | select(.window=="SESSION:WIN")'`
-> and `gh pr view PR_NUMBER --json title,body,headRefName` to reorient.
-> Output each completed step as `CHECKPOINT:<step-name>` on its own line.
-
-## Passing images and screenshots to agents
-
-`tmux send-keys` is text-only — you cannot paste a raw image into a pane. To give an agent visual context (screenshots, diagrams, mockups):
-
-1. **Save the image to a temp file** with a stable path:
-   ```bash
-   # If the user drags in a screenshot or you receive a file path:
-   IMAGE_PATH="/tmp/orchestrator-context-$(date +%s).png"
-   cp "$USER_PROVIDED_PATH" "$IMAGE_PATH"
-   ```
-
-2. **Reference the path in the objective string**:
-   ```bash
-   OBJECTIVE="Implement the layout shown in /tmp/orchestrator-context-1234567890.png. Read that image first with the Read tool to understand the design."
-   ```
-
-3. The agent uses its `Read` tool to view the image at startup — Claude Code agents are multimodal and can read image files directly.
-
-**Rule**: always use `/tmp/orchestrator-context-<timestamp>.png` as the naming convention so the supervisor knows what to look for if it needs to re-brief an agent with the same image.
-
----
-
-## Orchestrator final evaluation (YOU decide, not the script)
-
-`verify-complete.sh` is a gate — it blocks premature marking. But it cannot tell you if the work is actually good. That is YOUR job.
-
-When run-loop marks an agent `pending_evaluation` and you're notified, do all of these before marking done:
-
-### 1. Run /pr-test (required, serialized, use TodoWrite to queue)
-
-`/pr-test` is the only reliable confirmation that the objective is actually met. Run it yourself, not the agent.
-
-**When multiple PRs reach `pending_evaluation` at the same time, use TodoWrite to queue them:**
-```
-- [ ] /pr-test PR #12636 — fix copilot retry logic
-- [ ] /pr-test PR #12699 — builder chat panel
-```
-Run one at a time. Check off as you go.
-
-```
-/pr-test https://github.com/Significant-Gravitas/AutoGPT/pull/PR_NUMBER
-```
-
-**/pr-test can be lazy** — if it gives vague output, re-run with full context:
-
-```
-/pr-test https://github.com/OWNER/REPO/pull/PR_NUMBER
-Context: This PR implements <objective from state file>. Key files: <list>.
-Please verify: <specific behaviors to check>.
-```
-
-Only one `/pr-test` at a time — they share ports and DB.
-
-### 2. Do your own evaluation
-
-1. **Read the PR diff and objective** — does the code actually implement what was asked? Is anything obviously missing or half-done?
-2. **Read the resolved threads** — were comments addressed with real fixes, or just dismissed/resolved without changes?
-3. **Check CI run names** — any suspicious retries that shouldn't have passed?
-4. **Check the PR description** — title, summary, test plan complete?
-
-### 3. Decide
-
-- `/pr-test` passes + evaluation looks good → mark `done` in state, tell the user the PR is ready, ask if window should be closed
-- `/pr-test` fails or evaluation finds gaps → re-brief the agent with specific failures, set state back to `running`
-
-**Never mark done based purely on script output.** You hold the full objective context; the script does not.
-
-```bash
-# Mark done after your positive evaluation:
-jq --arg w "SESSION:WIN" '(.agents[] | select(.window == $w)).state = "done"' \
-  ~/.claude/orchestrator-state.json > /tmp/orch.tmp && mv /tmp/orch.tmp ~/.claude/orchestrator-state.json
-```
-
-## When to stop the fleet
-
-Stop the fleet (`active = false`) when **all** of the following are true:
-
-| Check | How to verify |
-|---|---|
-| All agents are `done` or `escalated` | `jq '[.agents[] | select(.state | test("running\|stuck\|idle\|waiting_approval"))] | length' ~/.claude/orchestrator-state.json` == 0 |
-| All PRs have 0 unresolved review threads | GraphQL `isResolved` check per PR |
-| All PRs have green CI **on a run triggered after the agent's last push** | `gh run list --branch BRANCH --limit 1` timestamp > `spawned_at` in state |
-| No agents are `escalated` without human review | If any are escalated, surface to user first |
-
-**Do NOT stop just because agents output `ORCHESTRATOR:DONE`.** That is a signal to verify, not a signal to stop.
-
-**Do stop** if the user explicitly says "stop", "shut down", or "kill everything", even with agents still running.
-
-```bash
-# Graceful stop
-jq '.active = false' ~/.claude/orchestrator-state.json > /tmp/orch.tmp \
-  && mv /tmp/orch.tmp ~/.claude/orchestrator-state.json
-
-LOOP_WINDOW=$(jq -r '.loop_window // ""' ~/.claude/orchestrator-state.json)
-[ -n "$LOOP_WINDOW" ] && tmux kill-window -t "$LOOP_WINDOW" 2>/dev/null || true
-```
-
-Does **not** recycle running worktrees — agents may still be mid-task. Run `capacity.sh` to see what's still in progress.
-
-## tmux send-keys pattern
-
-**Always split long messages into text + Enter as two separate calls with a sleep between them.** If sent as one call (`"text" Enter`), Enter can fire before the full string is buffered into Claude's input — leaving the message stuck as `[Pasted text +N lines]` unsent.
-
-```bash
-# CORRECT — text then Enter separately
-tmux send-keys -t "$WINDOW" "your long message here"
-sleep 0.3
-tmux send-keys -t "$WINDOW" Enter
-
-# WRONG — Enter may fire before text is buffered
-tmux send-keys -t "$WINDOW" "your long message here" Enter
-```
-
-Short single-character sends (`y`, `Down`, empty Enter for dialog approval) are safe to combine since they have no buffering lag.
-
----
-
-## Protected worktrees
-
-Some worktrees must **never** be used as spare worktrees for agent tasks because they host files critical to the orchestrator itself:
-
-| Worktree | Protected branch | Why |
-|---|---|---|
-| `AutoGPT1` | `dx/orchestrate-skill` | Hosts the orchestrate skill scripts. `recycle-agent.sh` would check out `spare/1`, wiping `.claude/skills/` and breaking all subsequent `spawn-agent.sh` calls. |
-
-**Rule**: when selecting spare worktrees via `find-spare.sh`, skip any worktree whose CURRENT branch matches a protected branch. If you accidentally spawn an agent in a protected worktree, do not let `recycle-agent.sh` run on it — manually restore the branch after the agent finishes.
-
-When `dx/orchestrate-skill` is merged into `dev`, `AutoGPT1` becomes a normal spare again.
-
----
-
-## Key rules
-
-1. **Scripts do all the heavy lifting** — don't reimplement their logic inline in this file
-2. **Never ask the user to pick a worktree** — auto-assign from `find-spare.sh` output
-3. **Never restart a running agent** — only restart on `idle` kicks (foreground is a shell)
-4. **Auto-dismiss settings dialogs** — if "Enter to confirm" appears, send Down+Enter
-5. **Always `--permission-mode bypassPermissions`** on every spawn
-6. **Escalate after 3 kicks** — mark `escalated`, surface to user
-7. **Atomic state writes** — always write to `.tmp` then `mv`
-8. **Never approve destructive commands** outside the worktree scope — when in doubt, escalate
-9. **Never recycle without verification** — `verify-complete.sh` must pass before recycling
-10. **No TASK.md files** — commit risk; use state file + `gh pr view` for agent context persistence
-11. **Re-brief stalled agents** — read objective from state file + `gh pr view`, send via tmux
-12. **ORCHESTRATOR:DONE is a signal to verify, not to accept** — always run `verify-complete.sh` and check CI run timestamp before recycling
-13. **Protected worktrees** — never use the worktree hosting the skill scripts as a spare
-14. **Images via file path** — save screenshots to `/tmp/orchestrator-context-<ts>.png`, pass path in objective; agents read with the `Read` tool
-15. **Split send-keys** — always separate text and Enter with `sleep 0.3` between calls for long strings

.claude/skills/orchestrate/scripts/capacity.sh

@@ -1,43 +0,0 @@
-#!/usr/bin/env bash
-# capacity.sh — show fleet capacity: available spare worktrees + in-use agents
-#
-# Usage: capacity.sh [REPO_ROOT]
-#   REPO_ROOT defaults to the root worktree of the current git repo.
-#
-# Reads: ~/.claude/orchestrator-state.json (skipped if missing or corrupt)
-
-set -euo pipefail
-
-SCRIPTS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-STATE_FILE="${ORCHESTRATOR_STATE_FILE:-$HOME/.claude/orchestrator-state.json}"
-REPO_ROOT="${1:-$(git rev-parse --show-toplevel 2>/dev/null || echo "")}"
-
-echo "=== Available (spare) worktrees ==="
-if [ -n "$REPO_ROOT" ]; then
-  SPARE=$("$SCRIPTS_DIR/find-spare.sh" "$REPO_ROOT" 2>/dev/null || echo "")
-else
-  SPARE=$("$SCRIPTS_DIR/find-spare.sh" 2>/dev/null || echo "")
-fi
-
-if [ -z "$SPARE" ]; then
-  echo "  (none)"
-else
-  while IFS= read -r line; do
-    [ -z "$line" ] && continue
-    echo "  ✓ $line"
-  done <<< "$SPARE"
-fi
-
-echo ""
-echo "=== In-use worktrees ==="
-if [ -f "$STATE_FILE" ] && jq -e '.' "$STATE_FILE" >/dev/null 2>&1; then
-  IN_USE=$(jq -r '.agents[] | select(.state != "done") | "  [\(.state)] \(.worktree_path) → \(.branch)"' \
-    "$STATE_FILE" 2>/dev/null || echo "")
-  if [ -n "$IN_USE" ]; then
-    echo "$IN_USE"
-  else
-    echo "  (none)"
-  fi
-else
-  echo "  (no active state file)"
-fi

.claude/skills/orchestrate/scripts/classify-pane.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# classify-pane.sh — Classify the current state of a tmux pane
-#
-# Usage: classify-pane.sh <tmux-target>
-#   tmux-target: e.g. "work:0", "work:1.0"
-#
-# Output (stdout): JSON object:
-#   { "state": "running|idle|waiting_approval|complete", "reason": "...", "pane_cmd": "..." }
-#
-# Exit codes: 0=ok, 1=error (invalid target or tmux window not found)
-
-set -euo pipefail
-
-TARGET="${1:-}"
-
-if [ -z "$TARGET" ]; then
-  echo '{"state":"error","reason":"no target provided","pane_cmd":""}'
-  exit 1
-fi
-
-# Validate tmux target format: session:window or session:window.pane
-if ! [[ "$TARGET" =~ ^[a-zA-Z0-9_.-]+:[a-zA-Z0-9_.-]+(\.[0-9]+)?$ ]]; then
-  echo '{"state":"error","reason":"invalid tmux target format","pane_cmd":""}'
-  exit 1
-fi
-
-# Check session exists (use %%:* to extract session name from session:window)
-if ! tmux list-windows -t "${TARGET%%:*}" &>/dev/null 2>&1; then
-  echo '{"state":"error","reason":"tmux target not found","pane_cmd":""}'
-  exit 1
-fi
-
-# Get the current foreground command in the pane
-PANE_CMD=$(tmux display-message -t "$TARGET" -p '#{pane_current_command}' 2>/dev/null || echo "unknown")
-
-# Capture and strip ANSI codes (use perl for cross-platform compatibility — BSD sed lacks \x1b support)
-RAW=$(tmux capture-pane -t "$TARGET" -p -S -50 2>/dev/null || echo "")
-CLEAN=$(echo "$RAW" | perl -pe 's/\x1b\[[0-9;]*[a-zA-Z]//g; s/\x1b\(B//g; s/\x1b\[\?[0-9]*[hl]//g; s/\r//g' \
-  | grep -v '^[[:space:]]*$' || true)
-
-# --- Check: explicit completion marker ---
-# Must be on its own line (not buried in the objective text sent at spawn time).
-if echo "$CLEAN" | grep -qE "^[[:space:]]*ORCHESTRATOR:DONE[[:space:]]*$"; then
-  jq -n --arg cmd "$PANE_CMD" '{"state":"complete","reason":"ORCHESTRATOR:DONE marker found","pane_cmd":$cmd}'
-  exit 0
-fi
-
-# --- Check: Claude Code approval prompt patterns ---
-LAST_40=$(echo "$CLEAN" | tail -40)
-APPROVAL_PATTERNS=(
-  "Do you want to proceed"
-  "Do you want to make this"
-  "\\[y/n\\]"
-  "\\[Y/n\\]"
-  "\\[n/Y\\]"
-  "Proceed\\?"
-  "Allow this command"
-  "Run bash command"
-  "Allow bash"
-  "Would you like"
-  "Press enter to continue"
-  "Esc to cancel"
-)
-for pattern in "${APPROVAL_PATTERNS[@]}"; do
-  if echo "$LAST_40" | grep -qiE "$pattern"; then
-    jq -n --arg pattern "$pattern" --arg cmd "$PANE_CMD" \
-      '{"state":"waiting_approval","reason":"approval pattern: \($pattern)","pane_cmd":$cmd}'
-    exit 0
-  fi
-done
-
-# --- Check: shell prompt (claude has exited) ---
-# If the foreground process is a shell (not claude/node), the agent has exited
-case "$PANE_CMD" in
-  zsh|bash|fish|sh|dash|tcsh|ksh)
-    jq -n --arg cmd "$PANE_CMD" \
-      '{"state":"idle","reason":"agent exited — shell prompt active","pane_cmd":$cmd}'
-    exit 0
-    ;;
-esac
-
-# Agent is still running (claude/node/python is the foreground process)
-jq -n --arg cmd "$PANE_CMD" \
-  '{"state":"running","reason":"foreground process: \($cmd)","pane_cmd":$cmd}'
-exit 0

.claude/skills/orchestrate/scripts/find-spare.sh

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-# find-spare.sh — list worktrees on spare/N branches (free to use)
-#
-# Usage: find-spare.sh [REPO_ROOT]
-#   REPO_ROOT defaults to the root worktree containing the current git repo.
-#
-# Output (stdout): one line per available worktree: "PATH BRANCH"
-#   e.g.: /Users/me/Code/AutoGPT3 spare/3
-
-set -euo pipefail
-
-REPO_ROOT="${1:-$(git rev-parse --show-toplevel 2>/dev/null || echo "")}"
-if [ -z "$REPO_ROOT" ]; then
-  echo "Error: not inside a git repo and no REPO_ROOT provided" >&2
-  exit 1
-fi
-
-git -C "$REPO_ROOT" worktree list --porcelain \
-  | awk '
-      /^worktree / { path = substr($0, 10) }
-      /^branch /   { branch = substr($0, 8); print path " " branch }
-    ' \
-  | { grep -E " refs/heads/spare/[0-9]+$" || true; } \
-  | sed 's|refs/heads/||'

.claude/skills/orchestrate/scripts/notify.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-# notify.sh — send a fleet notification message
-#
-# Delivery order (first available wins):
-#   1. Discord webhook — DISCORD_WEBHOOK_URL env var OR state file .discord_webhook
-#   2. macOS notification center — osascript (silent fail if unavailable)
-#   3. Stdout only
-#
-# Usage: notify.sh MESSAGE
-# Exit: always 0 (notification failure must not abort the caller)
-
-MESSAGE="${1:-}"
-[ -z "$MESSAGE" ] && exit 0
-
-STATE_FILE="${ORCHESTRATOR_STATE_FILE:-$HOME/.claude/orchestrator-state.json}"
-
-# --- Resolve Discord webhook ---
-WEBHOOK="${DISCORD_WEBHOOK_URL:-}"
-if [ -z "$WEBHOOK" ] && [ -f "$STATE_FILE" ]; then
-  WEBHOOK=$(jq -r '.discord_webhook // ""' "$STATE_FILE" 2>/dev/null || echo "")
-fi
-
-# --- Discord delivery ---
-if [ -n "$WEBHOOK" ]; then
-  PAYLOAD=$(jq -n --arg msg "$MESSAGE" '{"content": $msg}')
-  curl -s -X POST "$WEBHOOK" \
-    -H "Content-Type: application/json" \
-    -d "$PAYLOAD" > /dev/null 2>&1 || true
-fi
-
-# --- macOS notification center (silent if not macOS or osascript missing) ---
-if command -v osascript &>/dev/null 2>&1; then
-  # Escape single quotes for AppleScript
-  SAFE_MSG=$(echo "$MESSAGE" | sed "s/'/\\\\'/g")
-  osascript -e "display notification \"${SAFE_MSG}\" with title \"Orchestrator\"" 2>/dev/null || true
-fi
-
-# Always print to stdout so run-loop.sh logs it
-echo "$MESSAGE"
-exit 0

.claude/skills/orchestrate/scripts/poll-cycle.sh

@@ -1,257 +0,0 @@
-#!/usr/bin/env bash
-# poll-cycle.sh — Single orchestrator poll cycle
-#
-# Reads ~/.claude/orchestrator-state.json, classifies each agent, updates state,
-# and outputs a JSON array of actions for Claude to take.
-#
-# Usage: poll-cycle.sh
-# Output (stdout): JSON array of action objects
-#   [{ "window": "work:0", "action": "kick|approve|none", "state": "...",
-#      "worktree": "...", "objective": "...", "reason": "..." }]
-#
-# The state file is updated in-place (atomic write via .tmp).
-
-set -euo pipefail
-
-STATE_FILE="${ORCHESTRATOR_STATE_FILE:-$HOME/.claude/orchestrator-state.json}"
-SCRIPTS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-CLASSIFY="$SCRIPTS_DIR/classify-pane.sh"
-
-# Cross-platform md5: always outputs just the hex digest
-md5_hash() {
-  if command -v md5sum &>/dev/null; then
-    md5sum | awk '{print $1}'
-  else
-    md5 | awk '{print $NF}'
-  fi
-}
-
-# Clean up temp file on any exit (avoids stale .tmp if jq write fails)
-trap 'rm -f "${STATE_FILE}.tmp"' EXIT
-
-# Ensure state file exists
-if [ ! -f "$STATE_FILE" ]; then
-  echo '{"active":false,"agents":[]}' > "$STATE_FILE"
-fi
-
-# Validate JSON upfront before any jq reads that run under set -e.
-# A truncated/corrupt file (e.g. from a SIGKILL mid-write) would otherwise
-# abort the script at the ACTIVE read below without emitting any JSON output.
-if ! jq -e '.' "$STATE_FILE" >/dev/null 2>&1; then
-  echo "State file parse error — check $STATE_FILE" >&2
-  echo "[]"
-  exit 0
-fi
-
-ACTIVE=$(jq -r '.active // false' "$STATE_FILE")
-if [ "$ACTIVE" != "true" ]; then
-  echo "[]"
-  exit 0
-fi
-
-NOW=$(date +%s)
-IDLE_THRESHOLD=$(jq -r '.idle_threshold_seconds // 300' "$STATE_FILE")
-
-ACTIONS="[]"
-UPDATED_AGENTS="[]"
-
-# Read agents as newline-delimited JSON objects.
-# jq exits non-zero when .agents[] has no matches on an empty array, which is valid —
-# so we suppress that exit code and separately validate the file is well-formed JSON.
-if ! AGENTS_JSON=$(jq -e -c '.agents // empty | .[]' "$STATE_FILE" 2>/dev/null); then
-  if ! jq -e '.' "$STATE_FILE" > /dev/null 2>&1; then
-    echo "State file parse error — check $STATE_FILE" >&2
-  fi
-  echo "[]"
-  exit 0
-fi
-
-if [ -z "$AGENTS_JSON" ]; then
-  echo "[]"
-  exit 0
-fi
-
-while IFS= read -r agent; do
-  [ -z "$agent" ] && continue
-
-  # Use // "" defaults so a single malformed field doesn't abort the whole cycle
-  WINDOW=$(echo "$agent"   | jq -r '.window // ""')
-  WORKTREE=$(echo "$agent" | jq -r '.worktree // ""')
-  OBJECTIVE=$(echo "$agent"| jq -r '.objective // ""')
-  STATE=$(echo "$agent"    | jq -r '.state // "running"')
-  LAST_HASH=$(echo "$agent"| jq -r '.last_output_hash // ""')
-  IDLE_SINCE=$(echo "$agent"| jq -r '.idle_since // 0')
-  REVISION_COUNT=$(echo "$agent"| jq -r '.revision_count // 0')
-
-  # Validate window format to prevent tmux target injection.
-  # Allow session:window (numeric or named) and session:window.pane
-  if ! [[ "$WINDOW" =~ ^[a-zA-Z0-9_.-]+:[a-zA-Z0-9_.-]+(\.[0-9]+)?$ ]]; then
-    echo "Skipping agent with invalid window value: $WINDOW" >&2
-    UPDATED_AGENTS=$(echo "$UPDATED_AGENTS" | jq --argjson a "$agent" '. + [$a]')
-    continue
-  fi
-
-  # Pass-through terminal-state agents
-  if [[ "$STATE" == "done" || "$STATE" == "escalated" || "$STATE" == "complete" || "$STATE" == "pending_evaluation" ]]; then
-    UPDATED_AGENTS=$(echo "$UPDATED_AGENTS" | jq --argjson a "$agent" '. + [$a]')
-    continue
-  fi
-
-  # Classify pane.
-  # classify-pane.sh always emits JSON before exit (even on error), so using
-  # "|| echo '...'" would concatenate two JSON objects when it exits non-zero.
-  # Use "|| true" inside the substitution so set -euo pipefail does not abort
-  # the poll cycle when classify exits with a non-zero status code.
-  CLASSIFICATION=$("$CLASSIFY" "$WINDOW" 2>/dev/null || true)
-  [ -z "$CLASSIFICATION" ] && CLASSIFICATION='{"state":"error","reason":"classify failed","pane_cmd":"unknown"}'
-
-  PANE_STATE=$(echo "$CLASSIFICATION" | jq -r '.state')
-  PANE_REASON=$(echo "$CLASSIFICATION" | jq -r '.reason')
-
-  # Capture full pane output once — used for hash (stuck detection) and checkpoint parsing.
-  # Use -S -500 to get the last ~500 lines of scrollback so checkpoints aren't missed.
-  RAW=$(tmux capture-pane -t "$WINDOW" -p -S -500 2>/dev/null || echo "")
-
-  # --- Checkpoint tracking ---
-  # Parse any "CHECKPOINT:<step>" lines the agent has output and merge into state file.
-  # The agent writes these as it completes each required step so verify-complete.sh can gate recycling.
-  EXISTING_CPS=$(echo "$agent" | jq -c '.checkpoints // []')
-  NEW_CHECKPOINTS_JSON="$EXISTING_CPS"
-  if [ -n "$RAW" ]; then
-    FOUND_CPS=$(echo "$RAW" \
-      | grep -oE "CHECKPOINT:[a-zA-Z0-9_-]+" \
-      | sed 's/CHECKPOINT://' \
-      | sort -u \
-      | jq -R . | jq -s . 2>/dev/null || echo "[]")
-    NEW_CHECKPOINTS_JSON=$(jq -n \
-      --argjson existing "$EXISTING_CPS" \
-      --argjson found "$FOUND_CPS" \
-      '($existing + $found) | unique' 2>/dev/null || echo "$EXISTING_CPS")
-  fi
-
-  # Compute content hash for stuck-detection (only for running agents)
-  CURRENT_HASH=""
-  if [[ "$PANE_STATE" == "running" ]] && [ -n "$RAW" ]; then
-    CURRENT_HASH=$(echo "$RAW" | tail -20 | md5_hash)
-  fi
-
-  NEW_STATE="$STATE"
-  NEW_IDLE_SINCE="$IDLE_SINCE"
-  NEW_REVISION_COUNT="$REVISION_COUNT"
-  ACTION="none"
-  REASON="$PANE_REASON"
-
-  case "$PANE_STATE" in
-    complete)
-      # Agent output ORCHESTRATOR:DONE — mark pending_evaluation so orchestrator handles it.
-      # run-loop does NOT verify or notify; orchestrator's background poll picks this up.
-      NEW_STATE="pending_evaluation"
-      ACTION="complete"  # run-loop logs it but takes no action
-      ;;
-    waiting_approval)
-      NEW_STATE="waiting_approval"
-      ACTION="approve"
-      ;;
-    idle)
-      # Agent process has exited — needs restart
-      NEW_STATE="idle"
-      ACTION="kick"
-      REASON="agent exited (shell is foreground)"
-      NEW_REVISION_COUNT=$(( REVISION_COUNT + 1 ))
-      NEW_IDLE_SINCE=$NOW
-      if [ "$NEW_REVISION_COUNT" -ge 3 ]; then
-        NEW_STATE="escalated"
-        ACTION="none"
-        REASON="escalated after ${NEW_REVISION_COUNT} kicks — needs human attention"
-      fi
-      ;;
-    running)
-      # Clear idle_since only when transitioning from idle (agent was kicked and
-      # restarted). Do NOT reset for stuck — idle_since must persist across polls
-      # so STUCK_DURATION can accumulate and trigger escalation.
-      # Also update the local IDLE_SINCE so the hash-stability check below uses
-      # the reset value on this same poll, not the stale kick timestamp.
-      if [[ "$STATE" == "idle" ]]; then
-        NEW_IDLE_SINCE=0
-        IDLE_SINCE=0
-      fi
-      # Check if hash has been stable (agent may be stuck mid-task)
-      if [ -n "$CURRENT_HASH" ] && [ "$CURRENT_HASH" = "$LAST_HASH" ] && [ "$LAST_HASH" != "" ]; then
-        if [ "$IDLE_SINCE" = "0" ] || [ "$IDLE_SINCE" = "null" ]; then
-          NEW_IDLE_SINCE=$NOW
-        else
-          STUCK_DURATION=$(( NOW - IDLE_SINCE ))
-          if [ "$STUCK_DURATION" -gt "$IDLE_THRESHOLD" ]; then
-            NEW_REVISION_COUNT=$(( REVISION_COUNT + 1 ))
-            NEW_IDLE_SINCE=$NOW
-            if [ "$NEW_REVISION_COUNT" -ge 3 ]; then
-              NEW_STATE="escalated"
-              ACTION="none"
-              REASON="escalated after ${NEW_REVISION_COUNT} kicks — needs human attention"
-            else
-              NEW_STATE="stuck"
-              ACTION="kick"
-              REASON="output unchanged for ${STUCK_DURATION}s (threshold: ${IDLE_THRESHOLD}s)"
-            fi
-          fi
-        fi
-      else
-        # Only reset the idle timer when we have a valid hash comparison (pane
-        # capture succeeded). If CURRENT_HASH is empty (tmux capture-pane failed),
-        # preserve existing timers so stuck detection is not inadvertently reset.
-        if [ -n "$CURRENT_HASH" ]; then
-          NEW_STATE="running"
-          NEW_IDLE_SINCE=0
-        fi
-      fi
-      ;;
-    error)
-      REASON="classify error: $PANE_REASON"
-      ;;
-  esac
-
-  # Build updated agent record (ensure idle_since and revision_count are numeric)
-  # Use || true on each jq call so a malformed field skips this agent rather than
-  # aborting the entire poll cycle under set -e.
-  UPDATED_AGENT=$(echo "$agent" | jq \
-    --arg state "$NEW_STATE" \
-    --arg hash "$CURRENT_HASH" \
-    --argjson now "$NOW" \
-    --arg idle_since "$NEW_IDLE_SINCE" \
-    --arg revision_count "$NEW_REVISION_COUNT" \
-    --argjson checkpoints "$NEW_CHECKPOINTS_JSON" \
-    '.state = $state
-     | .last_output_hash = (if $hash == "" then .last_output_hash else $hash end)
-     | .last_seen_at = $now
-     | .idle_since = ($idle_since | tonumber)
-     | .revision_count = ($revision_count | tonumber)
-     | .checkpoints = $checkpoints' 2>/dev/null) || {
-    echo "Warning: failed to build updated agent for window $WINDOW — keeping original" >&2
-    UPDATED_AGENTS=$(echo "$UPDATED_AGENTS" | jq --argjson a "$agent" '. + [$a]')
-    continue
-  }
-
-  UPDATED_AGENTS=$(echo "$UPDATED_AGENTS" | jq --argjson a "$UPDATED_AGENT" '. + [$a]')
-
-  # Add action if needed
-  if [ "$ACTION" != "none" ]; then
-    ACTION_OBJ=$(jq -n \
-      --arg window "$WINDOW" \
-      --arg action "$ACTION" \
-      --arg state "$NEW_STATE" \
-      --arg worktree "$WORKTREE" \
-      --arg objective "$OBJECTIVE" \
-      --arg reason "$REASON" \
-      '{window:$window, action:$action, state:$state, worktree:$worktree, objective:$objective, reason:$reason}')
-    ACTIONS=$(echo "$ACTIONS" | jq --argjson a "$ACTION_OBJ" '. + [$a]')
-  fi
-
-done <<< "$AGENTS_JSON"
-
-# Atomic state file update
-jq --argjson agents "$UPDATED_AGENTS" \
-   --argjson now "$NOW" \
-   '.agents = $agents | .last_poll_at = $now' \
-   "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
-
-echo "$ACTIONS"

.claude/skills/orchestrate/scripts/recycle-agent.sh

@@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-# recycle-agent.sh — kill a tmux window and restore the worktree to its spare branch
-#
-# Usage: recycle-agent.sh WINDOW WORKTREE_PATH SPARE_BRANCH
-#   WINDOW        — tmux target, e.g. autogpt1:3
-#   WORKTREE_PATH — absolute path to the git worktree
-#   SPARE_BRANCH  — branch to restore, e.g. spare/6
-#
-# Stdout: one status line
-
-set -euo pipefail
-
-if [ $# -lt 3 ]; then
-  echo "Usage: recycle-agent.sh WINDOW WORKTREE_PATH SPARE_BRANCH" >&2
-  exit 1
-fi
-
-WINDOW="$1"
-WORKTREE_PATH="$2"
-SPARE_BRANCH="$3"
-
-# Kill the tmux window (ignore error — may already be gone)
-tmux kill-window -t "$WINDOW" 2>/dev/null || true
-
-# Restore to spare branch: abort any in-progress operation, then clean
-git -C "$WORKTREE_PATH" rebase --abort 2>/dev/null || true
-git -C "$WORKTREE_PATH" merge --abort 2>/dev/null || true
-git -C "$WORKTREE_PATH" reset --hard HEAD 2>/dev/null
-git -C "$WORKTREE_PATH" clean -fd 2>/dev/null
-git -C "$WORKTREE_PATH" checkout "$SPARE_BRANCH"
-
-echo "Recycled: $(basename "$WORKTREE_PATH") → $SPARE_BRANCH (window $WINDOW closed)"

.claude/skills/orchestrate/scripts/run-loop.sh

@@ -1,164 +0,0 @@
-#!/usr/bin/env bash
-# run-loop.sh — Mechanical babysitter for the agent fleet (runs in its own tmux window)
-#
-# Handles ONLY two things that need no intelligence:
-#   idle    → restart claude using --resume SESSION_ID (or --continue) to restore context
-#   approve → auto-approve safe dialogs, press Enter on numbered-option dialogs
-#
-# Everything else — ORCHESTRATOR:DONE, verification, /pr-test, final evaluation,
-# marking done, deciding to close windows — is the orchestrating Claude's job.
-# poll-cycle.sh sets state to pending_evaluation when ORCHESTRATOR:DONE is detected;
-# the orchestrator's background poll loop handles it from there.
-#
-# Usage: run-loop.sh
-# Env:   POLL_INTERVAL (default: 30), ORCHESTRATOR_STATE_FILE
-
-set -euo pipefail
-
-# Copy scripts to a stable location outside the repo so they survive branch
-# checkouts (e.g. recycle-agent.sh switching spare/N back into this worktree
-# would wipe .claude/skills/orchestrate/scripts if the skill only exists on the
-# current branch).
-_ORIGIN_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-STABLE_SCRIPTS_DIR="$HOME/.claude/orchestrator/scripts"
-mkdir -p "$STABLE_SCRIPTS_DIR"
-cp "$_ORIGIN_DIR"/*.sh "$STABLE_SCRIPTS_DIR/"
-chmod +x "$STABLE_SCRIPTS_DIR"/*.sh
-SCRIPTS_DIR="$STABLE_SCRIPTS_DIR"
-
-STATE_FILE="${ORCHESTRATOR_STATE_FILE:-$HOME/.claude/orchestrator-state.json}"
-POLL_INTERVAL="${POLL_INTERVAL:-30}"
-
-# ---------------------------------------------------------------------------
-# update_state WINDOW FIELD VALUE
-# ---------------------------------------------------------------------------
-update_state() {
-  local window="$1" field="$2" value="$3"
-  jq --arg w "$window" --arg f "$field" --arg v "$value" \
-    '.agents |= map(if .window == $w then .[$f] = $v else . end)' \
-    "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
-}
-
-update_state_int() {
-  local window="$1" field="$2" value="$3"
-  jq --arg w "$window" --arg f "$field" --argjson v "$value" \
-    '.agents |= map(if .window == $w then .[$f] = $v else . end)' \
-    "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
-}
-
-agent_field() {
-  jq -r --arg w "$1" --arg f "$2" \
-    '.agents[] | select(.window == $w) | .[$f] // ""' \
-    "$STATE_FILE" 2>/dev/null
-}
-
-# ---------------------------------------------------------------------------
-# wait_for_prompt WINDOW — wait up to 60s for Claude's ❯ prompt
-# ---------------------------------------------------------------------------
-wait_for_prompt() {
-  local window="$1"
-  for i in $(seq 1 60); do
-    local cmd pane
-    cmd=$(tmux display-message -t "$window" -p '#{pane_current_command}' 2>/dev/null || echo "")
-    pane=$(tmux capture-pane -t "$window" -p 2>/dev/null || echo "")
-    if echo "$pane" | grep -q "Enter to confirm"; then
-      tmux send-keys -t "$window" Down Enter; sleep 2; continue
-    fi
-    [[ "$cmd" == "node" ]] && echo "$pane" | grep -q "❯" && return 0
-    sleep 1
-  done
-  return 1  # timed out
-}
-
-# ---------------------------------------------------------------------------
-# handle_kick WINDOW STATE — only for idle (crashed) agents, not stuck
-# ---------------------------------------------------------------------------
-handle_kick() {
-  local window="$1" state="$2"
-  [[ "$state" != "idle" ]] && return  # stuck agents handled by supervisor
-
-  local worktree_path session_id
-  worktree_path=$(agent_field "$window" "worktree_path")
-  session_id=$(agent_field "$window" "session_id")
-
-  echo "[$(date +%H:%M:%S)] KICK restart  $window — agent exited, resuming session"
-
-  # Resume the exact session so the agent retains full context — no need to re-send objective
-  if [ -n "$session_id" ]; then
-    tmux send-keys -t "$window" "cd '${worktree_path}' && claude --resume '${session_id}' --permission-mode bypassPermissions" Enter
-  else
-    tmux send-keys -t "$window" "cd '${worktree_path}' && claude --continue --permission-mode bypassPermissions" Enter
-  fi
-
-  wait_for_prompt "$window" || echo "[$(date +%H:%M:%S)] KICK WARNING  $window — timed out waiting for ❯"
-}
-
-# ---------------------------------------------------------------------------
-# handle_approve WINDOW — auto-approve dialogs that need no judgment
-# ---------------------------------------------------------------------------
-handle_approve() {
-  local window="$1"
-  local pane_tail
-  pane_tail=$(tmux capture-pane -t "$window" -p 2>/dev/null | tail -3 || echo "")
-
-  # Settings error dialog at startup
-  if echo "$pane_tail" | grep -q "Enter to confirm"; then
-    echo "[$(date +%H:%M:%S)] APPROVE dialog $window — settings error"
-    tmux send-keys -t "$window" Down Enter
-    return
-  fi
-
-  # Numbered-option dialog (e.g. "Do you want to make this edit?")
-  # ❯ is already on option 1 (Yes) — Enter confirms it
-  if echo "$pane_tail" | grep -qE "❯\s*1\." || echo "$pane_tail" | grep -q "Esc to cancel"; then
-    echo "[$(date +%H:%M:%S)] APPROVE edit   $window"
-    tmux send-keys -t "$window" "" Enter
-    return
-  fi
-
-  # y/n prompt for safe operations
-  if echo "$pane_tail" | grep -qiE "(^git |^npm |^pnpm |^poetry |^pytest|^docker |^make |^cargo |^pip |^yarn |curl .*(localhost|127\.0\.0\.1))"; then
-    echo "[$(date +%H:%M:%S)] APPROVE safe   $window"
-    tmux send-keys -t "$window" "y" Enter
-    return
-  fi
-
-  # Anything else — supervisor handles it, just log
-  echo "[$(date +%H:%M:%S)] APPROVE skip   $window — unknown dialog, supervisor will handle"
-}
-
-# ---------------------------------------------------------------------------
-# Main loop
-# ---------------------------------------------------------------------------
-echo "[$(date +%H:%M:%S)] run-loop started (mechanical only, poll every ${POLL_INTERVAL}s)"
-echo "[$(date +%H:%M:%S)] Supervisor: orchestrating Claude session (not a separate window)"
-echo "---"
-
-while true; do
-  if ! jq -e '.active == true' "$STATE_FILE" >/dev/null 2>&1; then
-    echo "[$(date +%H:%M:%S)] active=false — exiting."
-    exit 0
-  fi
-
-  ACTIONS=$("$SCRIPTS_DIR/poll-cycle.sh" 2>/dev/null || echo "[]")
-  KICKED=0; DONE=0
-
-  while IFS= read -r action; do
-    [ -z "$action" ] && continue
-    WINDOW=$(echo "$action" | jq -r '.window // ""')
-    ACTION=$(echo "$action" | jq -r '.action // ""')
-    STATE=$(echo "$action"  | jq -r '.state // ""')
-
-    case "$ACTION" in
-      kick)     handle_kick "$WINDOW" "$STATE" || true; KICKED=$(( KICKED + 1 )) ;;
-      approve)  handle_approve "$WINDOW" || true ;;
-      complete) DONE=$(( DONE + 1 )) ;;  # poll-cycle already set state=pending_evaluation; orchestrator handles
-    esac
-  done < <(echo "$ACTIONS" | jq -c '.[]' 2>/dev/null || true)
-
-  RUNNING=$(jq '[.agents[] | select(.state | test("running|stuck|waiting_approval|idle"))] | length' \
-    "$STATE_FILE" 2>/dev/null || echo 0)
-
-  echo "[$(date +%H:%M:%S)] Poll — ${RUNNING} running  ${KICKED} kicked  ${DONE} recycled"
-  sleep "$POLL_INTERVAL"
-done

.claude/skills/orchestrate/scripts/spawn-agent.sh

@@ -1,122 +0,0 @@
-#!/usr/bin/env bash
-# spawn-agent.sh — create tmux window, checkout branch, launch claude, send task
-#
-# Usage: spawn-agent.sh SESSION WORKTREE_PATH SPARE_BRANCH NEW_BRANCH OBJECTIVE [PR_NUMBER] [STEPS...]
-#   SESSION       — tmux session name, e.g. autogpt1
-#   WORKTREE_PATH — absolute path to the git worktree
-#   SPARE_BRANCH  — spare branch being replaced, e.g. spare/6 (saved for recycle)
-#   NEW_BRANCH    — task branch to create, e.g. feat/my-feature
-#   OBJECTIVE     — task description sent to the agent
-#   PR_NUMBER     — (optional) GitHub PR number for completion verification
-#   STEPS...      — (optional) required checkpoint names, e.g. pr-address pr-test
-#
-# Stdout: SESSION:WINDOW_INDEX (nothing else — callers rely on this)
-# Exit non-zero on failure.
-
-set -euo pipefail
-
-if [ $# -lt 5 ]; then
-  echo "Usage: spawn-agent.sh SESSION WORKTREE_PATH SPARE_BRANCH NEW_BRANCH OBJECTIVE [PR_NUMBER] [STEPS...]" >&2
-  exit 1
-fi
-
-SESSION="$1"
-WORKTREE_PATH="$2"
-SPARE_BRANCH="$3"
-NEW_BRANCH="$4"
-OBJECTIVE="$5"
-PR_NUMBER="${6:-}"
-STEPS=("${@:7}")
-WORKTREE_NAME=$(basename "$WORKTREE_PATH")
-STATE_FILE="${ORCHESTRATOR_STATE_FILE:-$HOME/.claude/orchestrator-state.json}"
-
-# Generate a stable session ID so this agent's Claude session can always be resumed:
-#   claude --resume $SESSION_ID --permission-mode bypassPermissions
-SESSION_ID=$(uuidgen 2>/dev/null || python3 -c "import uuid; print(uuid.uuid4())")
-
-# Create (or switch to) the task branch
-git -C "$WORKTREE_PATH" checkout -b "$NEW_BRANCH" 2>/dev/null \
-  || git -C "$WORKTREE_PATH" checkout "$NEW_BRANCH"
-
-# Open a new named tmux window; capture its numeric index
-WIN_IDX=$(tmux new-window -t "$SESSION" -n "$WORKTREE_NAME" -P -F '#{window_index}')
-WINDOW="${SESSION}:${WIN_IDX}"
-
-# Append the initial agent record to the state file so subsequent jq updates find it.
-# This must happen before the pr_number/steps update below.
-if [ -f "$STATE_FILE" ]; then
-  NOW=$(date +%s)
-  jq --arg window "$WINDOW" \
-     --arg worktree "$WORKTREE_NAME" \
-     --arg worktree_path "$WORKTREE_PATH" \
-     --arg spare_branch "$SPARE_BRANCH" \
-     --arg branch "$NEW_BRANCH" \
-     --arg objective "$OBJECTIVE" \
-     --arg session_id "$SESSION_ID" \
-     --argjson now "$NOW" \
-     '.agents += [{
-       "window": $window,
-       "worktree": $worktree,
-       "worktree_path": $worktree_path,
-       "spare_branch": $spare_branch,
-       "branch": $branch,
-       "objective": $objective,
-       "session_id": $session_id,
-       "state": "running",
-       "checkpoints": [],
-       "last_output_hash": "",
-       "last_seen_at": $now,
-       "spawned_at": $now,
-       "idle_since": 0,
-       "revision_count": 0,
-       "last_rebriefed_at": 0
-     }]' "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
-fi
-
-# Store pr_number + steps in state file if provided (enables verify-complete.sh).
-# The agent record was appended above so the jq select now finds it.
-if [ -n "$PR_NUMBER" ] && [ -f "$STATE_FILE" ]; then
-  if [ "${#STEPS[@]}" -gt 0 ]; then
-    STEPS_JSON=$(printf '%s\n' "${STEPS[@]}" | jq -R . | jq -s .)
-  else
-    STEPS_JSON='[]'
-  fi
-  jq --arg w "$WINDOW" --arg pr "$PR_NUMBER" --argjson steps "$STEPS_JSON" \
-    '.agents |= map(if .window == $w then . + {pr_number: $pr, steps: $steps, checkpoints: []} else . end)' \
-    "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
-fi
-
-# Launch claude with a stable session ID so it can always be resumed after a crash:
-#   claude --resume SESSION_ID --permission-mode bypassPermissions
-tmux send-keys -t "$WINDOW" "cd '${WORKTREE_PATH}' && claude --permission-mode bypassPermissions --session-id '${SESSION_ID}'" Enter
-
-# Wait up to 60s for claude to be fully interactive:
-# both pane_current_command == 'node' AND the '❯' prompt is visible.
-PROMPT_FOUND=false
-for i in $(seq 1 60); do
-  CMD=$(tmux display-message -t "$WINDOW" -p '#{pane_current_command}' 2>/dev/null || echo "")
-  PANE=$(tmux capture-pane -t "$WINDOW" -p 2>/dev/null || echo "")
-  if echo "$PANE" | grep -q "Enter to confirm"; then
-    tmux send-keys -t "$WINDOW" Down Enter
-    sleep 2
-    continue
-  fi
-  if [[ "$CMD" == "node" ]] && echo "$PANE" | grep -q "❯"; then
-    PROMPT_FOUND=true
-    break
-  fi
-  sleep 1
-done
-
-if ! $PROMPT_FOUND; then
-  echo "[spawn-agent] WARNING: timed out waiting for ❯ prompt on $WINDOW — sending objective anyway" >&2
-fi
-
-# Send the task. Split text and Enter — if combined, Enter can fire before the string
-# is fully buffered, leaving the message stuck as "[Pasted text +N lines]" unsent.
-tmux send-keys -t "$WINDOW" "${OBJECTIVE} Output each completed step as CHECKPOINT:<step-name>. When ALL steps are done, output ORCHESTRATOR:DONE on its own line."
-sleep 0.3
-tmux send-keys -t "$WINDOW" Enter
-
-# Only output the window address — nothing else (callers parse this)
-echo "$WINDOW"

.claude/skills/orchestrate/scripts/status.sh

@@ -1,43 +0,0 @@
-#!/usr/bin/env bash
-# status.sh — print orchestrator status: state file summary + live tmux pane commands
-#
-# Usage: status.sh
-# Reads: ~/.claude/orchestrator-state.json
-
-set -euo pipefail
-
-STATE_FILE="${ORCHESTRATOR_STATE_FILE:-$HOME/.claude/orchestrator-state.json}"
-
-if [ ! -f "$STATE_FILE" ] || ! jq -e '.' "$STATE_FILE" >/dev/null 2>&1; then
-  echo "No orchestrator state found at $STATE_FILE"
-  exit 0
-fi
-
-# Header: active status, session, thresholds, last poll
-jq -r '
-  "=== Orchestrator [\(if .active then "RUNNING" else "STOPPED" end)] ===",
-  "Session: \(.tmux_session // "unknown")  |  Idle threshold: \(.idle_threshold_seconds // 300)s",
-  "Last poll: \(if (.last_poll_at // 0) == 0 then "never" else (.last_poll_at | strftime("%H:%M:%S")) end)",
-  ""
-' "$STATE_FILE"
-
-# Each agent: state, window, worktree/branch, truncated objective
-AGENT_COUNT=$(jq '.agents | length' "$STATE_FILE")
-if [ "$AGENT_COUNT" -eq 0 ]; then
-  echo "  (no agents registered)"
-else
-  jq -r '
-    .agents[] |
-    "  [\(.state | ascii_upcase)] \(.window)  \(.worktree)/\(.branch)",
-    "    \(.objective // "" | .[0:70])"
-  ' "$STATE_FILE"
-fi
-
-echo ""
-
-# Live pane_current_command for non-done agents
-while IFS= read -r WINDOW; do
-  [ -z "$WINDOW" ] && continue
-  CMD=$(tmux display-message -t "$WINDOW" -p '#{pane_current_command}' 2>/dev/null || echo "unreachable")
-  echo "  $WINDOW live: $CMD"
-done < <(jq -r '.agents[] | select(.state != "done") | .window' "$STATE_FILE" 2>/dev/null || true)

.claude/skills/orchestrate/scripts/verify-complete.sh

@@ -1,129 +0,0 @@
-#!/usr/bin/env bash
-# verify-complete.sh — verify a PR task is truly done before marking the agent done
-#
-# Check order matters:
-#   1. Checkpoints — did the agent do all required steps?
-#   2. CI complete — no pending (bots post comments AFTER their check runs, must wait)
-#   3. CI passing — no failures (agent must fix before done)
-#   4. spawned_at — a new CI run was triggered after agent spawned (proves real work)
-#   5. Unresolved threads — checked AFTER CI so bot-posted comments are included
-#   6. CHANGES_REQUESTED — checked AFTER CI so bot reviews are included
-#
-# Usage: verify-complete.sh WINDOW
-# Exit 0 = verified complete; exit 1 = not complete (stderr has reason)
-
-set -euo pipefail
-
-WINDOW="$1"
-STATE_FILE="${ORCHESTRATOR_STATE_FILE:-$HOME/.claude/orchestrator-state.json}"
-
-PR_NUMBER=$(jq -r --arg w "$WINDOW" '.agents[] | select(.window == $w) | .pr_number // ""' "$STATE_FILE" 2>/dev/null)
-STEPS=$(jq -r --arg w "$WINDOW" '.agents[] | select(.window == $w) | .steps // [] | .[]' "$STATE_FILE" 2>/dev/null || true)
-CHECKPOINTS=$(jq -r --arg w "$WINDOW" '.agents[] | select(.window == $w) | .checkpoints // [] | .[]' "$STATE_FILE" 2>/dev/null || true)
-WORKTREE_PATH=$(jq -r --arg w "$WINDOW" '.agents[] | select(.window == $w) | .worktree_path // ""' "$STATE_FILE" 2>/dev/null)
-BRANCH=$(jq -r --arg w "$WINDOW" '.agents[] | select(.window == $w) | .branch // ""' "$STATE_FILE" 2>/dev/null)
-SPAWNED_AT=$(jq -r --arg w "$WINDOW" '.agents[] | select(.window == $w) | .spawned_at // "0"' "$STATE_FILE" 2>/dev/null || echo "0")
-
-# No PR number = cannot verify
-if [ -z "$PR_NUMBER" ]; then
-  echo "NOT COMPLETE: no pr_number in state — set pr_number or mark done manually" >&2
-  exit 1
-fi
-
-# --- Check 1: all required steps are checkpointed ---
-MISSING=""
-while IFS= read -r step; do
-  [ -z "$step" ] && continue
-  if ! echo "$CHECKPOINTS" | grep -qFx "$step"; then
-    MISSING="$MISSING $step"
-  fi
-done <<< "$STEPS"
-
-if [ -n "$MISSING" ]; then
-  echo "NOT COMPLETE: missing checkpoints:$MISSING on PR #$PR_NUMBER" >&2
-  exit 1
-fi
-
-# Resolve repo for all GitHub checks below
-REPO=$(jq -r '.repo // ""' "$STATE_FILE" 2>/dev/null || echo "")
-if [ -z "$REPO" ] && [ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ]; then
-  REPO=$(git -C "$WORKTREE_PATH" remote get-url origin 2>/dev/null \
-    | sed 's|.*github\.com[:/]||; s|\.git$||' || echo "")
-fi
-
-if [ -z "$REPO" ]; then
-  echo "Warning: cannot resolve repo — skipping CI/thread checks" >&2
-  echo "VERIFIED: PR #$PR_NUMBER — checkpoints ✓ (CI/thread checks skipped — no repo)"
-  exit 0
-fi
-
-CI_BUCKETS=$(gh pr checks "$PR_NUMBER" --repo "$REPO" --json bucket 2>/dev/null || echo "[]")
-
-# --- Check 2: CI fully complete — no pending checks ---
-# Pending checks MUST finish before we check threads/reviews:
-# bots (Seer, Check PR Status, etc.) post comments and CHANGES_REQUESTED AFTER their CI check runs.
-PENDING=$(echo "$CI_BUCKETS" | jq '[.[] | select(.bucket == "pending")] | length' 2>/dev/null || echo "0")
-if [ "$PENDING" -gt 0 ]; then
-  PENDING_NAMES=$(gh pr checks "$PR_NUMBER" --repo "$REPO" --json bucket,name 2>/dev/null \
-    | jq -r '[.[] | select(.bucket == "pending") | .name] | join(", ")' 2>/dev/null || echo "unknown")
-  echo "NOT COMPLETE: $PENDING CI checks still pending on PR #$PR_NUMBER ($PENDING_NAMES)" >&2
-  exit 1
-fi
-
-# --- Check 3: CI passing — no failures ---
-FAILING=$(echo "$CI_BUCKETS" | jq '[.[] | select(.bucket == "fail")] | length' 2>/dev/null || echo "0")
-if [ "$FAILING" -gt 0 ]; then
-  FAILING_NAMES=$(gh pr checks "$PR_NUMBER" --repo "$REPO" --json bucket,name 2>/dev/null \
-    | jq -r '[.[] | select(.bucket == "fail") | .name] | join(", ")' 2>/dev/null || echo "unknown")
-  echo "NOT COMPLETE: $FAILING failing CI checks on PR #$PR_NUMBER ($FAILING_NAMES)" >&2
-  exit 1
-fi
-
-# --- Check 4: a new CI run was triggered AFTER the agent spawned ---
-if [ -n "$BRANCH" ] && [ "${SPAWNED_AT:-0}" -gt 0 ]; then
-  LATEST_RUN_AT=$(gh run list --repo "$REPO" --branch "$BRANCH" \
-    --json createdAt --limit 1 2>/dev/null | jq -r '.[0].createdAt // ""')
-  if [ -n "$LATEST_RUN_AT" ]; then
-    if date --version >/dev/null 2>&1; then
-      LATEST_RUN_EPOCH=$(date -d "$LATEST_RUN_AT" "+%s" 2>/dev/null || echo "0")
-    else
-      LATEST_RUN_EPOCH=$(TZ=UTC date -j -f "%Y-%m-%dT%H:%M:%SZ" "$LATEST_RUN_AT" "+%s" 2>/dev/null || echo "0")
-    fi
-    if [ "$LATEST_RUN_EPOCH" -le "$SPAWNED_AT" ]; then
-      echo "NOT COMPLETE: latest CI run on $BRANCH predates agent spawn — agent may not have pushed yet" >&2
-      exit 1
-    fi
-  fi
-fi
-
-OWNER=$(echo "$REPO" | cut -d/ -f1)
-REPONAME=$(echo "$REPO" | cut -d/ -f2)
-
-# --- Check 5: no unresolved review threads (checked AFTER CI — bots post after their check) ---
-UNRESOLVED=$(gh api graphql -f query="
-  { repository(owner: \"${OWNER}\", name: \"${REPONAME}\") {
-      pullRequest(number: ${PR_NUMBER}) {
-        reviewThreads(first: 50) { nodes { isResolved } }
-      }
-    }
-  }
-" --jq '[.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved == false)] | length' 2>/dev/null || echo "0")
-
-if [ "$UNRESOLVED" -gt 0 ]; then
-  echo "NOT COMPLETE: $UNRESOLVED unresolved review threads on PR #$PR_NUMBER" >&2
-  exit 1
-fi
-
-# --- Check 6: no CHANGES_REQUESTED (checked AFTER CI — bots post reviews after their check) ---
-CHANGES_REQUESTED=$(gh pr view "$PR_NUMBER" --repo "$REPO" \
-  --json reviews --jq '[.reviews[] | select(.state == "CHANGES_REQUESTED")] | length' 2>/dev/null || echo "0")
-
-if [ "$CHANGES_REQUESTED" -gt 0 ]; then
-  REQUESTERS=$(gh pr view "$PR_NUMBER" --repo "$REPO" \
-    --json reviews --jq '[.reviews[] | select(.state == "CHANGES_REQUESTED") | .author.login] | join(", ")' 2>/dev/null || echo "unknown")
-  echo "NOT COMPLETE: CHANGES_REQUESTED from ${REQUESTERS} on PR #$PR_NUMBER" >&2
-  exit 1
-fi
-
-echo "VERIFIED: PR #$PR_NUMBER — checkpoints ✓, CI complete + green, 0 unresolved threads, no CHANGES_REQUESTED"
-exit 0

.claude/skills/pr-address/SKILL.md

@@ -1,234 +0,0 @@
----
-name: pr-address
-description: Address PR review comments and loop until CI green and all comments resolved. TRIGGER when user asks to address comments, fix PR feedback, respond to reviewers, or babysit/monitor a PR.
-user-invocable: true
-argument-hint: "[PR number or URL] — if omitted, finds PR for current branch."
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
----
-
-# PR Address
-
-## Find the PR
-
-```bash
-gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT
-gh pr view {N}
-```
-
-## Read the PR description
-
-Understand the **Why / What / How** before addressing comments — you need context to make good fixes:
-
-```bash
-gh pr view {N} --json body --jq '.body'
-```
-
-## Fetch comments (all sources)
-
-### 1. Inline review threads — GraphQL (primary source of actionable items)
-
-Use GraphQL to fetch inline threads. It natively exposes `isResolved`, returns threads already grouped with all replies, and paginates via cursor — no manual thread reconstruction needed.
-
-```bash
-gh api graphql -f query='
-{
-  repository(owner: "Significant-Gravitas", name: "AutoGPT") {
-    pullRequest(number: {N}) {
-      reviewThreads(first: 100) {
-        pageInfo { hasNextPage endCursor }
-        nodes {
-          id
-          isResolved
-          path
-          comments(last: 1) {
-            nodes { databaseId body author { login } createdAt }
-          }
-        }
-      }
-    }
-  }
-}'
-```
-
-If `pageInfo.hasNextPage` is true, fetch subsequent pages by adding `after: "<endCursor>"` to `reviewThreads(first: 100, after: "...")` and repeat until `hasNextPage` is false.
-
-**Filter to unresolved threads only** — skip any thread where `isResolved: true`. `comments(last: 1)` returns the most recent comment in the thread — act on that; it reflects the reviewer's final ask. Use the thread `id` (Relay global ID) to track threads across polls.
-
-### 2. Top-level reviews — REST (MUST paginate)
-
-```bash
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews --paginate
-```
-
-**CRITICAL — always `--paginate`.** Reviews default to 30 per page. PRs can have 80–170+ reviews (mostly empty resolution events). Without pagination you miss reviews past position 30 — including `autogpt-reviewer`'s structured review which is typically posted after several CI runs and sits well beyond the first page.
-
-Two things to extract:
-- **Overall state**: look for `CHANGES_REQUESTED` or `APPROVED` reviews.
-- **Actionable feedback**: non-empty bodies only. Empty-body reviews are thread-resolution events — they indicate progress but have no feedback to act on.
-
-**Where each reviewer posts:**
-- `autogpt-reviewer` — posts detailed structured reviews ("Blockers", "Should Fix", "Nice to Have") as **top-level reviews**. Not present on every PR. Address ALL items.
-- `sentry[bot]` — posts bug predictions as **inline threads**. Fix real bugs, explain false positives.
-- `coderabbitai[bot]` — posts summaries as **top-level reviews** AND actionable items as **inline threads**. Address actionable items.
-- Human reviewers — can post in any source. Address ALL non-empty feedback.
-
-### 3. PR conversation comments — REST
-
-```bash
-gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments --paginate
-```
-
-Mostly contains: bot summaries (`coderabbitai[bot]`), CI/conflict detection (`github-actions[bot]`), and author status updates. Scan for non-empty messages from non-bot human reviewers that aren't the PR author — those are the ones that need a response.
-
-## For each unaddressed comment
-
-Address comments **one at a time**: fix → commit → push → inline reply → next.
-
-1. Read the referenced code, make the fix (or reply explaining why it's not needed)
-2. Commit and push the fix
-3. Reply **inline** (not as a new top-level comment) referencing the fixing commit — this is what resolves the conversation for bot reviewers (coderabbitai, sentry):
-
-Use a **markdown commit link** so GitHub renders it as a clickable reference. Get the full SHA with `git rev-parse HEAD` after committing:
-
-| Comment type | How to reply |
-|---|---|
-| Inline review (`pulls/{N}/comments`) | `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments/{ID}/replies -f body="🤖 Fixed in [abc1234](https://github.com/Significant-Gravitas/AutoGPT/commit/FULL_SHA): <description>"` |
-| Conversation (`issues/{N}/comments`) | `gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments -f body="🤖 Fixed in [abc1234](https://github.com/Significant-Gravitas/AutoGPT/commit/FULL_SHA): <description>"` |
-
-## Codecov coverage
-
-Codecov patch target is **80%** on changed lines. Checks are **informational** (not blocking) but should be green.
-
-### Running coverage locally
-
-**Backend** (from `autogpt_platform/backend/`):
-```bash
-poetry run pytest -s -vv --cov=backend --cov-branch --cov-report term-missing
-```
-
-**Frontend** (from `autogpt_platform/frontend/`):
-```bash
-pnpm vitest run --coverage
-```
-
-### When codecov/patch fails
-
-1. Find uncovered files: `git diff --name-only $(gh pr view --json baseRefName --jq '.baseRefName')...HEAD`
-2. For each uncovered file — extract inline logic to `helpers.ts`/`helpers.py` and test those (highest ROI). Colocate tests as `*_test.py` (backend) or `__tests__/*.test.ts` (frontend).
-3. Run coverage locally to verify, commit, push.
-
-## Format and commit
-
-After fixing, format the changed code:
-
-- **Backend** (from `autogpt_platform/backend/`): `poetry run format`
-- **Frontend** (from `autogpt_platform/frontend/`): `pnpm format && pnpm lint && pnpm types`
-
-If API routes changed, regenerate the frontend client:
-```bash
-cd autogpt_platform/backend && poetry run rest &
-REST_PID=$!
-trap "kill $REST_PID 2>/dev/null" EXIT
-WAIT=0; until curl -sf http://localhost:8006/health > /dev/null 2>&1; do sleep 1; WAIT=$((WAIT+1)); [ $WAIT -ge 60 ] && echo "Timed out" && exit 1; done
-cd ../frontend && pnpm generate:api:force
-kill $REST_PID 2>/dev/null; trap - EXIT
-```
-Never manually edit files in `src/app/api/__generated__/`.
-
-Then commit and **push immediately** — never batch commits without pushing. Each fix should be visible on GitHub right away so CI can start and reviewers can see progress.
-
-**Never push empty commits** (`git commit --allow-empty`) to re-trigger CI or bot checks. When a check fails, investigate the root cause (unchecked PR checklist, unaddressed review comments, code issues) and fix those directly. Empty commits add noise to git history.
-
-For backend commits in worktrees: `poetry run git commit` (pre-commit hooks).
-
-## The loop
-
-```text
-address comments → format → commit → push
-→ wait for CI (while addressing new comments) → fix failures → push
-→ re-check comments after CI settles
-→ repeat until: all comments addressed AND CI green AND no new comments arriving
-```
-
-### Polling for CI + new comments
-
-After pushing, poll for **both** CI status and new comments in a single loop. Do not use `gh pr checks --watch` — it blocks the tool and prevents reacting to new comments while CI is running.
-
-> **Note:** `gh pr checks --watch --fail-fast` is tempting but it blocks the entire Bash tool call, meaning the agent cannot check for or address new comments until CI fully completes. Always poll manually instead.
-
-**Polling loop — repeat every 30 seconds:**
-
-1. Check CI status:
-```bash
-gh pr checks {N} --repo Significant-Gravitas/AutoGPT --json bucket,name,link
-```
-   Parse the results: if every check has `bucket` of `"pass"` or `"skipping"`, CI is green. If any has `"fail"`, CI has failed. Otherwise CI is still pending.
-
-2. Check for merge conflicts:
-```bash
-gh pr view {N} --repo Significant-Gravitas/AutoGPT --json mergeable --jq '.mergeable'
-```
-   If the result is `"CONFLICTING"`, the PR has a merge conflict — see "Resolving merge conflicts" below. If `"UNKNOWN"`, GitHub is still computing mergeability — wait and re-check next poll.
-
-3. Check for new/changed comments (all three sources):
-
-   **Inline threads** — re-run the GraphQL query from "Fetch comments". For each unresolved thread, record `{thread_id, last_comment_databaseId}` as your baseline. On each poll, action is needed if:
-   - A new thread `id` appears that wasn't in the baseline (new thread), OR
-   - An existing thread's `last_comment_databaseId` has changed (new reply on existing thread)
-
-   **Conversation comments:**
-   ```bash
-   gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments --paginate
-   ```
-   Compare total count and newest `id` against baseline. Filter to non-empty, non-bot, non-author-update messages.
-
-   **Top-level reviews:**
-   ```bash
-   gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews --paginate
-   ```
-   Watch for new non-empty reviews (`CHANGES_REQUESTED` or `COMMENTED` with body). Compare total count and newest `id` against baseline.
-
-4. **React in this precedence order (first match wins):**
-
-| What happened | Action |
-|---|---|
-| Merge conflict detected | See "Resolving merge conflicts" below. |
-| Mergeability is `UNKNOWN` | GitHub is still computing mergeability. Sleep 30 seconds, then restart polling from the top. |
-| New comments detected | Address them (fix → commit → push → reply). After pushing, re-fetch all comments to update your baseline, then restart this polling loop from the top (new commits invalidate CI status). |
-| CI failed (bucket == "fail") | Get failed check links: `gh pr checks {N} --repo Significant-Gravitas/AutoGPT --json bucket,link --jq '.[] \| select(.bucket == "fail") \| .link'`. Extract run ID from link (format: `.../actions/runs/<run-id>/job/...`), read logs with `gh run view <run-id> --repo Significant-Gravitas/AutoGPT --log-failed`. Fix → commit → push → restart polling. |
-| CI green + no new comments | **Do not exit immediately.** Bots (coderabbitai, sentry) often post reviews shortly after CI settles. Continue polling for **2 more cycles (60s)** after CI goes green. Only exit after 2 consecutive green+quiet polls. |
-| CI pending + no new comments | Sleep 30 seconds, then poll again. |
-
-**The loop ends when:** CI fully green + all comments addressed + **2 consecutive polls with no new comments after CI settled.**
-
-### Resolving merge conflicts
-
-1. Identify the PR's target branch and remote:
-```bash
-gh pr view {N} --repo Significant-Gravitas/AutoGPT --json baseRefName --jq '.baseRefName'
-git remote -v   # find the remote pointing to Significant-Gravitas/AutoGPT (typically 'upstream' in forks, 'origin' for direct contributors)
-```
-
-2. Pull the latest base branch with a 3-way merge:
-```bash
-git pull {base-remote} {base-branch} --no-rebase
-```
-
-3. Resolve conflicting files, then verify no conflict markers remain:
-```bash
-if grep -R -n -E '^(<<<<<<<|=======|>>>>>>>)' <conflicted-files>; then
-  echo "Unresolved conflict markers found — resolve before proceeding."
-  exit 1
-fi
-```
-
-4. Stage and push:
-```bash
-git add <conflicted-files>
-git commit -m "Resolve merge conflicts with {base-branch}"
-git push
-```
-
-5. Restart the polling loop from the top — new commits reset CI status.

.claude/skills/pr-review/SKILL.md

@@ -1,86 +0,0 @@
----
-name: pr-review
-description: Review a PR for correctness, security, code quality, and testing issues. TRIGGER when user asks to review a PR, check PR quality, or give feedback on a PR.
-user-invocable: true
-args: "[PR number or URL] — if omitted, finds PR for current branch."
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
----
-
-# PR Review
-
-## Find the PR
-
-```bash
-gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT
-gh pr view {N}
-```
-
-## Read the PR description
-
-Before reading code, understand the **why**, **what**, and **how** from the PR description:
-
-```bash
-gh pr view {N} --json body --jq '.body'
-```
-
-Every PR should have a Why / What / How structure. If any of these are missing, note it as feedback.
-
-## Read the diff
-
-```bash
-gh pr diff {N}
-```
-
-## Fetch existing review comments
-
-Before posting anything, fetch existing inline comments to avoid duplicates:
-
-```bash
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments --paginate
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews
-```
-
-## What to check
-
-**Description quality:** Does the PR description cover Why (motivation/problem), What (summary of changes), and How (approach/implementation details)? If any are missing, request them — you can't judge the approach without understanding the problem and intent.
-
-**Correctness:** logic errors, off-by-one, missing edge cases, race conditions (TOCTOU in file access, credit charging), error handling gaps, async correctness (missing `await`, unclosed resources).
-
-**Security:** input validation at boundaries, no injection (command, XSS, SQL), secrets not logged, file paths sanitized (`os.path.basename()` in error messages).
-
-**Code quality:** apply rules from backend/frontend CLAUDE.md files.
-
-**Architecture:** DRY, single responsibility, modular functions. `Security()` vs `Depends()` for FastAPI auth. `data:` for SSE events, `: comment` for heartbeats. `transaction=True` for Redis pipelines.
-
-**Testing:** edge cases covered, colocated `*_test.py` (backend) / `__tests__/` (frontend), mocks target where symbol is **used** not defined, `AsyncMock` for async.
-
-## Output format
-
-Every comment **must** be prefixed with `🤖` and a criticality badge:
-
-| Tier | Badge | Meaning |
-|---|---|---|
-| Blocker | `🔴 **Blocker**` | Must fix before merge |
-| Should Fix | `🟠 **Should Fix**` | Important improvement |
-| Nice to Have | `🟡 **Nice to Have**` | Minor suggestion |
-| Nit | `🔵 **Nit**` | Style / wording |
-
-Example: `🤖 🔴 **Blocker**: Missing error handling for X — suggest wrapping in try/except.`
-
-## Post inline comments
-
-For each finding, post an inline comment on the PR (do not just write a local report):
-
-```bash
-# Get the latest commit SHA for the PR
-COMMIT_SHA=$(gh api repos/Significant-Gravitas/AutoGPT/pulls/{N} --jq '.head.sha')
-
-# Post an inline comment on a specific file/line
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments \
-  -f body="🤖 🔴 **Blocker**: <description>" \
-  -f commit_id="$COMMIT_SHA" \
-  -f path="<file path>" \
-  -F line=<line number>
-```

.claude/skills/pr-test/SKILL.md

@@ -1,874 +0,0 @@
----
-name: pr-test
-description: "E2E manual testing of PRs/branches using docker compose, agent-browser, and API calls. TRIGGER when user asks to manually test a PR, test a feature end-to-end, or run integration tests against a running system."
-user-invocable: true
-argument-hint: "[worktree path or PR number] — tests the PR in the given worktree. Optional flags: --fix (auto-fix issues found)"
-metadata:
-  author: autogpt-team
-  version: "2.0.0"
----
-
-# Manual E2E Test
-
-Test a PR/branch end-to-end by building the full platform, interacting via browser and API, capturing screenshots, and reporting results.
-
-## Critical Requirements
-
-These are NON-NEGOTIABLE. Every test run MUST satisfy ALL the following:
-
-### 1. Screenshots at Every Step
-- Take a screenshot at EVERY significant test step — not just at the end
-- Every test scenario MUST have at least one BEFORE and one AFTER screenshot
-- Name screenshots sequentially: `{NN}-{action}-{state}.png` (e.g., `01-credits-before.png`, `02-credits-after.png`)
-- If a screenshot is missing for a scenario, the test is INCOMPLETE — go back and take it
-
-### 2. Screenshots MUST Be Posted to PR
-- Push ALL screenshots to a temp branch `test-screenshots/pr-{N}`
-- Post a PR comment with ALL screenshots embedded inline using GitHub raw URLs
-- This is NOT optional — every test run MUST end with a PR comment containing screenshots
-- If screenshot upload fails, retry. If it still fails, list failed files and require manual drag-and-drop/paste attachment in the PR comment
-
-### 3. State Verification with Before/After Evidence
-- For EVERY state-changing operation (API call, user action), capture the state BEFORE and AFTER
-- Log the actual API response values (e.g., `credits_before=100, credits_after=95`)
-- Screenshot MUST show the relevant UI state change
-- Compare expected vs actual values explicitly — do not just eyeball it
-
-### 4. Negative Test Cases Are Mandatory
-- Test at least ONE negative case per feature (e.g., insufficient credits, invalid input, unauthorized access)
-- Verify error messages are user-friendly and accurate
-- Verify the system state did NOT change after a rejected operation
-
-### 5. Test Report Must Include Full Evidence
-Each test scenario in the report MUST have:
-- **Steps**: What was done (exact commands or UI actions)
-- **Expected**: What should happen
-- **Actual**: What actually happened
-- **API Evidence**: Before/after API response values for state-changing operations
-- **Screenshot Evidence**: Before/after screenshots with explanations
-
-## State Manipulation for Realistic Testing
-
-When testing features that depend on specific states (rate limits, credits, quotas):
-
-1. **Use Redis CLI to set counters directly:**
-   ```bash
-   # Find the Redis container
-   REDIS_CONTAINER=$(docker ps --format '{{.Names}}' | grep redis | head -1)
-   # Set a key with expiry
-   docker exec $REDIS_CONTAINER redis-cli SET key value EX ttl
-   # Example: Set rate limit counter to near-limit
-   docker exec $REDIS_CONTAINER redis-cli SET "rate_limit:user:test@test.com" 99 EX 3600
-   # Example: Check current value
-   docker exec $REDIS_CONTAINER redis-cli GET "rate_limit:user:test@test.com"
-   ```
-
-2. **Use API calls to check before/after state:**
-   ```bash
-   # BEFORE: Record current state
-   BEFORE=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/credits | jq '.credits')
-   echo "Credits BEFORE: $BEFORE"
-
-   # Perform the action...
-
-   # AFTER: Record new state and compare
-   AFTER=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/credits | jq '.credits')
-   echo "Credits AFTER: $AFTER"
-   echo "Delta: $(( BEFORE - AFTER ))"
-   ```
-
-3. **Take screenshots BEFORE and AFTER state changes** — the UI must reflect the backend state change
-
-4. **Never rely on mocked/injected browser state** — always use real backend state. Do NOT use `agent-browser eval` to fake UI state. The backend must be the source of truth.
-
-5. **Use direct DB queries when needed:**
-   ```bash
-   # Query via Supabase's PostgREST or docker exec into the DB
-   docker exec supabase-db psql -U supabase_admin -d postgres -c "SELECT credits FROM user_credits WHERE user_id = '...';"
-   ```
-
-6. **After every API test, verify the state change actually persisted:**
-   ```bash
-   # Example: After a credits purchase, verify DB matches API
-   API_CREDITS=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/credits | jq '.credits')
-   DB_CREDITS=$(docker exec supabase-db psql -U supabase_admin -d postgres -t -c "SELECT credits FROM user_credits WHERE user_id = '...';" | tr -d ' ')
-   [ "$API_CREDITS" = "$DB_CREDITS" ] && echo "CONSISTENT" || echo "MISMATCH: API=$API_CREDITS DB=$DB_CREDITS"
-   ```
-
-## Arguments
-
-- `$ARGUMENTS` — worktree path (e.g. `$REPO_ROOT`) or PR number
-- If `--fix` flag is present, auto-fix bugs found and push fixes (like pr-address loop)
-
-## Step 0: Resolve the target
-
-```bash
-# If argument is a PR number, find its worktree
-gh pr view {N} --json headRefName --jq '.headRefName'
-# If argument is a path, use it directly
-```
-
-Determine:
-- `REPO_ROOT` — the root repo directory: `git -C "$WORKTREE_PATH" worktree list | head -1 | awk '{print $1}'` (or `git rev-parse --show-toplevel` if not a worktree)
-- `WORKTREE_PATH` — the worktree directory
-- `PLATFORM_DIR` — `$WORKTREE_PATH/autogpt_platform`
-- `BACKEND_DIR` — `$PLATFORM_DIR/backend`
-- `FRONTEND_DIR` — `$PLATFORM_DIR/frontend`
-- `PR_NUMBER` — the PR number (from `gh pr list --head $(git branch --show-current)`)
-- `PR_TITLE` — the PR title, slugified (e.g. "Add copilot permissions" → "add-copilot-permissions")
-- `RESULTS_DIR` — `$REPO_ROOT/test-results/PR-{PR_NUMBER}-{slugified-title}`
-
-Create the results directory:
-```bash
-PR_NUMBER=$(cd $WORKTREE_PATH && gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT --json number --jq '.[0].number')
-PR_TITLE=$(cd $WORKTREE_PATH && gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT --json title --jq '.[0].title' | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//' | head -c 50)
-RESULTS_DIR="$REPO_ROOT/test-results/PR-${PR_NUMBER}-${PR_TITLE}"
-mkdir -p $RESULTS_DIR
-```
-
-**Test user credentials** (for logging into the UI or verifying results manually):
-- Email: `test@test.com`
-- Password: `testtest123`
-
-## Step 1: Understand the PR
-
-Before testing, understand what changed:
-
-```bash
-cd $WORKTREE_PATH
-
-# Read PR description to understand the WHY
-gh pr view {N} --json body --jq '.body'
-
-git log --oneline dev..HEAD | head -20
-git diff dev --stat
-```
-
-Read the PR description (Why / What / How) and changed files to understand:
-0. **Why** does this PR exist? What problem does it solve?
-1. **What** feature/fix does this PR implement?
-2. **How** does it work? What's the approach?
-3. What components are affected? (backend, frontend, copilot, executor, etc.)
-4. What are the key user-facing behaviors to test?
-
-## Step 2: Write test scenarios
-
-Based on the PR analysis, write a test plan to `$RESULTS_DIR/test-plan.md`:
-
-```markdown
-# Test Plan: PR #{N} — {title}
-
-## Scenarios
-1. [Scenario name] — [what to verify]
-2. ...
-
-## API Tests (if applicable)
-1. [Endpoint] — [expected behavior]
-   - Before state: [what to check before]
-   - After state: [what to verify changed]
-
-## UI Tests (if applicable)
-1. [Page/component] — [interaction to test]
-   - Screenshot before: [what to capture]
-   - Screenshot after: [what to capture]
-
-## Negative Tests (REQUIRED — at least one per feature)
-1. [What should NOT happen] — [how to trigger it]
-   - Expected error: [what error message/code]
-   - State unchanged: [what to verify did NOT change]
-```
-
-**Be critical** — include edge cases, error paths, and security checks. Every scenario MUST specify what screenshots to take and what state to verify.
-
-## Step 3: Environment setup
-
-### 3a. Copy .env files from the root worktree
-
-The root worktree (`$REPO_ROOT`) has the canonical `.env` files with all API keys. Copy them to the target worktree:
-
-```bash
-# CRITICAL: .env files are NOT checked into git. They must be copied manually.
-cp $REPO_ROOT/autogpt_platform/.env $PLATFORM_DIR/.env
-cp $REPO_ROOT/autogpt_platform/backend/.env $BACKEND_DIR/.env
-cp $REPO_ROOT/autogpt_platform/frontend/.env $FRONTEND_DIR/.env
-```
-
-### 3b. Configure copilot authentication
-
-The copilot needs an LLM API to function. Two approaches (try subscription first):
-
-#### Option 1: Subscription mode (preferred — uses your Claude Max/Pro subscription)
-
-The `claude_agent_sdk` Python package **bundles its own Claude CLI binary** — no need to install `@anthropic-ai/claude-code` via npm. The backend auto-provisions credentials from environment variables on startup.
-
-Run the helper script to extract tokens from your host and auto-update `backend/.env` (works on macOS, Linux, and Windows/WSL):
-
-```bash
-# Extracts OAuth tokens and writes CLAUDE_CODE_OAUTH_TOKEN + CLAUDE_CODE_REFRESH_TOKEN into .env
-bash $BACKEND_DIR/scripts/refresh_claude_token.sh --env-file $BACKEND_DIR/.env
-```
-
-**How it works:** The script reads the OAuth token from:
-- **macOS**: system keychain (`"Claude Code-credentials"`)
-- **Linux/WSL**: `~/.claude/.credentials.json`
-- **Windows**: `%APPDATA%/claude/.credentials.json`
-
-It sets `CLAUDE_CODE_OAUTH_TOKEN`, `CLAUDE_CODE_REFRESH_TOKEN`, and `CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=true` in the `.env` file. On container startup, the backend auto-provisions `~/.claude/.credentials.json` inside the container from these env vars. The SDK's bundled CLI then authenticates using that file. No `claude login`, no npm install needed.
-
-**Note:** The OAuth token expires (~24h). If copilot returns auth errors, re-run the script and restart: `$BACKEND_DIR/scripts/refresh_claude_token.sh --env-file $BACKEND_DIR/.env && docker compose up -d copilot_executor`
-
-#### Option 2: OpenRouter API key mode (fallback)
-
-If subscription mode doesn't work, switch to API key mode using OpenRouter:
-
-```bash
-# In $BACKEND_DIR/.env, ensure these are set:
-CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=false
-CHAT_API_KEY=<value of OPEN_ROUTER_API_KEY from the same .env>
-CHAT_BASE_URL=https://openrouter.ai/api/v1
-CHAT_USE_CLAUDE_AGENT_SDK=true
-```
-
-Use `sed` to update these values:
-```bash
-ORKEY=$(grep "^OPEN_ROUTER_API_KEY=" $BACKEND_DIR/.env | cut -d= -f2)
-[ -n "$ORKEY" ] || { echo "ERROR: OPEN_ROUTER_API_KEY is missing in $BACKEND_DIR/.env"; exit 1; }
-perl -i -pe 's/CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=true/CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=false/' $BACKEND_DIR/.env
-# Add or update CHAT_API_KEY and CHAT_BASE_URL
-grep -q "^CHAT_API_KEY=" $BACKEND_DIR/.env && perl -i -pe "s|^CHAT_API_KEY=.*|CHAT_API_KEY=$ORKEY|" $BACKEND_DIR/.env || echo "CHAT_API_KEY=$ORKEY" >> $BACKEND_DIR/.env
-grep -q "^CHAT_BASE_URL=" $BACKEND_DIR/.env && perl -i -pe 's|^CHAT_BASE_URL=.*|CHAT_BASE_URL=https://openrouter.ai/api/v1|' $BACKEND_DIR/.env || echo "CHAT_BASE_URL=https://openrouter.ai/api/v1" >> $BACKEND_DIR/.env
-```
-
-### 3c. Stop conflicting containers
-
-```bash
-# Stop any running app containers (keep infra: supabase, redis, rabbitmq, clamav)
-docker ps --format "{{.Names}}" | grep -E "rest_server|executor|copilot|websocket|database_manager|scheduler|notification|frontend|migrate" | while read name; do
-  docker stop "$name" 2>/dev/null
-done
-```
-
-### 3e. Build and start
-
-```bash
-cd $PLATFORM_DIR && docker compose build --no-cache 2>&1 | tail -20
-if [ ${PIPESTATUS[0]} -ne 0 ]; then echo "ERROR: Docker build failed"; exit 1; fi
-
-cd $PLATFORM_DIR && docker compose up -d 2>&1 | tail -20
-if [ ${PIPESTATUS[0]} -ne 0 ]; then echo "ERROR: Docker compose up failed"; exit 1; fi
-```
-
-**Note:** If the container appears to be running old code (e.g. missing PR changes), use `docker compose build --no-cache` to force a full rebuild. Docker BuildKit may sometimes reuse cached `COPY` layers from a previous build on a different branch.
-
-**Expected time: 3-8 minutes** for build, 5-10 minutes with `--no-cache`.
-
-### 3f. Wait for services to be ready
-
-```bash
-# Poll until backend and frontend respond
-for i in $(seq 1 60); do
-  BACKEND=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:8006/docs 2>/dev/null)
-  FRONTEND=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:3000 2>/dev/null)
-  if [ "$BACKEND" = "200" ] && [ "$FRONTEND" = "200" ]; then
-    echo "Services ready"
-    break
-  fi
-  sleep 5
-done
-```
-
-
-### 3h. Create test user and get auth token
-
-```bash
-ANON_KEY=$(grep "NEXT_PUBLIC_SUPABASE_ANON_KEY=" $FRONTEND_DIR/.env | sed 's/.*NEXT_PUBLIC_SUPABASE_ANON_KEY=//' | tr -d '[:space:]')
-
-# Signup (idempotent — returns "User already registered" if exists)
-RESULT=$(curl -s -X POST 'http://localhost:8000/auth/v1/signup' \
-  -H "apikey: $ANON_KEY" \
-  -H 'Content-Type: application/json' \
-  -d '{"email":"test@test.com","password":"testtest123"}')
-
-# If "Database error finding user", restart supabase-auth and retry
-if echo "$RESULT" | grep -q "Database error"; then
-  docker restart supabase-auth && sleep 5
-  curl -s -X POST 'http://localhost:8000/auth/v1/signup' \
-    -H "apikey: $ANON_KEY" \
-    -H 'Content-Type: application/json' \
-    -d '{"email":"test@test.com","password":"testtest123"}'
-fi
-
-# Get auth token
-TOKEN=$(curl -s -X POST 'http://localhost:8000/auth/v1/token?grant_type=password' \
-  -H "apikey: $ANON_KEY" \
-  -H 'Content-Type: application/json' \
-  -d '{"email":"test@test.com","password":"testtest123"}' | jq -r '.access_token // ""')
-```
-
-**Use this token for ALL API calls:**
-```bash
-curl -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/...
-```
-
-## Step 4: Run tests
-
-### Service ports reference
-
-| Service | Port | URL |
-|---------|------|-----|
-| Frontend | 3000 | http://localhost:3000 |
-| Backend REST | 8006 | http://localhost:8006 |
-| Supabase Auth (via Kong) | 8000 | http://localhost:8000 |
-| Executor | 8002 | http://localhost:8002 |
-| Copilot Executor | 8008 | http://localhost:8008 |
-| WebSocket | 8001 | http://localhost:8001 |
-| Database Manager | 8005 | http://localhost:8005 |
-| Redis | 6379 | localhost:6379 |
-| RabbitMQ | 5672 | localhost:5672 |
-
-### API testing
-
-Use `curl` with the auth token for backend API tests. **For EVERY API call that changes state, record before/after values:**
-
-```bash
-# Example: List agents
-curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/graphs | jq . | head -20
-
-# Example: Create an agent
-curl -s -X POST http://localhost:8006/api/graphs \
-  -H "Authorization: Bearer $TOKEN" \
-  -H 'Content-Type: application/json' \
-  -d '{...}' | jq .
-
-# Example: Run an agent
-curl -s -X POST "http://localhost:8006/api/graphs/{graph_id}/execute" \
-  -H "Authorization: Bearer $TOKEN" \
-  -H 'Content-Type: application/json' \
-  -d '{"data": {...}}'
-
-# Example: Get execution results
-curl -s -H "Authorization: Bearer $TOKEN" \
-  "http://localhost:8006/api/graphs/{graph_id}/executions/{exec_id}" | jq .
-```
-
-**State verification pattern (use for EVERY state-changing API call):**
-```bash
-# 1. Record BEFORE state
-BEFORE_STATE=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/{resource} | jq '{relevant_fields}')
-echo "BEFORE: $BEFORE_STATE"
-
-# 2. Perform the action
-ACTION_RESULT=$(curl -s -X POST ... | jq .)
-echo "ACTION RESULT: $ACTION_RESULT"
-
-# 3. Record AFTER state
-AFTER_STATE=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/{resource} | jq '{relevant_fields}')
-echo "AFTER: $AFTER_STATE"
-
-# 4. Log the comparison
-echo "=== STATE CHANGE VERIFICATION ==="
-echo "Before: $BEFORE_STATE"
-echo "After: $AFTER_STATE"
-echo "Expected change: {describe what should have changed}"
-```
-
-### Browser testing with agent-browser
-
-```bash
-# Close any existing session
-agent-browser close 2>/dev/null || true
-
-# Use --session-name to persist cookies across navigations
-# This means login only needs to happen once per test session
-agent-browser --session-name pr-test open 'http://localhost:3000/login' --timeout 15000
-
-# Get interactive elements
-agent-browser --session-name pr-test snapshot | grep "textbox\|button"
-
-# Login
-agent-browser --session-name pr-test fill {email_ref} "test@test.com"
-agent-browser --session-name pr-test fill {password_ref} "testtest123"
-agent-browser --session-name pr-test click {login_button_ref}
-sleep 5
-
-# Dismiss cookie banner if present
-agent-browser --session-name pr-test click 'text=Accept All' 2>/dev/null || true
-
-# Navigate — cookies are preserved so login persists
-agent-browser --session-name pr-test open 'http://localhost:3000/copilot' --timeout 10000
-
-# Take screenshot
-agent-browser --session-name pr-test screenshot $RESULTS_DIR/01-page.png
-
-# Interact with elements
-agent-browser --session-name pr-test fill {ref} "text"
-agent-browser --session-name pr-test press "Enter"
-agent-browser --session-name pr-test click {ref}
-agent-browser --session-name pr-test click 'text=Button Text'
-
-# Read page content
-agent-browser --session-name pr-test snapshot | grep "text:"
-```
-
-**Key pages:**
-- `/copilot` — CoPilot chat (for testing copilot features)
-- `/build` — Agent builder (for testing block/node features)
-- `/build?flowID={id}` — Specific agent in builder
-- `/library` — Agent library (for testing listing/import features)
-- `/library/agents/{id}` — Agent detail with run history
-- `/marketplace` — Marketplace
-
-### Checking logs
-
-```bash
-# Backend REST server
-docker logs autogpt_platform-rest_server-1 2>&1 | tail -30
-
-# Executor (runs agent graphs)
-docker logs autogpt_platform-executor-1 2>&1 | tail -30
-
-# Copilot executor (runs copilot chat sessions)
-docker logs autogpt_platform-copilot_executor-1 2>&1 | tail -30
-
-# Frontend
-docker logs autogpt_platform-frontend-1 2>&1 | tail -30
-
-# Filter for errors
-docker logs autogpt_platform-executor-1 2>&1 | grep -i "error\|exception\|traceback" | tail -20
-```
-
-### Copilot chat testing
-
-The copilot uses SSE streaming. To test via API:
-
-```bash
-# Create a session
-SESSION_ID=$(curl -s -X POST 'http://localhost:8006/api/chat/sessions' \
-  -H "Authorization: Bearer $TOKEN" \
-  -H 'Content-Type: application/json' \
-  -d '{}' | jq -r '.id // .session_id // ""')
-
-# Stream a message (SSE - will stream chunks)
-curl -N -X POST "http://localhost:8006/api/chat/sessions/$SESSION_ID/stream" \
-  -H "Authorization: Bearer $TOKEN" \
-  -H 'Content-Type: application/json' \
-  -d '{"message": "Hello, what can you help me with?"}' \
-  --max-time 60 2>/dev/null | head -50
-```
-
-Or test via browser (preferred for UI verification):
-```bash
-agent-browser --session-name pr-test open 'http://localhost:3000/copilot' --timeout 10000
-# ... fill chat input and press Enter, wait 20-30s for response
-```
-
-## Step 5: Record results and take screenshots
-
-**Take a screenshot at EVERY significant test step** — before and after interactions, on success, and on failure. This is NON-NEGOTIABLE.
-
-**Required screenshot pattern for each test scenario:**
-```bash
-# BEFORE the action
-agent-browser --session-name pr-test screenshot $RESULTS_DIR/{NN}-{scenario}-before.png
-
-# Perform the action...
-
-# AFTER the action
-agent-browser --session-name pr-test screenshot $RESULTS_DIR/{NN}-{scenario}-after.png
-```
-
-**Naming convention:**
-```bash
-# Examples:
-# $RESULTS_DIR/01-login-page-before.png
-# $RESULTS_DIR/02-login-page-after.png
-# $RESULTS_DIR/03-credits-page-before.png
-# $RESULTS_DIR/04-credits-purchase-after.png
-# $RESULTS_DIR/05-negative-insufficient-credits.png
-# $RESULTS_DIR/06-error-state.png
-```
-
-**Minimum requirements:**
-- At least TWO screenshots per test scenario (before + after)
-- At least ONE screenshot for each negative test case showing the error state
-- If a test fails, screenshot the failure state AND any error logs visible in the UI
-
-## Step 6: Show results to user with screenshots
-
-**CRITICAL: After all tests complete, you MUST show every screenshot to the user using the Read tool, with an explanation of what each screenshot shows.** This is the most important part of the test report — the user needs to visually verify the results.
-
-For each screenshot:
-1. Use the `Read` tool to display the PNG file (Claude can read images)
-2. Write a 1-2 sentence explanation below it describing:
-   - What page/state is being shown
-   - What the screenshot proves (which test scenario it validates)
-   - Any notable details visible in the UI
-
-Format the output like this:
-
-```markdown
-### Screenshot 1: {descriptive title}
-[Read the PNG file here]
-
-**What it shows:** {1-2 sentence explanation of what this screenshot proves}
-
----
-```
-
-After showing all screenshots, output a **detailed** summary table:
-
-| # | Scenario | Result | API Evidence | Screenshot Evidence |
-|---|----------|--------|-------------|-------------------|
-| 1 | {name} | PASS/FAIL | Before: X, After: Y | 01-before.png, 02-after.png |
-| 2 | ... | ... | ... | ... |
-
-**IMPORTANT:** As you show each screenshot and record test results, persist them in shell variables for Step 7:
-
-```bash
-# Build these variables during Step 6 — they are required by Step 7's script
-# NOTE: declare -A requires Bash 4.0+. This is standard on modern systems (macOS ships zsh
-# but Homebrew bash is 5.x; Linux typically has bash 5.x). If running on Bash <4, use a
-# plain variable with a lookup function instead.
-declare -A SCREENSHOT_EXPLANATIONS=(
-  ["01-login-page.png"]="Shows the login page loaded successfully with SSO options visible."
-  ["02-builder-with-block.png"]="The builder canvas displays the newly added block connected to the trigger."
-  # ... one entry per screenshot, using the same explanations you showed the user above
-)
-
-TEST_RESULTS_TABLE="| 1 | Login flow | PASS | N/A | 01-login-before.png, 02-login-after.png |
-| 2 | Credits purchase | PASS | Before: 100, After: 95 | 03-credits-before.png, 04-credits-after.png |
-| 3 | Insufficient credits (negative) | PASS | Credits: 0, rejected | 05-insufficient-credits-error.png |"
-# ... one row per test scenario with actual results
-```
-
-## Step 7: Post test report as PR comment with screenshots
-
-Upload screenshots to the PR using the GitHub Git API (no local git operations — safe for worktrees), then post a comment with inline images and per-screenshot explanations.
-
-**This step is MANDATORY. Every test run MUST post a PR comment with screenshots. No exceptions.**
-
-**CRITICAL — NEVER post a bare directory link like `https://github.com/.../tree/...`.** Every screenshot MUST appear as `![name](raw_url)` inline in the PR comment so reviewers can see them without clicking any links. After posting, the verification step below greps the comment for `![` tags and exits 1 if none are found — the test run is considered incomplete until this passes.
-
-```bash
-# Upload screenshots via GitHub Git API (creates blobs, tree, commit, and ref remotely)
-REPO="Significant-Gravitas/AutoGPT"
-SCREENSHOTS_BRANCH="test-screenshots/pr-${PR_NUMBER}"
-SCREENSHOTS_DIR="test-screenshots/PR-${PR_NUMBER}"
-
-# Step 1: Create blobs for each screenshot and build tree JSON
-# Retry each blob upload up to 3 times. If still failing, list them at end of report.
-shopt -s nullglob
-SCREENSHOT_FILES=("$RESULTS_DIR"/*.png)
-if [ ${#SCREENSHOT_FILES[@]} -eq 0 ]; then
-  echo "ERROR: No screenshots found in $RESULTS_DIR. Test run is incomplete."
-  exit 1
-fi
-TREE_JSON='['
-FIRST=true
-FAILED_UPLOADS=()
-for img in "${SCREENSHOT_FILES[@]}"; do
-  BASENAME=$(basename "$img")
-  B64=$(base64 < "$img")
-  BLOB_SHA=""
-  for attempt in 1 2 3; do
-    BLOB_SHA=$(gh api "repos/${REPO}/git/blobs" -f content="$B64" -f encoding="base64" --jq '.sha' 2>/dev/null || true)
-    [ -n "$BLOB_SHA" ] && break
-    sleep 1
-  done
-  if [ -z "$BLOB_SHA" ]; then
-    FAILED_UPLOADS+=("$img")
-    continue
-  fi
-  if [ "$FIRST" = true ]; then FIRST=false; else TREE_JSON+=','; fi
-  TREE_JSON+="{\"path\":\"${SCREENSHOTS_DIR}/${BASENAME}\",\"mode\":\"100644\",\"type\":\"blob\",\"sha\":\"${BLOB_SHA}\"}"
-done
-TREE_JSON+=']'
-
-# Step 2: Create tree, commit, and branch ref
-TREE_SHA=$(echo "$TREE_JSON" | jq -c '{tree: .}' | gh api "repos/${REPO}/git/trees" --input - --jq '.sha')
-
-# Resolve parent commit so screenshots are chained, not orphan root commits
-PARENT_SHA=$(gh api "repos/${REPO}/git/refs/heads/${SCREENSHOTS_BRANCH}" --jq '.object.sha' 2>/dev/null || echo "")
-if [ -n "$PARENT_SHA" ]; then
-  COMMIT_SHA=$(gh api "repos/${REPO}/git/commits" \
-    -f message="test: add E2E test screenshots for PR #${PR_NUMBER}" \
-    -f tree="$TREE_SHA" \
-    -f "parents[]=$PARENT_SHA" \
-    --jq '.sha')
-else
-  COMMIT_SHA=$(gh api "repos/${REPO}/git/commits" \
-    -f message="test: add E2E test screenshots for PR #${PR_NUMBER}" \
-    -f tree="$TREE_SHA" \
-    --jq '.sha')
-fi
-
-gh api "repos/${REPO}/git/refs" \
-  -f ref="refs/heads/${SCREENSHOTS_BRANCH}" \
-  -f sha="$COMMIT_SHA" 2>/dev/null \
-  || gh api "repos/${REPO}/git/refs/heads/${SCREENSHOTS_BRANCH}" \
-    -X PATCH -f sha="$COMMIT_SHA" -F force=true
-```
-
-Then post the comment with **inline images AND explanations for each screenshot**:
-
-```bash
-REPO_URL="https://raw.githubusercontent.com/${REPO}/${SCREENSHOTS_BRANCH}"
-
-# Build image markdown using uploaded image URLs; skip FAILED_UPLOADS (listed separately)
-
-IMAGE_MARKDOWN=""
-for img in "${SCREENSHOT_FILES[@]}"; do
-  BASENAME=$(basename "$img")
-  TITLE=$(echo "${BASENAME%.png}" | sed 's/^[0-9]*-//' | sed 's/-/ /g' | awk '{for(i=1;i<=NF;i++) $i=toupper(substr($i,1,1)) tolower(substr($i,2))}1')
-  # Skip images that failed to upload — they will be listed at the end
-  IS_FAILED=false
-  for failed in "${FAILED_UPLOADS[@]}"; do
-    [ "$(basename "$failed")" = "$BASENAME" ] && IS_FAILED=true && break
-  done
-  if [ "$IS_FAILED" = true ]; then
-    continue
-  fi
-  EXPLANATION="${SCREENSHOT_EXPLANATIONS[$BASENAME]}"
-  if [ -z "$EXPLANATION" ]; then
-    echo "ERROR: Missing screenshot explanation for $BASENAME. Add it to SCREENSHOT_EXPLANATIONS in Step 6."
-    exit 1
-  fi
-  IMAGE_MARKDOWN="${IMAGE_MARKDOWN}
-### ${TITLE}
-![${BASENAME}](${REPO_URL}/${SCREENSHOTS_DIR}/${BASENAME})
-${EXPLANATION}
-"
-done
-
-# Write comment body to file to avoid shell interpretation issues with special characters
-COMMENT_FILE=$(mktemp)
-# If any uploads failed, append a section listing them with instructions
-FAILED_SECTION=""
-if [ ${#FAILED_UPLOADS[@]} -gt 0 ]; then
-  FAILED_SECTION="
-## ⚠️ Failed Screenshot Uploads
-The following screenshots could not be uploaded via the GitHub API after 3 retries.
-**To add them:** drag-and-drop or paste these files into a PR comment manually:
-"
-  for failed in "${FAILED_UPLOADS[@]}"; do
-    FAILED_SECTION="${FAILED_SECTION}
-- \`$(basename "$failed")\` (local path: \`$failed\`)"
-  done
-  FAILED_SECTION="${FAILED_SECTION}
-
-**Run status:** INCOMPLETE until the files above are manually attached and visible inline in the PR."
-fi
-
-cat > "$COMMENT_FILE" <<INNEREOF
-## E2E Test Report
-
-| # | Scenario | Result | API Evidence | Screenshot Evidence |
-|---|----------|--------|-------------|-------------------|
-${TEST_RESULTS_TABLE}
-
-${IMAGE_MARKDOWN}
-${FAILED_SECTION}
-INNEREOF
-
-gh api "repos/${REPO}/issues/$PR_NUMBER/comments" -F body=@"$COMMENT_FILE"
-rm -f "$COMMENT_FILE"
-
-# Verify the posted comment contains inline images — exit 1 if none found
-# Use separate --paginate + jq pipe: --jq applies per-page, not to the full list
-LAST_COMMENT=$(gh api "repos/${REPO}/issues/$PR_NUMBER/comments" --paginate 2>/dev/null | jq -r '.[-1].body // ""')
-if ! echo "$LAST_COMMENT" | grep -q '!\['; then
-  echo "ERROR: Posted comment contains no inline images (![). Bare directory links are not acceptable." >&2
-  exit 1
-fi
-echo "✓ Inline images verified in posted comment"
-```
-
-**The PR comment MUST include:**
-1. A summary table of all scenarios with PASS/FAIL and before/after API evidence
-2. Every successfully uploaded screenshot rendered inline; any failed uploads listed with manual attachment instructions
-3. A 1-2 sentence explanation below each screenshot describing what it proves
-
-This approach uses the GitHub Git API to create blobs, trees, commits, and refs entirely server-side. No local `git checkout` or `git push` — safe for worktrees and won't interfere with the PR branch.
-
-## Step 8: Evaluate and post a formal PR review
-
-After the test comment is posted, evaluate whether the run was thorough enough to make a merge decision, then post a formal GitHub review (approve or request changes). **This step is mandatory — every test run MUST end with a formal review decision.**
-
-### Evaluation criteria
-
-Re-read the PR description:
-```bash
-gh pr view "$PR_NUMBER" --json body --jq '.body' --repo "$REPO"
-```
-
-Score the run against each criterion:
-
-| Criterion | Pass condition |
-|-----------|---------------|
-| **Coverage** | Every feature/change described in the PR has at least one test scenario |
-| **All scenarios pass** | No FAIL rows in the results table |
-| **Negative tests** | At least one failure-path test per feature (invalid input, unauthorized, edge case) |
-| **Before/after evidence** | Every state-changing API call has before/after values logged |
-| **Screenshots are meaningful** | Screenshots show the actual state change, not just a loading spinner or blank page |
-| **No regressions** | Existing core flows (login, agent create/run) still work |
-
-### Decision logic
-
-```
-ALL criteria pass                            → APPROVE
-Any scenario FAIL or missing PR feature      → REQUEST_CHANGES (list gaps)
-Evidence weak (no before/after, vague shots) → REQUEST_CHANGES (list what's missing)
-```
-
-### Post the review
-
-```bash
-REVIEW_FILE=$(mktemp)
-
-# Count results
-PASS_COUNT=$(echo "$TEST_RESULTS_TABLE" | grep -c "PASS" || true)
-FAIL_COUNT=$(echo "$TEST_RESULTS_TABLE" | grep -c "FAIL" || true)
-TOTAL=$(( PASS_COUNT + FAIL_COUNT ))
-
-# List any coverage gaps found during evaluation (populate this array as you assess)
-# e.g. COVERAGE_GAPS=("PR claims to add X but no test covers it")
-COVERAGE_GAPS=()
-```
-
-**If APPROVING** — all criteria met, zero failures, full coverage:
-
-```bash
-cat > "$REVIEW_FILE" <<REVIEWEOF
-## E2E Test Evaluation — APPROVED
-
-**Results:** ${PASS_COUNT}/${TOTAL} scenarios passed.
-
-**Coverage:** All features described in the PR were exercised.
-
-**Evidence:** Before/after API values logged for all state-changing operations; screenshots show meaningful state transitions.
-
-**Negative tests:** Failure paths tested for each feature.
-
-No regressions observed on core flows.
-REVIEWEOF
-
-gh pr review "$PR_NUMBER" --repo "$REPO" --approve --body "$(cat "$REVIEW_FILE")"
-echo "✅ PR approved"
-```
-
-**If REQUESTING CHANGES** — any failure, coverage gap, or missing evidence:
-
-```bash
-FAIL_LIST=$(echo "$TEST_RESULTS_TABLE" | grep "FAIL" | awk -F'|' '{print "- Scenario" $2 "failed"}' || true)
-
-cat > "$REVIEW_FILE" <<REVIEWEOF
-## E2E Test Evaluation — Changes Requested
-
-**Results:** ${PASS_COUNT}/${TOTAL} scenarios passed, ${FAIL_COUNT} failed.
-
-### Required before merge
-
-${FAIL_LIST}
-$(for gap in "${COVERAGE_GAPS[@]}"; do echo "- $gap"; done)
-
-Please fix the above and re-run the E2E tests.
-REVIEWEOF
-
-gh pr review "$PR_NUMBER" --repo "$REPO" --request-changes --body "$(cat "$REVIEW_FILE")"
-echo "❌ Changes requested"
-```
-
-```bash
-rm -f "$REVIEW_FILE"
-```
-
-**Rules:**
-- In `--fix` mode, fix all failures before posting the review — the review reflects the final state after fixes
-- Never approve if any scenario failed, even if it seems like a flake — rerun that scenario first
-- Never request changes for issues already fixed in this run
-
-## Fix mode (--fix flag)
-
-When `--fix` is present, the standard is HIGHER. Do not just note issues — FIX them immediately.
-
-### Fix protocol for EVERY issue found (including UX issues):
-
-1. **Identify** the root cause in the code — read the relevant source files
-2. **Write a failing test first** (TDD): For backend bugs, write a test marked with `pytest.mark.xfail(reason="...")`. For frontend/Playwright bugs, write a test with `.fixme` annotation. Run it to confirm it fails as expected.
-3. **Screenshot** the broken state: `agent-browser screenshot $RESULTS_DIR/{NN}-broken-{description}.png`
-4. **Fix** the code in the worktree
-5. **Rebuild** ONLY the affected service (not the whole stack):
-   ```bash
-   cd $PLATFORM_DIR && docker compose up --build -d {service_name}
-   # e.g., docker compose up --build -d rest_server
-   # e.g., docker compose up --build -d frontend
-   ```
-6. **Wait** for the service to be ready (poll health endpoint)
-7. **Re-test** the same scenario
-8. **Screenshot** the fixed state: `agent-browser screenshot $RESULTS_DIR/{NN}-fixed-{description}.png`
-9. **Remove the xfail/fixme marker** from the test written in step 2, and verify it passes
-10. **Verify** the fix did not break other scenarios (run a quick smoke test)
-11. **Commit and push** immediately:
-   ```bash
-   cd $WORKTREE_PATH
-   git add -A
-   git commit -m "fix: {description of fix}"
-   git push
-   ```
-12. **Continue** to the next test scenario
-
-### Fix loop (like pr-address)
-
-```text
-test scenario → find issue (bug OR UX problem) → screenshot broken state
-→ fix code → rebuild affected service only → re-test → screenshot fixed state
-→ verify no regressions → commit + push
-→ repeat for next scenario
-→ after ALL scenarios pass, run full re-test to verify everything together
-```
-
-**Key differences from non-fix mode:**
-- UX issues count as bugs — fix them (bad alignment, confusing labels, missing loading states)
-- Every fix MUST have a before/after screenshot pair proving it works
-- Commit after EACH fix, not in a batch at the end
-- The final re-test must produce a clean set of all-passing screenshots
-
-## Known issues and workarounds
-
-### Problem: "Database error finding user" on signup
-**Cause:** Supabase auth service schema cache is stale after migration.
-**Fix:** `docker restart supabase-auth && sleep 5` then retry signup.
-
-### Problem: Copilot returns auth errors in subscription mode
-**Cause:** `CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=true` but `CLAUDE_CODE_OAUTH_TOKEN` is not set or expired.
-**Fix:** Re-extract the OAuth token from macOS keychain (see step 3b, Option 1) and recreate the container (`docker compose up -d copilot_executor`). The backend auto-provisions `~/.claude/.credentials.json` from the env var on startup. No `npm install` or `claude login` needed — the SDK bundles its own CLI binary.
-
-### Problem: agent-browser can't find chromium
-**Cause:** The Dockerfile auto-provisions system chromium on all architectures (including ARM64). If your branch is behind `dev`, this may not be present yet.
-**Fix:** Check if chromium exists: `which chromium || which chromium-browser`. If missing, install it: `apt-get install -y chromium` and set `AGENT_BROWSER_EXECUTABLE_PATH=/usr/bin/chromium` in the container environment.
-
-### Problem: agent-browser selector matches multiple elements
-**Cause:** `text=X` matches all elements containing that text.
-**Fix:** Use `agent-browser snapshot` to get specific `ref=eNN` references, then use those: `agent-browser click eNN`.
-
-### Problem: Frontend shows cookie banner blocking interaction
-**Fix:** `agent-browser click 'text=Accept All'` before other interactions.
-
-### Problem: Container loses npm packages after rebuild
-**Cause:** `docker compose up --build` rebuilds the image, losing runtime installs.
-**Fix:** Add packages to the Dockerfile instead of installing at runtime.
-
-### Problem: Services not starting after `docker compose up`
-**Fix:** Wait and check health: `docker compose ps`. Common cause: migration hasn't finished. Check: `docker logs autogpt_platform-migrate-1 2>&1 | tail -5`. If supabase-db isn't healthy: `docker restart supabase-db && sleep 10`.
-
-### Problem: Docker uses cached layers with old code (PR changes not visible)
-**Cause:** `docker compose up --build` reuses cached `COPY` layers from previous builds. If the PR branch changes Python files but the previous build already cached that layer from `dev`, the container runs `dev` code.
-**Fix:** Always use `docker compose build --no-cache` for the first build of a PR branch. Subsequent rebuilds within the same branch can use `--build`.
-
-### Problem: `agent-browser open` loses login session
-**Cause:** Without session persistence, `agent-browser open` starts fresh.
-**Fix:** Use `--session-name pr-test` on ALL agent-browser commands. This auto-saves/restores cookies and localStorage across navigations. Alternatively, use `agent-browser eval "window.location.href = '...'"` to navigate within the same context.
-
-### Problem: Supabase auth returns "Database error querying schema"
-**Cause:** The database schema changed (migration ran) but supabase-auth has a stale schema cache.
-**Fix:** `docker restart supabase-db && sleep 10 && docker restart supabase-auth && sleep 8`. If user data was lost, re-signup.

.claude/skills/setup-repo/SKILL.md

@@ -1,195 +0,0 @@
----
-name: setup-repo
-description: Initialize a worktree-based repo layout for parallel development. Creates a main worktree, a reviews worktree for PR reviews, and N numbered work branches. Handles .env creation, dependency installation, and branchlet config. TRIGGER when user asks to set up the repo from scratch, initialize worktrees, bootstrap their dev environment, "setup repo", "setup worktrees", "initialize dev environment", "set up branches", or when a freshly cloned repo has no sibling worktrees.
-user-invocable: true
-args: "No arguments — interactive setup via prompts."
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
----
-
-# Repository Setup
-
-This skill sets up a worktree-based development layout from a freshly cloned repo. It creates:
-- A **main** worktree (the primary checkout)
-- A **reviews** worktree (for PR reviews)
-- **N work branches** (branch1..branchN) for parallel development
-
-## Step 1: Identify the repo
-
-Determine the repo root and parent directory:
-
-```bash
-ROOT=$(git rev-parse --show-toplevel)
-REPO_NAME=$(basename "$ROOT")
-PARENT=$(dirname "$ROOT")
-```
-
-Detect if the repo is already inside a worktree layout by counting sibling worktrees (not just checking the directory name, which could be anything):
-
-```bash
-# Count worktrees that are siblings (live under $PARENT but aren't $ROOT itself)
-SIBLING_COUNT=$(git worktree list --porcelain 2>/dev/null | grep "^worktree " | grep -c "$PARENT/" || true)
-if [ "$SIBLING_COUNT" -gt 1 ]; then
-  echo "INFO: Existing worktree layout detected at $PARENT ($SIBLING_COUNT worktrees)"
-  # Use $ROOT as-is; skip renaming/restructuring
-else
-  echo "INFO: Fresh clone detected, proceeding with setup"
-fi
-```
-
-## Step 2: Ask the user questions
-
-Use AskUserQuestion to gather setup preferences:
-
-1. **How many parallel work branches do you need?** (Options: 4, 8, 16, or custom)
-   - These become `branch1` through `branchN`
-2. **Which branch should be the base?** (Options: origin/master, origin/dev, or custom)
-   - All work branches and reviews will start from this
-
-## Step 3: Fetch and set up branches
-
-```bash
-cd "$ROOT"
-git fetch origin
-
-# Create the reviews branch from base (skip if already exists)
-if git show-ref --verify --quiet refs/heads/reviews; then
-  echo "INFO: Branch 'reviews' already exists, skipping"
-else
-  git branch reviews <base-branch>
-fi
-
-# Create numbered work branches from base (skip if already exists)
-for i in $(seq 1 "$COUNT"); do
-  if git show-ref --verify --quiet "refs/heads/branch$i"; then
-    echo "INFO: Branch 'branch$i' already exists, skipping"
-  else
-    git branch "branch$i" <base-branch>
-  fi
-done
-```
-
-## Step 4: Create worktrees
-
-Create worktrees as siblings to the main checkout:
-
-```bash
-if [ -d "$PARENT/reviews" ]; then
-  echo "INFO: Worktree '$PARENT/reviews' already exists, skipping"
-else
-  git worktree add "$PARENT/reviews" reviews
-fi
-
-for i in $(seq 1 "$COUNT"); do
-  if [ -d "$PARENT/branch$i" ]; then
-    echo "INFO: Worktree '$PARENT/branch$i' already exists, skipping"
-  else
-    git worktree add "$PARENT/branch$i" "branch$i"
-  fi
-done
-```
-
-## Step 5: Set up environment files
-
-**Do NOT assume .env files exist.** For each worktree (including main if needed):
-
-1. Check if `.env` exists in the source worktree for each path
-2. If `.env` exists, copy it
-3. If only `.env.default` or `.env.example` exists, copy that as `.env`
-4. If neither exists, warn the user and list which env files are missing
-
-Env file locations to check (same as the `/worktree` skill — keep these in sync):
-- `autogpt_platform/.env`
-- `autogpt_platform/backend/.env`
-- `autogpt_platform/frontend/.env`
-
-> **Note:** This env copying logic intentionally mirrors the `/worktree` skill's approach. If you update the path list or fallback logic here, update `/worktree` as well.
-
-```bash
-SOURCE="$ROOT"
-WORKTREES="reviews"
-for i in $(seq 1 "$COUNT"); do WORKTREES="$WORKTREES branch$i"; done
-
-FOUND_ANY_ENV=0
-for wt in $WORKTREES; do
-  TARGET="$PARENT/$wt"
-  for envpath in autogpt_platform autogpt_platform/backend autogpt_platform/frontend; do
-    if [ -f "$SOURCE/$envpath/.env" ]; then
-      FOUND_ANY_ENV=1
-      cp "$SOURCE/$envpath/.env" "$TARGET/$envpath/.env"
-    elif [ -f "$SOURCE/$envpath/.env.default" ]; then
-      FOUND_ANY_ENV=1
-      cp "$SOURCE/$envpath/.env.default" "$TARGET/$envpath/.env"
-      echo "NOTE: $wt/$envpath/.env was created from .env.default — you may need to edit it"
-    elif [ -f "$SOURCE/$envpath/.env.example" ]; then
-      FOUND_ANY_ENV=1
-      cp "$SOURCE/$envpath/.env.example" "$TARGET/$envpath/.env"
-      echo "NOTE: $wt/$envpath/.env was created from .env.example — you may need to edit it"
-    else
-      echo "WARNING: No .env, .env.default, or .env.example found at $SOURCE/$envpath/"
-    fi
-  done
-done
-
-if [ "$FOUND_ANY_ENV" -eq 0 ]; then
-  echo "WARNING: No environment files or templates were found in the source worktree."
-  # Use AskUserQuestion to confirm: "Continue setup without env files?"
-  # If the user declines, stop here and let them set up .env files first.
-fi
-```
-
-## Step 6: Copy branchlet config
-
-Copy `.branchlet.json` from main to each worktree so branchlet can manage sub-worktrees:
-
-```bash
-if [ -f "$ROOT/.branchlet.json" ]; then
-  for wt in $WORKTREES; do
-    cp "$ROOT/.branchlet.json" "$PARENT/$wt/.branchlet.json"
-  done
-fi
-```
-
-## Step 7: Install dependencies
-
-Install deps in all worktrees. Run these sequentially per worktree:
-
-```bash
-for wt in $WORKTREES; do
-  TARGET="$PARENT/$wt"
-  echo "=== Installing deps for $wt ==="
-  (cd "$TARGET/autogpt_platform/autogpt_libs" && poetry install) &&
-  (cd "$TARGET/autogpt_platform/backend" && poetry install && poetry run prisma generate) &&
-  (cd "$TARGET/autogpt_platform/frontend" && pnpm install) &&
-  echo "=== Done: $wt ===" ||
-  echo "=== FAILED: $wt ==="
-done
-```
-
-This is slow. Run in background if possible and notify when complete.
-
-## Step 8: Verify and report
-
-After setup, verify and report to the user:
-
-```bash
-git worktree list
-```
-
-Summarize:
-- Number of worktrees created
-- Which env files were copied vs created from defaults vs missing
-- Any warnings or errors encountered
-
-## Final directory layout
-
-```
-parent/
-  main/              # Primary checkout (already exists)
-  reviews/           # PR review worktree
-  branch1/           # Work branch 1
-  branch2/           # Work branch 2
-  ...
-  branchN/           # Work branch N
-```

.claude/skills/vercel-react-best-practices/SKILL.md

@@ -1,125 +0,0 @@
----
-name: vercel-react-best-practices
-description: React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.
-license: MIT
-metadata:
-  author: vercel
-  version: "1.0.0"
----
-
-# Vercel React Best Practices
-
-Comprehensive performance optimization guide for React and Next.js applications, maintained by Vercel. Contains 45 rules across 8 categories, prioritized by impact to guide automated refactoring and code generation.
-
-## When to Apply
-
-Reference these guidelines when:
-- Writing new React components or Next.js pages
-- Implementing data fetching (client or server-side)
-- Reviewing code for performance issues
-- Refactoring existing React/Next.js code
-- Optimizing bundle size or load times
-
-## Rule Categories by Priority
-
-| Priority | Category | Impact | Prefix |
-|----------|----------|--------|--------|
-| 1 | Eliminating Waterfalls | CRITICAL | `async-` |
-| 2 | Bundle Size Optimization | CRITICAL | `bundle-` |
-| 3 | Server-Side Performance | HIGH | `server-` |
-| 4 | Client-Side Data Fetching | MEDIUM-HIGH | `client-` |
-| 5 | Re-render Optimization | MEDIUM | `rerender-` |
-| 6 | Rendering Performance | MEDIUM | `rendering-` |
-| 7 | JavaScript Performance | LOW-MEDIUM | `js-` |
-| 8 | Advanced Patterns | LOW | `advanced-` |
-
-## Quick Reference
-
-### 1. Eliminating Waterfalls (CRITICAL)
-
-- `async-defer-await` - Move await into branches where actually used
-- `async-parallel` - Use Promise.all() for independent operations
-- `async-dependencies` - Use better-all for partial dependencies
-- `async-api-routes` - Start promises early, await late in API routes
-- `async-suspense-boundaries` - Use Suspense to stream content
-
-### 2. Bundle Size Optimization (CRITICAL)
-
-- `bundle-barrel-imports` - Import directly, avoid barrel files
-- `bundle-dynamic-imports` - Use next/dynamic for heavy components
-- `bundle-defer-third-party` - Load analytics/logging after hydration
-- `bundle-conditional` - Load modules only when feature is activated
-- `bundle-preload` - Preload on hover/focus for perceived speed
-
-### 3. Server-Side Performance (HIGH)
-
-- `server-cache-react` - Use React.cache() for per-request deduplication
-- `server-cache-lru` - Use LRU cache for cross-request caching
-- `server-serialization` - Minimize data passed to client components
-- `server-parallel-fetching` - Restructure components to parallelize fetches
-- `server-after-nonblocking` - Use after() for non-blocking operations
-
-### 4. Client-Side Data Fetching (MEDIUM-HIGH)
-
-- `client-swr-dedup` - Use SWR for automatic request deduplication
-- `client-event-listeners` - Deduplicate global event listeners
-
-### 5. Re-render Optimization (MEDIUM)
-
-- `rerender-defer-reads` - Don't subscribe to state only used in callbacks
-- `rerender-memo` - Extract expensive work into memoized components
-- `rerender-dependencies` - Use primitive dependencies in effects
-- `rerender-derived-state` - Subscribe to derived booleans, not raw values
-- `rerender-functional-setstate` - Use functional setState for stable callbacks
-- `rerender-lazy-state-init` - Pass function to useState for expensive values
-- `rerender-transitions` - Use startTransition for non-urgent updates
-
-### 6. Rendering Performance (MEDIUM)
-
-- `rendering-animate-svg-wrapper` - Animate div wrapper, not SVG element
-- `rendering-content-visibility` - Use content-visibility for long lists
-- `rendering-hoist-jsx` - Extract static JSX outside components
-- `rendering-svg-precision` - Reduce SVG coordinate precision
-- `rendering-hydration-no-flicker` - Use inline script for client-only data
-- `rendering-activity` - Use Activity component for show/hide
-- `rendering-conditional-render` - Use ternary, not && for conditionals
-
-### 7. JavaScript Performance (LOW-MEDIUM)
-
-- `js-batch-dom-css` - Group CSS changes via classes or cssText
-- `js-index-maps` - Build Map for repeated lookups
-- `js-cache-property-access` - Cache object properties in loops
-- `js-cache-function-results` - Cache function results in module-level Map
-- `js-cache-storage` - Cache localStorage/sessionStorage reads
-- `js-combine-iterations` - Combine multiple filter/map into one loop
-- `js-length-check-first` - Check array length before expensive comparison
-- `js-early-exit` - Return early from functions
-- `js-hoist-regexp` - Hoist RegExp creation outside loops
-- `js-min-max-loop` - Use loop for min/max instead of sort
-- `js-set-map-lookups` - Use Set/Map for O(1) lookups
-- `js-tosorted-immutable` - Use toSorted() for immutability
-
-### 8. Advanced Patterns (LOW)
-
-- `advanced-event-handler-refs` - Store event handlers in refs
-- `advanced-use-latest` - useLatest for stable callback refs
-
-## How to Use
-
-Read individual rule files for detailed explanations and code examples:
-
-```
-rules/async-parallel.md
-rules/bundle-barrel-imports.md
-rules/_sections.md
-```
-
-Each rule file contains:
-- Brief explanation of why it matters
-- Incorrect code example with explanation
-- Correct code example with explanation
-- Additional context and references
-
-## Full Compiled Document
-
-For the complete guide with all rules expanded: `AGENTS.md`

.claude/skills/vercel-react-best-practices/rules/advanced-event-handler-refs.md

@@ -1,55 +0,0 @@
----
-title: Store Event Handlers in Refs
-impact: LOW
-impactDescription: stable subscriptions
-tags: advanced, hooks, refs, event-handlers, optimization
----
-
-## Store Event Handlers in Refs
-
-Store callbacks in refs when used in effects that shouldn't re-subscribe on callback changes.
-
-**Incorrect (re-subscribes on every render):**
-
-```tsx
-function useWindowEvent(event: string, handler: () => void) {
-  useEffect(() => {
-    window.addEventListener(event, handler)
-    return () => window.removeEventListener(event, handler)
-  }, [event, handler])
-}
-```
-
-**Correct (stable subscription):**
-
-```tsx
-function useWindowEvent(event: string, handler: () => void) {
-  const handlerRef = useRef(handler)
-  useEffect(() => {
-    handlerRef.current = handler
-  }, [handler])
-
-  useEffect(() => {
-    const listener = () => handlerRef.current()
-    window.addEventListener(event, listener)
-    return () => window.removeEventListener(event, listener)
-  }, [event])
-}
-```
-
-**Alternative: use `useEffectEvent` if you're on latest React:**
-
-```tsx
-import { useEffectEvent } from 'react'
-
-function useWindowEvent(event: string, handler: () => void) {
-  const onEvent = useEffectEvent(handler)
-
-  useEffect(() => {
-    window.addEventListener(event, onEvent)
-    return () => window.removeEventListener(event, onEvent)
-  }, [event])
-}
-```
-
-`useEffectEvent` provides a cleaner API for the same pattern: it creates a stable function reference that always calls the latest version of the handler.

.claude/skills/vercel-react-best-practices/rules/advanced-use-latest.md

@@ -1,49 +0,0 @@
----
-title: useLatest for Stable Callback Refs
-impact: LOW
-impactDescription: prevents effect re-runs
-tags: advanced, hooks, useLatest, refs, optimization
----
-
-## useLatest for Stable Callback Refs
-
-Access latest values in callbacks without adding them to dependency arrays. Prevents effect re-runs while avoiding stale closures.
-
-**Implementation:**
-
-```typescript
-function useLatest<T>(value: T) {
-  const ref = useRef(value)
-  useEffect(() => {
-    ref.current = value
-  }, [value])
-  return ref
-}
-```
-
-**Incorrect (effect re-runs on every callback change):**
-
-```tsx
-function SearchInput({ onSearch }: { onSearch: (q: string) => void }) {
-  const [query, setQuery] = useState('')
-
-  useEffect(() => {
-    const timeout = setTimeout(() => onSearch(query), 300)
-    return () => clearTimeout(timeout)
-  }, [query, onSearch])
-}
-```
-
-**Correct (stable effect, fresh callback):**
-
-```tsx
-function SearchInput({ onSearch }: { onSearch: (q: string) => void }) {
-  const [query, setQuery] = useState('')
-  const onSearchRef = useLatest(onSearch)
-
-  useEffect(() => {
-    const timeout = setTimeout(() => onSearchRef.current(query), 300)
-    return () => clearTimeout(timeout)
-  }, [query])
-}
-```

.claude/skills/vercel-react-best-practices/rules/async-api-routes.md

@@ -1,38 +0,0 @@
----
-title: Prevent Waterfall Chains in API Routes
-impact: CRITICAL
-impactDescription: 2-10× improvement
-tags: api-routes, server-actions, waterfalls, parallelization
----
-
-## Prevent Waterfall Chains in API Routes
-
-In API routes and Server Actions, start independent operations immediately, even if you don't await them yet.
-
-**Incorrect (config waits for auth, data waits for both):**
-
-```typescript
-export async function GET(request: Request) {
-  const session = await auth()
-  const config = await fetchConfig()
-  const data = await fetchData(session.user.id)
-  return Response.json({ data, config })
-}
-```
-
-**Correct (auth and config start immediately):**
-
-```typescript
-export async function GET(request: Request) {
-  const sessionPromise = auth()
-  const configPromise = fetchConfig()
-  const session = await sessionPromise
-  const [config, data] = await Promise.all([
-    configPromise,
-    fetchData(session.user.id)
-  ])
-  return Response.json({ data, config })
-}
-```
-
-For operations with more complex dependency chains, use `better-all` to automatically maximize parallelism (see Dependency-Based Parallelization).

.claude/skills/vercel-react-best-practices/rules/async-defer-await.md

@@ -1,80 +0,0 @@
----
-title: Defer Await Until Needed
-impact: HIGH
-impactDescription: avoids blocking unused code paths
-tags: async, await, conditional, optimization
----
-
-## Defer Await Until Needed
-
-Move `await` operations into the branches where they're actually used to avoid blocking code paths that don't need them.
-
-**Incorrect (blocks both branches):**
-
-```typescript
-async function handleRequest(userId: string, skipProcessing: boolean) {
-  const userData = await fetchUserData(userId)
-  
-  if (skipProcessing) {
-    // Returns immediately but still waited for userData
-    return { skipped: true }
-  }
-  
-  // Only this branch uses userData
-  return processUserData(userData)
-}
-```
-
-**Correct (only blocks when needed):**
-
-```typescript
-async function handleRequest(userId: string, skipProcessing: boolean) {
-  if (skipProcessing) {
-    // Returns immediately without waiting
-    return { skipped: true }
-  }
-  
-  // Fetch only when needed
-  const userData = await fetchUserData(userId)
-  return processUserData(userData)
-}
-```
-
-**Another example (early return optimization):**
-
-```typescript
-// Incorrect: always fetches permissions
-async function updateResource(resourceId: string, userId: string) {
-  const permissions = await fetchPermissions(userId)
-  const resource = await getResource(resourceId)
-  
-  if (!resource) {
-    return { error: 'Not found' }
-  }
-  
-  if (!permissions.canEdit) {
-    return { error: 'Forbidden' }
-  }
-  
-  return await updateResourceData(resource, permissions)
-}
-
-// Correct: fetches only when needed
-async function updateResource(resourceId: string, userId: string) {
-  const resource = await getResource(resourceId)
-  
-  if (!resource) {
-    return { error: 'Not found' }
-  }
-  
-  const permissions = await fetchPermissions(userId)
-  
-  if (!permissions.canEdit) {
-    return { error: 'Forbidden' }
-  }
-  
-  return await updateResourceData(resource, permissions)
-}
-```
-
-This optimization is especially valuable when the skipped branch is frequently taken, or when the deferred operation is expensive.

.claude/skills/vercel-react-best-practices/rules/async-dependencies.md

@@ -1,36 +0,0 @@
----
-title: Dependency-Based Parallelization
-impact: CRITICAL
-impactDescription: 2-10× improvement
-tags: async, parallelization, dependencies, better-all
----
-
-## Dependency-Based Parallelization
-
-For operations with partial dependencies, use `better-all` to maximize parallelism. It automatically starts each task at the earliest possible moment.
-
-**Incorrect (profile waits for config unnecessarily):**
-
-```typescript
-const [user, config] = await Promise.all([
-  fetchUser(),
-  fetchConfig()
-])
-const profile = await fetchProfile(user.id)
-```
-
-**Correct (config and profile run in parallel):**
-
-```typescript
-import { all } from 'better-all'
-
-const { user, config, profile } = await all({
-  async user() { return fetchUser() },
-  async config() { return fetchConfig() },
-  async profile() {
-    return fetchProfile((await this.$.user).id)
-  }
-})
-```
-
-Reference: [https://github.com/shuding/better-all](https://github.com/shuding/better-all)

.claude/skills/vercel-react-best-practices/rules/async-parallel.md

@@ -1,28 +0,0 @@
----
-title: Promise.all() for Independent Operations
-impact: CRITICAL
-impactDescription: 2-10× improvement
-tags: async, parallelization, promises, waterfalls
----
-
-## Promise.all() for Independent Operations
-
-When async operations have no interdependencies, execute them concurrently using `Promise.all()`.
-
-**Incorrect (sequential execution, 3 round trips):**
-
-```typescript
-const user = await fetchUser()
-const posts = await fetchPosts()
-const comments = await fetchComments()
-```
-
-**Correct (parallel execution, 1 round trip):**
-
-```typescript
-const [user, posts, comments] = await Promise.all([
-  fetchUser(),
-  fetchPosts(),
-  fetchComments()
-])
-```

.claude/skills/vercel-react-best-practices/rules/async-suspense-boundaries.md

@@ -1,99 +0,0 @@
----
-title: Strategic Suspense Boundaries
-impact: HIGH
-impactDescription: faster initial paint
-tags: async, suspense, streaming, layout-shift
----
-
-## Strategic Suspense Boundaries
-
-Instead of awaiting data in async components before returning JSX, use Suspense boundaries to show the wrapper UI faster while data loads.
-
-**Incorrect (wrapper blocked by data fetching):**
-
-```tsx
-async function Page() {
-  const data = await fetchData() // Blocks entire page
-  
-  return (
-    <div>
-      <div>Sidebar</div>
-      <div>Header</div>
-      <div>
-        <DataDisplay data={data} />
-      </div>
-      <div>Footer</div>
-    </div>
-  )
-}
-```
-
-The entire layout waits for data even though only the middle section needs it.
-
-**Correct (wrapper shows immediately, data streams in):**
-
-```tsx
-function Page() {
-  return (
-    <div>
-      <div>Sidebar</div>
-      <div>Header</div>
-      <div>
-        <Suspense fallback={<Skeleton />}>
-          <DataDisplay />
-        </Suspense>
-      </div>
-      <div>Footer</div>
-    </div>
-  )
-}
-
-async function DataDisplay() {
-  const data = await fetchData() // Only blocks this component
-  return <div>{data.content}</div>
-}
-```
-
-Sidebar, Header, and Footer render immediately. Only DataDisplay waits for data.
-
-**Alternative (share promise across components):**
-
-```tsx
-function Page() {
-  // Start fetch immediately, but don't await
-  const dataPromise = fetchData()
-  
-  return (
-    <div>
-      <div>Sidebar</div>
-      <div>Header</div>
-      <Suspense fallback={<Skeleton />}>
-        <DataDisplay dataPromise={dataPromise} />
-        <DataSummary dataPromise={dataPromise} />
-      </Suspense>
-      <div>Footer</div>
-    </div>
-  )
-}
-
-function DataDisplay({ dataPromise }: { dataPromise: Promise<Data> }) {
-  const data = use(dataPromise) // Unwraps the promise
-  return <div>{data.content}</div>
-}
-
-function DataSummary({ dataPromise }: { dataPromise: Promise<Data> }) {
-  const data = use(dataPromise) // Reuses the same promise
-  return <div>{data.summary}</div>
-}
-```
-
-Both components share the same promise, so only one fetch occurs. Layout renders immediately while both components wait together.
-
-**When NOT to use this pattern:**
-
-- Critical data needed for layout decisions (affects positioning)
-- SEO-critical content above the fold
-- Small, fast queries where suspense overhead isn't worth it
-- When you want to avoid layout shift (loading → content jump)
-
-**Trade-off:** Faster initial paint vs potential layout shift. Choose based on your UX priorities.

.claude/skills/vercel-react-best-practices/rules/bundle-barrel-imports.md

@@ -1,59 +0,0 @@
----
-title: Avoid Barrel File Imports
-impact: CRITICAL
-impactDescription: 200-800ms import cost, slow builds
-tags: bundle, imports, tree-shaking, barrel-files, performance
----
-
-## Avoid Barrel File Imports
-
-Import directly from source files instead of barrel files to avoid loading thousands of unused modules. **Barrel files** are entry points that re-export multiple modules (e.g., `index.js` that does `export * from './module'`).
-
-Popular icon and component libraries can have **up to 10,000 re-exports** in their entry file. For many React packages, **it takes 200-800ms just to import them**, affecting both development speed and production cold starts.
-
-**Why tree-shaking doesn't help:** When a library is marked as external (not bundled), the bundler can't optimize it. If you bundle it to enable tree-shaking, builds become substantially slower analyzing the entire module graph.
-
-**Incorrect (imports entire library):**
-
-```tsx
-import { Check, X, Menu } from 'lucide-react'
-// Loads 1,583 modules, takes ~2.8s extra in dev
-// Runtime cost: 200-800ms on every cold start
-
-import { Button, TextField } from '@mui/material'
-// Loads 2,225 modules, takes ~4.2s extra in dev
-```
-
-**Correct (imports only what you need):**
-
-```tsx
-import Check from 'lucide-react/dist/esm/icons/check'
-import X from 'lucide-react/dist/esm/icons/x'
-import Menu from 'lucide-react/dist/esm/icons/menu'
-// Loads only 3 modules (~2KB vs ~1MB)
-
-import Button from '@mui/material/Button'
-import TextField from '@mui/material/TextField'
-// Loads only what you use
-```
-
-**Alternative (Next.js 13.5+):**
-
-```js
-// next.config.js - use optimizePackageImports
-module.exports = {
-  experimental: {
-    optimizePackageImports: ['lucide-react', '@mui/material']
-  }
-}
-
-// Then you can keep the ergonomic barrel imports:
-import { Check, X, Menu } from 'lucide-react'
-// Automatically transformed to direct imports at build time
-```
-
-Direct imports provide 15-70% faster dev boot, 28% faster builds, 40% faster cold starts, and significantly faster HMR.
-
-Libraries commonly affected: `lucide-react`, `@mui/material`, `@mui/icons-material`, `@tabler/icons-react`, `react-icons`, `@headlessui/react`, `@radix-ui/react-*`, `lodash`, `ramda`, `date-fns`, `rxjs`, `react-use`.
-
-Reference: [How we optimized package imports in Next.js](https://vercel.com/blog/how-we-optimized-package-imports-in-next-js)

.claude/skills/vercel-react-best-practices/rules/bundle-conditional.md

@@ -1,31 +0,0 @@
----
-title: Conditional Module Loading
-impact: HIGH
-impactDescription: loads large data only when needed
-tags: bundle, conditional-loading, lazy-loading
----
-
-## Conditional Module Loading
-
-Load large data or modules only when a feature is activated.
-
-**Example (lazy-load animation frames):**
-
-```tsx
-function AnimationPlayer({ enabled }: { enabled: boolean }) {
-  const [frames, setFrames] = useState<Frame[] | null>(null)
-
-  useEffect(() => {
-    if (enabled && !frames && typeof window !== 'undefined') {
-      import('./animation-frames.js')
-        .then(mod => setFrames(mod.frames))
-        .catch(() => setEnabled(false))
-    }
-  }, [enabled, frames])
-
-  if (!frames) return <Skeleton />
-  return <Canvas frames={frames} />
-}
-```
-
-The `typeof window !== 'undefined'` check prevents bundling this module for SSR, optimizing server bundle size and build speed.

.claude/skills/vercel-react-best-practices/rules/bundle-defer-third-party.md

@@ -1,49 +0,0 @@
----
-title: Defer Non-Critical Third-Party Libraries
-impact: MEDIUM
-impactDescription: loads after hydration
-tags: bundle, third-party, analytics, defer
----
-
-## Defer Non-Critical Third-Party Libraries
-
-Analytics, logging, and error tracking don't block user interaction. Load them after hydration.
-
-**Incorrect (blocks initial bundle):**
-
-```tsx
-import { Analytics } from '@vercel/analytics/react'
-
-export default function RootLayout({ children }) {
-  return (
-    <html>
-      <body>
-        {children}
-        <Analytics />
-      </body>
-    </html>
-  )
-}
-```
-
-**Correct (loads after hydration):**
-
-```tsx
-import dynamic from 'next/dynamic'
-
-const Analytics = dynamic(
-  () => import('@vercel/analytics/react').then(m => m.Analytics),
-  { ssr: false }
-)
-
-export default function RootLayout({ children }) {
-  return (
-    <html>
-      <body>
-        {children}
-        <Analytics />
-      </body>
-    </html>
-  )
-}
-```

.claude/skills/vercel-react-best-practices/rules/bundle-dynamic-imports.md

@@ -1,35 +0,0 @@
----
-title: Dynamic Imports for Heavy Components
-impact: CRITICAL
-impactDescription: directly affects TTI and LCP
-tags: bundle, dynamic-import, code-splitting, next-dynamic
----
-
-## Dynamic Imports for Heavy Components
-
-Use `next/dynamic` to lazy-load large components not needed on initial render.
-
-**Incorrect (Monaco bundles with main chunk ~300KB):**
-
-```tsx
-import { MonacoEditor } from './monaco-editor'
-
-function CodePanel({ code }: { code: string }) {
-  return <MonacoEditor value={code} />
-}
-```
-
-**Correct (Monaco loads on demand):**
-
-```tsx
-import dynamic from 'next/dynamic'
-
-const MonacoEditor = dynamic(
-  () => import('./monaco-editor').then(m => m.MonacoEditor),
-  { ssr: false }
-)
-
-function CodePanel({ code }: { code: string }) {
-  return <MonacoEditor value={code} />
-}
-```

.claude/skills/vercel-react-best-practices/rules/bundle-preload.md

@@ -1,50 +0,0 @@
----
-title: Preload Based on User Intent
-impact: MEDIUM
-impactDescription: reduces perceived latency
-tags: bundle, preload, user-intent, hover
----
-
-## Preload Based on User Intent
-
-Preload heavy bundles before they're needed to reduce perceived latency.
-
-**Example (preload on hover/focus):**
-
-```tsx
-function EditorButton({ onClick }: { onClick: () => void }) {
-  const preload = () => {
-    if (typeof window !== 'undefined') {
-      void import('./monaco-editor')
-    }
-  }
-
-  return (
-    <button
-      onMouseEnter={preload}
-      onFocus={preload}
-      onClick={onClick}
-    >
-      Open Editor
-    </button>
-  )
-}
-```
-
-**Example (preload when feature flag is enabled):**
-
-```tsx
-function FlagsProvider({ children, flags }: Props) {
-  useEffect(() => {
-    if (flags.editorEnabled && typeof window !== 'undefined') {
-      void import('./monaco-editor').then(mod => mod.init())
-    }
-  }, [flags.editorEnabled])
-
-  return <FlagsContext.Provider value={flags}>
-    {children}
-  </FlagsContext.Provider>
-}
-```
-
-The `typeof window !== 'undefined'` check prevents bundling preloaded modules for SSR, optimizing server bundle size and build speed.

.claude/skills/vercel-react-best-practices/rules/client-event-listeners.md

@@ -1,74 +0,0 @@
----
-title: Deduplicate Global Event Listeners
-impact: LOW
-impactDescription: single listener for N components
-tags: client, swr, event-listeners, subscription
----
-
-## Deduplicate Global Event Listeners
-
-Use `useSWRSubscription()` to share global event listeners across component instances.
-
-**Incorrect (N instances = N listeners):**
-
-```tsx
-function useKeyboardShortcut(key: string, callback: () => void) {
-  useEffect(() => {
-    const handler = (e: KeyboardEvent) => {
-      if (e.metaKey && e.key === key) {
-        callback()
-      }
-    }
-    window.addEventListener('keydown', handler)
-    return () => window.removeEventListener('keydown', handler)
-  }, [key, callback])
-}
-```
-
-When using the `useKeyboardShortcut` hook multiple times, each instance will register a new listener.
-
-**Correct (N instances = 1 listener):**
-
-```tsx
-import useSWRSubscription from 'swr/subscription'
-
-// Module-level Map to track callbacks per key
-const keyCallbacks = new Map<string, Set<() => void>>()
-
-function useKeyboardShortcut(key: string, callback: () => void) {
-  // Register this callback in the Map
-  useEffect(() => {
-    if (!keyCallbacks.has(key)) {
-      keyCallbacks.set(key, new Set())
-    }
-    keyCallbacks.get(key)!.add(callback)
-
-    return () => {
-      const set = keyCallbacks.get(key)
-      if (set) {
-        set.delete(callback)
-        if (set.size === 0) {
-          keyCallbacks.delete(key)
-        }
-      }
-    }
-  }, [key, callback])
-
-  useSWRSubscription('global-keydown', () => {
-    const handler = (e: KeyboardEvent) => {
-      if (e.metaKey && keyCallbacks.has(e.key)) {
-        keyCallbacks.get(e.key)!.forEach(cb => cb())
-      }
-    }
-    window.addEventListener('keydown', handler)
-    return () => window.removeEventListener('keydown', handler)
-  })
-}
-
-function Profile() {
-  // Multiple shortcuts will share the same listener
-  useKeyboardShortcut('p', () => { /* ... */ }) 
-  useKeyboardShortcut('k', () => { /* ... */ })
-  // ...
-}
-```

.claude/skills/vercel-react-best-practices/rules/client-swr-dedup.md

@@ -1,56 +0,0 @@
----
-title: Use SWR for Automatic Deduplication
-impact: MEDIUM-HIGH
-impactDescription: automatic deduplication
-tags: client, swr, deduplication, data-fetching
----
-
-## Use SWR for Automatic Deduplication
-
-SWR enables request deduplication, caching, and revalidation across component instances.
-
-**Incorrect (no deduplication, each instance fetches):**
-
-```tsx
-function UserList() {
-  const [users, setUsers] = useState([])
-  useEffect(() => {
-    fetch('/api/users')
-      .then(r => r.json())
-      .then(setUsers)
-  }, [])
-}
-```
-
-**Correct (multiple instances share one request):**
-
-```tsx
-import useSWR from 'swr'
-
-function UserList() {
-  const { data: users } = useSWR('/api/users', fetcher)
-}
-```
-
-**For immutable data:**
-
-```tsx
-import { useImmutableSWR } from '@/lib/swr'
-
-function StaticContent() {
-  const { data } = useImmutableSWR('/api/config', fetcher)
-}
-```
-
-**For mutations:**
-
-```tsx
-import { useSWRMutation } from 'swr/mutation'
-
-function UpdateButton() {
-  const { trigger } = useSWRMutation('/api/user', updateUser)
-  return <button onClick={() => trigger()}>Update</button>
-}
-```
-
-Reference: [https://swr.vercel.app](https://swr.vercel.app)

.claude/skills/vercel-react-best-practices/rules/js-batch-dom-css.md

@@ -1,82 +0,0 @@
----
-title: Batch DOM CSS Changes
-impact: MEDIUM
-impactDescription: reduces reflows/repaints
-tags: javascript, dom, css, performance, reflow
----
-
-## Batch DOM CSS Changes
-
-Avoid changing styles one property at a time. Group multiple CSS changes together via classes or `cssText` to minimize browser reflows.
-
-**Incorrect (multiple reflows):**
-
-```typescript
-function updateElementStyles(element: HTMLElement) {
-  // Each line triggers a reflow
-  element.style.width = '100px'
-  element.style.height = '200px'
-  element.style.backgroundColor = 'blue'
-  element.style.border = '1px solid black'
-}
-```
-
-**Correct (add class - single reflow):**
-
-```typescript
-// CSS file
-.highlighted-box {
-  width: 100px;
-  height: 200px;
-  background-color: blue;
-  border: 1px solid black;
-}
-
-// JavaScript
-function updateElementStyles(element: HTMLElement) {
-  element.classList.add('highlighted-box')
-}
-```
-
-**Correct (change cssText - single reflow):**
-
-```typescript
-function updateElementStyles(element: HTMLElement) {
-  element.style.cssText = `
-    width: 100px;
-    height: 200px;
-    background-color: blue;
-    border: 1px solid black;
-  `
-}
-```
-
-**React example:**
-
-```tsx
-// Incorrect: changing styles one by one
-function Box({ isHighlighted }: { isHighlighted: boolean }) {
-  const ref = useRef<HTMLDivElement>(null)
-  
-  useEffect(() => {
-    if (ref.current && isHighlighted) {
-      ref.current.style.width = '100px'
-      ref.current.style.height = '200px'
-      ref.current.style.backgroundColor = 'blue'
-    }
-  }, [isHighlighted])
-  
-  return <div ref={ref}>Content</div>
-}
-
-// Correct: toggle class
-function Box({ isHighlighted }: { isHighlighted: boolean }) {
-  return (
-    <div className={isHighlighted ? 'highlighted-box' : ''}>
-      Content
-    </div>
-  )
-}
-```
-
-Prefer CSS classes over inline styles when possible. Classes are cached by the browser and provide better separation of concerns.

.claude/skills/vercel-react-best-practices/rules/js-cache-function-results.md

@@ -1,80 +0,0 @@
----
-title: Cache Repeated Function Calls
-impact: MEDIUM
-impactDescription: avoid redundant computation
-tags: javascript, cache, memoization, performance
----
-
-## Cache Repeated Function Calls
-
-Use a module-level Map to cache function results when the same function is called repeatedly with the same inputs during render.
-
-**Incorrect (redundant computation):**
-
-```typescript
-function ProjectList({ projects }: { projects: Project[] }) {
-  return (
-    <div>
-      {projects.map(project => {
-        // slugify() called 100+ times for same project names
-        const slug = slugify(project.name)
-        
-        return <ProjectCard key={project.id} slug={slug} />
-      })}
-    </div>
-  )
-}
-```
-
-**Correct (cached results):**
-
-```typescript
-// Module-level cache
-const slugifyCache = new Map<string, string>()
-
-function cachedSlugify(text: string): string {
-  if (slugifyCache.has(text)) {
-    return slugifyCache.get(text)!
-  }
-  const result = slugify(text)
-  slugifyCache.set(text, result)
-  return result
-}
-
-function ProjectList({ projects }: { projects: Project[] }) {
-  return (
-    <div>
-      {projects.map(project => {
-        // Computed only once per unique project name
-        const slug = cachedSlugify(project.name)
-        
-        return <ProjectCard key={project.id} slug={slug} />
-      })}
-    </div>
-  )
-}
-```
-
-**Simpler pattern for single-value functions:**
-
-```typescript
-let isLoggedInCache: boolean | null = null
-
-function isLoggedIn(): boolean {
-  if (isLoggedInCache !== null) {
-    return isLoggedInCache
-  }
-  
-  isLoggedInCache = document.cookie.includes('auth=')
-  return isLoggedInCache
-}
-
-// Clear cache when auth changes
-function onAuthChange() {
-  isLoggedInCache = null
-}
-```
-
-Use a Map (not a hook) so it works everywhere: utilities, event handlers, not just React components.
-
-Reference: [How we made the Vercel Dashboard twice as fast](https://vercel.com/blog/how-we-made-the-vercel-dashboard-twice-as-fast)

.claude/skills/vercel-react-best-practices/rules/js-cache-property-access.md

@@ -1,28 +0,0 @@
----
-title: Cache Property Access in Loops
-impact: LOW-MEDIUM
-impactDescription: reduces lookups
-tags: javascript, loops, optimization, caching
----
-
-## Cache Property Access in Loops
-
-Cache object property lookups in hot paths.
-
-**Incorrect (3 lookups × N iterations):**
-
-```typescript
-for (let i = 0; i < arr.length; i++) {
-  process(obj.config.settings.value)
-}
-```
-
-**Correct (1 lookup total):**
-
-```typescript
-const value = obj.config.settings.value
-const len = arr.length
-for (let i = 0; i < len; i++) {
-  process(value)
-}
-```

.claude/skills/vercel-react-best-practices/rules/js-cache-storage.md

@@ -1,70 +0,0 @@
----
-title: Cache Storage API Calls
-impact: LOW-MEDIUM
-impactDescription: reduces expensive I/O
-tags: javascript, localStorage, storage, caching, performance
----
-
-## Cache Storage API Calls
-
-`localStorage`, `sessionStorage`, and `document.cookie` are synchronous and expensive. Cache reads in memory.
-
-**Incorrect (reads storage on every call):**
-
-```typescript
-function getTheme() {
-  return localStorage.getItem('theme') ?? 'light'
-}
-// Called 10 times = 10 storage reads
-```
-
-**Correct (Map cache):**
-
-```typescript
-const storageCache = new Map<string, string | null>()
-
-function getLocalStorage(key: string) {
-  if (!storageCache.has(key)) {
-    storageCache.set(key, localStorage.getItem(key))
-  }
-  return storageCache.get(key)
-}
-
-function setLocalStorage(key: string, value: string) {
-  localStorage.setItem(key, value)
-  storageCache.set(key, value)  // keep cache in sync
-}
-```
-
-Use a Map (not a hook) so it works everywhere: utilities, event handlers, not just React components.
-
-**Cookie caching:**
-
-```typescript
-let cookieCache: Record<string, string> | null = null
-
-function getCookie(name: string) {
-  if (!cookieCache) {
-    cookieCache = Object.fromEntries(
-      document.cookie.split('; ').map(c => c.split('='))
-    )
-  }
-  return cookieCache[name]
-}
-```
-
-**Important (invalidate on external changes):**
-
-If storage can change externally (another tab, server-set cookies), invalidate cache:
-
-```typescript
-window.addEventListener('storage', (e) => {
-  if (e.key) storageCache.delete(e.key)
-})
-
-document.addEventListener('visibilitychange', () => {
-  if (document.visibilityState === 'visible') {
-    storageCache.clear()
-  }
-})
-```

.claude/skills/vercel-react-best-practices/rules/js-combine-iterations.md

@@ -1,32 +0,0 @@
----
-title: Combine Multiple Array Iterations
-impact: LOW-MEDIUM
-impactDescription: reduces iterations
-tags: javascript, arrays, loops, performance
----
-
-## Combine Multiple Array Iterations
-
-Multiple `.filter()` or `.map()` calls iterate the array multiple times. Combine into one loop.
-
-**Incorrect (3 iterations):**
-
-```typescript
-const admins = users.filter(u => u.isAdmin)
-const testers = users.filter(u => u.isTester)
-const inactive = users.filter(u => !u.isActive)
-```
-
-**Correct (1 iteration):**
-
-```typescript
-const admins: User[] = []
-const testers: User[] = []
-const inactive: User[] = []
-
-for (const user of users) {
-  if (user.isAdmin) admins.push(user)
-  if (user.isTester) testers.push(user)
-  if (!user.isActive) inactive.push(user)
-}
-```

.claude/skills/vercel-react-best-practices/rules/js-early-exit.md

@@ -1,50 +0,0 @@
----
-title: Early Return from Functions
-impact: LOW-MEDIUM
-impactDescription: avoids unnecessary computation
-tags: javascript, functions, optimization, early-return
----
-
-## Early Return from Functions
-
-Return early when result is determined to skip unnecessary processing.
-
-**Incorrect (processes all items even after finding answer):**
-
-```typescript
-function validateUsers(users: User[]) {
-  let hasError = false
-  let errorMessage = ''
-  
-  for (const user of users) {
-    if (!user.email) {
-      hasError = true
-      errorMessage = 'Email required'
-    }
-    if (!user.name) {
-      hasError = true
-      errorMessage = 'Name required'
-    }
-    // Continues checking all users even after error found
-  }
-  
-  return hasError ? { valid: false, error: errorMessage } : { valid: true }
-}
-```
-
-**Correct (returns immediately on first error):**
-
-```typescript
-function validateUsers(users: User[]) {
-  for (const user of users) {
-    if (!user.email) {
-      return { valid: false, error: 'Email required' }
-    }
-    if (!user.name) {
-      return { valid: false, error: 'Name required' }
-    }
-  }
-
-  return { valid: true }
-}
-```

.claude/skills/vercel-react-best-practices/rules/js-hoist-regexp.md

@@ -1,45 +0,0 @@
----
-title: Hoist RegExp Creation
-impact: LOW-MEDIUM
-impactDescription: avoids recreation
-tags: javascript, regexp, optimization, memoization
----
-
-## Hoist RegExp Creation
-
-Don't create RegExp inside render. Hoist to module scope or memoize with `useMemo()`.
-
-**Incorrect (new RegExp every render):**
-
-```tsx
-function Highlighter({ text, query }: Props) {
-  const regex = new RegExp(`(${query})`, 'gi')
-  const parts = text.split(regex)
-  return <>{parts.map((part, i) => ...)}</>
-}
-```
-
-**Correct (memoize or hoist):**
-
-```tsx
-const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
-
-function Highlighter({ text, query }: Props) {
-  const regex = useMemo(
-    () => new RegExp(`(${escapeRegex(query)})`, 'gi'),
-    [query]
-  )
-  const parts = text.split(regex)
-  return <>{parts.map((part, i) => ...)}</>
-}
-```
-
-**Warning (global regex has mutable state):**
-
-Global regex (`/g`) has mutable `lastIndex` state:
-
-```typescript
-const regex = /foo/g
-regex.test('foo')  // true, lastIndex = 3
-regex.test('foo')  // false, lastIndex = 0
-```

.claude/skills/vercel-react-best-practices/rules/js-index-maps.md

@@ -1,37 +0,0 @@
----
-title: Build Index Maps for Repeated Lookups
-impact: LOW-MEDIUM
-impactDescription: 1M ops to 2K ops
-tags: javascript, map, indexing, optimization, performance
----
-
-## Build Index Maps for Repeated Lookups
-
-Multiple `.find()` calls by the same key should use a Map.
-
-**Incorrect (O(n) per lookup):**
-
-```typescript
-function processOrders(orders: Order[], users: User[]) {
-  return orders.map(order => ({
-    ...order,
-    user: users.find(u => u.id === order.userId)
-  }))
-}
-```
-
-**Correct (O(1) per lookup):**
-
-```typescript
-function processOrders(orders: Order[], users: User[]) {
-  const userById = new Map(users.map(u => [u.id, u]))
-
-  return orders.map(order => ({
-    ...order,
-    user: userById.get(order.userId)
-  }))
-}
-```
-
-Build map once (O(n)), then all lookups are O(1).
-For 1000 orders × 1000 users: 1M ops → 2K ops.

.claude/skills/vercel-react-best-practices/rules/js-length-check-first.md

@@ -1,49 +0,0 @@
----
-title: Early Length Check for Array Comparisons
-impact: MEDIUM-HIGH
-impactDescription: avoids expensive operations when lengths differ
-tags: javascript, arrays, performance, optimization, comparison
----
-
-## Early Length Check for Array Comparisons
-
-When comparing arrays with expensive operations (sorting, deep equality, serialization), check lengths first. If lengths differ, the arrays cannot be equal.
-
-In real-world applications, this optimization is especially valuable when the comparison runs in hot paths (event handlers, render loops).
-
-**Incorrect (always runs expensive comparison):**
-
-```typescript
-function hasChanges(current: string[], original: string[]) {
-  // Always sorts and joins, even when lengths differ
-  return current.sort().join() !== original.sort().join()
-}
-```
-
-Two O(n log n) sorts run even when `current.length` is 5 and `original.length` is 100. There is also overhead of joining the arrays and comparing the strings.
-
-**Correct (O(1) length check first):**
-
-```typescript
-function hasChanges(current: string[], original: string[]) {
-  // Early return if lengths differ
-  if (current.length !== original.length) {
-    return true
-  }
-  // Only sort/join when lengths match
-  const currentSorted = current.toSorted()
-  const originalSorted = original.toSorted()
-  for (let i = 0; i < currentSorted.length; i++) {
-    if (currentSorted[i] !== originalSorted[i]) {
-      return true
-    }
-  }
-  return false
-}
-```
-
-This new approach is more efficient because:
-- It avoids the overhead of sorting and joining the arrays when lengths differ
-- It avoids consuming memory for the joined strings (especially important for large arrays)
-- It avoids mutating the original arrays
-- It returns early when a difference is found

.claude/skills/vercel-react-best-practices/rules/js-min-max-loop.md

@@ -1,82 +0,0 @@
----
-title: Use Loop for Min/Max Instead of Sort
-impact: LOW
-impactDescription: O(n) instead of O(n log n)
-tags: javascript, arrays, performance, sorting, algorithms
----
-
-## Use Loop for Min/Max Instead of Sort
-
-Finding the smallest or largest element only requires a single pass through the array. Sorting is wasteful and slower.
-
-**Incorrect (O(n log n) - sort to find latest):**
-
-```typescript
-interface Project {
-  id: string
-  name: string
-  updatedAt: number
-}
-
-function getLatestProject(projects: Project[]) {
-  const sorted = [...projects].sort((a, b) => b.updatedAt - a.updatedAt)
-  return sorted[0]
-}
-```
-
-Sorts the entire array just to find the maximum value.
-
-**Incorrect (O(n log n) - sort for oldest and newest):**
-
-```typescript
-function getOldestAndNewest(projects: Project[]) {
-  const sorted = [...projects].sort((a, b) => a.updatedAt - b.updatedAt)
-  return { oldest: sorted[0], newest: sorted[sorted.length - 1] }
-}
-```
-
-Still sorts unnecessarily when only min/max are needed.
-
-**Correct (O(n) - single loop):**
-
-```typescript
-function getLatestProject(projects: Project[]) {
-  if (projects.length === 0) return null
-  
-  let latest = projects[0]
-  
-  for (let i = 1; i < projects.length; i++) {
-    if (projects[i].updatedAt > latest.updatedAt) {
-      latest = projects[i]
-    }
-  }
-  
-  return latest
-}
-
-function getOldestAndNewest(projects: Project[]) {
-  if (projects.length === 0) return { oldest: null, newest: null }
-  
-  let oldest = projects[0]
-  let newest = projects[0]
-  
-  for (let i = 1; i < projects.length; i++) {
-    if (projects[i].updatedAt < oldest.updatedAt) oldest = projects[i]
-    if (projects[i].updatedAt > newest.updatedAt) newest = projects[i]
-  }
-  
-  return { oldest, newest }
-}
-```
-
-Single pass through the array, no copying, no sorting.
-
-**Alternative (Math.min/Math.max for small arrays):**
-
-```typescript
-const numbers = [5, 2, 8, 1, 9]
-const min = Math.min(...numbers)
-const max = Math.max(...numbers)
-```
-
-This works for small arrays but can be slower for very large arrays due to spread operator limitations. Use the loop approach for reliability.

.claude/skills/vercel-react-best-practices/rules/js-set-map-lookups.md

@@ -1,24 +0,0 @@
----
-title: Use Set/Map for O(1) Lookups
-impact: LOW-MEDIUM
-impactDescription: O(n) to O(1)
-tags: javascript, set, map, data-structures, performance
----
-
-## Use Set/Map for O(1) Lookups
-
-Convert arrays to Set/Map for repeated membership checks.
-
-**Incorrect (O(n) per check):**
-
-```typescript
-const allowedIds = ['a', 'b', 'c', ...]
-items.filter(item => allowedIds.includes(item.id))
-```
-
-**Correct (O(1) per check):**
-
-```typescript
-const allowedIds = new Set(['a', 'b', 'c', ...])
-items.filter(item => allowedIds.has(item.id))
-```

.claude/skills/vercel-react-best-practices/rules/js-tosorted-immutable.md

@@ -1,57 +0,0 @@
----
-title: Use toSorted() Instead of sort() for Immutability
-impact: MEDIUM-HIGH
-impactDescription: prevents mutation bugs in React state
-tags: javascript, arrays, immutability, react, state, mutation
----
-
-## Use toSorted() Instead of sort() for Immutability
-
-`.sort()` mutates the array in place, which can cause bugs with React state and props. Use `.toSorted()` to create a new sorted array without mutation.
-
-**Incorrect (mutates original array):**
-
-```typescript
-function UserList({ users }: { users: User[] }) {
-  // Mutates the users prop array!
-  const sorted = useMemo(
-    () => users.sort((a, b) => a.name.localeCompare(b.name)),
-    [users]
-  )
-  return <div>{sorted.map(renderUser)}</div>
-}
-```
-
-**Correct (creates new array):**
-
-```typescript
-function UserList({ users }: { users: User[] }) {
-  // Creates new sorted array, original unchanged
-  const sorted = useMemo(
-    () => users.toSorted((a, b) => a.name.localeCompare(b.name)),
-    [users]
-  )
-  return <div>{sorted.map(renderUser)}</div>
-}
-```
-
-**Why this matters in React:**
-
-1. Props/state mutations break React's immutability model - React expects props and state to be treated as read-only
-2. Causes stale closure bugs - Mutating arrays inside closures (callbacks, effects) can lead to unexpected behavior
-
-**Browser support (fallback for older browsers):**
-
-`.toSorted()` is available in all modern browsers (Chrome 110+, Safari 16+, Firefox 115+, Node.js 20+). For older environments, use spread operator:
-
-```typescript
-// Fallback for older browsers
-const sorted = [...items].sort((a, b) => a.value - b.value)
-```
-
-**Other immutable array methods:**
-
-- `.toSorted()` - immutable sort
-- `.toReversed()` - immutable reverse
-- `.toSpliced()` - immutable splice
-- `.with()` - immutable element replacement

.claude/skills/vercel-react-best-practices/rules/rendering-activity.md

@@ -1,26 +0,0 @@
----
-title: Use Activity Component for Show/Hide
-impact: MEDIUM
-impactDescription: preserves state/DOM
-tags: rendering, activity, visibility, state-preservation
----
-
-## Use Activity Component for Show/Hide
-
-Use React's `<Activity>` to preserve state/DOM for expensive components that frequently toggle visibility.
-
-**Usage:**
-
-```tsx
-import { Activity } from 'react'
-
-function Dropdown({ isOpen }: Props) {
-  return (
-    <Activity mode={isOpen ? 'visible' : 'hidden'}>
-      <ExpensiveMenu />
-    </Activity>
-  )
-}
-```
-
-Avoids expensive re-renders and state loss.

.claude/skills/vercel-react-best-practices/rules/rendering-animate-svg-wrapper.md

@@ -1,47 +0,0 @@
----
-title: Animate SVG Wrapper Instead of SVG Element
-impact: LOW
-impactDescription: enables hardware acceleration
-tags: rendering, svg, css, animation, performance
----
-
-## Animate SVG Wrapper Instead of SVG Element
-
-Many browsers don't have hardware acceleration for CSS3 animations on SVG elements. Wrap SVG in a `<div>` and animate the wrapper instead.
-
-**Incorrect (animating SVG directly - no hardware acceleration):**
-
-```tsx
-function LoadingSpinner() {
-  return (
-    <svg 
-      className="animate-spin"
-      width="24" 
-      height="24" 
-      viewBox="0 0 24 24"
-    >
-      <circle cx="12" cy="12" r="10" stroke="currentColor" />
-    </svg>
-  )
-}
-```
-
-**Correct (animating wrapper div - hardware accelerated):**
-
-```tsx
-function LoadingSpinner() {
-  return (
-    <div className="animate-spin">
-      <svg 
-        width="24" 
-        height="24" 
-        viewBox="0 0 24 24"
-      >
-        <circle cx="12" cy="12" r="10" stroke="currentColor" />
-      </svg>
-    </div>
-  )
-}
-```
-
-This applies to all CSS transforms and transitions (`transform`, `opacity`, `translate`, `scale`, `rotate`). The wrapper div allows browsers to use GPU acceleration for smoother animations.

.claude/skills/vercel-react-best-practices/rules/rendering-conditional-render.md

@@ -1,40 +0,0 @@
----
-title: Use Explicit Conditional Rendering
-impact: LOW
-impactDescription: prevents rendering 0 or NaN
-tags: rendering, conditional, jsx, falsy-values
----
-
-## Use Explicit Conditional Rendering
-
-Use explicit ternary operators (`? :`) instead of `&&` for conditional rendering when the condition can be `0`, `NaN`, or other falsy values that render.
-
-**Incorrect (renders "0" when count is 0):**
-
-```tsx
-function Badge({ count }: { count: number }) {
-  return (
-    <div>
-      {count && <span className="badge">{count}</span>}
-    </div>
-  )
-}
-
-// When count = 0, renders: <div>0</div>
-// When count = 5, renders: <div><span class="badge">5</span></div>
-```
-
-**Correct (renders nothing when count is 0):**
-
-```tsx
-function Badge({ count }: { count: number }) {
-  return (
-    <div>
-      {count > 0 ? <span className="badge">{count}</span> : null}
-    </div>
-  )
-}
-
-// When count = 0, renders: <div></div>
-// When count = 5, renders: <div><span class="badge">5</span></div>
-```

.claude/skills/vercel-react-best-practices/rules/rendering-content-visibility.md

@@ -1,38 +0,0 @@
----
-title: CSS content-visibility for Long Lists
-impact: HIGH
-impactDescription: faster initial render
-tags: rendering, css, content-visibility, long-lists
----
-
-## CSS content-visibility for Long Lists
-
-Apply `content-visibility: auto` to defer off-screen rendering.
-
-**CSS:**
-
-```css
-.message-item {
-  content-visibility: auto;
-  contain-intrinsic-size: 0 80px;
-}
-```
-
-**Example:**
-
-```tsx
-function MessageList({ messages }: { messages: Message[] }) {
-  return (
-    <div className="overflow-y-auto h-screen">
-      {messages.map(msg => (
-        <div key={msg.id} className="message-item">
-          <Avatar user={msg.author} />
-          <div>{msg.content}</div>
-        </div>
-      ))}
-    </div>
-  )
-}
-```
-
-For 1000 messages, browser skips layout/paint for ~990 off-screen items (10× faster initial render).

.claude/skills/vercel-react-best-practices/rules/rendering-hoist-jsx.md

@@ -1,46 +0,0 @@
----
-title: Hoist Static JSX Elements
-impact: LOW
-impactDescription: avoids re-creation
-tags: rendering, jsx, static, optimization
----
-
-## Hoist Static JSX Elements
-
-Extract static JSX outside components to avoid re-creation.
-
-**Incorrect (recreates element every render):**
-
-```tsx
-function LoadingSkeleton() {
-  return <div className="animate-pulse h-20 bg-gray-200" />
-}
-
-function Container() {
-  return (
-    <div>
-      {loading && <LoadingSkeleton />}
-    </div>
-  )
-}
-```
-
-**Correct (reuses same element):**
-
-```tsx
-const loadingSkeleton = (
-  <div className="animate-pulse h-20 bg-gray-200" />
-)
-
-function Container() {
-  return (
-    <div>
-      {loading && loadingSkeleton}
-    </div>
-  )
-}
-```
-
-This is especially helpful for large and static SVG nodes, which can be expensive to recreate on every render.
-
-**Note:** If your project has [React Compiler](https://react.dev/learn/react-compiler) enabled, the compiler automatically hoists static JSX elements and optimizes component re-renders, making manual hoisting unnecessary.

.claude/skills/vercel-react-best-practices/rules/rendering-hydration-no-flicker.md

@@ -1,82 +0,0 @@
----
-title: Prevent Hydration Mismatch Without Flickering
-impact: MEDIUM
-impactDescription: avoids visual flicker and hydration errors
-tags: rendering, ssr, hydration, localStorage, flicker
----
-
-## Prevent Hydration Mismatch Without Flickering
-
-When rendering content that depends on client-side storage (localStorage, cookies), avoid both SSR breakage and post-hydration flickering by injecting a synchronous script that updates the DOM before React hydrates.
-
-**Incorrect (breaks SSR):**
-
-```tsx
-function ThemeWrapper({ children }: { children: ReactNode }) {
-  // localStorage is not available on server - throws error
-  const theme = localStorage.getItem('theme') || 'light'
-  
-  return (
-    <div className={theme}>
-      {children}
-    </div>
-  )
-}
-```
-
-Server-side rendering will fail because `localStorage` is undefined.
-
-**Incorrect (visual flickering):**
-
-```tsx
-function ThemeWrapper({ children }: { children: ReactNode }) {
-  const [theme, setTheme] = useState('light')
-  
-  useEffect(() => {
-    // Runs after hydration - causes visible flash
-    const stored = localStorage.getItem('theme')
-    if (stored) {
-      setTheme(stored)
-    }
-  }, [])
-  
-  return (
-    <div className={theme}>
-      {children}
-    </div>
-  )
-}
-```
-
-Component first renders with default value (`light`), then updates after hydration, causing a visible flash of incorrect content.
-
-**Correct (no flicker, no hydration mismatch):**
-
-```tsx
-function ThemeWrapper({ children }: { children: ReactNode }) {
-  return (
-    <>
-      <div id="theme-wrapper">
-        {children}
-      </div>
-      <script
-        dangerouslySetInnerHTML={{
-          __html: `
-            (function() {
-              try {
-                var theme = localStorage.getItem('theme') || 'light';
-                var el = document.getElementById('theme-wrapper');
-                if (el) el.className = theme;
-              } catch (e) {}
-            })();
-          `,
-        }}
-      />
-    </>
-  )
-}
-```
-
-The inline script executes synchronously before showing the element, ensuring the DOM already has the correct value. No flickering, no hydration mismatch.
-
-This pattern is especially useful for theme toggles, user preferences, authentication states, and any client-only data that should render immediately without flashing default values.

.claude/skills/vercel-react-best-practices/rules/rendering-svg-precision.md

@@ -1,28 +0,0 @@
----
-title: Optimize SVG Precision
-impact: LOW
-impactDescription: reduces file size
-tags: rendering, svg, optimization, svgo
----
-
-## Optimize SVG Precision
-
-Reduce SVG coordinate precision to decrease file size. The optimal precision depends on the viewBox size, but in general reducing precision should be considered.
-
-**Incorrect (excessive precision):**
-
-```svg
-<path d="M 10.293847 20.847362 L 30.938472 40.192837" />
-```
-
-**Correct (1 decimal place):**
-
-```svg
-<path d="M 10.3 20.8 L 30.9 40.2" />
-```
-
-**Automate with SVGO:**
-
-```bash
-npx svgo --precision=1 --multipass icon.svg
-```

.claude/skills/vercel-react-best-practices/rules/rerender-defer-reads.md

@@ -1,39 +0,0 @@
----
-title: Defer State Reads to Usage Point
-impact: MEDIUM
-impactDescription: avoids unnecessary subscriptions
-tags: rerender, searchParams, localStorage, optimization
----
-
-## Defer State Reads to Usage Point
-
-Don't subscribe to dynamic state (searchParams, localStorage) if you only read it inside callbacks.
-
-**Incorrect (subscribes to all searchParams changes):**
-
-```tsx
-function ShareButton({ chatId }: { chatId: string }) {
-  const searchParams = useSearchParams()
-
-  const handleShare = () => {
-    const ref = searchParams.get('ref')
-    shareChat(chatId, { ref })
-  }
-
-  return <button onClick={handleShare}>Share</button>
-}
-```
-
-**Correct (reads on demand, no subscription):**
-
-```tsx
-function ShareButton({ chatId }: { chatId: string }) {
-  const handleShare = () => {
-    const params = new URLSearchParams(window.location.search)
-    const ref = params.get('ref')
-    shareChat(chatId, { ref })
-  }
-
-  return <button onClick={handleShare}>Share</button>
-}
-```

.claude/skills/vercel-react-best-practices/rules/rerender-dependencies.md

@@ -1,45 +0,0 @@
----
-title: Narrow Effect Dependencies
-impact: LOW
-impactDescription: minimizes effect re-runs
-tags: rerender, useEffect, dependencies, optimization
----
-
-## Narrow Effect Dependencies
-
-Specify primitive dependencies instead of objects to minimize effect re-runs.
-
-**Incorrect (re-runs on any user field change):**
-
-```tsx
-useEffect(() => {
-  console.log(user.id)
-}, [user])
-```
-
-**Correct (re-runs only when id changes):**
-
-```tsx
-useEffect(() => {
-  console.log(user.id)
-}, [user.id])
-```
-
-**For derived state, compute outside effect:**
-
-```tsx
-// Incorrect: runs on width=767, 766, 765...
-useEffect(() => {
-  if (width < 768) {
-    enableMobileMode()
-  }
-}, [width])
-
-// Correct: runs only on boolean transition
-const isMobile = width < 768
-useEffect(() => {
-  if (isMobile) {
-    enableMobileMode()
-  }
-}, [isMobile])
-```

.claude/skills/vercel-react-best-practices/rules/rerender-derived-state.md

@@ -1,29 +0,0 @@
----
-title: Subscribe to Derived State
-impact: MEDIUM
-impactDescription: reduces re-render frequency
-tags: rerender, derived-state, media-query, optimization
----
-
-## Subscribe to Derived State
-
-Subscribe to derived boolean state instead of continuous values to reduce re-render frequency.
-
-**Incorrect (re-renders on every pixel change):**
-
-```tsx
-function Sidebar() {
-  const width = useWindowWidth()  // updates continuously
-  const isMobile = width < 768
-  return <nav className={isMobile ? 'mobile' : 'desktop'}>
-}
-```
-
-**Correct (re-renders only when boolean changes):**
-
-```tsx
-function Sidebar() {
-  const isMobile = useMediaQuery('(max-width: 767px)')
-  return <nav className={isMobile ? 'mobile' : 'desktop'}>
-}
-```

.claude/skills/vercel-react-best-practices/rules/rerender-functional-setstate.md

@@ -1,74 +0,0 @@
----
-title: Use Functional setState Updates
-impact: MEDIUM
-impactDescription: prevents stale closures and unnecessary callback recreations
-tags: react, hooks, useState, useCallback, callbacks, closures
----
-
-## Use Functional setState Updates
-
-When updating state based on the current state value, use the functional update form of setState instead of directly referencing the state variable. This prevents stale closures, eliminates unnecessary dependencies, and creates stable callback references.
-
-**Incorrect (requires state as dependency):**
-
-```tsx
-function TodoList() {
-  const [items, setItems] = useState(initialItems)
-  
-  // Callback must depend on items, recreated on every items change
-  const addItems = useCallback((newItems: Item[]) => {
-    setItems([...items, ...newItems])
-  }, [items])  // ❌ items dependency causes recreations
-  
-  // Risk of stale closure if dependency is forgotten
-  const removeItem = useCallback((id: string) => {
-    setItems(items.filter(item => item.id !== id))
-  }, [])  // ❌ Missing items dependency - will use stale items!
-  
-  return <ItemsEditor items={items} onAdd={addItems} onRemove={removeItem} />
-}
-```
-
-The first callback is recreated every time `items` changes, which can cause child components to re-render unnecessarily. The second callback has a stale closure bug—it will always reference the initial `items` value.
-
-**Correct (stable callbacks, no stale closures):**
-
-```tsx
-function TodoList() {
-  const [items, setItems] = useState(initialItems)
-  
-  // Stable callback, never recreated
-  const addItems = useCallback((newItems: Item[]) => {
-    setItems(curr => [...curr, ...newItems])
-  }, [])  // ✅ No dependencies needed
-  
-  // Always uses latest state, no stale closure risk
-  const removeItem = useCallback((id: string) => {
-    setItems(curr => curr.filter(item => item.id !== id))
-  }, [])  // ✅ Safe and stable
-  
-  return <ItemsEditor items={items} onAdd={addItems} onRemove={removeItem} />
-}
-```
-
-**Benefits:**
-
-1. **Stable callback references** - Callbacks don't need to be recreated when state changes
-2. **No stale closures** - Always operates on the latest state value
-3. **Fewer dependencies** - Simplifies dependency arrays and reduces memory leaks
-4. **Prevents bugs** - Eliminates the most common source of React closure bugs
-
-**When to use functional updates:**
-
-- Any setState that depends on the current state value
-- Inside useCallback/useMemo when state is needed
-- Event handlers that reference state
-- Async operations that update state
-
-**When direct updates are fine:**
-
-- Setting state to a static value: `setCount(0)`
-- Setting state from props/arguments only: `setName(newName)`
-- State doesn't depend on previous value
-
-**Note:** If your project has [React Compiler](https://react.dev/learn/react-compiler) enabled, the compiler can automatically optimize some cases, but functional updates are still recommended for correctness and to prevent stale closure bugs.

.claude/skills/vercel-react-best-practices/rules/rerender-lazy-state-init.md

@@ -1,58 +0,0 @@
----
-title: Use Lazy State Initialization
-impact: MEDIUM
-impactDescription: wasted computation on every render
-tags: react, hooks, useState, performance, initialization
----
-
-## Use Lazy State Initialization
-
-Pass a function to `useState` for expensive initial values. Without the function form, the initializer runs on every render even though the value is only used once.
-
-**Incorrect (runs on every render):**
-
-```tsx
-function FilteredList({ items }: { items: Item[] }) {
-  // buildSearchIndex() runs on EVERY render, even after initialization
-  const [searchIndex, setSearchIndex] = useState(buildSearchIndex(items))
-  const [query, setQuery] = useState('')
-  
-  // When query changes, buildSearchIndex runs again unnecessarily
-  return <SearchResults index={searchIndex} query={query} />
-}
-
-function UserProfile() {
-  // JSON.parse runs on every render
-  const [settings, setSettings] = useState(
-    JSON.parse(localStorage.getItem('settings') || '{}')
-  )
-  
-  return <SettingsForm settings={settings} onChange={setSettings} />
-}
-```
-
-**Correct (runs only once):**
-
-```tsx
-function FilteredList({ items }: { items: Item[] }) {
-  // buildSearchIndex() runs ONLY on initial render
-  const [searchIndex, setSearchIndex] = useState(() => buildSearchIndex(items))
-  const [query, setQuery] = useState('')
-  
-  return <SearchResults index={searchIndex} query={query} />
-}
-
-function UserProfile() {
-  // JSON.parse runs only on initial render
-  const [settings, setSettings] = useState(() => {
-    const stored = localStorage.getItem('settings')
-    return stored ? JSON.parse(stored) : {}
-  })
-  
-  return <SettingsForm settings={settings} onChange={setSettings} />
-}
-```
-
-Use lazy initialization when computing initial values from localStorage/sessionStorage, building data structures (indexes, maps), reading from the DOM, or performing heavy transformations.
-
-For simple primitives (`useState(0)`), direct references (`useState(props.value)`), or cheap literals (`useState({})`), the function form is unnecessary.

.claude/skills/vercel-react-best-practices/rules/rerender-memo.md

@@ -1,44 +0,0 @@
----
-title: Extract to Memoized Components
-impact: MEDIUM
-impactDescription: enables early returns
-tags: rerender, memo, useMemo, optimization
----
-
-## Extract to Memoized Components
-
-Extract expensive work into memoized components to enable early returns before computation.
-
-**Incorrect (computes avatar even when loading):**
-
-```tsx
-function Profile({ user, loading }: Props) {
-  const avatar = useMemo(() => {
-    const id = computeAvatarId(user)
-    return <Avatar id={id} />
-  }, [user])
-
-  if (loading) return <Skeleton />
-  return <div>{avatar}</div>
-}
-```
-
-**Correct (skips computation when loading):**
-
-```tsx
-const UserAvatar = memo(function UserAvatar({ user }: { user: User }) {
-  const id = useMemo(() => computeAvatarId(user), [user])
-  return <Avatar id={id} />
-})
-
-function Profile({ user, loading }: Props) {
-  if (loading) return <Skeleton />
-  return (
-    <div>
-      <UserAvatar user={user} />
-    </div>
-  )
-}
-```
-
-**Note:** If your project has [React Compiler](https://react.dev/learn/react-compiler) enabled, manual memoization with `memo()` and `useMemo()` is not necessary. The compiler automatically optimizes re-renders.

.claude/skills/vercel-react-best-practices/rules/rerender-transitions.md

@@ -1,40 +0,0 @@
----
-title: Use Transitions for Non-Urgent Updates
-impact: MEDIUM
-impactDescription: maintains UI responsiveness
-tags: rerender, transitions, startTransition, performance
----
-
-## Use Transitions for Non-Urgent Updates
-
-Mark frequent, non-urgent state updates as transitions to maintain UI responsiveness.
-
-**Incorrect (blocks UI on every scroll):**
-
-```tsx
-function ScrollTracker() {
-  const [scrollY, setScrollY] = useState(0)
-  useEffect(() => {
-    const handler = () => setScrollY(window.scrollY)
-    window.addEventListener('scroll', handler, { passive: true })
-    return () => window.removeEventListener('scroll', handler)
-  }, [])
-}
-```
-
-**Correct (non-blocking updates):**
-
-```tsx
-import { startTransition } from 'react'
-
-function ScrollTracker() {
-  const [scrollY, setScrollY] = useState(0)
-  useEffect(() => {
-    const handler = () => {
-      startTransition(() => setScrollY(window.scrollY))
-    }
-    window.addEventListener('scroll', handler, { passive: true })
-    return () => window.removeEventListener('scroll', handler)
-  }, [])
-}
-```

.claude/skills/vercel-react-best-practices/rules/server-after-nonblocking.md

@@ -1,73 +0,0 @@
----
-title: Use after() for Non-Blocking Operations
-impact: MEDIUM
-impactDescription: faster response times
-tags: server, async, logging, analytics, side-effects
----
-
-## Use after() for Non-Blocking Operations
-
-Use Next.js's `after()` to schedule work that should execute after a response is sent. This prevents logging, analytics, and other side effects from blocking the response.
-
-**Incorrect (blocks response):**
-
-```tsx
-import { logUserAction } from '@/app/utils'
-
-export async function POST(request: Request) {
-  // Perform mutation
-  await updateDatabase(request)
-  
-  // Logging blocks the response
-  const userAgent = request.headers.get('user-agent') || 'unknown'
-  await logUserAction({ userAgent })
-  
-  return new Response(JSON.stringify({ status: 'success' }), {
-    status: 200,
-    headers: { 'Content-Type': 'application/json' }
-  })
-}
-```
-
-**Correct (non-blocking):**
-
-```tsx
-import { after } from 'next/server'
-import { headers, cookies } from 'next/headers'
-import { logUserAction } from '@/app/utils'
-
-export async function POST(request: Request) {
-  // Perform mutation
-  await updateDatabase(request)
-  
-  // Log after response is sent
-  after(async () => {
-    const userAgent = (await headers()).get('user-agent') || 'unknown'
-    const sessionCookie = (await cookies()).get('session-id')?.value || 'anonymous'
-    
-    logUserAction({ sessionCookie, userAgent })
-  })
-  
-  return new Response(JSON.stringify({ status: 'success' }), {
-    status: 200,
-    headers: { 'Content-Type': 'application/json' }
-  })
-}
-```
-
-The response is sent immediately while logging happens in the background.
-
-**Common use cases:**
-
-- Analytics tracking
-- Audit logging
-- Sending notifications
-- Cache invalidation
-- Cleanup tasks
-
-**Important notes:**
-
-- `after()` runs even if the response fails or redirects
-- Works in Server Actions, Route Handlers, and Server Components
-
-Reference: [https://nextjs.org/docs/app/api-reference/functions/after](https://nextjs.org/docs/app/api-reference/functions/after)

.claude/skills/vercel-react-best-practices/rules/server-cache-lru.md

@@ -1,41 +0,0 @@
----
-title: Cross-Request LRU Caching
-impact: HIGH
-impactDescription: caches across requests
-tags: server, cache, lru, cross-request
----
-
-## Cross-Request LRU Caching
-
-`React.cache()` only works within one request. For data shared across sequential requests (user clicks button A then button B), use an LRU cache.
-
-**Implementation:**
-
-```typescript
-import { LRUCache } from 'lru-cache'
-
-const cache = new LRUCache<string, any>({
-  max: 1000,
-  ttl: 5 * 60 * 1000  // 5 minutes
-})
-
-export async function getUser(id: string) {
-  const cached = cache.get(id)
-  if (cached) return cached
-
-  const user = await db.user.findUnique({ where: { id } })
-  cache.set(id, user)
-  return user
-}
-
-// Request 1: DB query, result cached
-// Request 2: cache hit, no DB query
-```
-
-Use when sequential user actions hit multiple endpoints needing the same data within seconds.
-
-**With Vercel's [Fluid Compute](https://vercel.com/docs/fluid-compute):** LRU caching is especially effective because multiple concurrent requests can share the same function instance and cache. This means the cache persists across requests without needing external storage like Redis.
-
-**In traditional serverless:** Each invocation runs in isolation, so consider Redis for cross-process caching.
-
-Reference: [https://github.com/isaacs/node-lru-cache](https://github.com/isaacs/node-lru-cache)

.claude/skills/vercel-react-best-practices/rules/server-cache-react.md

@@ -1,26 +0,0 @@
----
-title: Per-Request Deduplication with React.cache()
-impact: MEDIUM
-impactDescription: deduplicates within request
-tags: server, cache, react-cache, deduplication
----
-
-## Per-Request Deduplication with React.cache()
-
-Use `React.cache()` for server-side request deduplication. Authentication and database queries benefit most.
-
-**Usage:**
-
-```typescript
-import { cache } from 'react'
-
-export const getCurrentUser = cache(async () => {
-  const session = await auth()
-  if (!session?.user?.id) return null
-  return await db.user.findUnique({
-    where: { id: session.user.id }
-  })
-})
-```
-
-Within a single request, multiple calls to `getCurrentUser()` execute the query only once.

.claude/skills/vercel-react-best-practices/rules/server-parallel-fetching.md

@@ -1,79 +0,0 @@
----
-title: Parallel Data Fetching with Component Composition
-impact: CRITICAL
-impactDescription: eliminates server-side waterfalls
-tags: server, rsc, parallel-fetching, composition
----
-
-## Parallel Data Fetching with Component Composition
-
-React Server Components execute sequentially within a tree. Restructure with composition to parallelize data fetching.
-
-**Incorrect (Sidebar waits for Page's fetch to complete):**
-
-```tsx
-export default async function Page() {
-  const header = await fetchHeader()
-  return (
-    <div>
-      <div>{header}</div>
-      <Sidebar />
-    </div>
-  )
-}
-
-async function Sidebar() {
-  const items = await fetchSidebarItems()
-  return <nav>{items.map(renderItem)}</nav>
-}
-```
-
-**Correct (both fetch simultaneously):**
-
-```tsx
-async function Header() {
-  const data = await fetchHeader()
-  return <div>{data}</div>
-}
-
-async function Sidebar() {
-  const items = await fetchSidebarItems()
-  return <nav>{items.map(renderItem)}</nav>
-}
-
-export default function Page() {
-  return (
-    <div>
-      <Header />
-      <Sidebar />
-    </div>
-  )
-}
-```
-
-**Alternative with children prop:**
-
-```tsx
-async function Layout({ children }: { children: ReactNode }) {
-  const header = await fetchHeader()
-  return (
-    <div>
-      <div>{header}</div>
-      {children}
-    </div>
-  )
-}
-
-async function Sidebar() {
-  const items = await fetchSidebarItems()
-  return <nav>{items.map(renderItem)}</nav>
-}
-
-export default function Page() {
-  return (
-    <Layout>
-      <Sidebar />
-    </Layout>
-  )
-}
-```

.claude/skills/vercel-react-best-practices/rules/server-serialization.md

@@ -1,38 +0,0 @@
----
-title: Minimize Serialization at RSC Boundaries
-impact: HIGH
-impactDescription: reduces data transfer size
-tags: server, rsc, serialization, props
----
-
-## Minimize Serialization at RSC Boundaries
-
-The React Server/Client boundary serializes all object properties into strings and embeds them in the HTML response and subsequent RSC requests. This serialized data directly impacts page weight and load time, so **size matters a lot**. Only pass fields that the client actually uses.
-
-**Incorrect (serializes all 50 fields):**
-
-```tsx
-async function Page() {
-  const user = await fetchUser()  // 50 fields
-  return <Profile user={user} />
-}
-
-'use client'
-function Profile({ user }: { user: User }) {
-  return <div>{user.name}</div>  // uses 1 field
-}
-```
-
-**Correct (serializes only 1 field):**
-
-```tsx
-async function Page() {
-  const user = await fetchUser()
-  return <Profile name={user.name} />
-}
-
-'use client'
-function Profile({ name }: { name: string }) {
-  return <div>{name}</div>
-}
-```

.claude/skills/worktree/SKILL.md

@@ -1,85 +0,0 @@
----
-name: worktree
-description: Set up a new git worktree for parallel development. Creates the worktree, copies .env files, installs dependencies, and generates Prisma client. TRIGGER when user asks to set up a worktree, work on a branch in isolation, or needs a separate environment for a branch or PR.
-user-invocable: true
-args: "[name] — optional worktree name (e.g., 'AutoGPT7'). If omitted, uses next available AutoGPT<N>."
-metadata:
-  author: autogpt-team
-  version: "3.0.0"
----
-
-# Worktree Setup
-
-## Create the worktree
-
-Derive paths from the git toplevel. If a name is provided as argument, use it. Otherwise, check `git worktree list` and pick the next `AutoGPT<N>`.
-
-```bash
-ROOT=$(git rev-parse --show-toplevel)
-PARENT=$(dirname "$ROOT")
-
-# From an existing branch
-git worktree add "$PARENT/<NAME>" <branch-name>
-
-# From a new branch off dev
-git worktree add -b <new-branch> "$PARENT/<NAME>" dev
-```
-
-## Copy environment files
-
-Copy `.env` from the root worktree. Falls back to `.env.default` if `.env` doesn't exist.
-
-```bash
-ROOT=$(git rev-parse --show-toplevel)
-TARGET="$(dirname "$ROOT")/<NAME>"
-
-for envpath in autogpt_platform/backend autogpt_platform/frontend autogpt_platform; do
-  if [ -f "$ROOT/$envpath/.env" ]; then
-    cp "$ROOT/$envpath/.env" "$TARGET/$envpath/.env"
-  elif [ -f "$ROOT/$envpath/.env.default" ]; then
-    cp "$ROOT/$envpath/.env.default" "$TARGET/$envpath/.env"
-  fi
-done
-```
-
-## Install dependencies
-
-```bash
-TARGET="$(dirname "$(git rev-parse --show-toplevel)")/<NAME>"
-cd "$TARGET/autogpt_platform/autogpt_libs" && poetry install
-cd "$TARGET/autogpt_platform/backend" && poetry install && poetry run prisma generate
-cd "$TARGET/autogpt_platform/frontend" && pnpm install
-```
-
-Replace `<NAME>` with the actual worktree name (e.g., `AutoGPT7`).
-
-## Running the app (optional)
-
-Backend uses ports: 8001, 8002, 8003, 8005, 8006, 8007, 8008. Free them first if needed:
-
-```bash
-TARGET="$(dirname "$(git rev-parse --show-toplevel)")/<NAME>"
-for port in 8001 8002 8003 8005 8006 8007 8008; do
-  lsof -ti :$port | xargs kill -9 2>/dev/null || true
-done
-cd "$TARGET/autogpt_platform/backend" && poetry run app
-```
-
-## CoPilot testing
-
-SDK mode spawns a Claude subprocess — won't work inside Claude Code. Set `CHAT_USE_CLAUDE_AGENT_SDK=false` in `backend/.env` to use baseline mode.
-
-## Cleanup
-
-```bash
-# Replace <NAME> with the actual worktree name (e.g., AutoGPT7)
-git worktree remove "$(dirname "$(git rev-parse --show-toplevel)")/<NAME>"
-```
-
-## Alternative: Branchlet (optional)
-
-If [branchlet](https://www.npmjs.com/package/branchlet) is installed:
-
-```bash
-branchlet create -n <name> -s <source-branch> -b <new-branch>
-```

.claude/skills/write-frontend-tests/SKILL.md

@@ -1,224 +0,0 @@
----
-name: write-frontend-tests
-description: "Analyze the current branch diff against dev, plan integration tests for changed frontend pages/components, and write them. TRIGGER when user asks to write frontend tests, add test coverage, or 'write tests for my changes'."
-user-invocable: true
-args: "[base branch] — defaults to dev. Optionally pass a specific base branch to diff against."
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
----
-
-# Write Frontend Tests
-
-Analyze the current branch's frontend changes, plan integration tests, and write them.
-
-## References
-
-Before writing any tests, read the testing rules and conventions:
-
-- `autogpt_platform/frontend/TESTING.md` — testing strategy, file locations, examples
-- `autogpt_platform/frontend/src/tests/AGENTS.md` — detailed testing rules, MSW patterns, decision flowchart
-- `autogpt_platform/frontend/src/tests/integrations/test-utils.tsx` — custom render with providers
-- `autogpt_platform/frontend/src/tests/integrations/vitest.setup.tsx` — MSW server setup
-
-## Step 1: Identify changed frontend files
-
-```bash
-BASE_BRANCH="${ARGUMENTS:-dev}"
-cd autogpt_platform/frontend
-
-# Get changed frontend files (excluding generated, config, and test files)
-git diff "$BASE_BRANCH"...HEAD --name-only -- src/ \
-  | grep -v '__generated__' \
-  | grep -v '__tests__' \
-  | grep -v '\.test\.' \
-  | grep -v '\.stories\.' \
-  | grep -v '\.spec\.'
-```
-
-Also read the diff to understand what changed:
-
-```bash
-git diff "$BASE_BRANCH"...HEAD --stat -- src/
-git diff "$BASE_BRANCH"...HEAD -- src/ | head -500
-```
-
-## Step 2: Categorize changes and find test targets
-
-For each changed file, determine:
-
-1. **Is it a page?** (`page.tsx`) — these are the primary test targets
-2. **Is it a hook?** (`use*.ts`) — test via the page that uses it
-3. **Is it a component?** (`.tsx` in `components/`) — test via the parent page unless it's complex enough to warrant isolation
-4. **Is it a helper?** (`helpers.ts`, `utils.ts`) — unit test directly if pure logic
-
-**Priority order:**
-1. Pages with new/changed data fetching or user interactions
-2. Components with complex internal logic (modals, forms, wizards)
-3. Hooks with non-trivial business logic
-4. Pure helper functions
-
-Skip: styling-only changes, type-only changes, config changes.
-
-## Step 3: Check for existing tests
-
-For each test target, check if tests already exist:
-
-```bash
-# For a page at src/app/(platform)/library/page.tsx
-ls src/app/\(platform\)/library/__tests__/ 2>/dev/null
-
-# For a component at src/app/(platform)/library/components/AgentCard/AgentCard.tsx
-ls src/app/\(platform\)/library/components/AgentCard/__tests__/ 2>/dev/null
-```
-
-Note which targets have no tests (need new files) vs which have tests that need updating.
-
-## Step 4: Identify API endpoints used
-
-For each test target, find which API hooks are used:
-
-```bash
-# Find generated API hook imports in the changed files
-grep -rn 'from.*__generated__/endpoints' src/app/\(platform\)/library/
-grep -rn 'use[A-Z].*V[12]' src/app/\(platform\)/library/
-```
-
-For each API hook found, locate the corresponding MSW handler:
-
-```bash
-# If the page uses useGetV2ListLibraryAgents, find its MSW handlers
-grep -rn 'getGetV2ListLibraryAgents.*Handler' src/app/api/__generated__/endpoints/library/library.msw.ts
-```
-
-List every MSW handler you will need (200 for happy path, 4xx for error paths).
-
-## Step 5: Write the test plan
-
-Before writing code, output a plan as a numbered list:
-
-```
-Test plan for [branch name]:
-
-1. src/app/(platform)/library/__tests__/main.test.tsx (NEW)
-   - Renders page with agent list (MSW 200)
-   - Shows loading state
-   - Shows error state (MSW 422)
-   - Handles empty agent list
-
-2. src/app/(platform)/library/__tests__/search.test.tsx (NEW)
-   - Filters agents by search query
-   - Shows no results message
-   - Clears search
-
-3. src/app/(platform)/library/components/AgentCard/__tests__/AgentCard.test.tsx (UPDATE)
-   - Add test for new "duplicate" action
-```
-
-Present this plan to the user. Wait for confirmation before proceeding. If the user has feedback, adjust the plan.
-
-## Step 6: Write the tests
-
-For each test file in the plan, follow these conventions:
-
-### File structure
-
-```tsx
-import { render, screen, waitFor } from "@/tests/integrations/test-utils";
-import { server } from "@/mocks/mock-server";
-// Import MSW handlers for endpoints the page uses
-import {
-  getGetV2ListLibraryAgentsMockHandler200,
-  getGetV2ListLibraryAgentsMockHandler422,
-} from "@/app/api/__generated__/endpoints/library/library.msw";
-// Import the component under test
-import LibraryPage from "../page";
-
-describe("LibraryPage", () => {
-  test("renders agent list from API", async () => {
-    server.use(getGetV2ListLibraryAgentsMockHandler200());
-
-    render(<LibraryPage />);
-
-    expect(await screen.findByText(/my agents/i)).toBeDefined();
-  });
-
-  test("shows error state on API failure", async () => {
-    server.use(getGetV2ListLibraryAgentsMockHandler422());
-
-    render(<LibraryPage />);
-
-    expect(await screen.findByText(/error/i)).toBeDefined();
-  });
-});
-```
-
-### Rules
-
-- Use `render()` from `@/tests/integrations/test-utils` (NOT from `@testing-library/react` directly)
-- Use `server.use()` to set up MSW handlers BEFORE rendering
-- Use `findBy*` (async) for elements that appear after data fetching — NOT `getBy*`
-- Use `getBy*` only for elements that are immediately present in the DOM
-- Use `screen` queries — do NOT destructure from `render()`
-- Use `waitFor` when asserting side effects or state changes after interactions
-- Import `fireEvent` or `userEvent` from the test-utils for interactions
-- Do NOT mock internal hooks or functions — mock at the API boundary via MSW
-- Do NOT use `act()` manually — `render` and `fireEvent` handle it
-- Keep tests focused: one behavior per test
-- Use descriptive test names that read like sentences
-
-### Test location
-
-```
-# For pages: __tests__/ next to page.tsx
-src/app/(platform)/library/__tests__/main.test.tsx
-
-# For complex standalone components: __tests__/ inside component folder
-src/app/(platform)/library/components/AgentCard/__tests__/AgentCard.test.tsx
-
-# For pure helpers: co-located .test.ts
-src/app/(platform)/library/helpers.test.ts
-```
-
-### Custom MSW overrides
-
-When the auto-generated faker data is not enough, override with specific data:
-
-```tsx
-import { http, HttpResponse } from "msw";
-
-server.use(
-  http.get("http://localhost:3000/api/proxy/api/v2/library/agents", () => {
-    return HttpResponse.json({
-      agents: [
-        { id: "1", name: "Test Agent", description: "A test agent" },
-      ],
-      pagination: { total_items: 1, total_pages: 1, page: 1, page_size: 10 },
-    });
-  }),
-);
-```
-
-Use the proxy URL pattern: `http://localhost:3000/api/proxy/api/v{version}/{path}` — this matches the MSW base URL configured in `orval.config.ts`.
-
-## Step 7: Run and verify
-
-After writing all tests:
-
-```bash
-cd autogpt_platform/frontend
-pnpm test:unit --reporter=verbose
-```
-
-If tests fail:
-1. Read the error output carefully
-2. Fix the test (not the source code, unless there is a genuine bug)
-3. Re-run until all pass
-
-Then run the full checks:
-
-```bash
-pnpm format
-pnpm lint
-pnpm types
-```

.deepsource.toml

@@ -1,18 +0,0 @@
-version = 1
-
-test_patterns = ["**/*.spec.ts","**/*_test.py","**/*_tests.py","**/test_*.py"]
-
-exclude_patterns = ["classic/**"]
-
-[[analyzers]]
-name = "javascript"
-
-[analyzers.meta]
-plugins = ["react"]
-environment = ["nodejs"]
-
-[[analyzers]]
-name = "python"
-
-[analyzers.meta]
-runtime_version = "3.x.x"

.dockerignore

@@ -1,72 +1,40 @@
 # Ignore everything by default, selectively add things to context
-*
+classic/run
 
-# Documentation (for embeddings/search)
-!docs/
-
-# Platform - Libs
-!autogpt_platform/autogpt_libs/
-
-# Platform - Backend
-!autogpt_platform/backend/
-
-# Platform - Frontend
-!autogpt_platform/frontend/
-
-# Classic - AutoGPT
+# AutoGPT
 !classic/original_autogpt/autogpt/
 !classic/original_autogpt/pyproject.toml
 !classic/original_autogpt/poetry.lock
 !classic/original_autogpt/README.md
 !classic/original_autogpt/tests/
 
-# Classic - Benchmark
+# Benchmark
 !classic/benchmark/agbenchmark/
 !classic/benchmark/pyproject.toml
 !classic/benchmark/poetry.lock
 !classic/benchmark/README.md
 
-# Classic - Forge
+# Forge
 !classic/forge/
 !classic/forge/pyproject.toml
 !classic/forge/poetry.lock
 !classic/forge/README.md
 
-# Classic - Frontend
+# Frontend
 !classic/frontend/build/web/
 
-# Explicitly re-ignore unwanted files from whitelisted directories
-# Note: These patterns MUST come after the whitelist rules to take effect
+# Platform
+!autogpt_platform/
 
-# Hidden files and directories (but keep frontend .env files needed for build)
-**/.*
-!autogpt_platform/frontend/.env
-!autogpt_platform/frontend/.env.default
-!autogpt_platform/frontend/.env.production
+# Explicitly re-ignore some folders
+.*
+**/__pycache__
 
-# Python artifacts
-**/__pycache__/
-**/*.pyc
-**/*.pyo
-**/.venv/
-**/.ruff_cache/
-**/.pytest_cache/
-**/.coverage
-**/htmlcov/
+autogpt_platform/frontend/.next/
+autogpt_platform/frontend/node_modules
+autogpt_platform/frontend/.env.example
+autogpt_platform/frontend/.env.local
+autogpt_platform/backend/.env
+autogpt_platform/backend/.venv/
 
-# Node artifacts
-**/node_modules/
-**/.next/
-**/storybook-static/
-**/playwright-report/
-**/test-results/
-
-# Build artifacts
-**/dist/
-**/build/
-!autogpt_platform/frontend/src/**/build/
-**/target/
-
-# Logs and temp files
-**/*.log
-**/*.tmp
+autogpt_platform/market/.env

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,43 +1,36 @@
-### Why / What / How
+### Background
 
-<!-- Why: Why does this PR exist? What problem does it solve, or what's broken/missing without it? -->
-<!-- What: What does this PR change? Summarize the changes at a high level. -->
-<!-- How: How does it work? Describe the approach, key implementation details, or architecture decisions. -->
+<!-- Clearly explain the need for these changes: -->
 
 ### Changes 🏗️
 
-<!-- List the key changes. Keep it higher level than the diff but specific enough to highlight what's new/modified. -->
+<!-- Concisely describe all of the changes made in this pull request: -->
 
-### Checklist 📋
 
-#### For code changes:
-- [ ] I have clearly listed my changes in the PR description
-- [ ] I have made a test plan
-- [ ] I have tested my changes according to the test plan:
-  <!-- Put your test plan here: -->
-  - [ ] ...
+### Testing 🔍
+> [!NOTE] 
+Only for the new autogpt platform, currently in autogpt_platform/
 
-<details>
-  <summary>Example test plan</summary>
-  
-  - [ ] Create from scratch and execute an agent with at least 3 blocks
-  - [ ] Import an agent from file upload, and confirm it executes correctly
-  - [ ] Upload agent to marketplace
-  - [ ] Import an agent from marketplace and confirm it executes correctly
-  - [ ] Edit an agent from monitor, and confirm it executes correctly
-</details>
+<!--
+Please make sure your changes have been tested and are in good working condition. 
+Here is a list of our critical paths, if you need some inspiration on what and how to test:
+-->
 
-#### For configuration changes:
+- Create from scratch and execute an agent with at least 3 blocks
+- Import an agent from file upload, and confirm it executes correctly
+- Upload agent to marketplace
+- Import an agent from marketplace and confirm it executes correctly
+- Edit an agent from monitor, and confirm it executes correctly
 
-- [ ] `.env.default` is updated or already compatible with my changes
-- [ ] `docker-compose.yml` is updated or already compatible with my changes
-- [ ] I have included a list of my configuration changes in the PR description (under **Changes**)
+### Configuration Changes 📝
+> [!NOTE] 
+Only for the new autogpt platform, currently in autogpt_platform/
 
-<details>
-  <summary>Examples of configuration changes</summary>
+If you're making configuration or infrastructure changes, please remember to check you've updated the related infrastructure code in the autogpt_platform/infra folder.
 
-  - Changing ports
-  - Adding new services that need to communicate with each other
-  - Secrets or environment variable changes
-  - New or infrastructure changes such as databases
-</details>
+Examples of such changes might include: 
+
+- Changing ports
+- Adding new services that need to communicate with each other
+- Secrets or environment variable changes
+- New or infrastructure changes such as databases

.github/copilot-instructions.md

@@ -1,322 +0,0 @@
-# GitHub Copilot Instructions for AutoGPT
-
-This file provides comprehensive onboarding information for GitHub Copilot coding agent to work efficiently with the AutoGPT repository.
-
-## Repository Overview
-
-**AutoGPT** is a powerful platform for creating, deploying, and managing continuous AI agents that automate complex workflows. This is a large monorepo (~150MB) containing multiple components:
-
-- **AutoGPT Platform** (`autogpt_platform/`) - Main focus: Modern AI agent platform (Polyform Shield License)
-- **Classic AutoGPT** (`classic/`) - Legacy agent system (MIT License)
-- **Documentation** (`docs/`) - MkDocs-based documentation site
-- **Infrastructure** - Docker configurations, CI/CD, and development tools
-
-**Primary Languages & Frameworks:**
-
-- **Backend**: Python 3.10-3.13, FastAPI, Prisma ORM, PostgreSQL, RabbitMQ
-- **Frontend**: TypeScript, Next.js 15, React, Tailwind CSS, Radix UI
-- **Development**: Docker, Poetry, pnpm, Playwright, Storybook
-
-## Build and Validation Instructions
-
-### Essential Setup Commands
-
-**Always run these commands in the correct directory and in this order:**
-
-1. **Initial Setup** (required once):
-
-   ```bash
-   # Clone and enter repository
-   git clone <repo> && cd AutoGPT
-
-   # Start all services (database, redis, rabbitmq, clamav)
-   cd autogpt_platform && docker compose --profile local up deps --build --detach
-   ```
-
-2. **Backend Setup** (always run before backend development):
-
-   ```bash
-   cd autogpt_platform/backend
-   poetry install                    # Install dependencies
-   poetry run prisma migrate dev     # Run database migrations
-   poetry run prisma generate        # Generate Prisma client
-   ```
-
-3. **Frontend Setup** (always run before frontend development):
-   ```bash
-   cd autogpt_platform/frontend
-   pnpm install                      # Install dependencies
-   ```
-
-### Runtime Requirements
-
-**Critical:** Always ensure Docker services are running before starting development:
-
-```bash
-cd autogpt_platform && docker compose --profile local up deps --build --detach
-```
-
-**Python Version:** Use Python 3.11 (required; managed by Poetry via pyproject.toml)
-**Node.js Version:** Use Node.js 21+ with pnpm package manager
-
-### Development Commands
-
-**Backend Development:**
-
-```bash
-cd autogpt_platform/backend
-poetry run serve                     # Start development server (port 8000)
-poetry run test                      # Run all tests (requires ~5 minutes)
-poetry run pytest path/to/test.py    # Run specific test
-poetry run format                    # Format code (Black + isort) - always run first
-poetry run lint                      # Lint code (ruff) - run after format
-```
-
-**Frontend Development:**
-
-```bash
-cd autogpt_platform/frontend
-pnpm dev                            # Start development server (port 3000) - use for active development
-pnpm build                          # Build for production (only needed for E2E tests or deployment)
-pnpm test                           # Run Playwright E2E tests (requires build first)
-pnpm test-ui                        # Run tests with UI
-pnpm format                         # Format and lint code
-pnpm storybook                      # Start component development server
-```
-
-### Testing Strategy
-
-**Backend Tests:**
-
-- **Block Tests**: `poetry run pytest backend/blocks/test/test_block.py -xvs` (validates all blocks)
-- **Specific Block**: `poetry run pytest 'backend/blocks/test/test_block.py::test_available_blocks[BlockName]' -xvs`
-- **Snapshot Tests**: Use `--snapshot-update` when output changes, always review with `git diff`
-
-**Frontend Tests:**
-
-- **E2E Tests**: Always run `pnpm dev` before `pnpm test` (Playwright requires running instance)
-- **Component Tests**: Use Storybook for isolated component development
-
-### Critical Validation Steps
-
-**Before committing changes:**
-
-1. Run `poetry run format` (backend) and `pnpm format` (frontend)
-2. Ensure all tests pass in modified areas
-3. Verify Docker services are still running
-4. Check that database migrations apply cleanly
-
-**Common Issues & Workarounds:**
-
-- **Prisma issues**: Run `poetry run prisma generate` after schema changes
-- **Permission errors**: Ensure Docker has proper permissions
-- **Port conflicts**: Check the `docker-compose.yml` file for the current list of exposed ports. You can list all mapped ports with:
-- **Test timeouts**: Backend tests can take 5+ minutes, use `-x` flag to stop on first failure
-
-## Project Layout & Architecture
-
-### Core Architecture
-
-**AutoGPT Platform** (`autogpt_platform/`):
-
-- `backend/` - FastAPI server with async support
-  - `backend/backend/` - Core API logic
-  - `backend/blocks/` - Agent execution blocks
-  - `backend/data/` - Database models and schemas
-  - `schema.prisma` - Database schema definition
-- `frontend/` - Next.js application
-  - `src/app/` - App Router pages and layouts
-  - `src/components/` - Reusable React components
-  - `src/lib/` - Utilities and configurations
-- `autogpt_libs/` - Shared Python utilities
-- `docker-compose.yml` - Development stack orchestration
-
-**Key Configuration Files:**
-
-- `pyproject.toml` - Python dependencies and tooling
-- `package.json` - Node.js dependencies and scripts
-- `schema.prisma` - Database schema and migrations
-- `next.config.mjs` - Next.js configuration
-- `tailwind.config.ts` - Styling configuration
-
-### Security & Middleware
-
-**Cache Protection**: Backend includes middleware preventing sensitive data caching in browsers/proxies
-**Authentication**: JWT-based with Supabase integration
-**User ID Validation**: All data access requires user ID checks - verify this for any `data/*.py` changes
-
-### Development Workflow
-
-**GitHub Actions**: Multiple CI/CD workflows in `.github/workflows/`
-
-- `platform-backend-ci.yml` - Backend testing and validation
-- `platform-frontend-ci.yml` - Frontend testing and validation
-- `platform-fullstack-ci.yml` - End-to-end integration tests
-
-**Pre-commit Hooks**: Run linting and formatting checks
-**Conventional Commits**: Use format `type(scope): description` (e.g., `feat(backend): add API`)
-
-### Key Source Files
-
-**Backend Entry Points:**
-
-- `backend/backend/api/rest_api.py` - FastAPI application setup
-- `backend/backend/data/` - Database models and user management
-- `backend/blocks/` - Agent execution blocks and logic
-
-**Frontend Entry Points:**
-
-- `frontend/src/app/layout.tsx` - Root application layout
-- `frontend/src/app/page.tsx` - Home page
-- `frontend/src/lib/supabase/` - Authentication and database client
-
-**Protected Routes**: Update `frontend/lib/supabase/middleware.ts` when adding protected routes
-
-### Agent Block System
-
-Agents are built using a visual block-based system where each block performs a single action. Blocks are defined in `backend/blocks/` and must include:
-
-- Block definition with input/output schemas
-- Execution logic with proper error handling
-- Tests validating functionality
-
-### Database & ORM
-
-**Prisma ORM** with PostgreSQL backend including pgvector for embeddings:
-
-- Schema in `schema.prisma`
-- Migrations in `backend/migrations/`
-- Always run `prisma migrate dev` and `prisma generate` after schema changes
-
-## Environment Configuration
-
-### Configuration Files Priority Order
-
-1. **Backend**: `/backend/.env.default` → `/backend/.env` (user overrides)
-2. **Frontend**: `/frontend/.env.default` → `/frontend/.env` (user overrides)
-3. **Platform**: `/.env.default` (Supabase/shared) → `/.env` (user overrides)
-4. Docker Compose `environment:` sections override file-based config
-5. Shell environment variables have highest precedence
-
-### Docker Environment Setup
-
-- All services use hardcoded defaults (no `${VARIABLE}` substitutions)
-- The `env_file` directive loads variables INTO containers at runtime
-- Backend/Frontend services use YAML anchors for consistent configuration
-- Copy `.env.default` files to `.env` for local development customization
-
-## Advanced Development Patterns
-
-### Adding New Blocks
-
-1. Create file in `/backend/backend/blocks/`
-2. Inherit from `Block` base class with input/output schemas
-3. Implement `run` method with proper error handling
-4. Generate block UUID using `uuid.uuid4()`
-5. Register in block registry
-6. Write tests alongside block implementation
-7. Consider how inputs/outputs connect with other blocks in graph editor
-
-### API Development
-
-1. Update routes in `/backend/backend/api/features/`
-2. Add/update Pydantic models in same directory
-3. Write tests alongside route files
-4. For `data/*.py` changes, validate user ID checks
-5. Run `poetry run test` to verify changes
-
-### Frontend Development
-
-**📖 Complete Frontend Guide**: See `autogpt_platform/frontend/CONTRIBUTING.md` and `autogpt_platform/frontend/.cursorrules` for comprehensive patterns and conventions.
-
-**Quick Reference:**
-
-**Component Structure:**
-
-- Separate render logic from data/behavior
-- Structure: `ComponentName/ComponentName.tsx` + `useComponentName.ts` + `helpers.ts`
-- Exception: Small components (3-4 lines of logic) can be inline
-- Render-only components can be direct files without folders
-
-**Data Fetching:**
-
-- Use generated API hooks from `@/app/api/__generated__/endpoints/`
-- Generated via Orval from backend OpenAPI spec
-- Pattern: `use{Method}{Version}{OperationName}`
-- Example: `useGetV2ListLibraryAgents`
-- Regenerate with: `pnpm generate:api`
-- **Never** use deprecated `BackendAPI` or `src/lib/autogpt-server-api/*`
-
-**Code Conventions:**
-
-- Use function declarations for components and handlers (not arrow functions)
-- Only arrow functions for small inline lambdas (map, filter, etc.)
-- Components: `PascalCase`, Hooks: `camelCase` with `use` prefix
-- No barrel files or `index.ts` re-exports
-- Minimal comments (code should be self-documenting)
-
-**Styling:**
-
-- Use Tailwind CSS utilities only
-- Use design system components from `src/components/` (atoms, molecules, organisms)
-- Never use `src/components/__legacy__/*`
-- Only use Phosphor Icons (`@phosphor-icons/react`)
-- Prefer design tokens over hardcoded values
-
-**Error Handling:**
-
-- Render errors: Use `<ErrorCard />` component
-- Mutation errors: Display with toast notifications
-- Manual exceptions: Use `Sentry.captureException()`
-- Global error boundaries already configured
-
-**Testing:**
-
-- Add/update Storybook stories for UI components (`pnpm storybook`)
-- Run Playwright E2E tests with `pnpm test`
-- Verify in Chromatic after PR
-
-**Architecture:**
-
-- Default to client components ("use client")
-- Server components only for SEO or extreme TTFB needs
-- Use React Query for server state (via generated hooks)
-- Co-locate UI state in components/hooks
-
-### Security Guidelines
-
-**Cache Protection Middleware** (`/backend/backend/api/middleware/security.py`):
-
-- Default: Disables caching for ALL endpoints with `Cache-Control: no-store, no-cache, must-revalidate, private`
-- Uses allow list approach for cacheable paths (static assets, health checks, public pages)
-- Prevents sensitive data caching in browsers/proxies
-- Add new cacheable endpoints to `CACHEABLE_PATHS`
-
-### CI/CD Alignment
-
-The repository has comprehensive CI workflows that test:
-
-- **Backend**: Python 3.11-3.13, services (Redis/RabbitMQ/ClamAV), Prisma migrations, Poetry lock validation
-- **Frontend**: Node.js 21, pnpm, Playwright with Docker Compose stack, API schema validation
-- **Integration**: Full-stack type checking and E2E testing
-
-Match these patterns when developing locally - the copilot setup environment mirrors these CI configurations.
-
-## Collaboration with Other AI Assistants
-
-This repository is actively developed with assistance from Claude (via CLAUDE.md files). When working on this codebase:
-
-- Check for existing CLAUDE.md files that provide additional context
-- Follow established patterns and conventions already in the codebase
-- Maintain consistency with existing code style and architecture
-- Consider that changes may be reviewed and extended by both human developers and AI assistants
-
-## Trust These Instructions
-
-These instructions are comprehensive and tested. Only perform additional searches if:
-
-1. Information here is incomplete for your specific task
-2. You encounter errors not covered by the workarounds
-3. You need to understand implementation details not covered above
-
-For detailed platform development patterns, refer to `autogpt_platform/CLAUDE.md` and `AGENTS.md` in the repository root.

.github/dependabot.yml

@@ -7,22 +7,17 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 10
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(libs/deps)"
-      prefix-development: "chore(libs/deps-dev)"
-    ignore:
-      - dependency-name: "poetry"
     groups:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
 
   # backend (Poetry project)
   - package-ecosystem: "pip"
@@ -31,22 +26,18 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 10
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(backend/deps)"
-      prefix-development: "chore(backend/deps-dev)"
-    ignore:
-      - dependency-name: "poetry"
     groups:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
 
   # frontend (Next.js project)
   - package-ecosystem: "npm"
@@ -55,20 +46,18 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 10
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(frontend/deps)"
-      prefix-development: "chore(frontend/deps-dev)"
     groups:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
 
   # infra (Terraform)
   - package-ecosystem: "terraform"
@@ -77,21 +66,38 @@ updates:
       interval: "weekly"
     open-pull-requests-limit: 5
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(infra/deps)"
-      prefix-development: "chore(infra/deps-dev)"
-
     groups:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
+
+  # market (Poetry project)
+  - package-ecosystem: "pip"
+    directory: "autogpt_platform/market"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10
+    target-branch: "dev"
+    groups:
+      production-dependencies:
+        dependency-type: "production"
+        update-types:
+        - "minor"
+        - "patch"
+      development-dependencies:
+        dependency-type: "development"
+        update-types:
+        - "minor"
+        - "patch"
+
 
   # GitHub Actions
   - package-ecosystem: "github-actions"
@@ -104,13 +110,14 @@ updates:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
 
   # Docker
   - package-ecosystem: "docker"
@@ -123,31 +130,50 @@ updates:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
+
+
+  # Submodules
+  - package-ecosystem: "gitsubmodule"
+    directory: "autogpt_platform/supabase"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 1
+    target-branch: "dev"
+    groups:
+      production-dependencies:
+        dependency-type: "production"
+        update-types:
+        - "minor"
+        - "patch"
+      development-dependencies:
+        dependency-type: "development"
+        update-types:
+        - "minor"
+        - "patch"
+
 
   # Docs
-  - package-ecosystem: "pip"
+  - package-ecosystem: 'pip'
     directory: "docs/"
     schedule:
       interval: "weekly"
     open-pull-requests-limit: 1
     target-branch: "dev"
-    commit-message:
-      prefix: "chore(docs/deps)"
     groups:
       production-dependencies:
         dependency-type: "production"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"
       development-dependencies:
         dependency-type: "development"
         update-types:
-          - "minor"
-          - "patch"
+        - "minor"
+        - "patch"

.github/labeler.yml

@@ -24,9 +24,8 @@ platform/frontend:
 
 platform/backend:
 - changed-files:
-  - all-globs-to-any-file:
-    - autogpt_platform/backend/**
-    - '!autogpt_platform/backend/backend/blocks/**'
+  - any-glob-to-any-file: autogpt_platform/backend/**
+  - all-globs-to-all-files: '!autogpt_platform/backend/backend/blocks/**'
 
 platform/blocks:
 - changed-files:

.github/workflows/classic-autogpt-ci.yml

@@ -6,19 +6,11 @@ on:
     paths:
       - '.github/workflows/classic-autogpt-ci.yml'
       - 'classic/original_autogpt/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/forge/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
   pull_request:
     branches: [ master, dev, release-* ]
     paths:
       - '.github/workflows/classic-autogpt-ci.yml'
       - 'classic/original_autogpt/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/forge/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
 
 concurrency:
   group: ${{ format('classic-autogpt-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -27,22 +19,47 @@ concurrency:
 defaults:
   run:
     shell: bash
-    working-directory: classic
+    working-directory: classic/original_autogpt
 
 jobs:
   test:
     permissions:
       contents: read
     timeout-minutes: 30
-    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+        platform-os: [ubuntu, macos, macos-arm64, windows]
+    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
 
     steps:
-      - name: Start MinIO service
+      # Quite slow on macOS (2~4 minutes to set up Docker)
+      # - name: Set up Docker (macOS)
+      #   if: runner.os == 'macOS'
+      #   uses: crazy-max/ghaction-setup-docker@v3
+
+      - name: Start MinIO service (Linux)
+        if: runner.os == 'Linux'
         working-directory: '.'
         run: |
           docker pull minio/minio:edge-cicd
           docker run -d -p 9000:9000 minio/minio:edge-cicd
 
+      - name: Start MinIO service (macOS)
+        if: runner.os == 'macOS'
+        working-directory: ${{ runner.temp }}
+        run: |
+          brew install minio/stable/minio
+          mkdir data
+          minio server ./data &
+
+      # No MinIO on Windows:
+      # - Windows doesn't support running Linux Docker containers
+      # - It doesn't seem possible to start background processes on Windows. They are
+      #   killed after the step returns.
+      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
+
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -54,23 +71,41 @@ jobs:
           git config --global user.name "Auto-GPT-Bot"
           git config --global user.email "github-bot@agpt.co"
 
-      - name: Set up Python 3.12
+      - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: ${{ matrix.python-version }}
 
       - id: get_date
         name: Get date
         run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
 
       - name: Set up Python dependency cache
+        # On Windows, unpacking cached dependencies takes longer than just installing them
+        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
+          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
+          key: poetry-${{ runner.os }}-${{ hashFiles('classic/original_autogpt/poetry.lock') }}
 
-      - name: Install Poetry
-        run: curl -sSL https://install.python-poetry.org | python3 -
+      - name: Install Poetry (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+
+          if [ "${{ runner.os }}" = "macOS" ]; then
+            PATH="$HOME/.local/bin:$PATH"
+            echo "$HOME/.local/bin" >> $GITHUB_PATH
+          fi
+
+      - name: Install Poetry (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
+
+          $env:PATH += ";$env:APPDATA\Python\Scripts"
+          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
 
       - name: Install Python dependencies
         run: poetry install
@@ -80,32 +115,24 @@ jobs:
           poetry run pytest -vv \
             --cov=autogpt --cov-branch --cov-report term-missing --cov-report xml \
             --numprocesses=logical --durations=10 \
-            --junitxml=junit.xml -o junit_family=legacy \
-            original_autogpt/tests/unit original_autogpt/tests/integration
+            tests/unit tests/integration
         env:
           CI: true
           PLAIN_OUTPUT: True
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          S3_ENDPOINT_URL: http://127.0.0.1:9000
+          S3_ENDPOINT_URL: ${{ runner.os != 'Windows' && 'http://127.0.0.1:9000' || '' }}
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}  # Run even if tests fail
-        uses: codecov/test-results-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          flags: autogpt-agent
+          flags: autogpt-agent,${{ runner.os }}
 
       - name: Upload logs to artifact
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: test-logs
-          path: classic/logs/
+          path: classic/original_autogpt/logs/

.github/workflows/classic-autogpt-docker-cache-clean.yml

@@ -5,7 +5,7 @@ on:
     - cron: 20 4 * * 1,4
 
 env:
-  BASE_BRANCH: dev
+  BASE_BRANCH: development
   IMAGE_NAME: auto-gpt
 
 jobs:
@@ -15,46 +15,46 @@ jobs:
       matrix:
         build-type: [release, dev]
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+    - name: Checkout repository
+      uses: actions/checkout@v4
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
 
-      - id: build
-        name: Build image
-        uses: docker/build-push-action@v6
-        with:
-          context: classic/
-          file: classic/Dockerfile.autogpt
-          build-args: BUILD_TYPE=${{ matrix.build-type }}
-          load: true # save to docker images
-          # use GHA cache as read-only
-          cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
+    - id: build
+      name: Build image
+      uses: docker/build-push-action@v5
+      with:
+        context: classic/
+        file: classic/Dockerfile.autogpt
+        build-args: BUILD_TYPE=${{ matrix.build-type }}
+        load: true    # save to docker images
+        # use GHA cache as read-only
+        cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
 
-      - name: Generate build report
-        env:
-          event_name: ${{ github.event_name }}
-          event_ref: ${{ github.event.schedule }}
+    - name: Generate build report
+      env:
+        event_name: ${{ github.event_name }}
+        event_ref: ${{ github.event.schedule }}
 
-          build_type: ${{ matrix.build-type }}
+        build_type: ${{ matrix.build-type }}
 
-          prod_branch: master
-          dev_branch: dev
-          repository: ${{ github.repository }}
-          base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'dev' && 'dev' || 'master' }}
+        prod_branch: master
+        dev_branch: development
+        repository: ${{ github.repository }}
+        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
 
-          current_ref: ${{ github.ref_name }}
-          commit_hash: ${{ github.sha }}
-          source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.sha) }}
-          push_forced_label:
+        current_ref: ${{ github.ref_name }}
+        commit_hash: ${{ github.sha }}
+        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.sha) }}
+        push_forced_label:
 
-          new_commits_json: ${{ null }}
-          compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
+        new_commits_json: ${{ null }}
+        compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
 
-          github_context_json: ${{ toJSON(github) }}
-          job_env_json: ${{ toJSON(env) }}
-          vars_json: ${{ toJSON(vars) }}
+        github_context_json: ${{ toJSON(github) }}
+        job_env_json: ${{ toJSON(env) }}
+        vars_json: ${{ toJSON(vars) }}
 
-        run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
-        continue-on-error: true
+      run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
+      continue-on-error: true

.github/workflows/classic-autogpt-docker-ci.yml

@@ -2,7 +2,7 @@ name: Classic - AutoGPT Docker CI
 
 on:
   push:
-    branches: [master, dev]
+    branches: [ master, development ]
     paths:
       - '.github/workflows/classic-autogpt-docker-ci.yml'
       - 'classic/original_autogpt/**'
@@ -34,58 +34,58 @@ jobs:
       matrix:
         build-type: [release, dev]
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+    - name: Checkout repository
+      uses: actions/checkout@v4
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
 
-      - if: runner.debug
-        run: |
-          ls -al
-          du -hs *
+    - if: runner.debug
+      run: |
+        ls -al
+        du -hs *
 
-      - id: build
-        name: Build image
-        uses: docker/build-push-action@v6
-        with:
-          context: classic/
-          file: classic/Dockerfile.autogpt
-          build-args: BUILD_TYPE=${{ matrix.build-type }}
-          tags: ${{ env.IMAGE_NAME }}
-          labels: GIT_REVISION=${{ github.sha }}
-          load: true # save to docker images
-          # cache layers in GitHub Actions cache to speed up builds
-          cache-from: type=gha,scope=autogpt-docker-${{ matrix.build-type }}
-          cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
+    - id: build
+      name: Build image
+      uses: docker/build-push-action@v5
+      with:
+        context: classic/
+        file: classic/Dockerfile.autogpt
+        build-args: BUILD_TYPE=${{ matrix.build-type }}
+        tags: ${{ env.IMAGE_NAME }}
+        labels: GIT_REVISION=${{ github.sha }}
+        load: true    # save to docker images
+        # cache layers in GitHub Actions cache to speed up builds
+        cache-from: type=gha,scope=autogpt-docker-${{ matrix.build-type }}
+        cache-to: type=gha,scope=autogpt-docker-${{ matrix.build-type }},mode=max
 
-      - name: Generate build report
-        env:
-          event_name: ${{ github.event_name }}
-          event_ref: ${{ github.event.ref }}
-          event_ref_type: ${{ github.event.ref}}
+    - name: Generate build report
+      env:
+        event_name: ${{ github.event_name }}
+        event_ref: ${{ github.event.ref }}
+        event_ref_type: ${{ github.event.ref}}
 
-          build_type: ${{ matrix.build-type }}
+        build_type: ${{ matrix.build-type }}
 
-          prod_branch: master
-          dev_branch: dev
-          repository: ${{ github.repository }}
-          base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'dev' && 'dev' || 'master' }}
+        prod_branch: master
+        dev_branch: development
+        repository: ${{ github.repository }}
+        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
 
-          current_ref: ${{ github.ref_name }}
-          commit_hash: ${{ github.event.after }}
-          source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
-          push_forced_label: ${{ github.event.forced && '☢️ forced' || '' }}
+        current_ref: ${{ github.ref_name }}
+        commit_hash: ${{ github.event.after }}
+        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
+        push_forced_label: ${{ github.event.forced && '☢️ forced' || '' }}
 
-          new_commits_json: ${{ toJSON(github.event.commits) }}
-          compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
+        new_commits_json: ${{ toJSON(github.event.commits) }}
+        compare_url_template: ${{ format('/{0}/compare/{{base}}...{{head}}', github.repository) }}
 
-          github_context_json: ${{ toJSON(github) }}
-          job_env_json: ${{ toJSON(env) }}
-          vars_json: ${{ toJSON(vars) }}
+        github_context_json: ${{ toJSON(github) }}
+        job_env_json: ${{ toJSON(env) }}
+        vars_json: ${{ toJSON(vars) }}
 
-        run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
-        continue-on-error: true
+      run: .github/workflows/scripts/docker-ci-summary.sh >> $GITHUB_STEP_SUMMARY
+      continue-on-error: true
 
   test:
     runs-on: ubuntu-latest
@@ -117,16 +117,16 @@ jobs:
 
       - id: build
         name: Build image
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v5
         with:
           context: classic/
           file: classic/Dockerfile.autogpt
-          build-args: BUILD_TYPE=dev # include pytest
+          build-args: BUILD_TYPE=dev  # include pytest
           tags: >
             ${{ env.IMAGE_NAME }},
             ${{ env.DEPLOY_IMAGE_NAME }}:${{ env.DEV_IMAGE_TAG }}
           labels: GIT_REVISION=${{ github.sha }}
-          load: true # save to docker images
+          load: true                  # save to docker images
           # cache layers in GitHub Actions cache to speed up builds
           cache-from: type=gha,scope=autogpt-docker-dev
           cache-to: type=gha,scope=autogpt-docker-dev,mode=max
@@ -148,7 +148,7 @@ jobs:
             --entrypoint poetry ${{ env.IMAGE_NAME }} run \
             pytest -v --cov=autogpt --cov-branch --cov-report term-missing \
             --numprocesses=4 --durations=10 \
-            original_autogpt/tests/unit original_autogpt/tests/integration 2>&1 | tee test_output.txt
+            tests/unit tests/integration 2>&1 | tee test_output.txt
 
           test_failure=${PIPESTATUS[0]}
 

.github/workflows/classic-autogpt-docker-release.yml

@@ -2,7 +2,7 @@ name: Classic - AutoGPT Docker Release
 
 on:
   release:
-    types: [published, edited]
+    types: [ published, edited ]
 
   workflow_dispatch:
     inputs:
@@ -19,69 +19,69 @@ jobs:
     if: startsWith(github.ref, 'refs/tags/autogpt-')
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+    - name: Checkout repository
+      uses: actions/checkout@v4
 
-      - name: Log in to Docker hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKER_USER }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
+    - name: Log in to Docker hub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ secrets.DOCKER_USER }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
 
-        # slashes are not allowed in image tags, but can appear in git branch or tag names
-      - id: sanitize_tag
-        name: Sanitize image tag
-        run: |
-          tag=${raw_tag//\//-}
-          echo tag=${tag#autogpt-} >> $GITHUB_OUTPUT
-        env:
-          raw_tag: ${{ github.ref_name }}
+      # slashes are not allowed in image tags, but can appear in git branch or tag names
+    - id: sanitize_tag
+      name: Sanitize image tag
+      run: |
+        tag=${raw_tag//\//-}
+        echo tag=${tag#autogpt-} >> $GITHUB_OUTPUT
+      env:
+        raw_tag: ${{ github.ref_name }}
 
-      - id: build
-        name: Build image
-        uses: docker/build-push-action@v6
-        with:
-          context: classic/
-          file: Dockerfile.autogpt
-          build-args: BUILD_TYPE=release
-          load: true # save to docker images
-          # push: true  # TODO: uncomment when this issue is fixed: https://github.com/moby/buildkit/issues/1555
-          tags: >
-            ${{ env.IMAGE_NAME }},
-            ${{ env.DEPLOY_IMAGE_NAME }}:latest,
-            ${{ env.DEPLOY_IMAGE_NAME }}:${{ steps.sanitize_tag.outputs.tag }}
-          labels: GIT_REVISION=${{ github.sha }}
+    - id: build
+      name: Build image
+      uses: docker/build-push-action@v5
+      with:
+        context: classic/
+        file: Dockerfile.autogpt
+        build-args: BUILD_TYPE=release
+        load: true    # save to docker images
+        # push: true  # TODO: uncomment when this issue is fixed: https://github.com/moby/buildkit/issues/1555
+        tags: >
+          ${{ env.IMAGE_NAME }},
+          ${{ env.DEPLOY_IMAGE_NAME }}:latest,
+          ${{ env.DEPLOY_IMAGE_NAME }}:${{ steps.sanitize_tag.outputs.tag }}
+        labels: GIT_REVISION=${{ github.sha }}
 
-          # cache layers in GitHub Actions cache to speed up builds
-          cache-from: ${{ !inputs.no_cache && 'type=gha' || '' }},scope=autogpt-docker-release
-          cache-to: type=gha,scope=autogpt-docker-release,mode=max
+        # cache layers in GitHub Actions cache to speed up builds
+        cache-from: ${{ !inputs.no_cache && 'type=gha' || '' }},scope=autogpt-docker-release
+        cache-to: type=gha,scope=autogpt-docker-release,mode=max
 
-      - name: Push image to Docker Hub
-        run: docker push --all-tags ${{ env.DEPLOY_IMAGE_NAME }}
+    - name: Push image to Docker Hub
+      run: docker push --all-tags ${{ env.DEPLOY_IMAGE_NAME }}
 
-      - name: Generate build report
-        env:
-          event_name: ${{ github.event_name }}
-          event_ref: ${{ github.event.ref }}
-          event_ref_type: ${{ github.event.ref}}
-          inputs_no_cache: ${{ inputs.no_cache }}
+    - name: Generate build report
+      env:
+        event_name: ${{ github.event_name }}
+        event_ref: ${{ github.event.ref }}
+        event_ref_type: ${{ github.event.ref}}
+        inputs_no_cache: ${{ inputs.no_cache }}
 
-          prod_branch: master
-          dev_branch: dev
-          repository: ${{ github.repository }}
-          base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'dev' && 'dev' || 'master' }}
+        prod_branch: master
+        dev_branch: development
+        repository: ${{ github.repository }}
+        base_branch: ${{ github.ref_name != 'master' && github.ref_name != 'development' && 'development' || 'master' }}
 
-          ref_type: ${{ github.ref_type }}
-          current_ref: ${{ github.ref_name }}
-          commit_hash: ${{ github.sha }}
-          source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
+        ref_type: ${{ github.ref_type }}
+        current_ref: ${{ github.ref_name }}
+        commit_hash: ${{ github.sha }}
+        source_url: ${{ format('{0}/tree/{1}', github.event.repository.url, github.event.release && github.event.release.tag_name || github.sha) }}
 
-          github_context_json: ${{ toJSON(github) }}
-          job_env_json: ${{ toJSON(env) }}
-          vars_json: ${{ toJSON(vars) }}
+        github_context_json: ${{ toJSON(github) }}
+        job_env_json: ${{ toJSON(env) }}
+        vars_json: ${{ toJSON(vars) }}
 
-        run: .github/workflows/scripts/docker-release-summary.sh >> $GITHUB_STEP_SUMMARY
-        continue-on-error: true
+      run: .github/workflows/scripts/docker-release-summary.sh >> $GITHUB_STEP_SUMMARY
+      continue-on-error: true

.github/workflows/classic-autogpts-ci.yml

@@ -10,9 +10,10 @@ on:
       - '.github/workflows/classic-autogpts-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - 'classic/benchmark/**'
+      - 'classic/run'
+      - 'classic/cli.py'
+      - 'classic/setup.py'
       - '!**/*.md'
   pull_request:
     branches: [ master, dev, release-* ]
@@ -20,9 +21,10 @@ on:
       - '.github/workflows/classic-autogpts-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - 'classic/benchmark/**'
+      - 'classic/run'
+      - 'classic/cli.py'
+      - 'classic/setup.py'
       - '!**/*.md'
 
 defaults:
@@ -33,9 +35,13 @@ defaults:
 jobs:
   serve-agent-protocol:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        agent-name: [ original_autogpt ]
+      fail-fast: false
     timeout-minutes: 20
     env:
-      min-python-version: '3.12'
+      min-python-version: '3.10'
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -49,22 +55,22 @@ jobs:
           python-version: ${{ env.min-python-version }}
 
       - name: Install Poetry
+        working-directory: ./classic/${{ matrix.agent-name }}/
         run: |
           curl -sSL https://install.python-poetry.org | python -
 
-      - name: Install dependencies
-        run: poetry install
-
-      - name: Run smoke tests with direct-benchmark
+      - name: Run regression tests
         run: |
-          poetry run direct-benchmark run \
-            --strategies one_shot \
-            --models claude \
-            --tests ReadFile,WriteFile \
-            --json
+          ./run agent start ${{ matrix.agent-name }}
+          cd ${{ matrix.agent-name }}
+          poetry run agbenchmark --mock --test=BasicRetrieval --test=Battleship --test=WebArenaTask_0
+          poetry run agbenchmark --test=WriteFile
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          AGENT_NAME: ${{ matrix.agent-name }}
           REQUESTS_CA_BUNDLE: /etc/ssl/certs/ca-certificates.crt
-          NONINTERACTIVE_MODE: "true"
-          CI: true
+          HELICONE_CACHE_ENABLED: false
+          HELICONE_PROPERTY_AGENT: ${{ matrix.agent-name }}
+          REPORTS_FOLDER: ${{ format('../../reports/{0}', matrix.agent-name) }}
+          TELEMETRY_ENVIRONMENT: autogpt-ci
+          TELEMETRY_OPT_IN: ${{ github.ref_name == 'master' }}

.github/workflows/classic-benchmark-ci.yml

@@ -1,24 +1,18 @@
-name: Classic - Direct Benchmark CI
+name: Classic - AGBenchmark CI
 
 on:
   push:
     branches: [ master, dev, ci-test* ]
     paths:
-      - 'classic/direct_benchmark/**'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
+      - 'classic/benchmark/**'
+      - '!classic/benchmark/reports/**'
       - .github/workflows/classic-benchmark-ci.yml
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
   pull_request:
     branches: [ master, dev, release-* ]
     paths:
-      - 'classic/direct_benchmark/**'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
+      - 'classic/benchmark/**'
+      - '!classic/benchmark/reports/**'
       - .github/workflows/classic-benchmark-ci.yml
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
 
 concurrency:
   group: ${{ format('benchmark-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -29,16 +23,23 @@ defaults:
     shell: bash
 
 env:
-  min-python-version: '3.12'
+  min-python-version: '3.10'
 
 jobs:
-  benchmark-tests:
-    runs-on: ubuntu-latest
+  test:
+    permissions:
+      contents: read
     timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+        platform-os: [ubuntu, macos, macos-arm64, windows]
+    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
     defaults:
       run:
         shell: bash
-        working-directory: classic
+        working-directory: classic/benchmark
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -46,88 +47,64 @@ jobs:
           fetch-depth: 0
           submodules: true
 
-      - name: Set up Python ${{ env.min-python-version }}
+      - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
-          python-version: ${{ env.min-python-version }}
+          python-version: ${{ matrix.python-version }}
 
       - name: Set up Python dependency cache
+        # On Windows, unpacking cached dependencies takes longer than just installing them
+        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
+          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
+          key: poetry-${{ runner.os }}-${{ hashFiles('classic/benchmark/poetry.lock') }}
 
-      - name: Install Poetry
+      - name: Install Poetry (Unix)
+        if: runner.os != 'Windows'
         run: |
           curl -sSL https://install.python-poetry.org | python3 -
 
-      - name: Install dependencies
+          if [ "${{ runner.os }}" = "macOS" ]; then
+            PATH="$HOME/.local/bin:$PATH"
+            echo "$HOME/.local/bin" >> $GITHUB_PATH
+          fi
+
+      - name: Install Poetry (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
+
+          $env:PATH += ";$env:APPDATA\Python\Scripts"
+          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
+
+      - name: Install Python dependencies
         run: poetry install
 
-      - name: Run basic benchmark tests
+      - name: Run pytest with coverage
         run: |
-          echo "Testing ReadFile challenge with one_shot strategy..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot \
-            --models claude \
-            --tests ReadFile \
-            --json
-
-          echo "Testing WriteFile challenge..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot \
-            --models claude \
-            --tests WriteFile \
-            --json
+          poetry run pytest -vv \
+            --cov=agbenchmark --cov-branch --cov-report term-missing --cov-report xml \
+            --durations=10 \
+            tests
         env:
           CI: true
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          NONINTERACTIVE_MODE: "true"
 
-      - name: Test category filtering
-        run: |
-          echo "Testing coding category..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot \
-            --models claude \
-            --categories coding \
-            --tests ReadFile,WriteFile \
-            --json
-        env:
-          CI: true
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          NONINTERACTIVE_MODE: "true"
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          flags: agbenchmark,${{ runner.os }}
 
-      - name: Test multiple strategies
-        run: |
-          echo "Testing multiple strategies..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot,plan_execute \
-            --models claude \
-            --tests ReadFile \
-            --parallel 2 \
-            --json
-        env:
-          CI: true
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          NONINTERACTIVE_MODE: "true"
-
-  # Run regression tests on maintain challenges
-  regression-tests:
+  self-test-with-agent:
     runs-on: ubuntu-latest
-    timeout-minutes: 45
-    if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/dev'
-    defaults:
-      run:
-        shell: bash
-        working-directory: classic
+    strategy:
+      matrix:
+        agent-name: [ forge ]
+      fail-fast: false
+    timeout-minutes: 20
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -140,31 +117,53 @@ jobs:
         with:
           python-version: ${{ env.min-python-version }}
 
-      - name: Set up Python dependency cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
-
       - name: Install Poetry
         run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-      - name: Install dependencies
-        run: poetry install
+          curl -sSL https://install.python-poetry.org | python -
 
       - name: Run regression tests
+        working-directory: classic
         run: |
-          echo "Running regression tests (previously beaten challenges)..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot \
-            --models claude \
-            --maintain \
-            --parallel 4 \
-            --json
+          ./run agent start ${{ matrix.agent-name }}
+          cd ${{ matrix.agent-name }}
+
+          set +e # Ignore non-zero exit codes and continue execution
+          echo "Running the following command: poetry run agbenchmark --maintain --mock"
+          poetry run agbenchmark --maintain --mock
+          EXIT_CODE=$?
+          set -e  # Stop ignoring non-zero exit codes
+          # Check if the exit code was 5, and if so, exit with 0 instead
+          if [ $EXIT_CODE -eq 5 ]; then
+            echo "regression_tests.json is empty."
+          fi
+
+          echo "Running the following command: poetry run agbenchmark --mock"
+          poetry run agbenchmark --mock
+
+          echo "Running the following command: poetry run agbenchmark --mock --category=data"
+          poetry run agbenchmark --mock --category=data
+
+          echo "Running the following command: poetry run agbenchmark --mock --category=coding"
+          poetry run agbenchmark --mock --category=coding
+
+          echo "Running the following command: poetry run agbenchmark --test=WriteFile"
+          poetry run agbenchmark --test=WriteFile
+          cd ../benchmark
+          poetry install
+          echo "Adding the BUILD_SKILL_TREE environment variable. This will attempt to add new elements in the skill tree. If new elements are added, the CI fails because they should have been pushed"
+          export BUILD_SKILL_TREE=true
+
+          poetry run agbenchmark --mock
+
+          CHANGED=$(git diff --name-only | grep -E '(agbenchmark/challenges)|(../classic/frontend/assets)') || echo "No diffs"
+          if [ ! -z "$CHANGED" ]; then
+            echo "There are unstaged changes please run agbenchmark and commit those changes since they are needed."
+            echo "$CHANGED"
+            exit 1
+          else
+            echo "No unstaged changes."
+          fi
         env:
-          CI: true
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          NONINTERACTIVE_MODE: "true"
+          TELEMETRY_ENVIRONMENT: autogpt-benchmark-ci
+          TELEMETRY_OPT_IN: ${{ github.ref_name == 'master' }}

.github/workflows/classic-forge-ci.yml

@@ -6,15 +6,13 @@ on:
     paths:
       - '.github/workflows/classic-forge-ci.yml'
       - 'classic/forge/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - '!classic/forge/tests/vcr_cassettes'
   pull_request:
     branches: [ master, dev, release-* ]
     paths:
       - '.github/workflows/classic-forge-ci.yml'
       - 'classic/forge/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - '!classic/forge/tests/vcr_cassettes'
 
 concurrency:
   group: ${{ format('forge-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -23,78 +21,216 @@ concurrency:
 defaults:
   run:
     shell: bash
-    working-directory: classic
+    working-directory: classic/forge
 
 jobs:
   test:
     permissions:
       contents: read
     timeout-minutes: 30
-    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+        platform-os: [ubuntu, macos, macos-arm64, windows]
+    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
 
     steps:
-      - name: Start MinIO service
+      # Quite slow on macOS (2~4 minutes to set up Docker)
+      # - name: Set up Docker (macOS)
+      #   if: runner.os == 'macOS'
+      #   uses: crazy-max/ghaction-setup-docker@v3
+
+      - name: Start MinIO service (Linux)
+        if: runner.os == 'Linux'
         working-directory: '.'
         run: |
           docker pull minio/minio:edge-cicd
           docker run -d -p 9000:9000 minio/minio:edge-cicd
 
+      - name: Start MinIO service (macOS)
+        if: runner.os == 'macOS'
+        working-directory: ${{ runner.temp }}
+        run: |
+          brew install minio/stable/minio
+          mkdir data
+          minio server ./data &
+
+      # No MinIO on Windows:
+      # - Windows doesn't support running Linux Docker containers
+      # - It doesn't seem possible to start background processes on Windows. They are
+      #   killed after the step returns.
+      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
+
       - name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
 
-      - name: Set up Python 3.12
+      - name: Checkout cassettes
+        if: ${{ startsWith(github.event_name, 'pull_request') }}
+        env:
+          PR_BASE: ${{ github.event.pull_request.base.ref }}
+          PR_BRANCH: ${{ github.event.pull_request.head.ref }}
+          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
+        run: |
+          cassette_branch="${PR_AUTHOR}-${PR_BRANCH}"
+          cassette_base_branch="${PR_BASE}"
+          cd tests/vcr_cassettes
+
+          if ! git ls-remote --exit-code --heads origin $cassette_base_branch ; then
+            cassette_base_branch="master"
+          fi
+
+          if git ls-remote --exit-code --heads origin $cassette_branch ; then
+            git fetch origin $cassette_branch
+            git fetch origin $cassette_base_branch
+
+            git checkout $cassette_branch
+
+            # Pick non-conflicting cassette updates from the base branch
+            git merge --no-commit --strategy-option=ours origin/$cassette_base_branch
+            echo "Using cassettes from mirror branch '$cassette_branch'," \
+              "synced to upstream branch '$cassette_base_branch'."
+          else
+            git checkout -b $cassette_branch
+            echo "Branch '$cassette_branch' does not exist in cassette submodule." \
+              "Using cassettes from '$cassette_base_branch'."
+          fi
+
+      - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: ${{ matrix.python-version }}
 
       - name: Set up Python dependency cache
+        # On Windows, unpacking cached dependencies takes longer than just installing them
+        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
+          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
+          key: poetry-${{ runner.os }}-${{ hashFiles('classic/forge/poetry.lock') }}
 
-      - name: Install Poetry
-        run: curl -sSL https://install.python-poetry.org | python3 -
+      - name: Install Poetry (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+
+          if [ "${{ runner.os }}" = "macOS" ]; then
+            PATH="$HOME/.local/bin:$PATH"
+            echo "$HOME/.local/bin" >> $GITHUB_PATH
+          fi
+
+      - name: Install Poetry (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
+
+          $env:PATH += ";$env:APPDATA\Python\Scripts"
+          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
 
       - name: Install Python dependencies
         run: poetry install
 
-      - name: Install Playwright browsers
-        run: poetry run playwright install chromium
-
       - name: Run pytest with coverage
         run: |
           poetry run pytest -vv \
             --cov=forge --cov-branch --cov-report term-missing --cov-report xml \
             --durations=10 \
-            --junitxml=junit.xml -o junit_family=legacy \
-            forge/forge forge/tests
+            forge
         env:
           CI: true
           PLAIN_OUTPUT: True
-          # API keys - tests that need these will skip if not available
-          # Secrets are not available to fork PRs (GitHub security feature)
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          S3_ENDPOINT_URL: http://127.0.0.1:9000
+          S3_ENDPOINT_URL: ${{ runner.os != 'Windows' && 'http://127.0.0.1:9000' || '' }}
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}  # Run even if tests fail
-        uses: codecov/test-results-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          flags: forge
+          flags: forge,${{ runner.os }}
+
+      - id: setup_git_auth
+        name: Set up git token authentication
+        # Cassettes may be pushed even when tests fail
+        if: success() || failure()
+        run: |
+          config_key="http.${{ github.server_url }}/.extraheader"
+          if [ "${{ runner.os }}" = 'macOS' ]; then
+            base64_pat=$(echo -n "pat:${{ secrets.PAT_REVIEW }}" | base64)
+          else
+            base64_pat=$(echo -n "pat:${{ secrets.PAT_REVIEW }}" | base64 -w0)
+          fi
+
+          git config "$config_key" \
+            "Authorization: Basic $base64_pat"
+
+          cd tests/vcr_cassettes
+          git config "$config_key" \
+            "Authorization: Basic $base64_pat"
+
+          echo "config_key=$config_key" >> $GITHUB_OUTPUT
+
+      - id: push_cassettes
+        name: Push updated cassettes
+        # For pull requests, push updated cassettes even when tests fail
+        if: github.event_name == 'push' || (! github.event.pull_request.head.repo.fork && (success() || failure()))
+        env:
+          PR_BRANCH: ${{ github.event.pull_request.head.ref }}
+          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
+        run: |
+          if [ "${{ startsWith(github.event_name, 'pull_request') }}" = "true" ]; then
+            is_pull_request=true
+            cassette_branch="${PR_AUTHOR}-${PR_BRANCH}"
+          else
+            cassette_branch="${{ github.ref_name }}"
+          fi
+
+          cd tests/vcr_cassettes
+          # Commit & push changes to cassettes if any
+          if ! git diff --quiet; then
+            git add .
+            git commit -m "Auto-update cassettes"
+            git push origin HEAD:$cassette_branch
+            if [ ! $is_pull_request ]; then
+              cd ../..
+              git add tests/vcr_cassettes
+              git commit -m "Update cassette submodule"
+              git push origin HEAD:$cassette_branch
+            fi
+            echo "updated=true" >> $GITHUB_OUTPUT
+          else
+            echo "updated=false" >> $GITHUB_OUTPUT
+            echo "No cassette changes to commit"
+          fi
+
+      - name: Post Set up git token auth
+        if: steps.setup_git_auth.outcome == 'success'
+        run: |
+          git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
+          git submodule foreach git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
+
+      - name: Apply "behaviour change" label and comment on PR
+        if: ${{ startsWith(github.event_name, 'pull_request') }}
+        run: |
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+          TOKEN="${{ secrets.PAT_REVIEW }}"
+          REPO="${{ github.repository }}"
+
+          if [[ "${{ steps.push_cassettes.outputs.updated }}" == "true" ]]; then
+            echo "Adding label and comment..."
+            echo $TOKEN | gh auth login --with-token
+            gh issue edit $PR_NUMBER --add-label "behaviour change"
+            gh issue comment $PR_NUMBER --body "You changed AutoGPT's behaviour on ${{ runner.os }}. The cassettes have been updated and will be merged to the submodule when this Pull Request gets merged."
+          fi
 
       - name: Upload logs to artifact
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: test-logs
-          path: classic/logs/
+          path: classic/forge/logs/

.github/workflows/classic-frontend-ci.yml

@@ -0,0 +1,60 @@
+name: Classic - Frontend CI/CD
+
+on:
+  push:
+    branches:
+      - master
+      - development
+      - 'ci-test*' # This will match any branch that starts with "ci-test"
+    paths:
+      - 'classic/frontend/**'
+      - '.github/workflows/classic-frontend-ci.yml'
+  pull_request:
+    paths:
+      - 'classic/frontend/**'
+      - '.github/workflows/classic-frontend-ci.yml'
+
+jobs:
+  build:
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    env:
+      BUILD_BRANCH: ${{ format('classic-frontend-build/{0}', github.ref_name) }}
+
+    steps:
+    - name: Checkout Repo
+      uses: actions/checkout@v4
+
+    - name: Setup Flutter
+      uses: subosito/flutter-action@v2
+      with:
+        flutter-version: '3.13.2'
+
+    - name: Build Flutter to Web
+      run: |
+        cd classic/frontend
+        flutter build web --base-href /app/
+
+    # - name: Commit and Push to ${{ env.BUILD_BRANCH }}
+    #   if: github.event_name == 'push'
+    #   run: |
+    #     git config --local user.email "action@github.com"
+    #     git config --local user.name "GitHub Action"
+    #     git add classic/frontend/build/web
+    #     git checkout -B ${{ env.BUILD_BRANCH }}
+    #     git commit -m "Update frontend build to ${GITHUB_SHA:0:7}" -a
+    #     git push -f origin ${{ env.BUILD_BRANCH }}
+
+    - name: Create PR ${{ env.BUILD_BRANCH }} -> ${{ github.ref_name }}
+      if: github.event_name == 'push'
+      uses: peter-evans/create-pull-request@v7
+      with:
+        add-paths: classic/frontend/build/web
+        base: ${{ github.ref_name }}
+        branch: ${{ env.BUILD_BRANCH }}
+        delete-branch: true
+        title: "Update frontend build in `${{ github.ref_name }}`"
+        body: "This PR updates the frontend build based on commit ${{ github.sha }}."
+        commit-message: "Update frontend build based on commit ${{ github.sha }}"

.github/workflows/classic-python-checks.yml

@@ -7,9 +7,7 @@ on:
       - '.github/workflows/classic-python-checks-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - 'classic/benchmark/**'
       - '**.py'
       - '!classic/forge/tests/vcr_cassettes'
   pull_request:
@@ -18,9 +16,7 @@ on:
       - '.github/workflows/classic-python-checks-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - 'classic/benchmark/**'
       - '**.py'
       - '!classic/forge/tests/vcr_cassettes'
 
@@ -31,13 +27,44 @@ concurrency:
 defaults:
   run:
     shell: bash
-    working-directory: classic
 
 jobs:
+  get-changed-parts:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - id: changes-in
+        name: Determine affected subprojects
+        uses: dorny/paths-filter@v3
+        with:
+          filters: |
+            original_autogpt:
+              - classic/original_autogpt/autogpt/**
+              - classic/original_autogpt/tests/**
+              - classic/original_autogpt/poetry.lock
+            forge:
+              - classic/forge/forge/**
+              - classic/forge/tests/**
+              - classic/forge/poetry.lock
+            benchmark:
+              - classic/benchmark/agbenchmark/**
+              - classic/benchmark/tests/**
+              - classic/benchmark/poetry.lock
+    outputs:
+      changed-parts: ${{ steps.changes-in.outputs.changes }}
+
   lint:
+    needs: get-changed-parts
     runs-on: ubuntu-latest
     env:
-      min-python-version: "3.12"
+      min-python-version: "3.10"
+
+    strategy:
+      matrix:
+        sub-package: ${{ fromJson(needs.get-changed-parts.outputs.changed-parts) }}
+      fail-fast: false
 
     steps:
       - name: Checkout repository
@@ -54,31 +81,42 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cache/pypoetry
-          key: ${{ runner.os }}-poetry-${{ hashFiles('classic/poetry.lock') }}
+          key: ${{ runner.os }}-poetry-${{ hashFiles(format('{0}/poetry.lock', matrix.sub-package)) }}
 
       - name: Install Poetry
         run: curl -sSL https://install.python-poetry.org | python3 -
 
+      # Install dependencies
+
       - name: Install Python dependencies
-        run: poetry install
+        run: poetry -C classic/${{ matrix.sub-package }} install
 
       # Lint
 
       - name: Lint (isort)
         run: poetry run isort --check .
+        working-directory: classic/${{ matrix.sub-package }}
 
       - name: Lint (Black)
         if: success() || failure()
         run: poetry run black --check .
+        working-directory: classic/${{ matrix.sub-package }}
 
       - name: Lint (Flake8)
         if: success() || failure()
         run: poetry run flake8 .
+        working-directory: classic/${{ matrix.sub-package }}
 
   types:
+    needs: get-changed-parts
     runs-on: ubuntu-latest
     env:
-      min-python-version: "3.12"
+      min-python-version: "3.10"
+
+    strategy:
+      matrix:
+        sub-package: ${{ fromJson(needs.get-changed-parts.outputs.changed-parts) }}
+      fail-fast: false
 
     steps:
       - name: Checkout repository
@@ -95,16 +133,19 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cache/pypoetry
-          key: ${{ runner.os }}-poetry-${{ hashFiles('classic/poetry.lock') }}
+          key: ${{ runner.os }}-poetry-${{ hashFiles(format('{0}/poetry.lock', matrix.sub-package)) }}
 
       - name: Install Poetry
         run: curl -sSL https://install.python-poetry.org | python3 -
 
+      # Install dependencies
+
       - name: Install Python dependencies
-        run: poetry install
+        run: poetry -C classic/${{ matrix.sub-package }} install
 
       # Typecheck
 
       - name: Typecheck
         if: success() || failure()
         run: poetry run pyright
+        working-directory: classic/${{ matrix.sub-package }}

.github/workflows/claude-ci-failure-auto-fix.yml

@@ -1,139 +0,0 @@
-name: Auto Fix CI Failures
-
-on:
-  workflow_run:
-    workflows: ["CI"]
-    types:
-      - completed
-
-permissions:
-  contents: write
-  pull-requests: write
-  actions: read
-  issues: write
-  id-token: write # Required for OIDC token exchange
-
-jobs:
-  auto-fix:
-    if: |
-      github.event.workflow_run.conclusion == 'failure' &&
-      github.event.workflow_run.pull_requests[0] &&
-      !startsWith(github.event.workflow_run.head_branch, 'claude-auto-fix-ci-')
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          ref: ${{ github.event.workflow_run.head_branch }}
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Setup git identity
-        run: |
-          git config --global user.email "claude[bot]@users.noreply.github.com"
-          git config --global user.name "claude[bot]"
-
-      - name: Create fix branch
-        id: branch
-        run: |
-          BRANCH_NAME="claude-auto-fix-ci-${{ github.event.workflow_run.head_branch }}-${{ github.run_id }}"
-          git checkout -b "$BRANCH_NAME"
-          echo "branch_name=$BRANCH_NAME" >> $GITHUB_OUTPUT
-
-      # Backend Python/Poetry setup (so Claude can run linting/tests)
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Install Poetry
-        run: |
-          cd autogpt_platform/backend
-          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: Install Python dependencies
-        working-directory: autogpt_platform/backend
-        run: poetry install
-
-      - name: Generate Prisma Client
-        working-directory: autogpt_platform/backend
-        run: poetry run prisma generate && poetry run gen-prisma-stub
-
-      # Frontend Node.js/pnpm setup (so Claude can run linting/tests)
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: "22"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
-
-      - name: Install JavaScript dependencies
-        working-directory: autogpt_platform/frontend
-        run: pnpm install --frozen-lockfile
-
-      - name: Get CI failure details
-        id: failure_details
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const run = await github.rest.actions.getWorkflowRun({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              run_id: ${{ github.event.workflow_run.id }}
-            });
-
-            const jobs = await github.rest.actions.listJobsForWorkflowRun({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              run_id: ${{ github.event.workflow_run.id }}
-            });
-
-            const failedJobs = jobs.data.jobs.filter(job => job.conclusion === 'failure');
-
-            let errorLogs = [];
-            for (const job of failedJobs) {
-              const logs = await github.rest.actions.downloadJobLogsForWorkflowRun({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                job_id: job.id
-              });
-              errorLogs.push({
-                jobName: job.name,
-                logs: logs.data
-              });
-            }
-
-            return {
-              runUrl: run.data.html_url,
-              failedJobs: failedJobs.map(j => j.name),
-              errorLogs: errorLogs
-            };
-
-      - name: Fix CI failures with Claude
-        id: claude
-        uses: anthropics/claude-code-action@v1
-        with:
-          prompt: |
-            /fix-ci 
-            Failed CI Run: ${{ fromJSON(steps.failure_details.outputs.result).runUrl }}
-            Failed Jobs: ${{ join(fromJSON(steps.failure_details.outputs.result).failedJobs, ', ') }}
-            PR Number: ${{ github.event.workflow_run.pull_requests[0].number }}
-            Branch Name: ${{ steps.branch.outputs.branch_name }}
-            Base Branch: ${{ github.event.workflow_run.head_branch }}
-            Repository: ${{ github.repository }}
-
-            Error logs:
-            ${{ toJSON(fromJSON(steps.failure_details.outputs.result).errorLogs) }}
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-          claude_args: "--allowedTools 'Edit,MultiEdit,Write,Read,Glob,Grep,LS,Bash(git:*),Bash(bun:*),Bash(npm:*),Bash(npx:*),Bash(gh:*)'"

.github/workflows/claude-dependabot.yml

@@ -1,368 +0,0 @@
-# Claude Dependabot PR Review Workflow
-# 
-# This workflow automatically runs Claude analysis on Dependabot PRs to:
-# - Identify dependency changes and their versions
-# - Look up changelogs for updated packages  
-# - Assess breaking changes and security impacts
-# - Provide actionable recommendations for the development team
-#
-# Triggered on: Dependabot PRs (opened, synchronize)
-# Requirements: CLAUDE_CODE_OAUTH_TOKEN secret must be configured
-
-name: Claude Dependabot PR Review
-
-on:
-  pull_request:
-    types: [opened, synchronize]
-
-jobs:
-  dependabot-review:
-    # Only run on Dependabot PRs
-    if: github.actor == 'dependabot[bot]'
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-
-    permissions:
-      contents: write
-      pull-requests: read
-      issues: read
-      id-token: write
-      actions: read # Required for CI access
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 1
-
-      # Backend Python/Poetry setup (mirrors platform-backend-ci.yml)
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"  # Use standard version matching CI
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Install Poetry
-        run: |
-          # Extract Poetry version from backend/poetry.lock (matches CI)
-          cd autogpt_platform/backend
-          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Found Poetry version ${HEAD_POETRY_VERSION} in backend/poetry.lock"
-          
-          # Install Poetry
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-          
-          # Add Poetry to PATH
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: Check poetry.lock
-        working-directory: autogpt_platform/backend
-        run: |
-          poetry lock
-          if ! git diff --quiet --ignore-matching-lines="^# " poetry.lock; then
-            echo "Warning: poetry.lock not up to date, but continuing for setup"
-            git checkout poetry.lock  # Reset for clean setup
-          fi
-
-      - name: Install Python dependencies
-        working-directory: autogpt_platform/backend
-        run: poetry install
-
-      - name: Generate Prisma Client
-        working-directory: autogpt_platform/backend
-        run: poetry run prisma generate && poetry run gen-prisma-stub
-
-      # Frontend Node.js/pnpm setup (mirrors platform-frontend-ci.yml)
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: "22"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
-
-      - name: Install JavaScript dependencies
-        working-directory: autogpt_platform/frontend
-        run: pnpm install --frozen-lockfile
-
-      # Install Playwright browsers for frontend testing
-      # NOTE: Disabled to save ~1 minute of setup time. Re-enable if Copilot needs browser automation (e.g., for MCP)
-      # - name: Install Playwright browsers
-      #   working-directory: autogpt_platform/frontend
-      #   run: pnpm playwright install --with-deps chromium
-
-      # Docker setup for development environment
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Copy default environment files
-        working-directory: autogpt_platform
-        run: |
-          # Copy default environment files for development
-          cp .env.default .env
-          cp backend/.env.default backend/.env
-          cp frontend/.env.default frontend/.env
-
-      # Phase 1: Cache and load Docker images for faster setup
-      - name: Set up Docker image cache
-        id: docker-cache
-        uses: actions/cache@v5
-        with:
-          path: ~/docker-cache
-          # Use a versioned key for cache invalidation when image list changes
-          key: docker-images-v2-${{ runner.os }}-${{ hashFiles('.github/workflows/copilot-setup-steps.yml') }}
-          restore-keys: |
-            docker-images-v2-${{ runner.os }}-
-            docker-images-v1-${{ runner.os }}-
-
-      - name: Load or pull Docker images
-        working-directory: autogpt_platform
-        run: |
-          mkdir -p ~/docker-cache
-          
-          # Define image list for easy maintenance
-          IMAGES=(
-            "redis:latest"
-            "rabbitmq:management"
-            "clamav/clamav-debian:latest"
-            "busybox:latest"
-            "kong:2.8.1"
-            "supabase/gotrue:v2.170.0"
-            "supabase/postgres:15.8.1.049"
-            "supabase/postgres-meta:v0.86.1"
-            "supabase/studio:20250224-d10db0f"
-          )
-          
-          # Check if any cached tar files exist (more reliable than cache-hit)
-          if ls ~/docker-cache/*.tar 1> /dev/null 2>&1; then
-            echo "Docker cache found, loading images in parallel..."
-            for image in "${IMAGES[@]}"; do
-              # Convert image name to filename (replace : and / with -)
-              filename=$(echo "$image" | tr ':/' '--')
-              if [ -f ~/docker-cache/${filename}.tar ]; then
-                echo "Loading $image..."
-                docker load -i ~/docker-cache/${filename}.tar || echo "Warning: Failed to load $image from cache" &
-              fi
-            done
-            wait
-            echo "All cached images loaded"
-          else
-            echo "No Docker cache found, pulling images in parallel..."
-            # Pull all images in parallel
-            for image in "${IMAGES[@]}"; do
-              docker pull "$image" &
-            done
-            wait
-            
-            # Only save cache on main branches (not PRs) to avoid cache pollution
-            if [[ "${{ github.ref }}" == "refs/heads/master" ]] || [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
-              echo "Saving Docker images to cache in parallel..."
-              for image in "${IMAGES[@]}"; do
-                # Convert image name to filename (replace : and / with -)
-                filename=$(echo "$image" | tr ':/' '--')
-                echo "Saving $image..."
-                docker save -o ~/docker-cache/${filename}.tar "$image" || echo "Warning: Failed to save $image" &
-              done
-              wait
-              echo "Docker image cache saved"
-            else
-              echo "Skipping cache save for PR/feature branch"
-            fi
-          fi
-          
-          echo "Docker images ready for use"
-
-      # Phase 2: Build migrate service with GitHub Actions cache
-      - name: Build migrate Docker image with cache
-        working-directory: autogpt_platform
-        run: |
-          # Build the migrate image with buildx for GHA caching
-          docker buildx build \
-            --cache-from type=gha \
-            --cache-to type=gha,mode=max \
-            --target migrate \
-            --tag autogpt_platform-migrate:latest \
-            --load \
-            -f backend/Dockerfile \
-            ..
-
-      # Start services using pre-built images
-      - name: Start Docker services for development
-        working-directory: autogpt_platform
-        run: |
-          # Start essential services (migrate image already built with correct tag)
-          docker compose --profile local up deps --no-build --detach
-          echo "Waiting for services to be ready..."
-          
-          # Wait for database to be ready
-          echo "Checking database readiness..."
-          timeout 30 sh -c 'until docker compose exec -T db pg_isready -U postgres 2>/dev/null; do 
-            echo "  Waiting for database..."
-            sleep 2
-          done' && echo "✅ Database is ready" || echo "⚠️ Database ready check timeout after 30s, continuing..."
-          
-          # Check migrate service status
-          echo "Checking migration status..."
-          docker compose ps migrate || echo "  Migrate service not visible in ps output"
-          
-          # Wait for migrate service to complete
-          echo "Waiting for migrations to complete..."
-          timeout 30 bash -c '
-            ATTEMPTS=0
-            while [ $ATTEMPTS -lt 15 ]; do
-              ATTEMPTS=$((ATTEMPTS + 1))
-              
-              # Check using docker directly (more reliable than docker compose ps)
-              CONTAINER_STATUS=$(docker ps -a --filter "label=com.docker.compose.service=migrate" --format "{{.Status}}" | head -1)
-              
-              if [ -z "$CONTAINER_STATUS" ]; then
-                echo "  Attempt $ATTEMPTS: Migrate container not found yet..."
-              elif echo "$CONTAINER_STATUS" | grep -q "Exited (0)"; then
-                echo "✅ Migrations completed successfully"
-                docker compose logs migrate --tail=5 2>/dev/null || true
-                exit 0
-              elif echo "$CONTAINER_STATUS" | grep -q "Exited ([1-9]"; then
-                EXIT_CODE=$(echo "$CONTAINER_STATUS" | grep -oE "Exited \([0-9]+\)" | grep -oE "[0-9]+")
-                echo "❌ Migrations failed with exit code: $EXIT_CODE"
-                echo "Migration logs:"
-                docker compose logs migrate --tail=20 2>/dev/null || true
-                exit 1
-              elif echo "$CONTAINER_STATUS" | grep -q "Up"; then
-                echo "  Attempt $ATTEMPTS: Migrate container is running... ($CONTAINER_STATUS)"
-              else
-                echo "  Attempt $ATTEMPTS: Migrate container status: $CONTAINER_STATUS"
-              fi
-              
-              sleep 2
-            done
-            
-            echo "⚠️ Timeout: Could not determine migration status after 30 seconds"
-            echo "Final container check:"
-            docker ps -a --filter "label=com.docker.compose.service=migrate" || true
-            echo "Migration logs (if available):"
-            docker compose logs migrate --tail=10 2>/dev/null || echo "  No logs available"
-          ' || echo "⚠️ Migration check completed with warnings, continuing..."
-          
-          # Brief wait for other services to stabilize
-          echo "Waiting 5 seconds for other services to stabilize..."
-          sleep 5
-
-      # Verify installations and provide environment info
-      - name: Verify setup and show environment info
-        run: |
-          echo "=== Python Setup ==="
-          python --version
-          poetry --version
-          
-          echo "=== Node.js Setup ==="
-          node --version
-          pnpm --version
-          
-          echo "=== Additional Tools ==="
-          docker --version
-          docker compose version
-          gh --version || true
-          
-          echo "=== Services Status ==="
-          cd autogpt_platform
-          docker compose ps || true
-          
-          echo "=== Backend Dependencies ==="
-          cd backend
-          poetry show | head -10 || true
-          
-          echo "=== Frontend Dependencies ==="
-          cd ../frontend
-          pnpm list --depth=0 | head -10 || true
-          
-          echo "=== Environment Files ==="
-          ls -la ../.env* || true
-          ls -la .env* || true
-          ls -la ../backend/.env* || true
-          
-          echo "✅ AutoGPT Platform development environment setup complete!"
-          echo "🚀 Ready for development with Docker services running"
-          echo "📝 Backend server: poetry run serve (port 8000)"
-          echo "🌐 Frontend server: pnpm dev (port 3000)"
-
-
-      - name: Run Claude Dependabot Analysis
-        id: claude_review
-        uses: anthropics/claude-code-action@v1
-        with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-          allowed_bots: "dependabot[bot]"
-          claude_args: |
-            --allowedTools "Bash(npm:*),Bash(pnpm:*),Bash(poetry:*),Bash(git:*),Edit,Replace,NotebookEditCell,mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*), Bash(gh pr diff:*), Bash(gh pr view:*)"
-          prompt: |
-            You are Claude, an AI assistant specialized in reviewing Dependabot dependency update PRs. 
-            
-            Your primary tasks are:
-            1. **Analyze the dependency changes** in this Dependabot PR
-            2. **Look up changelogs** for all updated dependencies to understand what changed
-            3. **Identify breaking changes** and assess potential impact on the AutoGPT codebase
-            4. **Provide actionable recommendations** for the development team
-            
-            ## Analysis Process:
-            
-            1. **Identify Changed Dependencies**: 
-               - Use git diff to see what dependencies were updated
-               - Parse package.json, poetry.lock, requirements files, etc.
-               - List all package versions: old → new
-            
-            2. **Changelog Research**:
-               - For each updated dependency, look up its changelog/release notes
-               - Use WebFetch to access GitHub releases, NPM package pages, PyPI project pages. The pr should also have some details
-               - Focus on versions between the old and new versions
-               - Identify: breaking changes, deprecations, security fixes, new features
-            
-            3. **Breaking Change Assessment**:
-               - Categorize changes: BREAKING, MAJOR, MINOR, PATCH, SECURITY
-               - Assess impact on AutoGPT's usage patterns
-               - Check if AutoGPT uses affected APIs/features
-               - Look for migration guides or upgrade instructions
-            
-            4. **Codebase Impact Analysis**:
-               - Search the AutoGPT codebase for usage of changed APIs
-               - Identify files that might be affected by breaking changes
-               - Check test files for deprecated usage patterns
-               - Look for configuration changes needed
-            
-            ## Output Format:
-            
-            Provide a comprehensive review comment with:
-            
-            ### 🔍 Dependency Analysis Summary
-            - List of updated packages with version changes
-            - Overall risk assessment (LOW/MEDIUM/HIGH)
-            
-            ### 📋 Detailed Changelog Review
-            For each updated dependency:
-            - **Package**: name (old_version → new_version)
-            - **Changes**: Summary of key changes
-            - **Breaking Changes**: List any breaking changes
-            - **Security Fixes**: Note security improvements
-            - **Migration Notes**: Any upgrade steps needed
-            
-            ### ⚠️ Impact Assessment
-            - **Breaking Changes Found**: Yes/No with details
-            - **Affected Files**: List AutoGPT files that may need updates
-            - **Test Impact**: Any tests that may need updating
-            - **Configuration Changes**: Required config updates
-            
-            ### 🛠️ Recommendations
-            - **Action Required**: What the team should do
-            - **Testing Focus**: Areas to test thoroughly
-            - **Follow-up Tasks**: Any additional work needed
-            - **Merge Recommendation**: APPROVE/REVIEW_NEEDED/HOLD
-            
-            ### 📚 Useful Links
-            - Links to relevant changelogs, migration guides, documentation
-            
-            Be thorough but concise. Focus on actionable insights that help the development team make informed decisions about the dependency updates.

.github/workflows/claude.yml

@@ -1,319 +0,0 @@
-name: Claude Code
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_review_comment:
-    types: [created]
-  issues:
-    types: [opened, assigned]
-  pull_request_review:
-    types: [submitted]
-
-jobs:
-  claude:
-    if: |
-      (
-        (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
-        (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
-        (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
-        (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
-      ) && (
-        github.event.comment.author_association == 'OWNER' ||
-        github.event.comment.author_association == 'MEMBER' ||
-        github.event.comment.author_association == 'COLLABORATOR' ||
-        github.event.review.author_association == 'OWNER' ||
-        github.event.review.author_association == 'MEMBER' ||
-        github.event.review.author_association == 'COLLABORATOR' ||
-        github.event.issue.author_association == 'OWNER' ||
-        github.event.issue.author_association == 'MEMBER' ||
-        github.event.issue.author_association == 'COLLABORATOR'
-      )
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-
-    permissions:
-      contents: write
-      pull-requests: read
-      issues: read
-      id-token: write
-      actions: read # Required for CI access
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 1
-
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@v1.3.1
-        with:
-          large-packages: false  # slow
-          docker-images: false  # limited benefit
-
-      # Backend Python/Poetry setup (mirrors platform-backend-ci.yml)
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"  # Use standard version matching CI
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Install Poetry
-        run: |
-          # Extract Poetry version from backend/poetry.lock (matches CI)
-          cd autogpt_platform/backend
-          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Found Poetry version ${HEAD_POETRY_VERSION} in backend/poetry.lock"
-          
-          # Install Poetry
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-          
-          # Add Poetry to PATH
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: Check poetry.lock
-        working-directory: autogpt_platform/backend
-        run: |
-          poetry lock
-          if ! git diff --quiet --ignore-matching-lines="^# " poetry.lock; then
-            echo "Warning: poetry.lock not up to date, but continuing for setup"
-            git checkout poetry.lock  # Reset for clean setup
-          fi
-
-      - name: Install Python dependencies
-        working-directory: autogpt_platform/backend
-        run: poetry install
-
-      - name: Generate Prisma Client
-        working-directory: autogpt_platform/backend
-        run: poetry run prisma generate && poetry run gen-prisma-stub
-
-      # Frontend Node.js/pnpm setup (mirrors platform-frontend-ci.yml)
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: "22"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
-
-      - name: Install JavaScript dependencies
-        working-directory: autogpt_platform/frontend
-        run: pnpm install --frozen-lockfile
-
-      # Install Playwright browsers for frontend testing
-      # NOTE: Disabled to save ~1 minute of setup time. Re-enable if Copilot needs browser automation (e.g., for MCP)
-      # - name: Install Playwright browsers
-      #   working-directory: autogpt_platform/frontend
-      #   run: pnpm playwright install --with-deps chromium
-
-      # Docker setup for development environment
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Copy default environment files
-        working-directory: autogpt_platform
-        run: |
-          # Copy default environment files for development
-          cp .env.default .env
-          cp backend/.env.default backend/.env
-          cp frontend/.env.default frontend/.env
-
-      # Phase 1: Cache and load Docker images for faster setup
-      - name: Set up Docker image cache
-        id: docker-cache
-        uses: actions/cache@v5
-        with:
-          path: ~/docker-cache
-          # Use a versioned key for cache invalidation when image list changes
-          key: docker-images-v2-${{ runner.os }}-${{ hashFiles('.github/workflows/copilot-setup-steps.yml') }}
-          restore-keys: |
-            docker-images-v2-${{ runner.os }}-
-            docker-images-v1-${{ runner.os }}-
-
-      - name: Load or pull Docker images
-        working-directory: autogpt_platform
-        run: |
-          mkdir -p ~/docker-cache
-          
-          # Define image list for easy maintenance
-          IMAGES=(
-            "redis:latest"
-            "rabbitmq:management"
-            "clamav/clamav-debian:latest"
-            "busybox:latest"
-            "kong:2.8.1"
-            "supabase/gotrue:v2.170.0"
-            "supabase/postgres:15.8.1.049"
-            "supabase/postgres-meta:v0.86.1"
-            "supabase/studio:20250224-d10db0f"
-          )
-          
-          # Check if any cached tar files exist (more reliable than cache-hit)
-          if ls ~/docker-cache/*.tar 1> /dev/null 2>&1; then
-            echo "Docker cache found, loading images in parallel..."
-            for image in "${IMAGES[@]}"; do
-              # Convert image name to filename (replace : and / with -)
-              filename=$(echo "$image" | tr ':/' '--')
-              if [ -f ~/docker-cache/${filename}.tar ]; then
-                echo "Loading $image..."
-                docker load -i ~/docker-cache/${filename}.tar || echo "Warning: Failed to load $image from cache" &
-              fi
-            done
-            wait
-            echo "All cached images loaded"
-          else
-            echo "No Docker cache found, pulling images in parallel..."
-            # Pull all images in parallel
-            for image in "${IMAGES[@]}"; do
-              docker pull "$image" &
-            done
-            wait
-            
-            # Only save cache on main branches (not PRs) to avoid cache pollution
-            if [[ "${{ github.ref }}" == "refs/heads/master" ]] || [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
-              echo "Saving Docker images to cache in parallel..."
-              for image in "${IMAGES[@]}"; do
-                # Convert image name to filename (replace : and / with -)
-                filename=$(echo "$image" | tr ':/' '--')
-                echo "Saving $image..."
-                docker save -o ~/docker-cache/${filename}.tar "$image" || echo "Warning: Failed to save $image" &
-              done
-              wait
-              echo "Docker image cache saved"
-            else
-              echo "Skipping cache save for PR/feature branch"
-            fi
-          fi
-          
-          echo "Docker images ready for use"
-
-      # Phase 2: Build migrate service with GitHub Actions cache
-      - name: Build migrate Docker image with cache
-        working-directory: autogpt_platform
-        run: |
-          # Build the migrate image with buildx for GHA caching
-          docker buildx build \
-            --cache-from type=gha \
-            --cache-to type=gha,mode=max \
-            --target migrate \
-            --tag autogpt_platform-migrate:latest \
-            --load \
-            -f backend/Dockerfile \
-            ..
-
-      # Start services using pre-built images
-      - name: Start Docker services for development
-        working-directory: autogpt_platform
-        run: |
-          # Start essential services (migrate image already built with correct tag)
-          docker compose --profile local up deps --no-build --detach
-          echo "Waiting for services to be ready..."
-          
-          # Wait for database to be ready
-          echo "Checking database readiness..."
-          timeout 30 sh -c 'until docker compose exec -T db pg_isready -U postgres 2>/dev/null; do 
-            echo "  Waiting for database..."
-            sleep 2
-          done' && echo "✅ Database is ready" || echo "⚠️ Database ready check timeout after 30s, continuing..."
-          
-          # Check migrate service status
-          echo "Checking migration status..."
-          docker compose ps migrate || echo "  Migrate service not visible in ps output"
-          
-          # Wait for migrate service to complete
-          echo "Waiting for migrations to complete..."
-          timeout 30 bash -c '
-            ATTEMPTS=0
-            while [ $ATTEMPTS -lt 15 ]; do
-              ATTEMPTS=$((ATTEMPTS + 1))
-              
-              # Check using docker directly (more reliable than docker compose ps)
-              CONTAINER_STATUS=$(docker ps -a --filter "label=com.docker.compose.service=migrate" --format "{{.Status}}" | head -1)
-              
-              if [ -z "$CONTAINER_STATUS" ]; then
-                echo "  Attempt $ATTEMPTS: Migrate container not found yet..."
-              elif echo "$CONTAINER_STATUS" | grep -q "Exited (0)"; then
-                echo "✅ Migrations completed successfully"
-                docker compose logs migrate --tail=5 2>/dev/null || true
-                exit 0
-              elif echo "$CONTAINER_STATUS" | grep -q "Exited ([1-9]"; then
-                EXIT_CODE=$(echo "$CONTAINER_STATUS" | grep -oE "Exited \([0-9]+\)" | grep -oE "[0-9]+")
-                echo "❌ Migrations failed with exit code: $EXIT_CODE"
-                echo "Migration logs:"
-                docker compose logs migrate --tail=20 2>/dev/null || true
-                exit 1
-              elif echo "$CONTAINER_STATUS" | grep -q "Up"; then
-                echo "  Attempt $ATTEMPTS: Migrate container is running... ($CONTAINER_STATUS)"
-              else
-                echo "  Attempt $ATTEMPTS: Migrate container status: $CONTAINER_STATUS"
-              fi
-              
-              sleep 2
-            done
-            
-            echo "⚠️ Timeout: Could not determine migration status after 30 seconds"
-            echo "Final container check:"
-            docker ps -a --filter "label=com.docker.compose.service=migrate" || true
-            echo "Migration logs (if available):"
-            docker compose logs migrate --tail=10 2>/dev/null || echo "  No logs available"
-          ' || echo "⚠️ Migration check completed with warnings, continuing..."
-          
-          # Brief wait for other services to stabilize
-          echo "Waiting 5 seconds for other services to stabilize..."
-          sleep 5
-
-      # Verify installations and provide environment info
-      - name: Verify setup and show environment info
-        run: |
-          echo "=== Python Setup ==="
-          python --version
-          poetry --version
-          
-          echo "=== Node.js Setup ==="
-          node --version
-          pnpm --version
-          
-          echo "=== Additional Tools ==="
-          docker --version
-          docker compose version
-          gh --version || true
-          
-          echo "=== Services Status ==="
-          cd autogpt_platform
-          docker compose ps || true
-          
-          echo "=== Backend Dependencies ==="
-          cd backend
-          poetry show | head -10 || true
-          
-          echo "=== Frontend Dependencies ==="
-          cd ../frontend
-          pnpm list --depth=0 | head -10 || true
-          
-          echo "=== Environment Files ==="
-          ls -la ../.env* || true
-          ls -la .env* || true
-          ls -la ../backend/.env* || true
-          
-          echo "✅ AutoGPT Platform development environment setup complete!"
-          echo "🚀 Ready for development with Docker services running"
-          echo "📝 Backend server: poetry run serve (port 8000)"
-          echo "🌐 Frontend server: pnpm dev (port 3000)"
-
-      - name: Run Claude Code
-        id: claude
-        uses: anthropics/claude-code-action@v1
-        with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-          claude_args: |
-            --allowedTools "Bash(npm:*),Bash(pnpm:*),Bash(poetry:*),Bash(git:*),Edit,Replace,NotebookEditCell,mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*), Bash(gh pr diff:*), Bash(gh pr view:*), Bash(gh pr edit:*)"
-            --model opus
-          additional_permissions: |
-            actions: read

.github/workflows/codeql.yml

@@ -16,7 +16,6 @@ on:
     branches: [ "master", "release-*", "dev" ]
   pull_request:
     branches: [ "master", "release-*", "dev" ]
-  merge_group:
   schedule:
     - cron: '15 4 * * 0'
 
@@ -58,11 +57,11 @@ jobs:
         # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v4
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
@@ -93,6 +92,6 @@ jobs:
         exit 1
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v4
+      uses: github/codeql-action/analyze@v3
       with:
         category: "/language:${{matrix.language}}"

.github/workflows/copilot-setup-steps.yml

@@ -1,312 +0,0 @@
-name: "Copilot Setup Steps"
-
-# Automatically run the setup steps when they are changed to allow for easy validation, and
-# allow manual testing through the repository's "Actions" tab
-on:
-  workflow_dispatch:
-  push:
-    paths:
-      - .github/workflows/copilot-setup-steps.yml
-  pull_request:
-    paths:
-      - .github/workflows/copilot-setup-steps.yml
-
-jobs:
-  # The job MUST be called `copilot-setup-steps` or it will not be picked up by Copilot.
-  copilot-setup-steps:
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-
-    # Set the permissions to the lowest permissions possible needed for your steps.
-    # Copilot will be given its own token for its operations.
-    permissions:
-      # If you want to clone the repository as part of your setup steps, for example to install dependencies, you'll need the `contents: read` permission. If you don't clone the repository in your setup steps, Copilot will do this for you automatically after the steps complete.
-      contents: read
-
-    # You can define any steps you want, and they will run before the agent starts.
-    # If you do not check out your code, Copilot will do this for you.
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      # Backend Python/Poetry setup (mirrors platform-backend-ci.yml)
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"  # Use standard version matching CI
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Install Poetry
-        run: |
-          # Extract Poetry version from backend/poetry.lock (matches CI)
-          cd autogpt_platform/backend
-          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Found Poetry version ${HEAD_POETRY_VERSION} in backend/poetry.lock"
-          
-          # Install Poetry
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-          
-          # Add Poetry to PATH
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: Check poetry.lock
-        working-directory: autogpt_platform/backend
-        run: |
-          poetry lock
-          if ! git diff --quiet --ignore-matching-lines="^# " poetry.lock; then
-            echo "Warning: poetry.lock not up to date, but continuing for setup"
-            git checkout poetry.lock  # Reset for clean setup
-          fi
-
-      - name: Install Python dependencies
-        working-directory: autogpt_platform/backend
-        run: poetry install
-
-      - name: Generate Prisma Client
-        working-directory: autogpt_platform/backend
-        run: poetry run prisma generate && poetry run gen-prisma-stub
-
-      # Frontend Node.js/pnpm setup (mirrors platform-frontend-ci.yml)
-      - name: Set up Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: "22"
-
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set pnpm store directory
-        run: |
-          pnpm config set store-dir ~/.pnpm-store
-          echo "PNPM_HOME=$HOME/.pnpm-store" >> $GITHUB_ENV
-
-      - name: Cache frontend dependencies
-        uses: actions/cache@v5
-        with:
-          path: ~/.pnpm-store
-          key: ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/package.json') }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
-            ${{ runner.os }}-pnpm-
-
-      - name: Install JavaScript dependencies
-        working-directory: autogpt_platform/frontend
-        run: pnpm install --frozen-lockfile
-
-      # Install Playwright browsers for frontend testing
-      # NOTE: Disabled to save ~1 minute of setup time. Re-enable if Copilot needs browser automation (e.g., for MCP)
-      # - name: Install Playwright browsers
-      #   working-directory: autogpt_platform/frontend
-      #   run: pnpm playwright install --with-deps chromium
-
-      # Docker setup for development environment
-      - name: Free up disk space
-        run: |
-          # Remove large unused tools to free disk space for Docker builds
-          sudo rm -rf /usr/share/dotnet
-          sudo rm -rf /usr/local/lib/android
-          sudo rm -rf /opt/ghc
-          sudo rm -rf /opt/hostedtoolcache/CodeQL
-          sudo docker system prune -af
-          df -h
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Copy default environment files
-        working-directory: autogpt_platform
-        run: |
-          # Copy default environment files for development
-          cp .env.default .env
-          cp backend/.env.default backend/.env
-          cp frontend/.env.default frontend/.env
-
-      # Phase 1: Cache and load Docker images for faster setup
-      - name: Set up Docker image cache
-        id: docker-cache
-        uses: actions/cache@v5
-        with:
-          path: ~/docker-cache
-          # Use a versioned key for cache invalidation when image list changes
-          key: docker-images-v2-${{ runner.os }}-${{ hashFiles('.github/workflows/copilot-setup-steps.yml') }}
-          restore-keys: |
-            docker-images-v2-${{ runner.os }}-
-            docker-images-v1-${{ runner.os }}-
-
-      - name: Load or pull Docker images
-        working-directory: autogpt_platform
-        run: |
-          mkdir -p ~/docker-cache
-          
-          # Define image list for easy maintenance
-          IMAGES=(
-            "redis:latest"
-            "rabbitmq:management"
-            "clamav/clamav-debian:latest"
-            "busybox:latest"
-            "kong:2.8.1"
-            "supabase/gotrue:v2.170.0"
-            "supabase/postgres:15.8.1.049"
-            "supabase/postgres-meta:v0.86.1"
-            "supabase/studio:20250224-d10db0f"
-          )
-          
-          # Check if any cached tar files exist (more reliable than cache-hit)
-          if ls ~/docker-cache/*.tar 1> /dev/null 2>&1; then
-            echo "Docker cache found, loading images in parallel..."
-            for image in "${IMAGES[@]}"; do
-              # Convert image name to filename (replace : and / with -)
-              filename=$(echo "$image" | tr ':/' '--')
-              if [ -f ~/docker-cache/${filename}.tar ]; then
-                echo "Loading $image..."
-                docker load -i ~/docker-cache/${filename}.tar || echo "Warning: Failed to load $image from cache" &
-              fi
-            done
-            wait
-            echo "All cached images loaded"
-          else
-            echo "No Docker cache found, pulling images in parallel..."
-            # Pull all images in parallel
-            for image in "${IMAGES[@]}"; do
-              docker pull "$image" &
-            done
-            wait
-            
-            # Only save cache on main branches (not PRs) to avoid cache pollution
-            if [[ "${{ github.ref }}" == "refs/heads/master" ]] || [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
-              echo "Saving Docker images to cache in parallel..."
-              for image in "${IMAGES[@]}"; do
-                # Convert image name to filename (replace : and / with -)
-                filename=$(echo "$image" | tr ':/' '--')
-                echo "Saving $image..."
-                docker save -o ~/docker-cache/${filename}.tar "$image" || echo "Warning: Failed to save $image" &
-              done
-              wait
-              echo "Docker image cache saved"
-            else
-              echo "Skipping cache save for PR/feature branch"
-            fi
-          fi
-          
-          echo "Docker images ready for use"
-
-      # Phase 2: Build migrate service with GitHub Actions cache
-      - name: Build migrate Docker image with cache
-        working-directory: autogpt_platform
-        run: |
-          # Build the migrate image with buildx for GHA caching
-          docker buildx build \
-            --cache-from type=gha \
-            --cache-to type=gha,mode=max \
-            --target migrate \
-            --tag autogpt_platform-migrate:latest \
-            --load \
-            -f backend/Dockerfile \
-            ..
-
-      # Start services using pre-built images
-      - name: Start Docker services for development
-        working-directory: autogpt_platform
-        run: |
-          # Start essential services (migrate image already built with correct tag)
-          docker compose --profile local up deps --no-build --detach
-          echo "Waiting for services to be ready..."
-          
-          # Wait for database to be ready
-          echo "Checking database readiness..."
-          timeout 30 sh -c 'until docker compose exec -T db pg_isready -U postgres 2>/dev/null; do 
-            echo "  Waiting for database..."
-            sleep 2
-          done' && echo "✅ Database is ready" || echo "⚠️ Database ready check timeout after 30s, continuing..."
-          
-          # Check migrate service status
-          echo "Checking migration status..."
-          docker compose ps migrate || echo "  Migrate service not visible in ps output"
-          
-          # Wait for migrate service to complete
-          echo "Waiting for migrations to complete..."
-          timeout 30 bash -c '
-            ATTEMPTS=0
-            while [ $ATTEMPTS -lt 15 ]; do
-              ATTEMPTS=$((ATTEMPTS + 1))
-              
-              # Check using docker directly (more reliable than docker compose ps)
-              CONTAINER_STATUS=$(docker ps -a --filter "label=com.docker.compose.service=migrate" --format "{{.Status}}" | head -1)
-              
-              if [ -z "$CONTAINER_STATUS" ]; then
-                echo "  Attempt $ATTEMPTS: Migrate container not found yet..."
-              elif echo "$CONTAINER_STATUS" | grep -q "Exited (0)"; then
-                echo "✅ Migrations completed successfully"
-                docker compose logs migrate --tail=5 2>/dev/null || true
-                exit 0
-              elif echo "$CONTAINER_STATUS" | grep -q "Exited ([1-9]"; then
-                EXIT_CODE=$(echo "$CONTAINER_STATUS" | grep -oE "Exited \([0-9]+\)" | grep -oE "[0-9]+")
-                echo "❌ Migrations failed with exit code: $EXIT_CODE"
-                echo "Migration logs:"
-                docker compose logs migrate --tail=20 2>/dev/null || true
-                exit 1
-              elif echo "$CONTAINER_STATUS" | grep -q "Up"; then
-                echo "  Attempt $ATTEMPTS: Migrate container is running... ($CONTAINER_STATUS)"
-              else
-                echo "  Attempt $ATTEMPTS: Migrate container status: $CONTAINER_STATUS"
-              fi
-              
-              sleep 2
-            done
-            
-            echo "⚠️ Timeout: Could not determine migration status after 30 seconds"
-            echo "Final container check:"
-            docker ps -a --filter "label=com.docker.compose.service=migrate" || true
-            echo "Migration logs (if available):"
-            docker compose logs migrate --tail=10 2>/dev/null || echo "  No logs available"
-          ' || echo "⚠️ Migration check completed with warnings, continuing..."
-          
-          # Brief wait for other services to stabilize
-          echo "Waiting 5 seconds for other services to stabilize..."
-          sleep 5
-
-      # Verify installations and provide environment info
-      - name: Verify setup and show environment info
-        run: |
-          echo "=== Python Setup ==="
-          python --version
-          poetry --version
-          
-          echo "=== Node.js Setup ==="
-          node --version
-          pnpm --version
-          
-          echo "=== Additional Tools ==="
-          docker --version
-          docker compose version
-          gh --version || true
-          
-          echo "=== Services Status ==="
-          cd autogpt_platform
-          docker compose ps || true
-          
-          echo "=== Backend Dependencies ==="
-          cd backend
-          poetry show | head -10 || true
-          
-          echo "=== Frontend Dependencies ==="
-          cd ../frontend
-          pnpm list --depth=0 | head -10 || true
-          
-          echo "=== Environment Files ==="
-          ls -la ../.env* || true
-          ls -la .env* || true
-          ls -la ../backend/.env* || true
-          
-          echo "✅ AutoGPT Platform development environment setup complete!"
-          echo "🚀 Ready for development with Docker services running"
-          echo "📝 Backend server: poetry run serve (port 8000)"
-          echo "🌐 Frontend server: pnpm dev (port 3000)"

.github/workflows/docs-block-sync.yml

@@ -1,78 +0,0 @@
-name: Block Documentation Sync Check
-
-on:
-  push:
-    branches: [master, dev]
-    paths:
-      - "autogpt_platform/backend/backend/blocks/**"
-      - "docs/integrations/**"
-      - "autogpt_platform/backend/scripts/generate_block_docs.py"
-      - ".github/workflows/docs-block-sync.yml"
-  pull_request:
-    branches: [master, dev]
-    paths:
-      - "autogpt_platform/backend/backend/blocks/**"
-      - "docs/integrations/**"
-      - "autogpt_platform/backend/scripts/generate_block_docs.py"
-      - ".github/workflows/docs-block-sync.yml"
-
-jobs:
-  check-docs-sync:
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 1
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-          restore-keys: |
-            poetry-${{ runner.os }}-
-
-      - name: Install Poetry
-        run: |
-          cd autogpt_platform/backend
-          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Found Poetry version ${HEAD_POETRY_VERSION} in backend/poetry.lock"
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: Install dependencies
-        working-directory: autogpt_platform/backend
-        run: |
-          poetry install --only main
-          poetry run prisma generate
-
-      - name: Check block documentation is in sync
-        working-directory: autogpt_platform/backend
-        run: |
-          echo "Checking if block documentation is in sync with code..."
-          poetry run python scripts/generate_block_docs.py --check
-
-      - name: Show diff if out of sync
-        if: failure()
-        working-directory: autogpt_platform/backend
-        run: |
-          echo "::error::Block documentation is out of sync with code!"
-          echo ""
-          echo "To fix this, run the following command locally:"
-          echo "  cd autogpt_platform/backend && poetry run python scripts/generate_block_docs.py"
-          echo ""
-          echo "Then commit the updated documentation files."
-          echo ""
-          echo "Regenerating docs to show diff..."
-          poetry run python scripts/generate_block_docs.py
-          echo ""
-          echo "Changes detected:"
-          git diff ../../docs/integrations/ || true

.github/workflows/docs-claude-review.yml

@@ -1,129 +0,0 @@
-name: Claude Block Docs Review
-
-on:
-  pull_request:
-    types: [opened, synchronize]
-    paths:
-      - "docs/integrations/**"
-      - "autogpt_platform/backend/backend/blocks/**"
-
-concurrency:
-  group: claude-docs-review-${{ github.event.pull_request.number }}
-  cancel-in-progress: true
-
-jobs:
-  claude-review:
-    # Only run for PRs from members/collaborators
-    if: |
-      github.event.pull_request.author_association == 'OWNER' ||
-      github.event.pull_request.author_association == 'MEMBER' ||
-      github.event.pull_request.author_association == 'COLLABORATOR'
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    permissions:
-      contents: read
-      pull-requests: write
-      id-token: write
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-          restore-keys: |
-            poetry-${{ runner.os }}-
-
-      - name: Install Poetry
-        run: |
-          cd autogpt_platform/backend
-          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: Install dependencies
-        working-directory: autogpt_platform/backend
-        run: |
-          poetry install --only main
-          poetry run prisma generate
-
-      - name: Run Claude Code Review
-        uses: anthropics/claude-code-action@v1
-        with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-          claude_args: |
-            --allowedTools "Read,Glob,Grep,Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*)"
-          prompt: |
-            You are reviewing a PR that modifies block documentation or block code for AutoGPT.
-
-            ## Your Task
-            Review the changes in this PR and provide constructive feedback. Focus on:
-
-            1. **Documentation Accuracy**: For any block code changes, verify that:
-               - Input/output tables in docs match the actual block schemas
-               - Description text accurately reflects what the block does
-               - Any new blocks have corresponding documentation
-
-            2. **Manual Content Quality**: Check manual sections (marked with `<!-- MANUAL: -->` markers):
-               - "How it works" sections should have clear technical explanations
-               - "Possible use case" sections should have practical, real-world examples
-               - Content should be helpful for users trying to understand the blocks
-
-            3. **Template Compliance**: Ensure docs follow the standard template:
-               - What it is (brief intro)
-               - What it does (description)
-               - How it works (technical explanation)
-               - Inputs table
-               - Outputs table
-               - Possible use case
-
-            4. **Cross-references**: Check that links and anchors are correct
-
-            ## Review Process
-            1. First, get the PR diff to see what changed: `gh pr diff ${{ github.event.pull_request.number }}`
-            2. Read any modified block files to understand the implementation
-            3. Read corresponding documentation files to verify accuracy
-            4. Provide your feedback as a PR comment
-
-            ## IMPORTANT: Comment Marker
-            Start your PR comment with exactly this HTML comment marker on its own line:
-            <!-- CLAUDE_DOCS_REVIEW -->
-
-            This marker is used to identify and replace your comment on subsequent runs.
-
-            Be constructive and specific. If everything looks good, say so!
-            If there are issues, explain what's wrong and suggest how to fix it.
-
-      - name: Delete old Claude review comments
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          # Get all comment IDs with our marker, sorted by creation date (oldest first)
-          COMMENT_IDS=$(gh api \
-            repos/${{ github.repository }}/issues/${{ github.event.pull_request.number }}/comments \
-            --jq '[.[] | select(.body | contains("<!-- CLAUDE_DOCS_REVIEW -->"))] | sort_by(.created_at) | .[].id')
-
-          # Count comments
-          COMMENT_COUNT=$(echo "$COMMENT_IDS" | grep -c . || true)
-
-          if [ "$COMMENT_COUNT" -gt 1 ]; then
-            # Delete all but the last (newest) comment
-            echo "$COMMENT_IDS" | head -n -1 | while read -r COMMENT_ID; do
-              if [ -n "$COMMENT_ID" ]; then
-                echo "Deleting old review comment: $COMMENT_ID"
-                gh api -X DELETE repos/${{ github.repository }}/issues/comments/$COMMENT_ID
-              fi
-            done
-          else
-            echo "No old review comments to clean up"
-          fi

.github/workflows/docs-enhance.yml

@@ -1,194 +0,0 @@
-name: Enhance Block Documentation
-
-on:
-  workflow_dispatch:
-    inputs:
-      block_pattern:
-        description: 'Block file pattern to enhance (e.g., "google/*.md" or "*" for all blocks)'
-        required: true
-        default: '*'
-        type: string
-      dry_run:
-        description: 'Dry run mode - show proposed changes without committing'
-        type: boolean
-        default: true
-      max_blocks:
-        description: 'Maximum number of blocks to process (0 for unlimited)'
-        type: number
-        default: 10
-
-jobs:
-  enhance-docs:
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    permissions:
-      contents: write
-      pull-requests: write
-      id-token: write
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 1
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-          restore-keys: |
-            poetry-${{ runner.os }}-
-
-      - name: Install Poetry
-        run: |
-          cd autogpt_platform/backend
-          HEAD_POETRY_VERSION=$(python3 ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: Install dependencies
-        working-directory: autogpt_platform/backend
-        run: |
-          poetry install --only main
-          poetry run prisma generate
-
-      - name: Run Claude Enhancement
-        uses: anthropics/claude-code-action@v1
-        with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-          claude_args: |
-            --allowedTools "Read,Edit,Glob,Grep,Write,Bash(git:*),Bash(gh:*),Bash(find:*),Bash(ls:*)"
-          prompt: |
-            You are enhancing block documentation for AutoGPT. Your task is to improve the MANUAL sections
-            of block documentation files by reading the actual block implementations and writing helpful content.
-
-            ## Configuration
-            - Block pattern: ${{ inputs.block_pattern }}
-            - Dry run: ${{ inputs.dry_run }}
-            - Max blocks to process: ${{ inputs.max_blocks }}
-
-            ## Your Task
-
-            1. **Find Documentation Files**
-               Find block documentation files matching the pattern in `docs/integrations/`
-               Pattern: ${{ inputs.block_pattern }}
-
-               Use: `find docs/integrations -name "*.md" -type f`
-
-            2. **For Each Documentation File** (up to ${{ inputs.max_blocks }} files):
-
-               a. Read the documentation file
-
-               b. Identify which block(s) it documents (look for the block class name)
-
-               c. Find and read the corresponding block implementation in `autogpt_platform/backend/backend/blocks/`
-
-               d. Improve the MANUAL sections:
-
-                  **"How it works" section** (within `<!-- MANUAL: how_it_works -->` markers):
-                  - Explain the technical flow of the block
-                  - Describe what APIs or services it connects to
-                  - Note any important configuration or prerequisites
-                  - Keep it concise but informative (2-4 paragraphs)
-
-                  **"Possible use case" section** (within `<!-- MANUAL: use_case -->` markers):
-                  - Provide 2-3 practical, real-world examples
-                  - Make them specific and actionable
-                  - Show how this block could be used in an automation workflow
-
-            3. **Important Rules**
-               - ONLY modify content within `<!-- MANUAL: -->` and `<!-- END MANUAL -->` markers
-               - Do NOT modify auto-generated sections (inputs/outputs tables, descriptions)
-               - Keep content accurate based on the actual block implementation
-               - Write for users who may not be technical experts
-
-            4. **Output**
-               ${{ inputs.dry_run == true && 'DRY RUN MODE: Show proposed changes for each file but do NOT actually edit the files. Describe what you would change.' || 'LIVE MODE: Actually edit the files to improve the documentation.' }}
-
-            ## Example Improvements
-
-            **Before (How it works):**
-            ```
-            _Add technical explanation here._
-            ```
-
-            **After (How it works):**
-            ```
-            This block connects to the GitHub API to retrieve issue information. When executed,
-            it authenticates using your GitHub credentials and fetches issue details including
-            title, body, labels, and assignees.
-
-            The block requires a valid GitHub OAuth connection with repository access permissions.
-            It supports both public and private repositories you have access to.
-            ```
-
-            **Before (Possible use case):**
-            ```
-            _Add practical use case examples here._
-            ```
-
-            **After (Possible use case):**
-            ```
-            **Customer Support Automation**: Monitor a GitHub repository for new issues with
-            the "bug" label, then automatically create a ticket in your support system and
-            notify the on-call engineer via Slack.
-
-            **Release Notes Generation**: When a new release is published, gather all closed
-            issues since the last release and generate a summary for your changelog.
-            ```
-
-            Begin by finding and listing the documentation files to process.
-
-      - name: Create PR with enhanced documentation
-        if: ${{ inputs.dry_run == false }}
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          # Check if there are changes
-          if git diff --quiet docs/integrations/; then
-            echo "No changes to commit"
-            exit 0
-          fi
-
-          # Configure git
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-          # Create branch and commit
-          BRANCH_NAME="docs/enhance-blocks-$(date +%Y%m%d-%H%M%S)"
-          git checkout -b "$BRANCH_NAME"
-          git add docs/integrations/
-          git commit -m "docs: enhance block documentation with LLM-generated content
-
-          Pattern: ${{ inputs.block_pattern }}
-          Max blocks: ${{ inputs.max_blocks }}
-
-          🤖 Generated with [Claude Code](https://claude.com/claude-code)
-
-          Co-Authored-By: Claude <noreply@anthropic.com>"
-
-          # Push and create PR
-          git push -u origin "$BRANCH_NAME"
-          gh pr create \
-            --title "docs: LLM-enhanced block documentation" \
-            --body "## Summary
-          This PR contains LLM-enhanced documentation for block files matching pattern: \`${{ inputs.block_pattern }}\`
-
-          The following manual sections were improved:
-          - **How it works**: Technical explanations based on block implementations
-          - **Possible use case**: Practical, real-world examples
-
-          ## Review Checklist
-          - [ ] Content is accurate based on block implementations
-          - [ ] Examples are practical and helpful
-          - [ ] No auto-generated sections were modified
-
-          ---
-          🤖 Generated with [Claude Code](https://claude.com/claude-code)" \
-            --base dev

.github/workflows/platform-autgpt-deploy-prod.yml

@@ -0,0 +1,182 @@
+name: AutoGPT Platform - Build, Push, and Deploy Prod Environment
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+
+env:
+  PROJECT_ID: ${{ secrets.GCP_PROJECT_ID }}
+  GKE_CLUSTER: prod-gke-cluster
+  GKE_ZONE: us-central1-a
+  NAMESPACE: prod-agpt
+
+jobs:
+  migrate:
+    environment: production
+    name: Run migrations for AutoGPT Platform
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install prisma
+
+      - name: Run Backend Migrations
+        working-directory: ./autogpt_platform/backend
+        run: |
+          python -m prisma migrate deploy
+        env:
+          DATABASE_URL: ${{ secrets.BACKEND_DATABASE_URL }}
+
+      - name: Run Market Migrations
+        working-directory: ./autogpt_platform/market
+        run: |
+          python -m prisma migrate deploy
+        env:
+          DATABASE_URL: ${{ secrets.MARKET_DATABASE_URL }}
+          
+  build-push-deploy:
+    environment: production
+    name: Build, Push, and Deploy
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - id: 'auth'
+      uses: 'google-github-actions/auth@v2'
+      with:
+        workload_identity_provider: 'projects/1021527134101/locations/global/workloadIdentityPools/prod-pool/providers/github'
+        service_account: 'prod-github-actions-sa@agpt-prod.iam.gserviceaccount.com'
+        token_format: 'access_token'
+        create_credentials_file: true
+
+    - name: 'Set up Cloud SDK'
+      uses: 'google-github-actions/setup-gcloud@v2'
+
+    - name: 'Configure Docker'
+      run: |
+        gcloud auth configure-docker us-east1-docker.pkg.dev
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Cache Docker layers
+      uses: actions/cache@v4
+      with:
+        path: /tmp/.buildx-cache
+        key: ${{ runner.os }}-buildx-${{ github.sha }}
+        restore-keys: |
+          ${{ runner.os }}-buildx-
+
+    - name: Check for changes
+      id: check_changes
+      run: |
+        git fetch origin master
+        BACKEND_CHANGED=$(git diff --name-only origin/master HEAD | grep "^autogpt_platform/backend/" && echo "true" || echo "false")
+        FRONTEND_CHANGED=$(git diff --name-only origin/master HEAD | grep "^autogpt_platform/frontend/" && echo "true" || echo "false")
+        MARKET_CHANGED=$(git diff --name-only origin/master HEAD | grep "^autogpt_platform/market/" && echo "true" || echo "false")
+        echo "backend_changed=$BACKEND_CHANGED" >> $GITHUB_OUTPUT
+        echo "frontend_changed=$FRONTEND_CHANGED" >> $GITHUB_OUTPUT
+        echo "market_changed=$MARKET_CHANGED" >> $GITHUB_OUTPUT
+
+    - name: Get GKE credentials
+      uses: 'google-github-actions/get-gke-credentials@v2'
+      with:
+        cluster_name: ${{ env.GKE_CLUSTER }}
+        location: ${{ env.GKE_ZONE }}
+
+    - name: Build and Push Backend
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/backend/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-prod/agpt-backend-prod/agpt-backend-prod:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Build and Push Frontend
+      if: steps.check_changes.outputs.frontend_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/frontend/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-prod/agpt-frontend-prod/agpt-frontend-prod:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Build and Push Market
+      if: steps.check_changes.outputs.market_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/market/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-prod/agpt-market-prod/agpt-market-prod:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Move cache
+      run: |
+        rm -rf /tmp/.buildx-cache
+        mv /tmp/.buildx-cache-new /tmp/.buildx-cache
+
+    - name: Set up Helm
+      uses: azure/setup-helm@v4
+      with:
+        version: v3.4.0
+
+    - name: Deploy Backend
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      run: |
+        helm upgrade autogpt-server ./autogpt-server \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-server/values.yaml \
+          -f autogpt-server/values.prod.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Websocket
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      run: |
+        helm upgrade autogpt-websocket-server ./autogpt-websocket-server \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-websocket-server/values.yaml \
+          -f autogpt-websocket-server/values.prod.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Market
+      if: steps.check_changes.outputs.market_changed == 'true'
+      run: |
+        helm upgrade autogpt-market ./autogpt-market \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-market/values.yaml \
+          -f autogpt-market/values.prod.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Frontend
+      if: steps.check_changes.outputs.frontend_changed == 'true'
+      run: |
+        helm upgrade autogpt-builder ./autogpt-builder \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-builder/values.yaml \
+          -f autogpt-builder/values.prod.yaml \
+          --set image.tag=${{ github.sha }}

.github/workflows/platform-autogpt-deploy-dev.yaml

@@ -1,60 +0,0 @@
-name: AutoGPT Platform - Deploy Dev Environment
-
-on:
-  push:
-    branches: [ dev ]
-    paths:
-      - 'autogpt_platform/**'
-  workflow_dispatch:
-    inputs:
-      git_ref:
-        description: 'Git ref (branch/tag) of AutoGPT to deploy'
-        required: true
-        default: 'master'
-        type: string
-
-permissions:
-  contents: 'read'
-  id-token: 'write'
-
-jobs:
-  migrate:
-    environment: develop
-    name: Run migrations for AutoGPT Platform
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          ref: ${{ github.event.inputs.git_ref || github.ref_name }}
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-
-      - name: Install Python dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install prisma
-
-      - name: Run Backend Migrations
-        working-directory: ./autogpt_platform/backend
-        run: |
-          python -m prisma migrate deploy
-        env:
-          DATABASE_URL: ${{ secrets.BACKEND_DATABASE_URL }}
-          DIRECT_URL: ${{ secrets.BACKEND_DATABASE_URL }}
-
-  trigger:
-    needs: migrate
-    runs-on: ubuntu-latest
-    steps:
-      - name: Trigger deploy workflow
-        uses: peter-evans/repository-dispatch@v4
-        with:
-          token: ${{ secrets.DEPLOY_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: build_deploy_dev
-          client-payload: '{"ref": "${{ github.event.inputs.git_ref || github.ref }}", "repository": "${{ github.repository }}"}'

.github/workflows/platform-autogpt-deploy-prod.yml

@@ -1,54 +0,0 @@
-name: AutoGPT Platform - Deploy Prod Environment
-
-on:
-  release:
-    types: [published]
-  workflow_dispatch:
-
-permissions:
-  contents: 'read'
-  id-token: 'write'
-
-jobs:
-  migrate:
-    environment: production
-    name: Run migrations for AutoGPT Platform
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          ref: ${{ github.ref_name || 'master' }}
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-
-      - name: Install Python dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install prisma
-
-      - name: Run Backend Migrations
-        working-directory: ./autogpt_platform/backend
-        run: |
-          python -m prisma migrate deploy
-        env:
-          DATABASE_URL: ${{ secrets.BACKEND_DATABASE_URL }}
-          DIRECT_URL: ${{ secrets.BACKEND_DATABASE_URL }}
-
-
-  trigger:
-    needs: migrate
-    runs-on: ubuntu-latest
-    steps:
-      - name: Trigger deploy workflow
-        uses: peter-evans/repository-dispatch@v4
-        with:
-          token: ${{ secrets.DEPLOY_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: build_deploy_prod
-          client-payload: |
-            {"ref": "${{ github.ref_name || 'master' }}", "repository": "${{ github.repository }}"}

.github/workflows/platform-autogpt-deploy.yaml

@@ -0,0 +1,186 @@
+name: AutoGPT Platform - Build, Push, and Deploy Dev Environment
+
+on:
+  push:
+    branches: [ dev ]
+    paths:
+      - 'autogpt_platform/backend/**'
+      - 'autogpt_platform/frontend/**'
+      - 'autogpt_platform/market/**'
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+
+env:
+  PROJECT_ID: ${{ secrets.GCP_PROJECT_ID }}
+  GKE_CLUSTER: dev-gke-cluster
+  GKE_ZONE: us-central1-a
+  NAMESPACE: dev-agpt
+
+jobs:
+  migrate:
+    environment: develop
+    name: Run migrations for AutoGPT Platform
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install prisma
+
+      - name: Run Backend Migrations
+        working-directory: ./autogpt_platform/backend
+        run: |
+          python -m prisma migrate deploy
+        env:
+          DATABASE_URL: ${{ secrets.BACKEND_DATABASE_URL }}
+
+      - name: Run Market Migrations
+        working-directory: ./autogpt_platform/market
+        run: |
+          python -m prisma migrate deploy
+        env:
+          DATABASE_URL: ${{ secrets.MARKET_DATABASE_URL }}
+
+  build-push-deploy:
+    name: Build, Push, and Deploy
+    needs: migrate
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - id: 'auth'
+      uses: 'google-github-actions/auth@v2'
+      with:
+        workload_identity_provider: 'projects/638488734936/locations/global/workloadIdentityPools/dev-pool/providers/github'
+        service_account: 'dev-github-actions-sa@agpt-dev.iam.gserviceaccount.com'
+        token_format: 'access_token'
+        create_credentials_file: true
+
+    - name: 'Set up Cloud SDK'
+      uses: 'google-github-actions/setup-gcloud@v2'
+
+    - name: 'Configure Docker'
+      run: |
+        gcloud auth configure-docker us-east1-docker.pkg.dev
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Cache Docker layers
+      uses: actions/cache@v4
+      with:
+        path: /tmp/.buildx-cache
+        key: ${{ runner.os }}-buildx-${{ github.sha }}
+        restore-keys: |
+          ${{ runner.os }}-buildx-
+
+    - name: Check for changes
+      id: check_changes
+      run: |
+        git fetch origin dev
+        BACKEND_CHANGED=$(git diff --name-only origin/dev HEAD | grep "^autogpt_platform/backend/" && echo "true" || echo "false")
+        FRONTEND_CHANGED=$(git diff --name-only origin/dev HEAD | grep "^autogpt_platform/frontend/" && echo "true" || echo "false")
+        MARKET_CHANGED=$(git diff --name-only origin/dev HEAD | grep "^autogpt_platform/market/" && echo "true" || echo "false")
+        echo "backend_changed=$BACKEND_CHANGED" >> $GITHUB_OUTPUT
+        echo "frontend_changed=$FRONTEND_CHANGED" >> $GITHUB_OUTPUT
+        echo "market_changed=$MARKET_CHANGED" >> $GITHUB_OUTPUT
+
+    - name: Get GKE credentials
+      uses: 'google-github-actions/get-gke-credentials@v2'
+      with:
+        cluster_name: ${{ env.GKE_CLUSTER }}
+        location: ${{ env.GKE_ZONE }}
+
+    - name: Build and Push Backend
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/backend/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-dev/agpt-backend-dev/agpt-backend-dev:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Build and Push Frontend
+      if: steps.check_changes.outputs.frontend_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/frontend/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-dev/agpt-frontend-dev/agpt-frontend-dev:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Build and Push Market
+      if: steps.check_changes.outputs.market_changed == 'true'
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./autogpt_platform/market/Dockerfile
+        push: true
+        tags: us-east1-docker.pkg.dev/agpt-dev/agpt-market-dev/agpt-market-dev:${{ github.sha }}
+        cache-from: type=local,src=/tmp/.buildx-cache
+        cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+    - name: Move cache
+      run: |
+        rm -rf /tmp/.buildx-cache
+        mv /tmp/.buildx-cache-new /tmp/.buildx-cache
+
+    - name: Set up Helm
+      uses: azure/setup-helm@v4
+      with:
+        version: v3.4.0
+
+    - name: Deploy Backend
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      run: |
+        helm upgrade autogpt-server ./autogpt-server \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-server/values.yaml \
+          -f autogpt-server/values.dev.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Websocket
+      if: steps.check_changes.outputs.backend_changed == 'true'
+      run: |
+        helm upgrade autogpt-websocket-server ./autogpt-websocket-server \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-websocket-server/values.yaml \
+          -f autogpt-websocket-server/values.dev.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Market
+      if: steps.check_changes.outputs.market_changed == 'true'
+      run: |
+        helm upgrade autogpt-market ./autogpt-market \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-market/values.yaml \
+          -f autogpt-market/values.dev.yaml \
+          --set image.tag=${{ github.sha }}
+
+    - name: Deploy Frontend
+      if: steps.check_changes.outputs.frontend_changed == 'true'
+      run: |
+        helm upgrade autogpt-builder ./autogpt-builder \
+          --namespace ${{ env.NAMESPACE }} \
+          -f autogpt-builder/values.yaml \
+          -f autogpt-builder/values.dev.yaml \
+          --set image.tag=${{ github.sha }}

.github/workflows/platform-autogpt-infra-ci.yml

@@ -0,0 +1,56 @@
+name: AutoGPT Platform - Infra
+
+on:
+  push:
+    branches: [ master, dev ]
+    paths:
+      - '.github/workflows/platform-autogpt-infra-ci.yml'
+      - 'autogpt_platform/infra/**'
+  pull_request:
+    paths:
+      - '.github/workflows/platform-autogpt-infra-ci.yml'
+      - 'autogpt_platform/infra/**'
+
+defaults:
+  run:
+    shell: bash
+    working-directory: autogpt_platform/infra
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: TFLint
+        uses: pauloconnor/tflint-action@v0.0.2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+            tflint_path: terraform/
+            tflint_recurse: true
+            tflint_changed_only: false
+
+      - name: Set up Helm
+        uses: azure/setup-helm@v4
+        with:
+          version: v3.14.4
+
+      - name: Set up chart-testing
+        uses: helm/chart-testing-action@v2.6.1
+
+      - name: Run chart-testing (list-changed)
+        id: list-changed
+        run: |
+          changed=$(ct list-changed --target-branch ${{ github.event.repository.default_branch }})
+          if [[ -n "$changed" ]]; then
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Run chart-testing (lint)
+        if: steps.list-changed.outputs.changed == 'true'
+        run: ct lint --target-branch ${{ github.event.repository.default_branch }}

.github/workflows/platform-backend-ci.yml

@@ -5,17 +5,12 @@ on:
     branches: [master, dev, ci-test*]
     paths:
       - ".github/workflows/platform-backend-ci.yml"
-      - ".github/workflows/scripts/get_package_version_from_lockfile.py"
       - "autogpt_platform/backend/**"
-      - "autogpt_platform/autogpt_libs/**"
   pull_request:
     branches: [master, dev, release-*]
     paths:
       - ".github/workflows/platform-backend-ci.yml"
-      - ".github/workflows/scripts/get_package_version_from_lockfile.py"
       - "autogpt_platform/backend/**"
-      - "autogpt_platform/autogpt_libs/**"
-  merge_group:
 
 concurrency:
   group: ${{ format('backend-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -27,136 +22,27 @@ defaults:
     working-directory: autogpt_platform/backend
 
 jobs:
-  lint:
-    permissions:
-      contents: read
-    timeout-minutes: 10
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Set up Python 3.12
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-py3.12-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Install Poetry
-        run: |
-          HEAD_POETRY_VERSION=$(python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Using Poetry version ${HEAD_POETRY_VERSION}"
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-
-      - name: Install Python dependencies
-        run: poetry install
-
-      - name: Run Linters
-        run: poetry run lint --skip-pyright
-
-    env:
-      CI: true
-      PLAIN_OUTPUT: True
-
-  type-check:
-    permissions:
-      contents: read
-    timeout-minutes: 10
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.11", "3.12", "3.13"]
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-py${{ matrix.python-version }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Install Poetry
-        run: |
-          HEAD_POETRY_VERSION=$(python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Using Poetry version ${HEAD_POETRY_VERSION}"
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-
-      - name: Install Python dependencies
-        run: poetry install
-
-      - name: Generate Prisma Client
-        run: poetry run prisma generate && poetry run gen-prisma-stub
-
-      - name: Run Pyright
-        run: poetry run pyright --pythonversion ${{ matrix.python-version }}
-
-    env:
-      CI: true
-      PLAIN_OUTPUT: True
-
   test:
     permissions:
       contents: read
-    timeout-minutes: 15
+    timeout-minutes: 30
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.11", "3.12", "3.13"]
+        python-version: ["3.10"]
     runs-on: ubuntu-latest
 
     services:
       redis:
-        image: redis:latest
+        image: bitnami/redis:6.2
+        env:
+          REDIS_PASSWORD: testpassword
         ports:
           - 6379:6379
-      rabbitmq:
-        image: rabbitmq:4.1.4
-        ports:
-          - 5672:5672
-        env:
-          RABBITMQ_DEFAULT_USER: ${{ env.RABBITMQ_DEFAULT_USER }}
-          RABBITMQ_DEFAULT_PASS: ${{ env.RABBITMQ_DEFAULT_PASS }}
-        options: >-
-          --health-cmd "rabbitmq-diagnostics -q ping"
-          --health-interval 30s
-          --health-timeout 10s
-          --health-retries 5
-          --health-start-period 10s
-      clamav:
-        image: clamav/clamav-debian:latest
-        ports:
-          - 3310:3310
-        env:
-          CLAMAV_NO_FRESHCLAMD: false
-          CLAMD_CONF_StreamMaxLength: 50M
-          CLAMD_CONF_MaxFileSize: 100M
-          CLAMD_CONF_MaxScanSize: 100M
-          CLAMD_CONF_MaxThreads: 4
-          CLAMD_CONF_ReadTimeout: 300
-        options: >-
-          --health-cmd "clamdscan --version || exit 1"
-          --health-interval 30s
-          --health-timeout 10s
-          --health-retries 5
-          --health-start-period 180s
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: true
@@ -169,60 +55,32 @@ jobs:
       - name: Setup Supabase
         uses: supabase/setup-cli@v1
         with:
-          version: 1.178.1
+          version: latest
 
       - id: get_date
         name: Get date
         run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
 
       - name: Set up Python dependency cache
-        uses: actions/cache@v5
+        uses: actions/cache@v4
         with:
           path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-py${{ matrix.python-version }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
+          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
 
-      - name: Install Poetry
+      - name: Install Poetry (Unix)
         run: |
-          # Extract Poetry version from backend/poetry.lock
-          HEAD_POETRY_VERSION=$(python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Found Poetry version ${HEAD_POETRY_VERSION} in backend/poetry.lock"
-
-          if [ -n "$BASE_REF" ]; then
-            BASE_BRANCH=${BASE_REF/refs\/heads\//}
-            BASE_POETRY_VERSION=$((git show "origin/$BASE_BRANCH":./poetry.lock; true) | python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry -)
-            echo "Found Poetry version ${BASE_POETRY_VERSION} in backend/poetry.lock on ${BASE_REF}"
-            POETRY_VERSION=$(printf '%s\n' "$HEAD_POETRY_VERSION" "$BASE_POETRY_VERSION" | sort -V | tail -n1)
-          else
-            POETRY_VERSION=$HEAD_POETRY_VERSION
-          fi
-          echo "Using Poetry version ${POETRY_VERSION}"
-
-          # Install Poetry
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$POETRY_VERSION python3 -
+          curl -sSL https://install.python-poetry.org | python3 -
 
           if [ "${{ runner.os }}" = "macOS" ]; then
             PATH="$HOME/.local/bin:$PATH"
             echo "$HOME/.local/bin" >> $GITHUB_PATH
           fi
-        env:
-          BASE_REF: ${{ github.base_ref || github.event.merge_group.base_ref }}
-
-      - name: Check poetry.lock
-        run: |
-          poetry lock
-
-          if ! git diff --quiet --ignore-matching-lines="^# " poetry.lock; then
-            echo "Error: poetry.lock not up to date."
-            echo
-            git diff poetry.lock
-            exit 1
-          fi
 
       - name: Install Python dependencies
         run: poetry install
 
       - name: Generate Prisma Client
-        run: poetry run prisma generate && poetry run gen-prisma-stub
+        run: poetry run prisma generate
 
       - id: supabase
         name: Start Supabase
@@ -234,68 +92,32 @@ jobs:
         # outputs:
         # DB_URL, API_URL, GRAPHQL_URL, ANON_KEY, SERVICE_ROLE_KEY, JWT_SECRET
 
-      - name: Wait for ClamAV to be ready
-        run: |
-          echo "Waiting for ClamAV daemon to start..."
-          max_attempts=60
-          attempt=0
-
-          until nc -z localhost 3310 || [ $attempt -eq $max_attempts ]; do
-            echo "ClamAV is unavailable - sleeping (attempt $((attempt+1))/$max_attempts)"
-            sleep 5
-            attempt=$((attempt+1))
-          done
-
-          if [ $attempt -eq $max_attempts ]; then
-            echo "ClamAV failed to start after $((max_attempts*5)) seconds"
-            echo "Checking ClamAV service logs..."
-            docker logs $(docker ps -q --filter "ancestor=clamav/clamav-debian:latest") 2>&1 | tail -50 || echo "No ClamAV container found"
-            exit 1
-          fi
-
-          echo "ClamAV is ready!"
-
-          # Verify ClamAV is responsive
-          echo "Testing ClamAV connection..."
-          timeout 10 bash -c 'echo "PING" | nc localhost 3310' || {
-            echo "ClamAV is not responding to PING"
-            docker logs $(docker ps -q --filter "ancestor=clamav/clamav-debian:latest") 2>&1 | tail -50 || echo "No ClamAV container found"
-            exit 1
-          }
-
       - name: Run Database Migrations
-        run: poetry run prisma migrate deploy
+        run: poetry run prisma migrate dev --name updates
         env:
           DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
-          DIRECT_URL: ${{ steps.supabase.outputs.DB_URL }}
+
+      - id: lint
+        name: Run Linter
+        run: poetry run lint
 
       - name: Run pytest with coverage
         run: |
           if [[ "${{ runner.debug }}" == "1" ]]; then
-            poetry run pytest -s -vv -o log_cli=true -o log_cli_level=DEBUG \
-              --cov=backend --cov-branch --cov-report term-missing --cov-report xml
+            poetry run pytest -s -vv -o log_cli=true -o log_cli_level=DEBUG test
           else
-            poetry run pytest -s -vv \
-              --cov=backend --cov-branch --cov-report term-missing --cov-report xml
+            poetry run pytest -s -vv test
           fi
+        if: success() || (failure() && steps.lint.outcome == 'failure')
         env:
           LOG_LEVEL: ${{ runner.debug && 'DEBUG' || 'INFO' }}
           DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
-          DIRECT_URL: ${{ steps.supabase.outputs.DB_URL }}
           SUPABASE_URL: ${{ steps.supabase.outputs.API_URL }}
           SUPABASE_SERVICE_ROLE_KEY: ${{ steps.supabase.outputs.SERVICE_ROLE_KEY }}
-          JWT_VERIFY_KEY: ${{ steps.supabase.outputs.JWT_SECRET }}
-          REDIS_HOST: "localhost"
-          REDIS_PORT: "6379"
-          ENCRYPTION_KEY: "dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw=" # DO NOT USE IN PRODUCTION!!
-
-      - name: Upload coverage reports to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: platform-backend
-          files: ./autogpt_platform/backend/coverage.xml
+          SUPABASE_JWT_SECRET: ${{ steps.supabase.outputs.JWT_SECRET }}
+          REDIS_HOST: 'localhost'
+          REDIS_PORT: '6379'
+          REDIS_PASSWORD: 'testpassword'
 
     env:
       CI: true
@@ -303,10 +125,9 @@ jobs:
       RUN_ENV: local
       PORT: 8080
       OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      # We know these are here, don't report this as a security vulnerability
-      # This is used as the default credential for the entire system's RabbitMQ instance
-      # If you want to replace this, you can do so by making our entire system generate
-      # new credentials for each local user and update the environment variables in
-      # the backend service, docker composes, and examples
-      RABBITMQ_DEFAULT_USER: "rabbitmq_user_default"
-      RABBITMQ_DEFAULT_PASS: "k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7"
+
+      # - name: Upload coverage reports to Codecov
+      #   uses: codecov/codecov-action@v4
+      #   with:
+      #     token: ${{ secrets.CODECOV_TOKEN }}
+      #     flags: backend,${{ runner.os }}

.github/workflows/platform-dev-deploy-event-dispatcher.yml

@@ -1,198 +0,0 @@
-name: AutoGPT Platform - Dev Deploy PR Event Dispatcher
-
-on:
-  pull_request:
-    types: [closed]
-  issue_comment:
-    types: [created]
-
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check comment permissions and deployment status
-        id: check_status
-        if: github.event_name == 'issue_comment' && github.event.issue.pull_request
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const commentBody = context.payload.comment.body.trim();
-            const commentUser = context.payload.comment.user.login;
-            const prAuthor = context.payload.issue.user.login;
-            const authorAssociation = context.payload.comment.author_association;
-            
-            // Check permissions
-            const hasPermission = (
-              authorAssociation === 'OWNER' ||
-              authorAssociation === 'MEMBER' ||
-              authorAssociation === 'COLLABORATOR'
-            );
-            
-            core.setOutput('comment_body', commentBody);
-            core.setOutput('has_permission', hasPermission);
-            
-            if (!hasPermission && (commentBody === '!deploy' || commentBody === '!undeploy')) {
-              core.setOutput('permission_denied', 'true');
-              return;
-            }
-            
-            if (commentBody !== '!deploy' && commentBody !== '!undeploy') {
-              return;
-            }
-            
-            // Process deploy command
-            if (commentBody === '!deploy') {
-              core.setOutput('should_deploy', 'true');
-            }
-            // Process undeploy command
-            else if (commentBody === '!undeploy') {
-              core.setOutput('should_undeploy', 'true');
-            }
-
-      - name: Post permission denied comment
-        if: steps.check_status.outputs.permission_denied == 'true'
-        uses: actions/github-script@v8
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `❌ **Permission denied**: Only the repository owners, members, or collaborators can use deployment commands.`
-            });
-
-      - name: Get PR details for deployment
-        id: pr_details
-        if: steps.check_status.outputs.should_deploy == 'true' || steps.check_status.outputs.should_undeploy == 'true'
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const pr = await github.rest.pulls.get({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              pull_number: context.issue.number
-            });
-            core.setOutput('pr_number', pr.data.number);
-            core.setOutput('pr_title', pr.data.title);
-            core.setOutput('pr_state', pr.data.state);
-          
-      - name: Dispatch Deploy Event
-        if: steps.check_status.outputs.should_deploy == 'true'
-        uses: peter-evans/repository-dispatch@v4
-        with:
-          token: ${{ secrets.DISPATCH_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: pr-event
-          client-payload: |
-            {
-              "action": "deploy",
-              "pr_number": "${{ steps.pr_details.outputs.pr_number }}",
-              "pr_title": "${{ steps.pr_details.outputs.pr_title }}",
-              "pr_state": "${{ steps.pr_details.outputs.pr_state }}",
-              "repo": "${{ github.repository }}"
-            }
-
-      - name: Post deploy success comment
-        if: steps.check_status.outputs.should_deploy == 'true'
-        uses: actions/github-script@v8
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `🚀 **Deploying PR #${{ steps.pr_details.outputs.pr_number }}** to development environment...`
-            });
-
-      - name: Dispatch Undeploy Event (from comment)
-        if: steps.check_status.outputs.should_undeploy == 'true'
-        uses: peter-evans/repository-dispatch@v4
-        with:
-          token: ${{ secrets.DISPATCH_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: pr-event
-          client-payload: |
-            {
-              "action": "undeploy",
-              "pr_number": "${{ steps.pr_details.outputs.pr_number }}",
-              "pr_title": "${{ steps.pr_details.outputs.pr_title }}",
-              "pr_state": "${{ steps.pr_details.outputs.pr_state }}",
-              "repo": "${{ github.repository }}"
-            }
-
-      - name: Post undeploy success comment
-        if: steps.check_status.outputs.should_undeploy == 'true'
-        uses: actions/github-script@v8
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `🗑️ **Undeploying PR #${{ steps.pr_details.outputs.pr_number }}** from development environment...`
-            });
-
-      - name: Check deployment status on PR close
-        id: check_pr_close
-        if: github.event_name == 'pull_request' && github.event.action == 'closed'
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const comments = await github.rest.issues.listComments({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number
-            });
-            
-            let lastDeployIndex = -1;
-            let lastUndeployIndex = -1;
-            
-            comments.data.forEach((comment, index) => {
-              if (comment.body.trim() === '!deploy') {
-                lastDeployIndex = index;
-              } else if (comment.body.trim() === '!undeploy') {
-                lastUndeployIndex = index;
-              }
-            });
-            
-            // Should undeploy if there's a !deploy without a subsequent !undeploy
-            const shouldUndeploy = lastDeployIndex !== -1 && lastDeployIndex > lastUndeployIndex;
-            core.setOutput('should_undeploy', shouldUndeploy);
-            
-      - name: Dispatch Undeploy Event (PR closed with active deployment)
-        if: >-
-          github.event_name == 'pull_request' &&
-          github.event.action == 'closed' &&
-          steps.check_pr_close.outputs.should_undeploy == 'true'
-        uses: peter-evans/repository-dispatch@v4
-        with:
-          token: ${{ secrets.DISPATCH_TOKEN }}
-          repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
-          event-type: pr-event
-          client-payload: |
-            {
-              "action": "undeploy",
-              "pr_number": "${{ github.event.pull_request.number }}",
-              "pr_title": "${{ github.event.pull_request.title }}",
-              "pr_state": "${{ github.event.pull_request.state }}",
-              "repo": "${{ github.repository }}"
-            }
-
-      - name: Post PR close undeploy comment
-        if: >-
-          github.event_name == 'pull_request' &&
-          github.event.action == 'closed' &&
-          steps.check_pr_close.outputs.should_undeploy == 'true'
-        uses: actions/github-script@v8
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `🧹 **Auto-undeploying**: PR closed with active deployment. Cleaning up development environment for PR #${{ github.event.pull_request.number }}.`
-            });

.github/workflows/platform-frontend-ci.yml

@@ -6,22 +6,10 @@ on:
     paths:
       - ".github/workflows/platform-frontend-ci.yml"
       - "autogpt_platform/frontend/**"
-      - "autogpt_platform/backend/Dockerfile"
-      - "autogpt_platform/docker-compose.yml"
-      - "autogpt_platform/docker-compose.platform.yml"
   pull_request:
     paths:
       - ".github/workflows/platform-frontend-ci.yml"
       - "autogpt_platform/frontend/**"
-      - "autogpt_platform/backend/Dockerfile"
-      - "autogpt_platform/docker-compose.yml"
-      - "autogpt_platform/docker-compose.platform.yml"
-  merge_group:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name == 'merge_group' && format('merge-queue-{0}', github.ref) || format('{0}-{1}', github.ref, github.event.pull_request.number || github.sha) }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 defaults:
   run:
@@ -29,130 +17,80 @@ defaults:
     working-directory: autogpt_platform/frontend
 
 jobs:
-  setup:
-    runs-on: ubuntu-latest
-    outputs:
-      components-changed: ${{ steps.filter.outputs.components }}
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Check for component changes
-        uses: dorny/paths-filter@v3
-        id: filter
-        with:
-          filters: |
-            components:
-              - 'autogpt_platform/frontend/src/components/**'
-
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set up Node
-        uses: actions/setup-node@v6
-        with:
-          node-version: "22.18.0"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
-
-      - name: Install dependencies to populate cache
-        run: pnpm install --frozen-lockfile
-
   lint:
     runs-on: ubuntu-latest
-    needs: setup
 
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set up Node
-        uses: actions/setup-node@v6
+      - uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
         with:
-          node-version: "22.18.0"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
+          node-version: "21"
 
       - name: Install dependencies
-        run: pnpm install --frozen-lockfile
+        run: |
+          yarn install --frozen-lockfile
 
       - name: Run lint
-        run: pnpm lint
+        run: |
+          yarn lint
 
-  chromatic:
+  test:
     runs-on: ubuntu-latest
-    needs: setup
-    # Disabled: to re-enable, remove 'false &&' from the condition below
-    if: >-
-      false
-      && (github.ref == 'refs/heads/dev' || github.base_ref == 'dev')
-      && needs.setup.outputs.components-changed == 'true'
 
     steps:
+      - name: Free Disk Space (Ubuntu)
+        uses: jlumbroso/free-disk-space@main
+        with:
+          # this might remove tools that are actually needed,
+          # if set to "true" but frees about 6 GB
+          tool-cache: false
+
+          # all of these default to true, but feel free to set to
+          # "false" if necessary for your workflow
+          android: false
+          dotnet: false
+          haskell: false
+          large-packages: true
+          docker-images: true
+          swap-storage: true
+
       - name: Checkout repository
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set up Node
-        uses: actions/setup-node@v6
-        with:
-          node-version: "22.18.0"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run Chromatic
-        uses: chromaui/action@latest
-        with:
-          projectToken: chpt_9e7c1a76478c9c8
-          onlyChanged: true
-          workingDir: autogpt_platform/frontend
-          token: ${{ secrets.GITHUB_TOKEN }}
-          exitOnceUploaded: true
-
-  integration_test:
-    runs-on: ubuntu-latest
-    needs: setup
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           submodules: recursive
 
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set up Node
-        uses: actions/setup-node@v6
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
         with:
-          node-version: "22.18.0"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
+          node-version: "21"
+
+      - name: Copy default supabase .env
+        run: |
+          cp ../supabase/docker/.env.example ../.env
+
+      - name: Run docker compose
+        run: |
+          docker compose -f ../docker-compose.yml up -d
 
       - name: Install dependencies
-        run: pnpm install --frozen-lockfile
+        run: |
+          yarn install --frozen-lockfile
 
-      - name: Generate API client
-        run: pnpm generate:api
+      - name: Setup Builder .env
+        run: |
+          cp .env.example .env
 
-      - name: Run Integration Tests
-        run: pnpm test:unit
+      - name: Install Playwright Browsers
+        run: yarn playwright install --with-deps
 
-      - name: Upload coverage reports to Codecov
+      - name: Run tests
+        run: |
+          yarn test
+
+      - uses: actions/upload-artifact@v4
         if: ${{ !cancelled() }}
-        uses: codecov/codecov-action@v5
         with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: platform-frontend
-          files: ./autogpt_platform/frontend/coverage/cobertura-coverage.xml
+          name: playwright-report
+          path: playwright-report/
+          retention-days: 30