Merge branch 'dev' into fix/claude-code-binary-files-v2

- Remove redundant inline comment on text_only param
- Simplify file filtering logic per review suggestion

.agents/skills

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

.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,709 +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 + no fresh CHANGES_REQUESTED. 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 + no fresh CHANGES_REQUESTED
-                                                                 ↓
-                                              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 |
-| GitHub abuse rate limit error | Nudge: "Wait 60 seconds then continue posting replies with sleep 3 between each" |
-| 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 | Query GraphQL for actual unresolved count. If >0, re-brief. If 0, run `verify-complete.sh` |
-
-**Poll all windows from state, not from memory.** Before each poll, run:
-```bash
-jq -r '.agents[] | select(.state | test("running|idle|stuck|waiting_approval|pending_evaluation")) | .window' ~/.claude/orchestrator-state.json
-```
-and capture every window listed. If you manually added a window outside spawn-agent.sh, ensure it's in the state file first.
-
-### RUNNING count includes waiting_approval agents
-
-The `RUNNING` count from run-loop.sh includes agents in `waiting_approval` state (they match the regex `running|stuck|waiting_approval|idle`). This means a fleet that is only `waiting_approval` still shows RUNNING > 0 in the log — it does **not** mean agents are actively working.
-
-When you see `RUNNING > 0` in the run-loop log but suspect agents are actually blocked, check state directly:
-```bash
-jq '.agents[] | {window, state, worktree}' ~/.claude/orchestrator-state.json
-```
-A count of `running=1 waiting=1` in the log actually means one agent is waiting for approval — the orchestrator should check and approve, not wait.
-
-### State file staleness recovery
-
-The state file is written by scripts but can drift from reality when windows are closed, sessions expire, or the orchestrator restarts across conversations.
-
-**Signs of stale state:**
-- `loop_window` points to a window that no longer exists in the tmux session
-- An agent's `state` is `running` but tmux window is closed or shows a shell prompt (not claude)
-- `last_seen_at` is hours old but state still says `running`
-
-**Recovery steps:**
-
-1. **Verify actual tmux windows:**
-```bash
-tmux list-windows -t SESSION -F '#{window_index}: #{window_name} (#{pane_current_command})'
-```
-
-2. **Cross-reference with state file:**
-```bash
-jq -r '.agents[] | "\(.window) \(.state) \(.worktree)"' ~/.claude/orchestrator-state.json
-```
-
-3. **Fix stale entries:**
-```bash
-# Agent window closed — mark idle so run-loop.sh will restart it
-jq --arg w "SESSION:WIN" '(.agents[] | select(.window==$w)).state = "idle"' \
-  ~/.claude/orchestrator-state.json > /tmp/orch.tmp && mv /tmp/orch.tmp ~/.claude/orchestrator-state.json
-
-# loop_window gone — kill the stale reference, then restart run-loop.sh
-jq '.loop_window = null' ~/.claude/orchestrator-state.json > /tmp/orch.tmp && mv /tmp/orch.tmp ~/.claude/orchestrator-state.json
-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
-```
-
-4. **After any state repair, re-run `status.sh` to confirm coherence before resuming supervision.**
-
-### Strict ORCHESTRATOR:DONE gate
-
-`verify-complete.sh` handles the main checks automatically (checkpoints, threads, CI green, spawned_at, and CHANGES_REQUESTED). Run it:
-
-**CHANGES_REQUESTED staleness rule**: a `CHANGES_REQUESTED` review only blocks if it was submitted *after* the latest commit. If the latest commit postdates the review, the review is considered stale (feedback already addressed) and does not block. This avoids false negatives when a bot reviewer hasn't re-reviewed after the agent's fixing commits.
-
-```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
-
-**Before sending any nudge, verify the pane is at an idle ❯ prompt.** Sending text into a still-processing pane produces stuck `[Pasted text +N lines]` that the agent never sees.
-
-Check:
-```bash
-tmux capture-pane -t SESSION:WIN -p 2>/dev/null | tail -5
-```
-If the last line shows a spinner (✳✽✢✶·), `Running…`, or no `❯` — wait 10–15s and check again before sending.
-
-```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 https://github.com/Significant-Gravitas/AutoGPT/pull/NNNN — <feature description>
-- [ ] /pr-test https://github.com/Significant-Gravitas/AutoGPT/pull/MMMM — <feature description>
-```
-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.
-
-### /pr-test result evaluation
-
-**PARTIAL on any headline feature scenario is an immediate blocker.** Do not approve, do not mark done, do not let the agent output `ORCHESTRATOR:DONE`.
-
-| `/pr-test` result | Action |
-|---|---|
-| All headline scenarios **PASS** | Proceed to evaluation step 2 |
-| Any headline scenario **PARTIAL** | Re-brief the agent immediately — see below |
-| Any headline scenario **FAIL** | Re-brief the agent immediately |
-
-**What PARTIAL means**: the feature is only partly working. Example: the Apply button never appeared, or the AI returned no action blocks. The agent addressed part of the objective but not all of it.
-
-**When any headline scenario is PARTIAL or FAIL:**
-
-1. Do NOT mark the agent done or accept `ORCHESTRATOR:DONE`
-2. Re-brief the agent with the specific scenario that failed and what was missing:
-   ```bash
-   tmux send-keys -t SESSION:WIN "PARTIAL result on /pr-test — S5 (Apply button) never appeared. The AI must output JSON action blocks for the Apply button to render. Fix this before re-running /pr-test."
-   sleep 0.3
-   tmux send-keys -t SESSION:WIN Enter
-   ```
-3. Set state back to `running`:
-   ```bash
-   jq --arg w "SESSION:WIN" '(.agents[] | select(.window == $w)).state = "running"' \
-     ~/.claude/orchestrator-state.json > /tmp/orch.tmp && mv /tmp/orch.tmp ~/.claude/orchestrator-state.json
-   ```
-4. Wait for new `ORCHESTRATOR:DONE`, then re-run `/pr-test` from scratch
-
-**Rule: only ALL-PASS qualifies for approval.** A mix of PASS + PARTIAL is a failure.
-
-> **Why this matters**: A PR was once wrongly approved with S5 PARTIAL — the AI never output JSON action blocks so the Apply button never appeared. The fix was already in the agent's reach but slipped through because PARTIAL was not treated as blocking.
-
-### 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` all scenarios PASS + evaluation looks good → mark `done` in state, tell the user the PR is ready, ask if window should be closed
-- `/pr-test` any scenario PARTIAL or FAIL → re-brief the agent with the specific failing scenario, set state back to `running` (see `/pr-test result evaluation` above)
-- Evaluation finds gaps even with all PASS → re-brief the agent with specific gaps, 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 fresh CHANGES_REQUESTED (after latest commit) | `verify-complete.sh` checks this — stale pre-commit reviews are ignored |
-| 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.
-
----
-
-## Thread resolution integrity (critical)
-
-**Agents MUST NOT resolve review threads via GraphQL unless a real code fix has been committed and pushed first.**
-
-This is the most common failure mode: agents call `resolveReviewThread` to make unresolved counts drop without actually fixing anything. This produces a false "done" signal that gets past verify-complete.sh.
-
-**The only valid resolution sequence:**
-1. Read the thread and understand what it's asking
-2. Make the actual code change
-3. `git commit` and `git push`
-4. Reply to the thread with the commit SHA (e.g. "Fixed in `abc1234`")
-5. THEN call `resolveReviewThread`
-
-**The supervisor must verify actual thread counts via GraphQL** — never trust an agent's claim of "0 unresolved." After any agent's ORCHESTRATOR:DONE, always run:
-
-```bash
-# Step 1: get total count
-TOTAL=$(gh api graphql -f query='{ repository(owner: "OWNER", name: "REPO") { pullRequest(number: PR) { reviewThreads { totalCount } } } }' \
-  | jq '.data.repository.pullRequest.reviewThreads.totalCount')
-echo "Total threads: $TOTAL"
-
-# Step 2: paginate all pages and count unresolved
-CURSOR=""; UNRESOLVED=0
-while true; do
-  AFTER=${CURSOR:+", after: \"$CURSOR\""}
-  PAGE=$(gh api graphql -f query="{ repository(owner: \"OWNER\", name: \"REPO\") { pullRequest(number: PR) { reviewThreads(first: 100${AFTER}) { pageInfo { hasNextPage endCursor } nodes { isResolved } } } } }")
-  UNRESOLVED=$(( UNRESOLVED + $(echo "$PAGE" | jq '[.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved==false)] | length') ))
-  HAS_NEXT=$(echo "$PAGE" | jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.hasNextPage')
-  CURSOR=$(echo "$PAGE" | jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.endCursor')
-  [ "$HAS_NEXT" = "false" ] && break
-done
-echo "Unresolved: $UNRESOLVED"
-```
-
-If unresolved > 0, the agent is NOT done — re-brief with the actual count and the rule.
-
-**Include this in every agent objective:**
-> IMPORTANT: Do NOT resolve any review thread via GraphQL unless the code fix is committed and pushed first. Fix the code → commit → push → reply with SHA → then resolve. Never resolve without a real commit. "Accepted" or "Acknowledged" replies are NOT resolutions — only real commits qualify.
-
-### Detecting fake resolutions
-
-When an agent claims "0 unresolved threads", query GitHub GraphQL yourself and also inspect how each thread was resolved. A resolved thread whose last comment is `"Acknowledged"`, `"Same as above"`, `"Accepted trade-off"`, or `"Deferred"` — with no commit SHA — is a fake resolution.
-
-To spot these, paginate all pages and collect resolved threads with missing SHA links:
-```bash
-# Paginate all pages — first:100 misses threads beyond page 1 on large PRs
-CURSOR=""; FAKE_RESOLUTIONS="[]"
-while true; do
-  AFTER=${CURSOR:+", after: \"$CURSOR\""}
-  PAGE=$(gh api graphql -f query="
-  {
-    repository(owner: \"Significant-Gravitas\", name: \"AutoGPT\") {
-      pullRequest(number: PR_NUMBER) {
-        reviewThreads(first: 100${AFTER}) {
-          pageInfo { hasNextPage endCursor }
-          nodes {
-            isResolved
-            comments(last: 1) {
-              nodes { body author { login } }
-            }
-          }
-        }
-      }
-    }
-  }")
-  PAGE_FAKES=$(echo "$PAGE" | jq '[.data.repository.pullRequest.reviewThreads.nodes[]
-    | select(.isResolved == true)
-    | {body: .comments.nodes[0].body[:120], author: .comments.nodes[0].author.login}
-    | select(.body | test("Fixed in|Removed in|Addressed in") | not)]')
-  FAKE_RESOLUTIONS=$(echo "$FAKE_RESOLUTIONS $PAGE_FAKES" | jq -s 'add')
-  HAS_NEXT=$(echo "$PAGE" | jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.hasNextPage')
-  CURSOR=$(echo "$PAGE" | jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.endCursor')
-  [ "$HAS_NEXT" = "false" ] && break
-done
-echo "$FAKE_RESOLUTIONS"
-```
-Any resolved thread whose last comment does NOT contain `"Fixed in"`, `"Removed in"`, or `"Addressed in"` (with a commit link) should be investigated — either the agent falsely resolved it, or it was a genuine false positive that needs explanation.
-
-## GitHub abuse rate limits
-
-Two distinct rate limits exist with different recovery times:
-
-| Error | HTTP status | Cause | Recovery |
-|---|---|---|---|
-| `{"code":"abuse"}` in body | 403 | Secondary rate limit — too many write operations (comments, mutations) in a short window | Wait **2–3 minutes**. 60s is often not enough. |
-| `API rate limit exceeded` | 429 | Primary rate limit — too many read calls per hour | Wait until `X-RateLimit-Reset` timestamp |
-
-**Prevention:** Agents must add `sleep 3` between individual thread reply API calls. For >20 unresolved threads, increase to `sleep 5`.
-
-If you see a 403 `abuse` error from an agent's pane:
-1. Nudge the agent: `"You hit a GitHub secondary rate limit (403). Stop all API writes. Wait 2 minutes, then resume with sleep 3 between each thread reply."`
-2. Do NOT nudge again during the 2-minute wait — a second nudge restarts the clock.
-
-Add this to agent briefings when there are >20 unresolved threads:
-> Post replies with `sleep 3` between each reply. If you hit a 403 abuse error, wait 2 minutes (not 60s — secondary limits take longer to clear) then continue.
-
-## 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
-16. **Poll ALL windows from state file** — never hardcode window count. Derive active windows dynamically: `jq -r '.agents[] | select(.state | test("running|idle|stuck")) | .window' ~/.claude/orchestrator-state.json`. If you added a window mid-session outside spawn-agent.sh, add it to the state file immediately.
-20. **Orchestrator handles its own approvals** — when spawning a subagent to make edits (SKILL.md, scripts, config), review the diff yourself and approve/reject without surfacing it to the user. The user should never have to open a file to check the orchestrator's work. Use the Agent tool with `subagent_type: general-purpose` for drafting, then verify the result yourself before considering the task done.
-17. **Update state file on re-task** — whenever an agent is re-tasked mid-session (objective changes, new PR assigned), update the state file record immediately so objectives stay accurate for re-briefing after compaction.
-18. **No GraphQL resolveReviewThread without a commit** — see Thread resolution integrity above. This is rule #1 for pr-address work.
-19. **Verify thread counts yourself** — after any agent claims "0 unresolved threads", query GitHub GraphQL directly before accepting. Never trust the agent's self-report.

.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,215 +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}"
-# Adaptive polling: starts at base interval, backs off up to POLL_IDLE_MAX when
-# no agents need attention, resets on any activity or waiting_approval state.
-POLL_INTERVAL="${POLL_INTERVAL:-30}"
-POLL_IDLE_MAX=${POLL_IDLE_MAX:-300}
-POLL_CURRENT=$POLL_INTERVAL
-
-# ---------------------------------------------------------------------------
-# 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
-}
-
-# ---------------------------------------------------------------------------
-# wait_for_claude_idle WINDOW — wait up to 30s for Claude to reach idle ❯ prompt
-# (no spinner or busy indicator visible in the last 3 lines of pane output)
-# Returns 0 when idle, 1 on timeout.
-# ---------------------------------------------------------------------------
-wait_for_claude_idle() {
-  local window="$1"
-  local timeout="${2:-30}"
-  local elapsed=0
-  while (( elapsed < timeout )); do
-    local cmd pane pane_tail
-    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 "")
-    pane_tail=$(echo "$pane" | tail -3)
-    # Check full pane (not just tail) — 'Enter to confirm' dialog can scroll above last 3 lines.
-    # Do NOT reset elapsed — resetting allows an infinite loop if the dialog never clears.
-    if echo "$pane" | grep -q "Enter to confirm"; then
-      tmux send-keys -t "$window" Down Enter
-      sleep 2; (( elapsed += 2 )); continue
-    fi
-    # Must be running under node (Claude is live)
-    if [[ "$cmd" == "node" ]]; then
-      # Idle: ❯ prompt visible AND no spinner/busy text in last 3 lines
-      if echo "$pane_tail" | grep -q "❯" && \
-         ! echo "$pane_tail" | grep -qE '[✳✽✢✶·✻✼✿❋✤]|Running…|Compacting'; then
-        return 0
-      fi
-    fi
-    sleep 2
-    (( elapsed += 2 ))
-  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"
-
-  # Wait for the shell prompt before typing — avoids sending into a still-draining pane
-  wait_for_claude_idle "$window" 30 \
-    || echo "[$(date +%H:%M:%S)] KICK WARNING  $window — pane still busy before resume, sending anyway"
-
-  # 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 ${POLL_INTERVAL}s→${POLL_IDLE_MAX}s adaptive)"
-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)
-
-  # Adaptive backoff: reset to base on activity or waiting_approval agents; back off when truly idle
-  WAITING=$(jq '[.agents[] | select(.state == "waiting_approval")] | length' "$STATE_FILE" 2>/dev/null || echo 0)
-  if (( KICKED > 0 || DONE > 0 || WAITING > 0 )); then
-    POLL_CURRENT=$POLL_INTERVAL
-  else
-    POLL_CURRENT=$(( POLL_CURRENT + POLL_CURRENT / 2 + 1 ))
-    (( POLL_CURRENT > POLL_IDLE_MAX )) && POLL_CURRENT=$POLL_IDLE_MAX
-  fi
-
-  echo "[$(date +%H:%M:%S)] Poll — ${RUNNING} running  ${KICKED} kicked  ${DONE} recycled  (next in ${POLL_CURRENT}s)"
-  sleep "$POLL_CURRENT"
-done

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

@@ -1,129 +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_for_claude_idle — poll until the pane shows idle ❯ with no spinner in the last 3 lines.
-# Returns 0 when idle, 1 on timeout.
-_wait_idle() {
-  local window="$1" timeout="${2:-60}" elapsed=0
-  while (( elapsed < timeout )); do
-    local cmd pane_tail
-    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 "")
-    pane_tail=$(echo "$pane" | tail -3)
-    # Check full pane (not just tail) — 'Enter to confirm' dialog can appear above the last 3 lines
-    if echo "$pane" | grep -q "Enter to confirm"; then
-      tmux send-keys -t "$window" Down Enter
-      sleep 2; (( elapsed += 2 )); continue
-    fi
-    if [[ "$cmd" == "node" ]] && \
-       echo "$pane_tail" | grep -q "❯" && \
-       ! echo "$pane_tail" | grep -qE '[✳✽✢✶·✻✼✿❋✤]|Running…|Compacting'; then
-      return 0
-    fi
-    sleep 2; (( elapsed += 2 ))
-  done
-  return 1
-}
-
-# Wait up to 60s for claude to be fully interactive and idle (❯ visible, no spinner).
-if ! _wait_idle "$WINDOW" 60; then
-  echo "[spawn-agent] WARNING: timed out waiting for idle ❯ 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,180 +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) ---
-# A CHANGES_REQUESTED review is stale if the latest commit was pushed AFTER the review was submitted.
-# Stale reviews (pre-dating the fixing commits) should not block verification.
-#
-# Fetch commits and latestReviews in a single call and fail closed — if gh fails,
-# treat that as NOT COMPLETE rather than silently passing.
-# Use latestReviews (not reviews) so each reviewer's latest state is used — superseded
-# CHANGES_REQUESTED entries are automatically excluded when the reviewer later approved.
-# Note: we intentionally use committedDate (not PR updatedAt) because updatedAt changes on any
-# PR activity (bot comments, label changes) which would create false negatives.
-PR_REVIEW_METADATA=$(gh pr view "$PR_NUMBER" --repo "$REPO" \
-  --json commits,latestReviews 2>/dev/null) || {
-  echo "NOT COMPLETE: unable to fetch PR review metadata for PR #$PR_NUMBER" >&2
-  exit 1
-}
-
-LATEST_COMMIT_DATE=$(jq -r '.commits[-1].committedDate // ""' <<< "$PR_REVIEW_METADATA")
-CHANGES_REQUESTED_REVIEWS=$(jq '[.latestReviews[]? | select(.state == "CHANGES_REQUESTED")]' <<< "$PR_REVIEW_METADATA")
-
-BLOCKING_CHANGES_REQUESTED=0
-BLOCKING_REQUESTERS=""
-
-if [ -n "$LATEST_COMMIT_DATE" ] && [ "$(echo "$CHANGES_REQUESTED_REVIEWS" | jq length)" -gt 0 ]; then
-  if date --version >/dev/null 2>&1; then
-    LATEST_COMMIT_EPOCH=$(date -d "$LATEST_COMMIT_DATE" "+%s" 2>/dev/null || echo "0")
-  else
-    LATEST_COMMIT_EPOCH=$(TZ=UTC date -j -f "%Y-%m-%dT%H:%M:%SZ" "$LATEST_COMMIT_DATE" "+%s" 2>/dev/null || echo "0")
-  fi
-
-  while IFS= read -r review; do
-    [ -z "$review" ] && continue
-    REVIEW_DATE=$(echo "$review" | jq -r '.submittedAt // ""')
-    REVIEWER=$(echo "$review" | jq -r '.author.login // "unknown"')
-    if [ -z "$REVIEW_DATE" ]; then
-      # No submission date — treat as fresh (conservative: blocks verification)
-      BLOCKING_CHANGES_REQUESTED=$(( BLOCKING_CHANGES_REQUESTED + 1 ))
-      BLOCKING_REQUESTERS="${BLOCKING_REQUESTERS:+$BLOCKING_REQUESTERS, }${REVIEWER}"
-    else
-      if date --version >/dev/null 2>&1; then
-        REVIEW_EPOCH=$(date -d "$REVIEW_DATE" "+%s" 2>/dev/null || echo "0")
-      else
-        REVIEW_EPOCH=$(TZ=UTC date -j -f "%Y-%m-%dT%H:%M:%SZ" "$REVIEW_DATE" "+%s" 2>/dev/null || echo "0")
-      fi
-      if [ "$REVIEW_EPOCH" -gt "$LATEST_COMMIT_EPOCH" ]; then
-        # Review was submitted AFTER latest commit — still fresh, blocks verification
-        BLOCKING_CHANGES_REQUESTED=$(( BLOCKING_CHANGES_REQUESTED + 1 ))
-        BLOCKING_REQUESTERS="${BLOCKING_REQUESTERS:+$BLOCKING_REQUESTERS, }${REVIEWER}"
-      fi
-      # Review submitted BEFORE latest commit — stale, skip
-    fi
-  done <<< "$(echo "$CHANGES_REQUESTED_REVIEWS" | jq -c '.[]')"
-else
-  # No commit date or no changes_requested — check raw count as fallback
-  BLOCKING_CHANGES_REQUESTED=$(echo "$CHANGES_REQUESTED_REVIEWS" | jq length 2>/dev/null || echo "0")
-  BLOCKING_REQUESTERS=$(echo "$CHANGES_REQUESTED_REVIEWS" | jq -r '[.[].author.login] | join(", ")' 2>/dev/null || echo "unknown")
-fi
-
-if [ "$BLOCKING_CHANGES_REQUESTED" -gt 0 ]; then
-  echo "NOT COMPLETE: CHANGES_REQUESTED (after latest commit) from ${BLOCKING_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,495 +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'
-```
-
-> If GraphQL is rate-limited, `gh pr view` fails. See [GitHub rate limits](#github-rate-limits) for REST fallbacks.
-
-## Fetch comments (all sources)
-
-### 1. Inline review threads — GraphQL (primary source of actionable items)
-
-> ⚠️ **WARNING — PAGINATE ALL PAGES BEFORE ADDRESSING ANYTHING**
->
-> `reviewThreads(first: 100)` returns at most 100 threads per page AND returns threads **oldest-first**. On a PR with many review cycles (e.g. 373 threads), the oldest 100–200 threads are from past cycles and are **all already resolved**. Filtering client-side with `select(.isResolved == false)` on page 1 therefore yields **0 results** — even though pages 2–4 contain many unresolved threads from recent review cycles.
->
-> **This is the most common failure mode:** agent fetches page 1, sees 0 unresolved after filtering, stops pagination, reports "done" — while hundreds of unresolved threads sit on later pages.
->
-> One observed PR had 142 total threads: page 1 returned 0 unresolved (all old/resolved), while pages 2–3 had 111 unresolved. Another with 373 threads across 4 pages also had page 1 entirely resolved.
->
-> **The rule: ALWAYS paginate to `hasNextPage == false` regardless of the per-page unresolved count. Never stop early because a page returns 0 unresolved.**
-
-**Step 1 — Fetch total count and sanity-check the newest threads:**
-
-```bash
-# Get total count and the newest 100 threads (last: 100 returns newest-first)
-gh api graphql -f query='
-{
-  repository(owner: "Significant-Gravitas", name: "AutoGPT") {
-    pullRequest(number: {N}) {
-      reviewThreads { totalCount }
-      newest: reviewThreads(last: 100) {
-        nodes { isResolved }
-      }
-    }
-  }
-}' | jq '{ total: .data.repository.pullRequest.reviewThreads.totalCount, newest_unresolved: [.data.repository.pullRequest.newest.nodes[] | select(.isResolved == false)] | length }'
-```
-
-If `total > 100`, you have multiple pages — you **must** paginate all of them regardless of what `newest_unresolved` shows. The `last: 100` check is a sanity signal only; the full loop below is mandatory.
-
-**Step 2 — Collect all unresolved thread IDs across all pages:**
-
-```bash
-# Accumulate all unresolved threads — loop until hasNextPage == false
-CURSOR=""
-ALL_THREADS="[]"
-while true; do
-  AFTER=${CURSOR:+", after: \"$CURSOR\""}
-  PAGE=$(gh api graphql -f query="
-  {
-    repository(owner: \"Significant-Gravitas\", name: \"AutoGPT\") {
-      pullRequest(number: {N}) {
-        reviewThreads(first: 100${AFTER}) {
-          pageInfo { hasNextPage endCursor }
-          nodes {
-            id
-            isResolved
-            path
-            line
-            comments(last: 1) {
-              nodes { databaseId body author { login } }
-            }
-          }
-        }
-      }
-    }
-  }")
-  # Append unresolved nodes from this page
-  PAGE_THREADS=$(echo "$PAGE" | jq '[.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved == false)]')
-  ALL_THREADS=$(echo "$ALL_THREADS $PAGE_THREADS" | jq -s 'add')
-  HAS_NEXT=$(echo "$PAGE" | jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.hasNextPage')
-  CURSOR=$(echo "$PAGE" | jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.endCursor')
-  [ "$HAS_NEXT" = "false" ] && break
-done
-
-# Reverse so newest threads (last pages) are addressed first — GitHub returns oldest-first
-# and the most recent review cycle's comments are the ones blocking approval.
-ALL_THREADS=$(echo "$ALL_THREADS" | jq 'reverse')
-
-echo "Total unresolved threads: $(echo "$ALL_THREADS" | jq 'length')"
-echo "$ALL_THREADS" | jq '[.[] | {id, path, line, body: .comments.nodes[0].body[:200]}]'
-```
-
-**Step 3 — Address every thread in `ALL_THREADS`, then resolve.**
-
-Only after this loop completes (all pages fetched, count confirmed) should you begin making fixes.
-
-> **Why reverse?** GraphQL returns threads oldest-first and exposes no `orderBy` option. A PR with 373 threads has ~4 pages; threads from the latest review cycle land on the last pages. Processing in reverse ensures the newest, most blocking comments are addressed first — the earlier pages mostly contain outdated threads from prior cycles.
-
-**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.
-
-> If GraphQL is rate-limited, see [GitHub rate limits](#github-rate-limits) for the REST fallback (flat comment list — no thread grouping or `isResolved`).
-
-### 2. Top-level reviews — REST (MUST paginate)
-
-```bash
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews --paginate
-```
-
-> **Already REST — unaffected by GraphQL rate limits or outages. Continue polling reviews normally even when GraphQL is exhausted.**
-
-**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
-```
-
-> **Already REST — unaffected by GraphQL rate limits.**
-
-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
-
-**CRITICAL: The only valid sequence is fix → commit → push → reply → resolve. Never resolve a thread without a real code commit.**
-
-Resolving a thread via `resolveReviewThread` without an actual fix is the most common failure mode — it makes unresolved counts drop without any real change, producing a false "done" signal. If the issue was genuinely a false positive (no code change needed), reply explaining why and then resolve. Otherwise:
-
-Address comments **one at a time**: fix → commit → push → inline reply → resolve.
-
-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. Always get the full SHA with `git rev-parse HEAD` **after** committing — never copy a SHA from a previous commit or hardcode one:
-
-```bash
-FULL_SHA=$(git rev-parse HEAD)
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments/{ID}/replies \
-  -f body="🤖 Fixed in [${FULL_SHA:0:9}](https://github.com/Significant-Gravitas/AutoGPT/commit/${FULL_SHA}): <description>"
-```
-
-| 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>"` |
-
-### What counts as a valid resolution
-
-Only two situations justify calling `resolveReviewThread`:
-
-1. **Real code fix**: you changed the code, committed + pushed, and replied with the SHA. The commit diff must actually address the concern — not just touch the same file.
-2. **Genuine false positive**: the reviewer's concern does not apply to this code, and you can give a specific technical reason (e.g. "Not applicable — `sdk_cwd` is pre-validated by `_make_sdk_cwd()` which applies normpath + prefix assertion before reaching this point").
-
-**Anti-patterns that look resolved but aren't — never do these:**
-- `"Accepted, tracked as follow-up"` — a deferral, not a fix. The concern is still open. Do not resolve.
-- `"Acknowledged"` or `"Same as above"` — these are acknowledgements, not fixes. Do not resolve.
-- `"Fixed in abc1234"` where `abc1234` is a commit that doesn't actually change the flagged line/logic — dishonest. Verify `git show abc1234 -- path/to/file` changes the right thing before posting.
-- Resolving without replying — the reviewer never sees what happened.
-
-When in doubt: if a code change is needed, make it. A deferred issue means the thread stays open until the follow-up PR is merged.
-
-## 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).
-
-## Coverage
-
-Codecov enforces patch coverage on new/changed lines — new code you write must be tested. Before pushing, verify you haven't left new lines uncovered:
-
-```bash
-cd autogpt_platform/backend
-poetry run pytest --cov=. --cov-report=term-missing {path/to/changed/module}
-```
-
-Look for lines marked `miss` — those are uncovered. Add tests for any new code you wrote as part of addressing comments.
-
-**Rules:**
-- New code you add should have tests
-- Don't remove existing tests when fixing comments
-- If a reviewer asks you to delete code, also delete its tests, but verify coverage hasn't dropped on remaining lines
-
-## 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.
-
-## GitHub rate limits
-
-Three distinct rate limits exist — they have different causes, error shapes, and recovery times:
-
-| Error | HTTP code | Cause | Recovery |
-|---|---|---|---|
-| `{"code":"abuse"}` | 403 | Secondary rate limit — too many write operations (comments, mutations) in a short window | Wait **2–3 minutes**. 60s is often not enough. |
-| `{"message":"API rate limit exceeded"}` | 429 | Primary REST rate limit — 5000 calls/hr per user | Wait until `X-RateLimit-Reset` header timestamp |
-| `GraphQL: API rate limit already exceeded for user ID ...` | 403 on stderr, `gh` exits 1 | **GraphQL-specific** per-user limit — distinct from REST's 5000/hr and from the abuse secondary limit. Trips faster than REST because point costs per query. | Wait until the GraphQL window resets (typically ~1 hour from the first call in the window). REST still works — use fallbacks below. |
-
-**Prevention:** Add `sleep 3` between individual thread reply API calls. When posting >20 replies, increase to `sleep 5`.
-
-### Detection
-
-The `gh` CLI surfaces the GraphQL limit on stderr with the exact string `GraphQL: API rate limit already exceeded for user ID <id>` and exits 1 — any `gh api graphql ...` **or** `gh pr view ...` call fails. Check current quota and reset time via the REST endpoint that reports GraphQL quota (this call is REST and still works whether GraphQL is rate-limited OR fully down):
-
-```bash
-gh api rate_limit --jq '.resources.graphql'   # { "limit": 5000, "used": 5000, "remaining": 0, "reset": 1729...}
-# Human-readable reset:
-gh api rate_limit --jq '.resources.graphql.reset' | xargs -I{} date -r {}
-```
-
-Retry when `remaining > 0`. If you need to proceed sooner, sleep 2–5 min and probe again — the limit is per user, not per machine, so other concurrent agents under the same token also consume it.
-
-### What keeps working
-
-When GraphQL is unavailable (rate-limited or outage):
-
-- **Keeps working (REST):** top-level reviews fetch, conversation comments fetch, all inline-comment replies, CI status (`gh pr checks`), and the `gh api rate_limit` probe.
-- **Degraded:** inline thread list — fall back to flat `/pulls/{N}/comments` REST, which drops thread grouping, `isResolved`, and Relay thread IDs. You still get comment bodies and the `databaseId` as `id`, enough to read and reply.
-- **Blocked:** `gh pr view`, the `resolveReviewThread` mutation, and any new `gh api graphql` queries — wait for the quota to reset.
-
-### Fall back to REST
-
-**PR metadata reads** — `gh pr view` uses GraphQL under the hood; use the REST pulls endpoint instead, which returns the full PR object:
-
-```bash
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N} --jq '.body'           # == --json body
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N} --jq '.base.ref'       # == --json baseRefName
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N} --jq '.mergeable'      # == --json mergeable
-```
-
-Note: REST `mergeable` returns `true|false|null`; GraphQL returns `MERGEABLE|CONFLICTING|UNKNOWN`. The `null` case maps to `UNKNOWN` — treat it the same (still computing; poll again).
-
-**Inline comments (flat list)** — no thread grouping or `isResolved`, but enough to read and reply:
-
-```bash
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments --paginate \
-  | jq '[.[] | {id, path, line, user: .user.login, body: .body[:200], in_reply_to_id}]'
-```
-
-Use this degraded mode to make progress on the fix → reply loop, then return to GraphQL for `resolveReviewThread` once the rate limit resets.
-
-**Replies** — already REST-native (`/pulls/{N}/comments/{ID}/replies`); no change needed, use the same command as the main flow.
-
-**`resolveReviewThread`** — **no REST equivalent**; GitHub does not expose a REST endpoint for thread resolution. Queue the thread IDs needing resolution, wait for the GraphQL limit to reset, then run the resolve mutations in a batch (with `sleep 3` between calls, per the secondary-limit guidance).
-
-### Recovery from secondary rate limit (403 abuse)
-
-1. Stop all API writes immediately
-2. Wait **2 minutes minimum** (not 60s — secondary limits are stricter)
-3. Resume with `sleep 3` between each call
-4. If 403 persists after 2 min, wait another 2 min before retrying
-
-Never batch all replies in a tight loop — always space them out.
-
-## Parallel thread resolution
-
-When a PR has more than 10 unresolved threads, addressing one commit per thread is slow. Use this strategy instead:
-
-### Group by file, batch per commit
-
-1. Sort `ALL_THREADS` by `path` — threads in the same file can share a single commit.
-2. Fix all threads in one file → `git commit` → `git push` → reply to **all** those threads with the same SHA → resolve them all.
-3. Move to the next file group and repeat.
-
-This reduces N commits to (number of files touched), which is usually 3–5 instead of 15–30.
-
-### Posting replies concurrently (for large batches)
-
-For truly independent thread groups (different files, no shared logic), you can post replies in parallel using background subshells — but always space out API writes:
-
-```bash
-# Post replies to a batch of threads concurrently, 3s apart
-(
-  sleep 3
-  gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments/{ID1}/replies \
-    -f body="🤖 Fixed in [${FULL_SHA:0:9}](https://github.com/Significant-Gravitas/AutoGPT/commit/${FULL_SHA}): ..."
-) &
-(
-  sleep 6
-  gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments/{ID2}/replies \
-    -f body="🤖 Fixed in [${FULL_SHA:0:9}](https://github.com/Significant-Gravitas/AutoGPT/commit/${FULL_SHA}): ..."
-) &
-wait  # wait for all background replies before resolving
-```
-
-Then resolve sequentially (GraphQL mutations):
-```bash
-for THREAD_ID in "$THREAD1" "$THREAD2" "$THREAD3"; do
-  gh api graphql -f query="mutation { resolveReviewThread(input: {threadId: \"${THREAD_ID}\"}) { thread { isResolved } } }"
-  sleep 3
-done
-```
-
-**Always sleep 3s between individual API writes** — GitHub's secondary rate limit (403) triggers on bursts of >20 writes. Increase to `sleep 5` when posting more than 20 replies in a batch.
-
-## Resolving threads via GraphQL
-
-Use `resolveReviewThread` **only after** the commit is pushed and the reply is posted:
-
-```bash
-gh api graphql -f query='mutation { resolveReviewThread(input: {threadId: "THREAD_ID"}) { thread { isResolved } } }'
-```
-
-**Never call this mutation before committing the fix.** The orchestrator will verify actual unresolved counts via GraphQL after you output `ORCHESTRATOR:DONE` — false resolutions will be caught and you will be re-briefed.
-
-> `resolveReviewThread` is GraphQL-only — no REST equivalent. If GraphQL is rate-limited, see [GitHub rate limits](#github-rate-limits) for the queue-and-retry flow.
-
-### Verify actual count before outputting ORCHESTRATOR:DONE
-
-Before claiming "0 unresolved threads", always query GitHub directly — don't rely on your own bookkeeping. Paginate all pages — a single `first: 100` query misses threads beyond page 1:
-
-```bash
-# Step 1: get total thread count
-gh api graphql -f query='
-{
-  repository(owner: "Significant-Gravitas", name: "AutoGPT") {
-    pullRequest(number: {N}) {
-      reviewThreads { totalCount }
-    }
-  }
-}' | jq '.data.repository.pullRequest.reviewThreads.totalCount'
-
-# Step 2: paginate all pages, count truly unresolved
-CURSOR=""; UNRESOLVED=0
-while true; do
-  AFTER=${CURSOR:+", after: \"$CURSOR\""}
-  PAGE=$(gh api graphql -f query="
-  {
-    repository(owner: \"Significant-Gravitas\", name: \"AutoGPT\") {
-      pullRequest(number: {N}) {
-        reviewThreads(first: 100${AFTER}) {
-          pageInfo { hasNextPage endCursor }
-          nodes { isResolved }
-        }
-      }
-    }
-  }")
-  UNRESOLVED=$(( UNRESOLVED + $(echo "$PAGE" | jq '[.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved==false)] | length') ))
-  HAS_NEXT=$(echo "$PAGE" | jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.hasNextPage')
-  CURSOR=$(echo "$PAGE" | jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.endCursor')
-  [ "$HAS_NEXT" = "false" ] && break
-done
-echo "Unresolved threads: $UNRESOLVED"
-```
-
-Only output `ORCHESTRATOR:DONE` after this loop reports 0.

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

@@ -1,245 +0,0 @@
----
-name: pr-polish
-description: Alternate /pr-review and /pr-address on a PR until the PR is truly mergeable — no new review findings, zero unresolved inline threads, zero unaddressed top-level reviews or issue comments, all CI checks green, and two consecutive quiet polls after CI settles. Use when the user wants a PR polished to merge-ready without setting a fixed number of rounds.
-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 Polish
-
-**Goal.** Drive a PR to merge-ready by alternating `/pr-review` and `/pr-address` until **all** of the following hold:
-
-1. The most recent `/pr-review` produces **zero new findings** (no new inline comments, no new top-level reviews with a non-empty body).
-2. Every inline review thread reachable via GraphQL reports `isResolved: true`.
-3. Every non-bot, non-author top-level review has been acknowledged (replied-to) OR resolved via a thread it spawned.
-4. Every non-bot, non-author issue comment has been acknowledged (replied-to).
-5. Every CI check is `conclusion: "success"` or `"skipped"` / `"neutral"` — none `"failure"` or still pending.
-6. **Two consecutive post-CI polls** (≥60s apart) stay clean — no new threads, no new non-empty reviews, no new issue comments. Bots (coderabbitai, sentry, autogpt-reviewer) frequently post late after CI settles; a single green snapshot is not sufficient.
-
-**Do not stop at a fixed number of rounds.** If round N introduces new comments, round N+1 is required. Cap at `_MAX_ROUNDS = 10` as a safety valve, but expect 2–5 in practice.
-
-## TodoWrite
-
-Before starting, write two todos so the user can see the loop progression:
-
-- `Round {current}: /pr-review + /pr-address on PR #{N}` — current iteration.
-- `Final polish polling: 2 consecutive clean polls, CI green, 0 unresolved` — runs after the last non-empty review round.
-
-Update the `current` round counter at the start of each iteration; mark `completed` only when the round's address step finishes (all new threads addressed + resolved).
-
-## Find the PR
-
-```bash
-ARG_PR="${ARG:-}"
-# Normalize URL → numeric ID if the skill arg is a pull-request URL.
-if [[ "$ARG_PR" =~ ^https?://github\.com/[^/]+/[^/]+/pull/([0-9]+) ]]; then
-  ARG_PR="${BASH_REMATCH[1]}"
-fi
-PR="${ARG_PR:-$(gh pr list --head "$(git branch --show-current)" --repo Significant-Gravitas/AutoGPT --json number --jq '.[0].number')}"
-if [ -z "$PR" ] || [ "$PR" = "null" ]; then
-  echo "No PR found for current branch. Provide a PR number or URL as the skill arg."
-  exit 1
-fi
-echo "Polishing PR #$PR"
-```
-
-## The outer loop
-
-```text
-round = 0
-while round < _MAX_ROUNDS:
-    round += 1
-    baseline = snapshot_state(PR)   # see "Snapshotting state" below
-    invoke_skill("pr-review", PR)   # posts findings as inline comments / top-level review
-    findings = diff_state(PR, baseline)
-    if findings.total == 0:
-        break  # no new findings → go to polish polling
-    invoke_skill("pr-address", PR)  # resolves every unresolved thread + CI failure
-# Post-loop: polish polling (see below).
-polish_polling(PR)
-```
-
-### Snapshotting state
-
-Before each `/pr-review`, capture a baseline so the diff after the review reflects **only** what the review just added (not pre-existing threads):
-
-```bash
-# Inline threads — total count + latest databaseId per thread
-gh api graphql -f query="
-{
-  repository(owner: \"Significant-Gravitas\", name: \"AutoGPT\") {
-    pullRequest(number: ${PR}) {
-      reviewThreads(first: 100) {
-        totalCount
-        nodes {
-          id
-          isResolved
-          comments(last: 1) { nodes { databaseId } }
-        }
-      }
-    }
-  }
-}" > /tmp/baseline_threads.json
-
-# Top-level reviews — count + latest id per non-empty review
-gh api "repos/Significant-Gravitas/AutoGPT/pulls/${PR}/reviews" --paginate \
-  --jq '[.[] | select((.body // "") != "") | {id, user: .user.login, state, submitted_at}]' \
-  > /tmp/baseline_reviews.json
-
-# Issue comments — count + latest id per non-bot, non-author comment.
-# Bots are filtered by User.type == "Bot" (GitHub sets this for app/bot
-# accounts like coderabbitai, github-actions, sentry-io). The author is
-# filtered by comparing login to the PR author — export it so jq can see it.
-AUTHOR=$(gh api "repos/Significant-Gravitas/AutoGPT/pulls/${PR}" --jq '.user.login')
-gh api "repos/Significant-Gravitas/AutoGPT/issues/${PR}/comments" --paginate \
-  --jq --arg author "$AUTHOR" \
-      '[.[] | select(.user.type != "Bot" and .user.login != $author)
-            | {id, user: .user.login, created_at}]' \
-  > /tmp/baseline_issue_comments.json
-```
-
-### Diffing after a review
-
-After `/pr-review` runs, any of these counting as "new findings" means another address round is needed:
-
-- New inline thread `id` not in the baseline.
-- An existing thread whose latest comment `databaseId` is higher than the baseline's (new reply on an old thread).
-- A new top-level review `id` with a non-empty body.
-- A new issue comment `id` from a non-bot, non-author user.
-
-If any of the four buckets is non-empty → not done; invoke `/pr-address` and loop.
-
-## Polish polling
-
-Once `/pr-review` produces zero new findings, do **not** exit yet. Bots (coderabbitai, sentry, autogpt-reviewer) commonly post late reviews after CI settles — 30–90 seconds after the final push. Poll at 60-second intervals:
-
-```text
-NON_SUCCESS_TERMINAL = {"failure", "cancelled", "timed_out", "action_required", "startup_failure"}
-clean_polls = 0
-required_clean = 2
-while clean_polls < required_clean:
-    # 1. CI gate — any terminal non-success conclusion (not just "failure")
-    # must trigger /pr-address. "success", "skipped", "neutral" are clean;
-    # anything else (including cancelled, timed_out, action_required) is a
-    # blocker that won't self-resolve.
-    ci = fetch_check_runs(PR)
-    if any ci.conclusion in NON_SUCCESS_TERMINAL:
-        invoke_skill("pr-address", PR)  # address failures + any new comments
-        baseline = snapshot_state(PR)   # reset — push during address invalidates old baseline
-        clean_polls = 0
-        continue
-    if any ci.conclusion is None (still in_progress):
-        sleep 60; continue  # wait without counting this as clean
-
-    # 2. Comment / thread gate
-    threads = fetch_unresolved_threads(PR)
-    new_issue_comments = diff_against_baseline(issue_comments)
-    new_reviews = diff_against_baseline(reviews)
-    if threads or new_issue_comments or new_reviews:
-        invoke_skill("pr-address", PR)
-        baseline = snapshot_state(PR)   # reset — the address loop just dealt with these,
-                                        # otherwise they stay "new" relative to the old baseline forever
-        clean_polls = 0
-        continue
-
-    # 3. Mergeability gate
-    mergeable = gh api repos/.../pulls/${PR} --jq '.mergeable'
-    if mergeable == false (CONFLICTING):
-        resolve_conflicts(PR)  # see pr-address skill
-        clean_polls = 0
-        continue
-    if mergeable is null (UNKNOWN):
-        sleep 60; continue
-
-    clean_polls += 1
-    sleep 60
-```
-
-Only after `clean_polls == 2` do you report `ORCHESTRATOR:DONE`.
-
-### Why 2 clean polls, not 1
-
-A single green snapshot can be misleading — the final CI check often completes ~30s before a bot posts its delayed review. One quiet cycle does not prove the PR is stable; two consecutive cycles with no new threads, reviews, or issue comments arriving gives high confidence nothing else is incoming.
-
-### Why checking every source each poll
-
-`/pr-address` polling inside a single round already re-checks its own comments, but `/pr-polish` sits a level above and must also catch:
-
-- New top-level reviews (autogpt-reviewer sometimes posts structured feedback only after several CI green cycles).
-- Issue comments from human reviewers (not caught by inline thread polling).
-- Sentry bug predictions that land on new line numbers post-push.
-- Merge conflicts introduced by a race between your push and a merge to `dev`.
-
-## Invocation pattern
-
-Delegate to existing skills with the `Skill` tool; do not re-implement the review or address logic inline. This keeps the polish loop focused on orchestration and lets the child skills evolve independently.
-
-```python
-Skill(skill="pr-review",  args=pr_url)
-Skill(skill="pr-address", args=pr_url)
-```
-
-After each child invocation, re-query GitHub state directly — never trust a summary for the stop condition. The orchestrator's `ORCHESTRATOR:DONE` is verified against actual GraphQL / REST responses per the rules in `pr-address`'s "Verify actual count before outputting ORCHESTRATOR:DONE" section.
-
-### **Auto-continue: do NOT end your response between child skills**
-
-`/pr-polish` is a single orchestration task — one invocation drives the PR all the way to merge-ready. When a child `Skill()` call returns control to you:
-
-- Do NOT summarize and stop.
-- Do NOT wait for user confirmation to continue.
-- Immediately, in the same response, perform the next loop step: state diff → decide next action → next `Skill()` call or polling sleep.
-
-The child skill returning is a **loop iteration boundary**, not a conversation turn boundary. You are expected to keep going until one of the exit conditions in the opening section is met (2 consecutive clean polls, `_MAX_ROUNDS` hit, or an unrecoverable error).
-
-If the user needs to approve a risky action mid-loop (e.g., a force-push or a destructive git operation), pause there — but not at the routine "round N finished, round N+1 needed" boundary. Those are silent transitions.
-
-## GitHub rate limits
-
-This skill issues many GraphQL calls (one review-thread query per outer iteration plus per-poll queries inside polish polling). Expect the GraphQL budget to be tight on large PRs. When `gh api rate_limit --jq .resources.graphql.remaining` drops below ~200, back off:
-
-- Fall back to REST for reads (flat `/pulls/{N}/comments`, `/pulls/{N}/reviews`, `/issues/{N}/comments`) per the `pr-address` skill's GraphQL-fallback section.
-- Queue thread resolutions (GraphQL-only) until the budget resets; keep making progress on fixes + REST replies meanwhile.
-- `sleep 5` between any batch of ≥20 writes to avoid secondary rate limits.
-
-## Safety valves
-
-- `_MAX_ROUNDS = 10` — if review+address rounds exceed this, stop and escalate to the user with a summary of what's still unresolved. A PR that cannot converge in 10 rounds has systemic issues that need human judgment.
-- After each commit, run `poetry run format` / `pnpm format && pnpm lint && pnpm types` per the target codebase's conventions. A failing format check is CI `failure` that will never self-resolve.
-- Every `/pr-review` round checks for **duplicate** concerns first (via `pr-review`'s own "Fetch existing review comments" step) so the loop does not re-post the same finding that a prior round already resolved.
-
-## Reporting
-
-When the skill finishes (either via two clean polls or hitting `_MAX_ROUNDS`), produce a compact summary:
-
-```
-PR #{N} polish complete ({rounds_completed} rounds):
-- {X} inline threads opened and resolved
-- {Y} CI failures fixed
-- {Z} new commits pushed
-Final state: CI green, {total} threads all resolved, mergeable.
-```
-
-If exiting via `_MAX_ROUNDS`, flag explicitly:
-
-```
-PR #{N} polish stopped at {_MAX_ROUNDS} rounds — NOT merge-ready:
-- {N} threads still unresolved: {titles}
-- CI status: {summary}
-Needs human review.
-```
-
-## When to use this skill
-
-Use when the user says any of:
-- "polish this PR"
-- "keep reviewing and addressing until it's mergeable"
-- "loop /pr-review + /pr-address until done"
-- "make sure the PR is actually merge-ready"
-
-Do **not** use when:
-- User wants just one review pass (→ `/pr-review`).
-- User wants to address already-posted comments without further self-review (→ `/pr-address`).
-- A fixed round count is explicitly requested (e.g., "do 3 rounds") — honour the count instead of converging.

.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/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/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,225 +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/component that uses it; avoid direct `renderHook()` tests unless it is a shared reusable hook with standalone business logic
-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. Shared hooks with standalone business logic when UI-level coverage is impractical
-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
-- Prefer Orval-generated MSW handlers and response builders over hand-built API response objects
-- 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
-```

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,12 +1,8 @@
-### Why / What / How
-
-<!-- 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 📋
 

.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
@@ -81,13 +116,12 @@ jobs:
             --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
 
@@ -101,11 +135,11 @@ jobs:
         uses: codecov/codecov-action@v5
         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-ci.yml

@@ -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-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,71 @@ 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 \
+            --junitxml=junit.xml -o junit_family=legacy \
+            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 test results to Codecov
+        if: ${{ !cancelled() }}  # Run even if tests fail
+        uses: codecov/test-results-action@v1
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
 
-      - 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"
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          flags: agbenchmark,${{ runner.os }}
 
-  # 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 +124,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,60 +21,131 @@ 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
 
@@ -90,11 +159,85 @@ jobs:
         uses: codecov/codecov-action@v5
         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
+      - dev
+      - '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@v8
+        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/platform-backend-ci.yml

@@ -5,14 +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:
@@ -27,91 +25,10 @@ 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:
@@ -119,12 +36,10 @@ jobs:
     runs-on: ubuntu-latest
 
     services:
-      # Redis is provisioned as a real 3-shard cluster below via docker
-      # run (see the "Start Redis Cluster" step). GHA services can't
-      # override the image CMD or stand up multi-container clusters, so
-      # that setup is inlined — it mirrors the topology of the local dev
-      # compose stack (autogpt_platform/docker-compose.platform.yml) and
-      # prod helm chart.
+      redis:
+        image: redis:latest
+        ports:
+          - 6379:6379
       rabbitmq:
         image: rabbitmq:4.1.4
         ports:
@@ -168,68 +83,6 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: Start Redis Cluster (3 shards)
-        run: |
-          # 3-master Redis Cluster matching the local compose stack
-          # (autogpt_platform/docker-compose.platform.yml) and prod. Each
-          # shard runs in its own container on a dedicated bridge network,
-          # announces its compose-style hostname for intra-network clients,
-          # and publishes 1700N on the GHA host so tests can reach every
-          # shard via localhost. The backend's ``_address_remap`` rewrites
-          # every CLUSTER SLOTS reply to localhost:<announced-port>, which
-          # picks the right published port per shard.
-          #
-          # Not reusing docker-compose.platform.yml directly because compose
-          # validates the full file even when only some services are ``up``,
-          # and that file references services (db/kong/...) defined in a
-          # sibling compose file — pulling both in would needlessly couple
-          # CI to the full local-dev stack.
-          docker network create redis-cluster-ci
-          for i in 0 1 2; do
-            port=$((17000 + i))
-            bus=$((27000 + i))
-            docker run -d --name redis-$i --network redis-cluster-ci \
-              --network-alias redis-$i \
-              -p $port:$port \
-              redis:7 \
-              redis-server --port $port \
-                --cluster-enabled yes \
-                --cluster-config-file nodes.conf \
-                --cluster-node-timeout 5000 \
-                --cluster-require-full-coverage no \
-                --cluster-announce-hostname redis-$i \
-                --cluster-announce-port $port \
-                --cluster-announce-bus-port $bus \
-                --cluster-preferred-endpoint-type hostname
-          done
-          # Wait for each shard to accept commands.
-          for i in 0 1 2; do
-            port=$((17000 + i))
-            for _ in $(seq 1 30); do
-              docker exec redis-$i redis-cli -p $port ping 2>/dev/null | grep -q PONG && break
-              sleep 1
-            done
-          done
-          # Form the cluster from an init container on the same network so
-          # --cluster-preferred-endpoint-type hostname resolves redis-0/1/2.
-          docker run --rm --network redis-cluster-ci redis:7 \
-            redis-cli --cluster create \
-              redis-0:17000 redis-1:17001 redis-2:17002 \
-              --cluster-replicas 0 --cluster-yes
-          # Confirm convergence.
-          for _ in $(seq 1 30); do
-            state=$(docker exec redis-0 redis-cli -p 17000 cluster info | awk -F: '/^cluster_state:/ {print $2}' | tr -d '[:cntrl:]')
-            if [ "$state" = "ok" ]; then
-              echo "Redis Cluster ready (3 shards, state=ok)"
-              docker exec redis-0 redis-cli -p 17000 cluster nodes
-              exit 0
-            fi
-            sleep 1
-          done
-          echo "Redis Cluster failed to reach ok state" >&2
-          docker exec redis-0 redis-cli -p 17000 cluster info >&2 || true
-          exit 1
-
       - name: Setup Supabase
         uses: supabase/setup-cli@v1
         with:
@@ -243,9 +96,9 @@ jobs:
         uses: actions/cache@v5
         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)
@@ -303,22 +156,22 @@ jobs:
           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' || {
@@ -333,15 +186,18 @@ jobs:
           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
           else
-            poetry run pytest -s -vv \
-              --cov=backend --cov-branch --cov-report term-missing --cov-report xml
+            poetry run pytest -s -vv
           fi
+        if: success() || (failure() && steps.lint.outcome == 'failure')
         env:
           LOG_LEVEL: ${{ runner.debug && 'DEBUG' || 'INFO' }}
           DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
@@ -350,21 +206,8 @@ jobs:
           SUPABASE_SERVICE_ROLE_KEY: ${{ steps.supabase.outputs.SERVICE_ROLE_KEY }}
           JWT_VERIFY_KEY: ${{ steps.supabase.outputs.JWT_SECRET }}
           REDIS_HOST: "localhost"
-          REDIS_PORT: "17000"
+          REDIS_PORT: "6379"
           ENCRYPTION_KEY: "dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw=" # DO NOT USE IN PRODUCTION!!
-          # Opt-in: lets backend/data/e2e_redis_restart_test.py spin up its
-          # own isolated 3-shard cluster (ports 27110–27112) and exercise
-          # ``docker restart <shard>`` mid-stream. Off locally so a
-          # contributor's ``poetry run test`` doesn't pay the ~15s cost.
-          E2E_RESTART_ISOLATED: "1"
-
-      - 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
 
     env:
       CI: true
@@ -379,3 +222,9 @@ jobs:
       # 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-frontend-ci.yml

@@ -120,6 +120,175 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           exitOnceUploaded: true
 
+  e2e_test:
+    name: end-to-end tests
+    runs-on: big-boi
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Set up Platform - Copy default supabase .env
+        run: |
+          cp ../.env.default ../.env
+
+      - name: Set up Platform - Copy backend .env and set OpenAI API key
+        run: |
+          cp ../backend/.env.default ../backend/.env
+          echo "OPENAI_INTERNAL_API_KEY=${{ secrets.OPENAI_API_KEY }}" >> ../backend/.env
+        env:
+          # Used by E2E test data script to generate embeddings for approved store agents
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+
+      - name: Set up Platform - Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          driver-opts: network=host
+
+      - name: Set up Platform - Expose GHA cache to docker buildx CLI
+        uses: crazy-max/ghaction-github-runtime@v4
+
+      - name: Set up Platform - Build Docker images (with cache)
+        working-directory: autogpt_platform
+        run: |
+          pip install pyyaml
+
+          # Resolve extends and generate a flat compose file that bake can understand
+          docker compose -f docker-compose.yml config > docker-compose.resolved.yml
+
+          # Add cache configuration to the resolved compose file
+          python ../.github/workflows/scripts/docker-ci-fix-compose-build-cache.py \
+            --source docker-compose.resolved.yml \
+            --cache-from "type=gha" \
+            --cache-to "type=gha,mode=max" \
+            --backend-hash "${{ hashFiles('autogpt_platform/backend/Dockerfile', 'autogpt_platform/backend/poetry.lock', 'autogpt_platform/backend/backend') }}" \
+            --frontend-hash "${{ hashFiles('autogpt_platform/frontend/Dockerfile', 'autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/src') }}" \
+            --git-ref "${{ github.ref }}"
+
+          # Build with bake using the resolved compose file (now includes cache config)
+          docker buildx bake --allow=fs.read=.. -f docker-compose.resolved.yml --load
+        env:
+          NEXT_PUBLIC_PW_TEST: true
+
+      - name: Set up tests - Cache E2E test data
+        id: e2e-data-cache
+        uses: actions/cache@v5
+        with:
+          path: /tmp/e2e_test_data.sql
+          key: e2e-test-data-${{ hashFiles('autogpt_platform/backend/test/e2e_test_data.py', 'autogpt_platform/backend/migrations/**', '.github/workflows/platform-frontend-ci.yml') }}
+
+      - name: Set up Platform - Start Supabase DB + Auth
+        run: |
+          docker compose -f ../docker-compose.resolved.yml up -d db auth --no-build
+          echo "Waiting for database to be ready..."
+          timeout 60 sh -c 'until docker compose -f ../docker-compose.resolved.yml exec -T db pg_isready -U postgres 2>/dev/null; do sleep 2; done'
+          echo "Waiting for auth service to be ready..."
+          timeout 60 sh -c 'until docker compose -f ../docker-compose.resolved.yml exec -T db psql -U postgres -d postgres -c "SELECT 1 FROM auth.users LIMIT 1" 2>/dev/null; do sleep 2; done' || echo "Auth schema check timeout, continuing..."
+
+      - name: Set up Platform - Run migrations
+        run: |
+          echo "Running migrations..."
+          docker compose -f ../docker-compose.resolved.yml run --rm migrate
+          echo "✅ Migrations completed"
+        env:
+          NEXT_PUBLIC_PW_TEST: true
+
+      - name: Set up tests - Load cached E2E test data
+        if: steps.e2e-data-cache.outputs.cache-hit == 'true'
+        run: |
+          echo "✅ Found cached E2E test data, restoring..."
+          {
+            echo "SET session_replication_role = 'replica';"
+            cat /tmp/e2e_test_data.sql
+            echo "SET session_replication_role = 'origin';"
+          } | docker compose -f ../docker-compose.resolved.yml exec -T db psql -U postgres -d postgres -b
+          # Refresh materialized views after restore
+          docker compose -f ../docker-compose.resolved.yml exec -T db \
+            psql -U postgres -d postgres -b -c "SET search_path TO platform; SELECT refresh_store_materialized_views();" || true
+
+          echo "✅ E2E test data restored from cache"
+
+      - name: Set up Platform - Start (all other services)
+        run: |
+          docker compose -f ../docker-compose.resolved.yml up -d --no-build
+          echo "Waiting for rest_server to be ready..."
+          timeout 60 sh -c 'until curl -f http://localhost:8006/health 2>/dev/null; do sleep 2; done' || echo "Rest server health check timeout, continuing..."
+        env:
+          NEXT_PUBLIC_PW_TEST: true
+
+      - name: Set up tests - Create E2E test data
+        if: steps.e2e-data-cache.outputs.cache-hit != 'true'
+        run: |
+          echo "Creating E2E test data..."
+          docker cp ../backend/test/e2e_test_data.py $(docker compose -f ../docker-compose.resolved.yml ps -q rest_server):/tmp/e2e_test_data.py
+          docker compose -f ../docker-compose.resolved.yml exec -T rest_server sh -c "cd /app/autogpt_platform && python /tmp/e2e_test_data.py" || {
+            echo "❌ E2E test data creation failed!"
+            docker compose -f ../docker-compose.resolved.yml logs --tail=50 rest_server
+            exit 1
+          }
+
+          # Dump auth.users + platform schema for cache (two separate dumps)
+          echo "Dumping database for cache..."
+          {
+            docker compose -f ../docker-compose.resolved.yml exec -T db \
+              pg_dump -U postgres --data-only --column-inserts \
+              --table='auth.users' postgres
+            docker compose -f ../docker-compose.resolved.yml exec -T db \
+              pg_dump -U postgres --data-only --column-inserts \
+              --schema=platform \
+              --exclude-table='platform._prisma_migrations' \
+              --exclude-table='platform.apscheduler_jobs' \
+              --exclude-table='platform.apscheduler_jobs_batched_notifications' \
+              postgres
+          } > /tmp/e2e_test_data.sql
+
+          echo "✅ Database dump created for caching ($(wc -l < /tmp/e2e_test_data.sql) lines)"
+
+      - name: Set up tests - Enable corepack
+        run: corepack enable
+
+      - name: Set up tests - 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: Set up tests - Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Set up tests - Install browser 'chromium'
+        run: pnpm playwright install --with-deps chromium
+
+      - name: Run Playwright tests
+        run: pnpm test:no-build
+        continue-on-error: false
+
+      - name: Upload Playwright report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-report
+          path: playwright-report
+          if-no-files-found: ignore
+          retention-days: 3
+
+      - name: Upload Playwright test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-test-results
+          path: test-results
+          if-no-files-found: ignore
+          retention-days: 3
+
+      - name: Print Final Docker Compose logs
+        if: always()
+        run: docker compose -f ../docker-compose.resolved.yml logs
+
   integration_test:
     runs-on: ubuntu-latest
     needs: setup
@@ -148,11 +317,3 @@ jobs:
 
       - name: Run Integration Tests
         run: pnpm test:unit
-
-      - name: Upload coverage reports to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: platform-frontend
-          files: ./autogpt_platform/frontend/coverage/cobertura-coverage.xml

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

@@ -1,18 +1,14 @@
-name: AutoGPT Platform - Full-stack CI
+name: AutoGPT Platform - Frontend CI
 
 on:
   push:
     branches: [master, dev]
     paths:
       - ".github/workflows/platform-fullstack-ci.yml"
-      - ".github/workflows/scripts/docker-ci-fix-compose-build-cache.py"
-      - ".github/workflows/scripts/get_package_version_from_lockfile.py"
       - "autogpt_platform/**"
   pull_request:
     paths:
       - ".github/workflows/platform-fullstack-ci.yml"
-      - ".github/workflows/scripts/docker-ci-fix-compose-build-cache.py"
-      - ".github/workflows/scripts/get_package_version_from_lockfile.py"
       - "autogpt_platform/**"
   merge_group:
 
@@ -28,28 +24,42 @@ defaults:
 jobs:
   setup:
     runs-on: ubuntu-latest
+    outputs:
+      cache-key: ${{ steps.cache-key.outputs.key }}
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@v6
 
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set up Node
+      - name: Set up Node.js
         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
+      - name: Enable corepack
+        run: corepack enable
+
+      - name: Generate cache key
+        id: cache-key
+        run: echo "key=${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/package.json') }}" >> $GITHUB_OUTPUT
+
+      - name: Cache dependencies
+        uses: actions/cache@v5
+        with:
+          path: ~/.pnpm-store
+          key: ${{ steps.cache-key.outputs.key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
+            ${{ runner.os }}-pnpm-
+
+      - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
-  check-api-types:
-    name: check API types
-    runs-on: ubuntu-latest
+  types:
+    runs-on: big-boi
     needs: setup
+    strategy:
+      fail-fast: false
 
     steps:
       - name: Checkout repository
@@ -57,288 +67,70 @@ jobs:
         with:
           submodules: recursive
 
-      # ------------------------ Backend setup ------------------------
-
-      - name: Set up Backend - Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-
-      - name: Set up Backend - Install Poetry
-        working-directory: autogpt_platform/backend
-        run: |
-          POETRY_VERSION=$(python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Installing Poetry version ${POETRY_VERSION}"
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$POETRY_VERSION python3 -
-
-      - name: Set up Backend - Set up dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Set up Backend - Install dependencies
-        working-directory: autogpt_platform/backend
-        run: poetry install
-
-      - name: Set up Backend - Generate Prisma client
-        working-directory: autogpt_platform/backend
-        run: poetry run prisma generate && poetry run gen-prisma-stub
-
-      - name: Set up Frontend - Export OpenAPI schema from Backend
-        working-directory: autogpt_platform/backend
-        run: poetry run export-api-schema --output ../frontend/src/app/api/openapi.json
-
-      # ------------------------ Frontend setup ------------------------
-
-      - name: Set up Frontend - Enable corepack
-        run: corepack enable
-
-      - name: Set up Frontend - Set up Node
+      - name: Set up Node.js
         uses: actions/setup-node@v6
         with:
           node-version: "22.18.0"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
 
-      - name: Set up Frontend - Install dependencies
+      - name: Enable corepack
+        run: corepack enable
+
+      - name: Copy default supabase .env
+        run: |
+          cp ../.env.default ../.env
+
+      - name: Copy backend .env
+        run: |
+          cp ../backend/.env.default ../backend/.env
+
+      - name: Run docker compose
+        run: |
+          docker compose -f ../docker-compose.yml --profile local up -d deps_backend
+
+      - name: Restore dependencies cache
+        uses: actions/cache@v5
+        with:
+          path: ~/.pnpm-store
+          key: ${{ needs.setup.outputs.cache-key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+
+      - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
-      - name: Set up Frontend - Format OpenAPI schema
-        id: format-schema
-        run: pnpm prettier --write ./src/app/api/openapi.json
+      - name: Setup .env
+        run: cp .env.default .env
+
+      - name: Wait for services to be ready
+        run: |
+          echo "Waiting for rest_server to be ready..."
+          timeout 60 sh -c 'until curl -f http://localhost:8006/health 2>/dev/null; do sleep 2; done' || echo "Rest server health check timeout, continuing..."
+          echo "Waiting for database to be ready..."
+          timeout 60 sh -c 'until docker compose -f ../docker-compose.yml exec -T db pg_isready -U postgres 2>/dev/null; do sleep 2; done' || echo "Database ready check timeout, continuing..."
+
+      - name: Generate API queries
+        run: pnpm generate:api:force
 
       - name: Check for API schema changes
         run: |
           if ! git diff --exit-code src/app/api/openapi.json; then
             echo "❌ API schema changes detected in src/app/api/openapi.json"
             echo ""
-            echo "The openapi.json file has been modified after exporting the API schema."
+            echo "The openapi.json file has been modified after running 'pnpm generate:api-all'."
             echo "This usually means changes have been made in the BE endpoints without updating the Frontend."
             echo "The API schema is now out of sync with the Front-end queries."
             echo ""
             echo "To fix this:"
-            echo "\nIn the backend directory:"
-            echo "1. Run 'poetry run export-api-schema --output ../frontend/src/app/api/openapi.json'"
-            echo "\nIn the frontend directory:"
-            echo "2. Run 'pnpm prettier --write src/app/api/openapi.json'"
-            echo "3. Run 'pnpm generate:api'"
-            echo "4. Run 'pnpm types'"
-            echo "5. Fix any TypeScript errors that may have been introduced"
-            echo "6. Commit and push your changes"
+            echo "1. Pull the backend 'docker compose pull && docker compose up -d --build --force-recreate'"
+            echo "2. Run 'pnpm generate:api' locally"
+            echo "3. Run 'pnpm types' locally"
+            echo "4. Fix any TypeScript errors that may have been introduced"
+            echo "5. Commit and push your changes"
             echo ""
             exit 1
           else
             echo "✅ No API schema changes detected"
           fi
 
-      - name: Set up Frontend - Generate API client
-        id: generate-api-client
-        run: pnpm orval --config ./orval.config.ts
-        # Continue with type generation & check even if there are schema changes
-        if: success() || (steps.format-schema.outcome == 'success')
-
-      - name: Check for TypeScript errors
+      - name: Run Typescript checks
         run: pnpm types
-        if: success() || (steps.generate-api-client.outcome == 'success')
-
-  e2e_test:
-    name: end-to-end tests
-    runs-on: big-boi
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
-
-      - name: Set up Platform - Copy default supabase .env
-        run: |
-          cp ../.env.default ../.env
-
-      - name: Set up Platform - Copy backend .env and set OpenAI API key
-        run: |
-          cp ../backend/.env.default ../backend/.env
-          echo "OPENAI_INTERNAL_API_KEY=${{ secrets.OPENAI_API_KEY }}" >> ../backend/.env
-          echo "SCHEDULER_STARTUP_EMBEDDING_BACKFILL=false" >> ../backend/.env
-        env:
-          # Used by E2E test data script to generate embeddings for approved store agents
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-
-      - name: Set up Platform - Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: docker-container
-          driver-opts: network=host
-
-      - name: Set up Platform - Expose GHA cache to docker buildx CLI
-        uses: crazy-max/ghaction-github-runtime@v4
-
-      - name: Set up Platform - Build Docker images (with cache)
-        working-directory: autogpt_platform
-        run: |
-          pip install pyyaml
-
-          # Resolve extends and generate a flat compose file that bake can understand
-          export NEXT_PUBLIC_SOURCEMAPS NEXT_PUBLIC_PW_TEST
-          docker compose -f docker-compose.yml config > docker-compose.resolved.yml
-
-          # Ensure NEXT_PUBLIC_SOURCEMAPS is in resolved compose
-          # (docker compose config on some versions drops this arg)
-          if ! grep -q "NEXT_PUBLIC_SOURCEMAPS" docker-compose.resolved.yml; then
-            echo "Injecting NEXT_PUBLIC_SOURCEMAPS into resolved compose (docker compose config dropped it)"
-            sed -i '/NEXT_PUBLIC_PW_TEST/a\        NEXT_PUBLIC_SOURCEMAPS: "true"' docker-compose.resolved.yml
-          fi
-
-          # Add cache configuration to the resolved compose file
-          python ../.github/workflows/scripts/docker-ci-fix-compose-build-cache.py \
-            --source docker-compose.resolved.yml \
-            --cache-from "type=gha" \
-            --cache-to "type=gha,mode=max" \
-            --backend-hash "${{ hashFiles('autogpt_platform/backend/Dockerfile', 'autogpt_platform/backend/poetry.lock', 'autogpt_platform/backend/backend/**') }}" \
-            --frontend-hash "${{ hashFiles('autogpt_platform/frontend/Dockerfile', 'autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/src/**') }}-sourcemaps" \
-            --git-ref "${{ github.ref }}"
-
-          # Build with bake using the resolved compose file (now includes cache config)
-          docker buildx bake --allow=fs.read=.. -f docker-compose.resolved.yml --load
-        env:
-          NEXT_PUBLIC_PW_TEST: true
-          NEXT_PUBLIC_SOURCEMAPS: true
-
-      - name: Set up tests - Cache E2E test data
-        id: e2e-data-cache
-        uses: actions/cache@v5
-        with:
-          path: /tmp/e2e_test_data.sql
-          key: e2e-test-data-${{ hashFiles('autogpt_platform/backend/test/e2e_test_data.py', 'autogpt_platform/backend/migrations/**', '.github/workflows/platform-fullstack-ci.yml') }}
-
-      - name: Set up Platform - Start Supabase DB + Auth
-        run: |
-          docker compose -f ../docker-compose.resolved.yml up -d db auth --no-build
-          echo "Waiting for database to be ready..."
-          timeout 60 sh -c 'until docker compose -f ../docker-compose.resolved.yml exec -T db pg_isready -U postgres 2>/dev/null; do sleep 2; done'
-          echo "Waiting for auth service to be ready..."
-          timeout 60 sh -c 'until docker compose -f ../docker-compose.resolved.yml exec -T db psql -U postgres -d postgres -c "SELECT 1 FROM auth.users LIMIT 1" 2>/dev/null; do sleep 2; done' || echo "Auth schema check timeout, continuing..."
-
-      - name: Set up Platform - Run migrations
-        run: |
-          echo "Running migrations..."
-          docker compose -f ../docker-compose.resolved.yml run --rm migrate
-          echo "✅ Migrations completed"
-        env:
-          NEXT_PUBLIC_PW_TEST: true
-
-      - name: Set up tests - Load cached E2E test data
-        if: steps.e2e-data-cache.outputs.cache-hit == 'true'
-        run: |
-          echo "✅ Found cached E2E test data, restoring..."
-          {
-            echo "SET session_replication_role = 'replica';"
-            cat /tmp/e2e_test_data.sql
-            echo "SET session_replication_role = 'origin';"
-          } | docker compose -f ../docker-compose.resolved.yml exec -T db psql -U postgres -d postgres -b
-          # Refresh materialized views after restore
-          docker compose -f ../docker-compose.resolved.yml exec -T db \
-            psql -U postgres -d postgres -b -c "SET search_path TO platform; SELECT refresh_store_materialized_views();" || true
-
-          echo "✅ E2E test data restored from cache"
-
-      - name: Set up Platform - Start (all other services)
-        run: |
-          docker compose -f ../docker-compose.resolved.yml up -d --no-build
-          echo "Waiting for rest_server to be ready..."
-          timeout 60 sh -c 'until curl -f http://localhost:8006/health 2>/dev/null; do sleep 2; done' || echo "Rest server health check timeout, continuing..."
-        env:
-          NEXT_PUBLIC_PW_TEST: true
-
-      - name: Set up tests - Create E2E test data
-        if: steps.e2e-data-cache.outputs.cache-hit != 'true'
-        run: |
-          echo "Creating E2E test data..."
-          docker cp ../backend/test/e2e_test_data.py $(docker compose -f ../docker-compose.resolved.yml ps -q rest_server):/tmp/e2e_test_data.py
-          docker compose -f ../docker-compose.resolved.yml exec -T rest_server sh -c "cd /app/autogpt_platform && python /tmp/e2e_test_data.py" || {
-            echo "❌ E2E test data creation failed!"
-            docker compose -f ../docker-compose.resolved.yml logs --tail=50 rest_server
-            exit 1
-          }
-
-          # Dump auth.users + platform schema for cache (two separate dumps)
-          echo "Dumping database for cache..."
-          {
-            docker compose -f ../docker-compose.resolved.yml exec -T db \
-              pg_dump -U postgres --data-only --column-inserts \
-              --table='auth.users' postgres
-            docker compose -f ../docker-compose.resolved.yml exec -T db \
-              pg_dump -U postgres --data-only --column-inserts \
-              --schema=platform \
-              --exclude-table='platform._prisma_migrations' \
-              --exclude-table='platform.apscheduler_jobs' \
-              --exclude-table='platform.apscheduler_jobs_batched_notifications' \
-              postgres
-          } > /tmp/e2e_test_data.sql
-
-          echo "✅ Database dump created for caching ($(wc -l < /tmp/e2e_test_data.sql) lines)"
-
-      - name: Set up tests - Enable corepack
-        run: corepack enable
-
-      - name: Set up tests - 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: Set up tests - Cache Playwright browsers
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-${{ runner.os }}-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
-          restore-keys: |
-            playwright-${{ runner.os }}-
-
-      - name: Copy source maps from Docker for E2E coverage
-        run: |
-          FRONTEND_CONTAINER=$(docker compose -f ../docker-compose.resolved.yml ps -q frontend)
-          docker cp "$FRONTEND_CONTAINER":/app/.next/static .next-static-coverage
-
-      - name: Set up tests - Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Set up tests - Install browser 'chromium'
-        run: pnpm playwright install --with-deps chromium
-
-      - name: Run Playwright E2E suite
-        run: pnpm test:e2e:no-build
-        continue-on-error: false
-
-      - name: Upload E2E coverage to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: platform-frontend-e2e
-          files: ./autogpt_platform/frontend/coverage/e2e/cobertura-coverage.xml
-          disable_search: true
-
-      - name: Upload Playwright report
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: playwright-report
-          path: autogpt_platform/frontend/playwright-report
-          if-no-files-found: ignore
-          retention-days: 3
-
-      - name: Upload Playwright test results
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: playwright-test-results
-          path: autogpt_platform/frontend/test-results
-          if-no-files-found: ignore
-          retention-days: 3
-
-      - name: Print Final Docker Compose logs
-        if: always()
-        run: docker compose -f ../docker-compose.resolved.yml logs

.gitignore

@@ -3,7 +3,6 @@
 classic/original_autogpt/keys.py
 classic/original_autogpt/*.json
 auto_gpt_workspace/*
-.autogpt/
 *.mpeg
 .env
 # Root .env files
@@ -17,7 +16,6 @@ log-ingestion.txt
 /logs
 *.log
 *.mp3
-!autogpt_platform/frontend/public/notification.mp3
 mem.sqlite3
 venvAutoGPT
 
@@ -161,10 +159,6 @@ CURRENT_BULLETIN.md
 
 # AgBenchmark
 classic/benchmark/agbenchmark/reports/
-classic/reports/
-classic/direct_benchmark/reports/
-classic/.benchmark_workspaces/
-classic/direct_benchmark/.benchmark_workspaces/
 
 # Nodejs
 package-lock.json
@@ -183,20 +177,9 @@ autogpt_platform/backend/settings.py
 
 *.ign.*
 .test-contents
-**/.claude/settings.local.json
 .claude/settings.local.json
 CLAUDE.local.md
 /autogpt_platform/backend/logs
-/autogpt_platform/backend/poetry.toml
-
-# Test database
-test.db
 .next
 # Implementation plans (generated by AI agents)
 plans/
-.claude/worktrees/
-test-results/
-
-# Playwright MCP / local browser-testing artifacts
-.playwright-mcp/
-copilot-session-switch-qa/

.gitleaks.toml

@@ -1,36 +0,0 @@
-title = "AutoGPT Gitleaks Config"
-
-[extend]
-useDefault = true
-
-[allowlist]
-description = "Global allowlist"
-paths = [
-    # Template/example env files (no real secrets)
-    '''\.env\.(default|example|template)$''',
-    # Lock files
-    '''pnpm-lock\.yaml$''',
-    '''poetry\.lock$''',
-    # Secrets baseline
-    '''\.secrets\.baseline$''',
-    # Build artifacts and caches (should not be committed)
-    '''__pycache__/''',
-    '''classic/frontend/build/''',
-    # Docker dev setup (local dev JWTs/keys only)
-    '''autogpt_platform/db/docker/''',
-    # Load test configs (dev JWTs)
-    '''load-tests/configs/''',
-    # Test files with fake/fixture keys (_test.py, test_*.py, conftest.py)
-    '''(_test|test_.*|conftest)\.py$''',
-    # Documentation (only contains placeholder keys in curl/API examples)
-    '''docs/.*\.md$''',
-    # Firebase config (public API keys by design)
-    '''google-services\.json$''',
-    '''classic/frontend/(lib|web)/''',
-]
-# CI test-only encryption key (marked DO NOT USE IN PRODUCTION)
-regexes = [
-    '''dvziYgz0KSK8FENhju0ZYi8''',
-    # LLM model name enum values falsely flagged as API keys
-    '''Llama-\d.*Instruct''',
-]

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "classic/forge/tests/vcr_cassettes"]
+	path = classic/forge/tests/vcr_cassettes
+	url = https://github.com/Significant-Gravitas/Auto-GPT-test-cassettes

.pre-commit-config.yaml

@@ -23,15 +23,9 @@ repos:
       - id: detect-secrets
         name: Detect secrets
         description: Detects high entropy strings that are likely to be passwords.
-        args: ["--baseline", ".secrets.baseline"]
         files: ^autogpt_platform/
-        exclude: (pnpm-lock\.yaml|\.env\.(default|example|template))$
-
-  - repo: https://github.com/gitleaks/gitleaks
-    rev: v8.24.3
-    hooks:
-      - id: gitleaks
-        name: Detect secrets (gitleaks)
+        exclude: pnpm-lock\.yaml$
+        stages: [pre-push]
 
   - repo: local
     # For proper type checking, all dependencies need to be up-to-date.
@@ -90,16 +84,51 @@ repos:
         stages: [pre-commit, post-checkout]
 
       - id: poetry-install
-        name: Check & Install dependencies - Classic
-        alias: poetry-install-classic
+        name: Check & Install dependencies - Classic - AutoGPT
+        alias: poetry-install-classic-autogpt
         entry: >
           bash -c '
           if [ -n "$PRE_COMMIT_FROM_REF" ]; then
             git diff --name-only "$PRE_COMMIT_FROM_REF" "$PRE_COMMIT_TO_REF"
           else
             git diff --cached --name-only
-          fi | grep -qE "^classic/poetry\.lock$" || exit 0;
-          poetry -C classic install
+          fi | grep -qE "^classic/(original_autogpt|forge)/poetry\.lock$" || exit 0;
+          poetry -C classic/original_autogpt install
+          '
+        # include forge source (since it's a path dependency)
+        always_run: true
+        language: system
+        pass_filenames: false
+        stages: [pre-commit, post-checkout]
+
+      - id: poetry-install
+        name: Check & Install dependencies - Classic - Forge
+        alias: poetry-install-classic-forge
+        entry: >
+          bash -c '
+          if [ -n "$PRE_COMMIT_FROM_REF" ]; then
+            git diff --name-only "$PRE_COMMIT_FROM_REF" "$PRE_COMMIT_TO_REF"
+          else
+            git diff --cached --name-only
+          fi | grep -qE "^classic/forge/poetry\.lock$" || exit 0;
+          poetry -C classic/forge install
+          '
+        always_run: true
+        language: system
+        pass_filenames: false
+        stages: [pre-commit, post-checkout]
+
+      - id: poetry-install
+        name: Check & Install dependencies - Classic - Benchmark
+        alias: poetry-install-classic-benchmark
+        entry: >
+          bash -c '
+          if [ -n "$PRE_COMMIT_FROM_REF" ]; then
+            git diff --name-only "$PRE_COMMIT_FROM_REF" "$PRE_COMMIT_TO_REF"
+          else
+            git diff --cached --name-only
+          fi | grep -qE "^classic/benchmark/poetry\.lock$" || exit 0;
+          poetry -C classic/benchmark install
           '
         always_run: true
         language: system
@@ -194,10 +223,26 @@ repos:
         language: system
 
       - id: isort
-        name: Lint (isort) - Classic
-        alias: isort-classic
-        entry: bash -c 'cd classic && poetry run isort $(echo "$@" | sed "s|classic/||g")' --
-        files: ^classic/(original_autogpt|forge|direct_benchmark)/
+        name: Lint (isort) - Classic - AutoGPT
+        alias: isort-classic-autogpt
+        entry: poetry -P classic/original_autogpt run isort -p autogpt
+        files: ^classic/original_autogpt/
+        types: [file, python]
+        language: system
+
+      - id: isort
+        name: Lint (isort) - Classic - Forge
+        alias: isort-classic-forge
+        entry: poetry -P classic/forge run isort -p forge
+        files: ^classic/forge/
+        types: [file, python]
+        language: system
+
+      - id: isort
+        name: Lint (isort) - Classic - Benchmark
+        alias: isort-classic-benchmark
+        entry: poetry -P classic/benchmark run isort -p agbenchmark
+        files: ^classic/benchmark/
         types: [file, python]
         language: system
 
@@ -211,13 +256,26 @@ repos:
 
   - repo: https://github.com/PyCQA/flake8
     rev: 7.0.0
-    # Use consolidated flake8 config at classic/.flake8
+    # To have flake8 load the config of the individual subprojects, we have to call
+    # them separately.
     hooks:
       - id: flake8
-        name: Lint (Flake8) - Classic
-        alias: flake8-classic
-        files: ^classic/(original_autogpt|forge|direct_benchmark)/
-        args: [--config=classic/.flake8]
+        name: Lint (Flake8) - Classic - AutoGPT
+        alias: flake8-classic-autogpt
+        files: ^classic/original_autogpt/(autogpt|scripts|tests)/
+        args: [--config=classic/original_autogpt/.flake8]
+
+      - id: flake8
+        name: Lint (Flake8) - Classic - Forge
+        alias: flake8-classic-forge
+        files: ^classic/forge/(forge|tests)/
+        args: [--config=classic/forge/.flake8]
+
+      - id: flake8
+        name: Lint (Flake8) - Classic - Benchmark
+        alias: flake8-classic-benchmark
+        files: ^classic/benchmark/(agbenchmark|tests)/((?!reports).)*[/.]
+        args: [--config=classic/benchmark/.flake8]
 
   - repo: local
     hooks:
@@ -253,10 +311,29 @@ repos:
         pass_filenames: false
 
       - id: pyright
-        name: Typecheck - Classic
-        alias: pyright-classic
-        entry: poetry -C classic run pyright
-        files: ^classic/(original_autogpt|forge|direct_benchmark)/.*\.py$|^classic/poetry\.lock$
+        name: Typecheck - Classic - AutoGPT
+        alias: pyright-classic-autogpt
+        entry: poetry -C classic/original_autogpt run pyright
+        # include forge source (since it's a path dependency) but exclude *_test.py files:
+        files: ^(classic/original_autogpt/((autogpt|scripts|tests)/|poetry\.lock$)|classic/forge/(forge/.*(?<!_test)\.py|poetry\.lock)$)
+        types: [file]
+        language: system
+        pass_filenames: false
+
+      - id: pyright
+        name: Typecheck - Classic - Forge
+        alias: pyright-classic-forge
+        entry: poetry -C classic/forge run pyright
+        files: ^classic/forge/(forge/|poetry\.lock$)
+        types: [file]
+        language: system
+        pass_filenames: false
+
+      - id: pyright
+        name: Typecheck - Classic - Benchmark
+        alias: pyright-classic-benchmark
+        entry: poetry -C classic/benchmark run pyright
+        files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
         types: [file]
         language: system
         pass_filenames: false
@@ -283,9 +360,26 @@ repos:
   #       pass_filenames: false
 
   #     - id: pytest
-  #       name: Run tests - Classic (excl. slow tests)
-  #       alias: pytest-classic
-  #       entry: bash -c 'cd classic && poetry run pytest -m "not slow"'
-  #       files: ^classic/(original_autogpt|forge|direct_benchmark)/
+  #       name: Run tests - Classic - AutoGPT (excl. slow tests)
+  #       alias: pytest-classic-autogpt
+  #       entry: bash -c 'cd classic/original_autogpt && poetry run pytest --cov=autogpt -m "not slow" tests/unit tests/integration'
+  #       # include forge source (since it's a path dependency) but exclude *_test.py files:
+  #       files: ^(classic/original_autogpt/((autogpt|tests)/|poetry\.lock$)|classic/forge/(forge/.*(?<!_test)\.py|poetry\.lock)$)
+  #       language: system
+  #       pass_filenames: false
+
+  #     - id: pytest
+  #       name: Run tests - Classic - Forge (excl. slow tests)
+  #       alias: pytest-classic-forge
+  #       entry: bash -c 'cd classic/forge && poetry run pytest --cov=forge -m "not slow"'
+  #       files: ^classic/forge/(forge/|tests/|poetry\.lock$)
+  #       language: system
+  #       pass_filenames: false
+
+  #     - id: pytest
+  #       name: Run tests - Classic - Benchmark
+  #       alias: pytest-classic-benchmark
+  #       entry: bash -c 'cd classic/benchmark && poetry run pytest --cov=benchmark'
+  #       files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
   #       language: system
   #       pass_filenames: false

.secrets.baseline

@@ -1,471 +0,0 @@
-{
-  "version": "1.5.0",
-  "plugins_used": [
-    {
-      "name": "ArtifactoryDetector"
-    },
-    {
-      "name": "AWSKeyDetector"
-    },
-    {
-      "name": "AzureStorageKeyDetector"
-    },
-    {
-      "name": "Base64HighEntropyString",
-      "limit": 4.5
-    },
-    {
-      "name": "BasicAuthDetector"
-    },
-    {
-      "name": "CloudantDetector"
-    },
-    {
-      "name": "DiscordBotTokenDetector"
-    },
-    {
-      "name": "GitHubTokenDetector"
-    },
-    {
-      "name": "GitLabTokenDetector"
-    },
-    {
-      "name": "HexHighEntropyString",
-      "limit": 3.0
-    },
-    {
-      "name": "IbmCloudIamDetector"
-    },
-    {
-      "name": "IbmCosHmacDetector"
-    },
-    {
-      "name": "IPPublicDetector"
-    },
-    {
-      "name": "JwtTokenDetector"
-    },
-    {
-      "name": "KeywordDetector",
-      "keyword_exclude": ""
-    },
-    {
-      "name": "MailchimpDetector"
-    },
-    {
-      "name": "NpmDetector"
-    },
-    {
-      "name": "OpenAIDetector"
-    },
-    {
-      "name": "PrivateKeyDetector"
-    },
-    {
-      "name": "PypiTokenDetector"
-    },
-    {
-      "name": "SendGridDetector"
-    },
-    {
-      "name": "SlackDetector"
-    },
-    {
-      "name": "SoftlayerDetector"
-    },
-    {
-      "name": "SquareOAuthDetector"
-    },
-    {
-      "name": "StripeDetector"
-    },
-    {
-      "name": "TelegramBotTokenDetector"
-    },
-    {
-      "name": "TwilioKeyDetector"
-    }
-  ],
-  "filters_used": [
-    {
-      "path": "detect_secrets.filters.allowlist.is_line_allowlisted"
-    },
-    {
-      "path": "detect_secrets.filters.common.is_baseline_file",
-      "filename": ".secrets.baseline"
-    },
-    {
-      "path": "detect_secrets.filters.common.is_ignored_due_to_verification_policies",
-      "min_level": 2
-    },
-    {
-      "path": "detect_secrets.filters.heuristic.is_indirect_reference"
-    },
-    {
-      "path": "detect_secrets.filters.heuristic.is_likely_id_string"
-    },
-    {
-      "path": "detect_secrets.filters.heuristic.is_lock_file"
-    },
-    {
-      "path": "detect_secrets.filters.heuristic.is_not_alphanumeric_string"
-    },
-    {
-      "path": "detect_secrets.filters.heuristic.is_potential_uuid"
-    },
-    {
-      "path": "detect_secrets.filters.heuristic.is_prefixed_with_dollar_sign"
-    },
-    {
-      "path": "detect_secrets.filters.heuristic.is_sequential_string"
-    },
-    {
-      "path": "detect_secrets.filters.heuristic.is_swagger_file"
-    },
-    {
-      "path": "detect_secrets.filters.heuristic.is_templated_secret"
-    },
-    {
-      "path": "detect_secrets.filters.regex.should_exclude_file",
-      "pattern": [
-        "\\.env$",
-        "pnpm-lock\\.yaml$",
-        "\\.env\\.(default|example|template)$",
-        "__pycache__",
-        "_test\\.py$",
-        "test_.*\\.py$",
-        "conftest\\.py$",
-        "poetry\\.lock$",
-        "node_modules"
-      ]
-    }
-  ],
-  "results": {
-    "autogpt_platform/backend/backend/api/external/v1/integrations.py": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/backend/backend/api/external/v1/integrations.py",
-        "hashed_secret": "665b1e3851eefefa3fb878654292f16597d25155",
-        "is_verified": false,
-        "line_number": 289
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/airtable/_config.py": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/backend/backend/blocks/airtable/_config.py",
-        "hashed_secret": "57e168b03afb7c1ee3cdc4ee3db2fe1cc6e0df26",
-        "is_verified": false,
-        "line_number": 29
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/dataforseo/_config.py": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/backend/backend/blocks/dataforseo/_config.py",
-        "hashed_secret": "32ce93887331fa5d192f2876ea15ec000c7d58b8",
-        "is_verified": false,
-        "line_number": 12
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/github/checks.py": [
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/github/checks.py",
-        "hashed_secret": "8ac6f92737d8586790519c5d7bfb4d2eb172c238",
-        "is_verified": false,
-        "line_number": 108
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/github/ci.py": [
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/github/ci.py",
-        "hashed_secret": "90bd1b48e958257948487b90bee080ba5ed00caa",
-        "is_verified": false,
-        "line_number": 123
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/github/example_payloads/pull_request.synchronize.json": [
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/github/example_payloads/pull_request.synchronize.json",
-        "hashed_secret": "f96896dafced7387dcd22343b8ea29d3d2c65663",
-        "is_verified": false,
-        "line_number": 42
-      },
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/github/example_payloads/pull_request.synchronize.json",
-        "hashed_secret": "b80a94d5e70bedf4f5f89d2f5a5255cc9492d12e",
-        "is_verified": false,
-        "line_number": 193
-      },
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/github/example_payloads/pull_request.synchronize.json",
-        "hashed_secret": "75b17e517fe1b3136394f6bec80c4f892da75e42",
-        "is_verified": false,
-        "line_number": 344
-      },
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/github/example_payloads/pull_request.synchronize.json",
-        "hashed_secret": "b0bfb5e4e2394e7f8906e5ed1dffd88b2bc89dd5",
-        "is_verified": false,
-        "line_number": 534
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/github/statuses.py": [
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/github/statuses.py",
-        "hashed_secret": "8ac6f92737d8586790519c5d7bfb4d2eb172c238",
-        "is_verified": false,
-        "line_number": 85
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/google/docs.py": [
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/google/docs.py",
-        "hashed_secret": "c95da0c6696342c867ef0c8258d2f74d20fd94d4",
-        "is_verified": false,
-        "line_number": 203
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/google/sheets.py": [
-      {
-        "type": "Base64 High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/google/sheets.py",
-        "hashed_secret": "bd5a04fa3667e693edc13239b6d310c5c7a8564b",
-        "is_verified": false,
-        "line_number": 57
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/linear/_config.py": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/backend/backend/blocks/linear/_config.py",
-        "hashed_secret": "b37f020f42d6d613b6ce30103e4d408c4499b3bb",
-        "is_verified": false,
-        "line_number": 53
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/medium.py": [
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/medium.py",
-        "hashed_secret": "ff998abc1ce6d8f01a675fa197368e44c8916e9c",
-        "is_verified": false,
-        "line_number": 131
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/replicate/replicate_block.py": [
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/replicate/replicate_block.py",
-        "hashed_secret": "8bbdd6f26368f58ea4011d13d7f763cb662e66f0",
-        "is_verified": false,
-        "line_number": 67
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/slant3d/webhook.py": [
-      {
-        "type": "Hex High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/slant3d/webhook.py",
-        "hashed_secret": "36263c76947443b2f6e6b78153967ac4a7da99f9",
-        "is_verified": false,
-        "line_number": 100
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/talking_head.py": [
-      {
-        "type": "Base64 High Entropy String",
-        "filename": "autogpt_platform/backend/backend/blocks/talking_head.py",
-        "hashed_secret": "44ce2d66222529eea4a32932823466fc0601c799",
-        "is_verified": false,
-        "line_number": 113
-      }
-    ],
-    "autogpt_platform/backend/backend/blocks/wordpress/_config.py": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/backend/backend/blocks/wordpress/_config.py",
-        "hashed_secret": "e62679512436161b78e8a8d68c8829c2a1031ccb",
-        "is_verified": false,
-        "line_number": 17
-      }
-    ],
-    "autogpt_platform/backend/backend/util/cache.py": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/backend/backend/util/cache.py",
-        "hashed_secret": "37f0c918c3fa47ca4a70e42037f9f123fdfbc75b",
-        "is_verified": false,
-        "line_number": 449
-      }
-    ],
-    "autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/helpers.ts": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/helpers.ts",
-        "hashed_secret": "5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8",
-        "is_verified": false,
-        "line_number": 6
-      }
-    ],
-    "autogpt_platform/frontend/src/app/(platform)/dictionaries/en.json": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/app/(platform)/dictionaries/en.json",
-        "hashed_secret": "8be3c943b1609fffbfc51aad666d0a04adf83c9d",
-        "is_verified": false,
-        "line_number": 5
-      }
-    ],
-    "autogpt_platform/frontend/src/app/(platform)/dictionaries/es.json": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/app/(platform)/dictionaries/es.json",
-        "hashed_secret": "5a6d1c612954979ea99ee33dbb2d231b00f6ac0a",
-        "is_verified": false,
-        "line_number": 5
-      }
-    ],
-    "autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/AgentInputsReadOnly/helpers.ts": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/AgentInputsReadOnly/helpers.ts",
-        "hashed_secret": "cf678cab87dc1f7d1b95b964f15375e088461679",
-        "is_verified": false,
-        "line_number": 6
-      },
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/AgentInputsReadOnly/helpers.ts",
-        "hashed_secret": "f72cbb45464d487064610c5411c576ca4019d380",
-        "is_verified": false,
-        "line_number": 8
-      }
-    ],
-    "autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentModal/components/ModalRunSection/helpers.ts": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentModal/components/ModalRunSection/helpers.ts",
-        "hashed_secret": "cf678cab87dc1f7d1b95b964f15375e088461679",
-        "is_verified": false,
-        "line_number": 5
-      },
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentModal/components/ModalRunSection/helpers.ts",
-        "hashed_secret": "f72cbb45464d487064610c5411c576ca4019d380",
-        "is_verified": false,
-        "line_number": 7
-      }
-    ],
-    "autogpt_platform/frontend/src/app/(platform)/profile/(user)/integrations/page.tsx": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/app/(platform)/profile/(user)/integrations/page.tsx",
-        "hashed_secret": "cf678cab87dc1f7d1b95b964f15375e088461679",
-        "is_verified": false,
-        "line_number": 192
-      },
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/app/(platform)/profile/(user)/integrations/page.tsx",
-        "hashed_secret": "86275db852204937bbdbdebe5fabe8536e030ab6",
-        "is_verified": false,
-        "line_number": 193
-      }
-    ],
-    "autogpt_platform/frontend/src/components/contextual/CredentialsInput/helpers.ts": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/components/contextual/CredentialsInput/helpers.ts",
-        "hashed_secret": "47acd2028cf81b5da88ddeedb2aea4eca4b71fbd",
-        "is_verified": false,
-        "line_number": 102
-      },
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/components/contextual/CredentialsInput/helpers.ts",
-        "hashed_secret": "8be3c943b1609fffbfc51aad666d0a04adf83c9d",
-        "is_verified": false,
-        "line_number": 103
-      }
-    ],
-    "autogpt_platform/frontend/src/lib/autogpt-server-api/utils.ts": [
-      {
-        "type": "Base64 High Entropy String",
-        "filename": "autogpt_platform/frontend/src/lib/autogpt-server-api/utils.ts",
-        "hashed_secret": "9c486c92f1a7420e1045c7ad963fbb7ba3621025",
-        "is_verified": false,
-        "line_number": 73
-      },
-      {
-        "type": "Base64 High Entropy String",
-        "filename": "autogpt_platform/frontend/src/lib/autogpt-server-api/utils.ts",
-        "hashed_secret": "9277508c7a6effc8fb59163efbfada189e35425c",
-        "is_verified": false,
-        "line_number": 75
-      },
-      {
-        "type": "Base64 High Entropy String",
-        "filename": "autogpt_platform/frontend/src/lib/autogpt-server-api/utils.ts",
-        "hashed_secret": "8dc7e2cb1d0935897d541bf5facab389b8a50340",
-        "is_verified": false,
-        "line_number": 77
-      },
-      {
-        "type": "Base64 High Entropy String",
-        "filename": "autogpt_platform/frontend/src/lib/autogpt-server-api/utils.ts",
-        "hashed_secret": "79a26ad48775944299be6aaf9fb1d5302c1ed75b",
-        "is_verified": false,
-        "line_number": 79
-      },
-      {
-        "type": "Base64 High Entropy String",
-        "filename": "autogpt_platform/frontend/src/lib/autogpt-server-api/utils.ts",
-        "hashed_secret": "a3b62b44500a1612e48d4cab8294df81561b3b1a",
-        "is_verified": false,
-        "line_number": 81
-      },
-      {
-        "type": "Base64 High Entropy String",
-        "filename": "autogpt_platform/frontend/src/lib/autogpt-server-api/utils.ts",
-        "hashed_secret": "a58979bd0b21ef4f50417d001008e60dd7a85c64",
-        "is_verified": false,
-        "line_number": 83
-      },
-      {
-        "type": "Base64 High Entropy String",
-        "filename": "autogpt_platform/frontend/src/lib/autogpt-server-api/utils.ts",
-        "hashed_secret": "6cb6e075f8e8c7c850f9d128d6608e5dbe209a79",
-        "is_verified": false,
-        "line_number": 85
-      }
-    ],
-    "autogpt_platform/frontend/src/lib/constants.ts": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/lib/constants.ts",
-        "hashed_secret": "27b924db06a28cc755fb07c54f0fddc30659fe4d",
-        "is_verified": false,
-        "line_number": 13
-      }
-    ],
-    "autogpt_platform/frontend/src/tests/credentials/index.ts": [
-      {
-        "type": "Secret Keyword",
-        "filename": "autogpt_platform/frontend/src/tests/credentials/index.ts",
-        "hashed_secret": "c18006fc138809314751cd1991f1e0b820fabd37",
-        "is_verified": false,
-        "line_number": 4
-      }
-    ]
-  },
-  "generated_at": "2026-04-24T16:42:44Z"
-}

AGENTS.md

@@ -1,6 +1,6 @@
 # AutoGPT Platform Contribution Guide
 
-This guide provides context for coding agents when updating the **autogpt_platform** folder.
+This guide provides context for Codex when updating the **autogpt_platform** folder.
 
 ## Directory overview
 
@@ -30,7 +30,7 @@ See `/frontend/CONTRIBUTING.md` for complete patterns. Quick reference:
    - Regenerate with `pnpm generate:api`
    - Pattern: `use{Method}{Version}{OperationName}`
 4. **Styling**: Tailwind CSS only, use design tokens, Phosphor Icons only
-5. **Testing**: Integration tests (Vitest + RTL + MSW) are the default (~90%, page-level). Playwright for E2E critical flows. Storybook for design system components. See `autogpt_platform/frontend/TESTING.md`
+5. **Testing**: Add Storybook stories for new components, Playwright for E2E
 6. **Code conventions**: Function declarations (not arrow functions) for components/handlers
 
 - Component props should be `interface Props { ... }` (not exported) unless the interface needs to be used outside the component
@@ -47,9 +47,7 @@ See `/frontend/CONTRIBUTING.md` for complete patterns. Quick reference:
 ## Testing
 
 - Backend: `poetry run test` (runs pytest with a docker based postgres + prisma).
-- Frontend integration tests: `pnpm test:unit` (Vitest + RTL + MSW, primary testing approach).
-- Frontend E2E tests: `pnpm test` or `pnpm test-ui` for Playwright tests.
-- See `autogpt_platform/frontend/TESTING.md` for the full testing strategy.
+- Frontend: `pnpm test` or `pnpm test-ui` for Playwright tests. See `docs/content/platform/contributing/tests.md` for tips.
 
 Always run the relevant linters and tests before committing.
 Use conventional commit messages for all commits (e.g. `feat(backend): add API`).

CLAUDE.md

@@ -1 +0,0 @@
-@AGENTS.md

README.md

@@ -83,13 +83,13 @@ The AutoGPT frontend is where users interact with our powerful AI automation pla
 
    **Agent Builder:** For those who want to customize, our intuitive, low-code interface allows you to design and configure your own AI agents. 
    
-   **Workflow Management:** Build, modify, and optimize your automation workflows with ease. You build your agent by connecting blocks, where each block performs a single action.
+   **Workflow Management:** Build, modify, and optimize your automation workflows with ease. You build your agent by connecting blocks, where each block     performs a single action.
    
    **Deployment Controls:** Manage the lifecycle of your agents, from testing to production.
    
    **Ready-to-Use Agents:** Don't want to build? Simply select from our library of pre-configured agents and put them to work immediately.
    
-   **Agent Interaction:** Whether you've built your own or are using pre-configured agents, easily run and interact with them through our user-friendly interface.
+   **Agent Interaction:** Whether you've built your own or are using pre-configured agents, easily run and interact with them through our user-friendly      interface.
 
    **Monitoring and Analytics:** Keep track of your agents' performance and gain insights to continually improve your automation processes.
 

autogpt_platform/.gitignore

@@ -1,6 +1,3 @@
 *.ignore.*
 *.ign.*
 .application.logs
-
-# Claude Code local settings only — the rest of .claude/ is shared (skills etc.)
-.claude/settings.local.json

autogpt_platform/AGENTS.md

@@ -1,120 +0,0 @@
-# AutoGPT Platform
-
-This file provides guidance to coding agents when working with code in this repository.
-
-## Repository Overview
-
-AutoGPT Platform is a monorepo containing:
-
-- **Backend** (`backend`): Python FastAPI server with async support
-- **Frontend** (`frontend`): Next.js React application
-- **Shared Libraries** (`autogpt_libs`): Common Python utilities
-
-## Component Documentation
-
-- **Backend**: See @backend/AGENTS.md for backend-specific commands, architecture, and development tasks
-- **Frontend**: See @frontend/AGENTS.md for frontend-specific commands, architecture, and development patterns
-
-## Key Concepts
-
-1. **Agent Graphs**: Workflow definitions stored as JSON, executed by the backend
-2. **Blocks**: Reusable components in `backend/backend/blocks/` that perform specific tasks
-3. **Integrations**: OAuth and API connections stored per user
-4. **Store**: Marketplace for sharing agent templates
-5. **Virus Scanning**: ClamAV integration for file upload security
-
-### Environment Configuration
-
-#### Configuration Files
-
-- **Backend**: `backend/.env.default` (defaults) → `backend/.env` (user overrides)
-- **Frontend**: `frontend/.env.default` (defaults) → `frontend/.env` (user overrides)
-- **Platform**: `.env.default` (Supabase/shared defaults) → `.env` (user overrides)
-
-#### Docker Environment Loading Order
-
-1. `.env.default` files provide base configuration (tracked in git)
-2. `.env` files provide user-specific overrides (gitignored)
-3. Docker Compose `environment:` sections provide service-specific overrides
-4. Shell environment variables have highest precedence
-
-#### Key Points
-
-- All services use hardcoded defaults in docker-compose files (no `${VARIABLE}` substitutions)
-- The `env_file` directive loads variables INTO containers at runtime
-- Backend/Frontend services use YAML anchors for consistent configuration
-- Supabase services (`db/docker/docker-compose.yml`) follow the same pattern
-
-### Branching Strategy
-
-- **`dev`** is the main development branch. All PRs should target `dev`.
-- **`master`** is the production branch. Only used for production releases.
-
-### Creating Pull Requests
-
-- Create the PR against the `dev` branch of the repository.
-- **Split PRs by concern** — each PR should have a single clear purpose. For example, "usage tracking" and "credit charging" should be separate PRs even if related. Combining multiple concerns makes it harder for reviewers to understand what belongs to what.
-- Ensure the branch name is descriptive (e.g., `feature/add-new-block`)
-- Use conventional commit messages (see below)
-- **Structure the PR description with Why / What / How** — Why: the motivation (what problem it solves, what's broken/missing without it); What: high-level summary of changes; How: approach, key implementation details, or architecture decisions. Reviewers need all three to judge whether the approach fits the problem.
-- Fill out the .github/PULL_REQUEST_TEMPLATE.md template as the PR description
-- Always use `--body-file` to pass PR body — avoids shell interpretation of backticks and special characters:
-  ```bash
-  PR_BODY=$(mktemp)
-  cat > "$PR_BODY" << 'PREOF'
-  ## Summary
-  - use `backticks` freely here
-  PREOF
-  gh pr create --title "..." --body-file "$PR_BODY" --base dev
-  rm "$PR_BODY"
-  ```
-- Run the github pre-commit hooks to ensure code quality.
-
-### Test-Driven Development (TDD)
-
-When fixing a bug or adding a feature, follow a test-first approach:
-
-1. **Write a failing test first** — create a test that reproduces the bug or validates the new behavior, marked with `@pytest.mark.xfail` (backend) or `.fixme` (Playwright). Run it to confirm it fails for the right reason.
-2. **Implement the fix/feature** — write the minimal code to make the test pass.
-3. **Remove the xfail marker** — once the test passes, remove the `xfail`/`.fixme` annotation and run the full test suite to confirm nothing else broke.
-
-This ensures every change is covered by a test and that the test actually validates the intended behavior.
-
-### Reviewing/Revising Pull Requests
-
-Use `/pr-review` to review a PR or `/pr-address` to address comments.
-
-When fetching comments manually:
-- `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews --paginate` — top-level reviews
-- `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments --paginate` — inline review comments (always paginate to avoid missing comments beyond page 1)
-- `gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments` — PR conversation comments
-
-### Conventional Commits
-
-Use this format for commit messages and Pull Request titles:
-
-**Conventional Commit Types:**
-
-- `feat`: Introduces a new feature to the codebase
-- `fix`: Patches a bug in the codebase
-- `refactor`: Code change that neither fixes a bug nor adds a feature; also applies to removing features
-- `ci`: Changes to CI configuration
-- `docs`: Documentation-only changes
-- `dx`: Improvements to the developer experience
-
-**Recommended Base Scopes:**
-
-- `platform`: Changes affecting both frontend and backend
-- `frontend`
-- `backend`
-- `infra`
-- `blocks`: Modifications/additions of individual blocks
-
-**Subscope Examples:**
-
-- `backend/executor`
-- `backend/db`
-- `frontend/builder` (includes changes to the block UI component)
-- `infra/prod`
-
-Use these scopes and subscopes for clarity and consistency in commit messages.

autogpt_platform/CLAUDE.md

@@ -1 +1,95 @@
-@AGENTS.md
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Repository Overview
+
+AutoGPT Platform is a monorepo containing:
+
+- **Backend** (`backend`): Python FastAPI server with async support
+- **Frontend** (`frontend`): Next.js React application
+- **Shared Libraries** (`autogpt_libs`): Common Python utilities
+
+## Component Documentation
+
+- **Backend**: See @backend/CLAUDE.md for backend-specific commands, architecture, and development tasks
+- **Frontend**: See @frontend/CLAUDE.md for frontend-specific commands, architecture, and development patterns
+
+## Key Concepts
+
+1. **Agent Graphs**: Workflow definitions stored as JSON, executed by the backend
+2. **Blocks**: Reusable components in `backend/backend/blocks/` that perform specific tasks
+3. **Integrations**: OAuth and API connections stored per user
+4. **Store**: Marketplace for sharing agent templates
+5. **Virus Scanning**: ClamAV integration for file upload security
+
+### Environment Configuration
+
+#### Configuration Files
+
+- **Backend**: `backend/.env.default` (defaults) → `backend/.env` (user overrides)
+- **Frontend**: `frontend/.env.default` (defaults) → `frontend/.env` (user overrides)
+- **Platform**: `.env.default` (Supabase/shared defaults) → `.env` (user overrides)
+
+#### Docker Environment Loading Order
+
+1. `.env.default` files provide base configuration (tracked in git)
+2. `.env` files provide user-specific overrides (gitignored)
+3. Docker Compose `environment:` sections provide service-specific overrides
+4. Shell environment variables have highest precedence
+
+#### Key Points
+
+- All services use hardcoded defaults in docker-compose files (no `${VARIABLE}` substitutions)
+- The `env_file` directive loads variables INTO containers at runtime
+- Backend/Frontend services use YAML anchors for consistent configuration
+- Supabase services (`db/docker/docker-compose.yml`) follow the same pattern
+
+### Branching Strategy
+
+- **`dev`** is the main development branch. All PRs should target `dev`.
+- **`master`** is the production branch. Only used for production releases.
+
+### Creating Pull Requests
+
+- Create the PR against the `dev` branch of the repository.
+- Ensure the branch name is descriptive (e.g., `feature/add-new-block`)
+- Use conventional commit messages (see below)
+- Fill out the .github/PULL_REQUEST_TEMPLATE.md template as the PR description
+- Run the github pre-commit hooks to ensure code quality.
+
+### Reviewing/Revising Pull Requests
+
+- When the user runs /pr-comments or tries to fetch them, also run gh api /repos/Significant-Gravitas/AutoGPT/pulls/[issuenum]/reviews to get the reviews
+- Use gh api /repos/Significant-Gravitas/AutoGPT/pulls/[issuenum]/reviews/[review_id]/comments to get the review contents
+- Use gh api /repos/Significant-Gravitas/AutoGPT/issues/9924/comments to get the pr specific comments
+
+### Conventional Commits
+
+Use this format for commit messages and Pull Request titles:
+
+**Conventional Commit Types:**
+
+- `feat`: Introduces a new feature to the codebase
+- `fix`: Patches a bug in the codebase
+- `refactor`: Code change that neither fixes a bug nor adds a feature; also applies to removing features
+- `ci`: Changes to CI configuration
+- `docs`: Documentation-only changes
+- `dx`: Improvements to the developer experience
+
+**Recommended Base Scopes:**
+
+- `platform`: Changes affecting both frontend and backend
+- `frontend`
+- `backend`
+- `infra`
+- `blocks`: Modifications/additions of individual blocks
+
+**Subscope Examples:**
+
+- `backend/executor`
+- `backend/db`
+- `frontend/builder` (includes changes to the block UI component)
+- `infra/prod`
+
+Use these scopes and subscopes for clarity and consistency in commit messages.

autogpt_platform/analytics/queries/auth_activities.sql

@@ -1,40 +0,0 @@
--- =============================================================
--- View: analytics.auth_activities
--- Looker source alias: ds49  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Tracks authentication events (login, logout, SSO, password
---   reset, etc.) from Supabase's internal audit log.
---   Useful for monitoring sign-in patterns and detecting anomalies.
---
--- SOURCE TABLES
---   auth.audit_log_entries  — Supabase internal auth event log
---
--- OUTPUT COLUMNS
---   created_at      TIMESTAMPTZ  When the auth event occurred
---   actor_id        TEXT         User ID who triggered the event
---   actor_via_sso   TEXT         Whether the action was via SSO ('true'/'false')
---   action          TEXT         Event type (e.g. 'login', 'logout', 'token_refreshed')
---
--- WINDOW
---   Rolling 90 days from current date
---
--- EXAMPLE QUERIES
---   -- Daily login counts
---   SELECT DATE_TRUNC('day', created_at) AS day, COUNT(*) AS logins
---   FROM analytics.auth_activities
---   WHERE action = 'login'
---   GROUP BY 1 ORDER BY 1;
---
---   -- SSO vs password login breakdown
---   SELECT actor_via_sso, COUNT(*) FROM analytics.auth_activities
---   WHERE action = 'login' GROUP BY 1;
--- =============================================================
-
-SELECT
-    created_at,
-    payload->>'actor_id'      AS actor_id,
-    payload->>'actor_via_sso' AS actor_via_sso,
-    payload->>'action'        AS action
-FROM auth.audit_log_entries
-WHERE created_at >= NOW() - INTERVAL '90 days'

autogpt_platform/analytics/queries/graph_execution.sql

@@ -1,105 +0,0 @@
--- =============================================================
--- View: analytics.graph_execution
--- Looker source alias: ds16  |  Charts: 21
--- =============================================================
--- DESCRIPTION
---   One row per agent graph execution (last 90 days).
---   Unpacks the JSONB stats column into individual numeric columns
---   and normalises the executionStatus — runs that failed due to
---   insufficient credits are reclassified as 'NO_CREDITS' for
---   easier filtering.  Error messages are scrubbed of IDs and URLs
---   to allow safe grouping.
---
--- SOURCE TABLES
---   platform.AgentGraphExecution  — Execution records
---   platform.AgentGraph           — Agent graph metadata (for name)
---   platform.LibraryAgent         — To flag possibly-AI (safe-mode) agents
---
--- OUTPUT COLUMNS
---   id                TEXT         Execution UUID
---   agentGraphId      TEXT         Agent graph UUID
---   agentGraphVersion INT          Graph version number
---   executionStatus   TEXT         COMPLETED | FAILED | NO_CREDITS | RUNNING | QUEUED | TERMINATED
---   createdAt         TIMESTAMPTZ  When the execution was queued
---   updatedAt         TIMESTAMPTZ  Last status update time
---   userId            TEXT         Owner user UUID
---   agentGraphName    TEXT         Human-readable agent name
---   cputime           DECIMAL      Total CPU seconds consumed
---   walltime          DECIMAL      Total wall-clock seconds
---   node_count        DECIMAL      Number of nodes in the graph
---   nodes_cputime     DECIMAL      CPU time across all nodes
---   nodes_walltime    DECIMAL      Wall time across all nodes
---   execution_cost    DECIMAL      Credit cost of this execution
---   correctness_score FLOAT        AI correctness score (if available)
---   possibly_ai       BOOLEAN      True if agent has sensitive_action_safe_mode enabled
---   groupedErrorMessage TEXT       Scrubbed error string (IDs/URLs replaced with wildcards)
---
--- WINDOW
---   Rolling 90 days (createdAt > CURRENT_DATE - 90 days)
---
--- EXAMPLE QUERIES
---   -- Daily execution counts by status
---   SELECT DATE_TRUNC('day', "createdAt") AS day, "executionStatus", COUNT(*)
---   FROM analytics.graph_execution
---   GROUP BY 1, 2 ORDER BY 1;
---
---   -- Average cost per execution by agent
---   SELECT "agentGraphName", AVG("execution_cost") AS avg_cost, COUNT(*) AS runs
---   FROM analytics.graph_execution
---   WHERE "executionStatus" = 'COMPLETED'
---   GROUP BY 1 ORDER BY avg_cost DESC;
---
---   -- Top error messages
---   SELECT "groupedErrorMessage", COUNT(*) AS occurrences
---   FROM analytics.graph_execution
---   WHERE "executionStatus" = 'FAILED'
---   GROUP BY 1 ORDER BY 2 DESC LIMIT 20;
--- =============================================================
-
-SELECT
-    ge."id"                                                        AS id,
-    ge."agentGraphId"                                              AS agentGraphId,
-    ge."agentGraphVersion"                                         AS agentGraphVersion,
-    CASE
-        WHEN jsonb_exists(ge."stats"::jsonb, 'error')
-         AND (
-               (ge."stats"::jsonb->>'error') ILIKE '%insufficient balance%'
-            OR (ge."stats"::jsonb->>'error') ILIKE '%you have no credits left%'
-             )
-        THEN 'NO_CREDITS'
-        ELSE CAST(ge."executionStatus" AS TEXT)
-    END                                                            AS executionStatus,
-    ge."createdAt"                                                 AS createdAt,
-    ge."updatedAt"                                                 AS updatedAt,
-    ge."userId"                                                    AS userId,
-    g."name"                                                       AS agentGraphName,
-    (ge."stats"::jsonb->>'cputime')::decimal                       AS cputime,
-    (ge."stats"::jsonb->>'walltime')::decimal                      AS walltime,
-    (ge."stats"::jsonb->>'node_count')::decimal                    AS node_count,
-    (ge."stats"::jsonb->>'nodes_cputime')::decimal                 AS nodes_cputime,
-    (ge."stats"::jsonb->>'nodes_walltime')::decimal                AS nodes_walltime,
-    (ge."stats"::jsonb->>'cost')::decimal                          AS execution_cost,
-    (ge."stats"::jsonb->>'correctness_score')::float               AS correctness_score,
-    COALESCE(la.possibly_ai, FALSE)                                AS possibly_ai,
-    REGEXP_REPLACE(
-        REGEXP_REPLACE(
-            TRIM(BOTH '"' FROM ge."stats"::jsonb->>'error'),
-            '(https?://)([A-Za-z0-9.-]+)(:[0-9]+)?(/[^\s]*)?',
-            '\1\2/...', 'gi'
-        ),
-        '[a-zA-Z0-9_:-]*\d[a-zA-Z0-9_:-]*', '*', 'g'
-    )                                                              AS groupedErrorMessage
-FROM platform."AgentGraphExecution" ge
-LEFT JOIN platform."AgentGraph" g
-       ON ge."agentGraphId" = g."id"
-      AND ge."agentGraphVersion" = g."version"
-LEFT JOIN (
-    SELECT DISTINCT ON ("userId", "agentGraphId")
-           "userId", "agentGraphId",
-           ("settings"::jsonb->>'sensitive_action_safe_mode')::boolean AS possibly_ai
-    FROM platform."LibraryAgent"
-    WHERE "isDeleted"  = FALSE
-      AND "isArchived" = FALSE
-    ORDER BY "userId", "agentGraphId", "agentGraphVersion" DESC
-) la ON la."userId" = ge."userId" AND la."agentGraphId" = ge."agentGraphId"
-WHERE ge."createdAt" > CURRENT_DATE - INTERVAL '90 days'

autogpt_platform/analytics/queries/node_block_execution.sql

@@ -1,101 +0,0 @@
--- =============================================================
--- View: analytics.node_block_execution
--- Looker source alias: ds14  |  Charts: 11
--- =============================================================
--- DESCRIPTION
---   One row per node (block) execution (last 90 days).
---   Unpacks stats JSONB and joins to identify which block type
---   was run.  For failed nodes, joins the error output and
---   scrubs it for safe grouping.
---
--- SOURCE TABLES
---   platform.AgentNodeExecution              — Node execution records
---   platform.AgentNode                       — Node → block mapping
---   platform.AgentBlock                      — Block name/ID
---   platform.AgentNodeExecutionInputOutput   — Error output values
---
--- OUTPUT COLUMNS
---   id                    TEXT         Node execution UUID
---   agentGraphExecutionId TEXT         Parent graph execution UUID
---   agentNodeId           TEXT         Node UUID within the graph
---   executionStatus       TEXT         COMPLETED | FAILED | QUEUED | RUNNING | TERMINATED
---   addedTime             TIMESTAMPTZ  When the node was queued
---   queuedTime            TIMESTAMPTZ  When it entered the queue
---   startedTime           TIMESTAMPTZ  When execution started
---   endedTime             TIMESTAMPTZ  When execution finished
---   inputSize             BIGINT       Input payload size in bytes
---   outputSize            BIGINT       Output payload size in bytes
---   walltime              NUMERIC      Wall-clock seconds for this node
---   cputime               NUMERIC      CPU seconds for this node
---   llmRetryCount         INT          Number of LLM retries
---   llmCallCount          INT          Number of LLM API calls made
---   inputTokenCount       BIGINT       LLM input tokens consumed
---   outputTokenCount      BIGINT       LLM output tokens produced
---   blockName             TEXT         Human-readable block name (e.g. 'OpenAIBlock')
---   blockId               TEXT         Block UUID
---   groupedErrorMessage   TEXT         Scrubbed error (IDs/URLs wildcarded)
---   errorMessage          TEXT         Raw error output (only set when FAILED)
---
--- WINDOW
---   Rolling 90 days (addedTime > CURRENT_DATE - 90 days)
---
--- EXAMPLE QUERIES
---   -- Most-used blocks by execution count
---   SELECT "blockName", COUNT(*) AS executions,
---          COUNT(*) FILTER (WHERE "executionStatus"='FAILED') AS failures
---   FROM analytics.node_block_execution
---   GROUP BY 1 ORDER BY executions DESC LIMIT 20;
---
---   -- Average LLM token usage per block
---   SELECT "blockName",
---          AVG("inputTokenCount") AS avg_input_tokens,
---          AVG("outputTokenCount") AS avg_output_tokens
---   FROM analytics.node_block_execution
---   WHERE "llmCallCount" > 0
---   GROUP BY 1 ORDER BY avg_input_tokens DESC;
---
---   -- Top failure reasons
---   SELECT "blockName", "groupedErrorMessage", COUNT(*) AS count
---   FROM analytics.node_block_execution
---   WHERE "executionStatus" = 'FAILED'
---   GROUP BY 1, 2 ORDER BY count DESC LIMIT 20;
--- =============================================================
-
-SELECT
-    ne."id"                                                            AS id,
-    ne."agentGraphExecutionId"                                         AS agentGraphExecutionId,
-    ne."agentNodeId"                                                   AS agentNodeId,
-    CAST(ne."executionStatus" AS TEXT)                                 AS executionStatus,
-    ne."addedTime"                                                     AS addedTime,
-    ne."queuedTime"                                                    AS queuedTime,
-    ne."startedTime"                                                   AS startedTime,
-    ne."endedTime"                                                     AS endedTime,
-    (ne."stats"::jsonb->>'input_size')::bigint                         AS inputSize,
-    (ne."stats"::jsonb->>'output_size')::bigint                        AS outputSize,
-    (ne."stats"::jsonb->>'walltime')::numeric                          AS walltime,
-    (ne."stats"::jsonb->>'cputime')::numeric                           AS cputime,
-    (ne."stats"::jsonb->>'llm_retry_count')::int                       AS llmRetryCount,
-    (ne."stats"::jsonb->>'llm_call_count')::int                        AS llmCallCount,
-    (ne."stats"::jsonb->>'input_token_count')::bigint                  AS inputTokenCount,
-    (ne."stats"::jsonb->>'output_token_count')::bigint                 AS outputTokenCount,
-    b."name"                                                           AS blockName,
-    b."id"                                                             AS blockId,
-    REGEXP_REPLACE(
-        REGEXP_REPLACE(
-            TRIM(BOTH '"' FROM eio."data"::text),
-            '(https?://)([A-Za-z0-9.-]+)(:[0-9]+)?(/[^\s]*)?',
-            '\1\2/...', 'gi'
-        ),
-        '[a-zA-Z0-9_:-]*\d[a-zA-Z0-9_:-]*', '*', 'g'
-    )                                                                  AS groupedErrorMessage,
-    eio."data"                                                         AS errorMessage
-FROM platform."AgentNodeExecution" ne
-LEFT JOIN platform."AgentNode" nd
-       ON ne."agentNodeId" = nd."id"
-LEFT JOIN platform."AgentBlock" b
-       ON nd."agentBlockId" = b."id"
-LEFT JOIN platform."AgentNodeExecutionInputOutput" eio
-       ON eio."referencedByOutputExecId" = ne."id"
-      AND eio."name" = 'error'
-      AND ne."executionStatus" = 'FAILED'
-WHERE ne."addedTime" > CURRENT_DATE - INTERVAL '90 days'

autogpt_platform/analytics/queries/platform_cost_log.sql

@@ -1,100 +0,0 @@
--- =============================================================
--- View: analytics.platform_cost_log
--- Looker source alias: ds115  |  Charts: 0
--- =============================================================
--- DESCRIPTION
---   One row per platform cost log entry (last 90 days).
---   Tracks real API spend at the call level: provider, model,
---   token counts (including Anthropic cache tokens), cost in
---   microdollars, and the block/execution that incurred the cost.
---   Joins the User table to provide email for per-user breakdowns.
---
--- SOURCE TABLES
---   platform.PlatformCostLog  — Per-call cost records
---   platform.User             — User email
---
--- OUTPUT COLUMNS
---   id                      TEXT         Log entry UUID
---   createdAt               TIMESTAMPTZ  When the cost was recorded
---   userId                  TEXT         User who incurred the cost (nullable)
---   email                   TEXT         User email (nullable)
---   graphExecId             TEXT         Graph execution UUID (nullable)
---   nodeExecId              TEXT         Node execution UUID (nullable)
---   blockName               TEXT         Block that made the API call (nullable)
---   provider                TEXT         API provider, lowercase (e.g. 'openai', 'anthropic')
---   model                   TEXT         Model name (nullable)
---   trackingType            TEXT         Cost unit: 'tokens' | 'cost_usd' | 'characters' | etc.
---   costMicrodollars        BIGINT       Cost in microdollars (divide by 1,000,000 for USD)
---   costUsd                 FLOAT        Cost in USD (costMicrodollars / 1,000,000)
---   inputTokens             INT          Prompt/input tokens (nullable)
---   outputTokens            INT          Completion/output tokens (nullable)
---   cacheReadTokens         INT          Anthropic cache-read tokens billed at 10% (nullable)
---   cacheCreationTokens     INT          Anthropic cache-write tokens billed at 125% (nullable)
---   totalTokens             INT          inputTokens + outputTokens (nullable if either is null)
---   duration                FLOAT        API call duration in seconds (nullable)
---
--- WINDOW
---   Rolling 90 days (createdAt > CURRENT_DATE - 90 days)
---
--- EXAMPLE QUERIES
---   -- Total spend by provider (last 90 days)
---   SELECT provider, SUM("costUsd") AS total_usd, COUNT(*) AS calls
---   FROM analytics.platform_cost_log
---   GROUP BY 1 ORDER BY total_usd DESC;
---
---   -- Spend by model
---   SELECT provider, model, SUM("costUsd") AS total_usd,
---          SUM("inputTokens") AS input_tokens,
---          SUM("outputTokens") AS output_tokens
---   FROM analytics.platform_cost_log
---   WHERE model IS NOT NULL
---   GROUP BY 1, 2 ORDER BY total_usd DESC;
---
---   -- Top 20 users by spend
---   SELECT "userId", email, SUM("costUsd") AS total_usd, COUNT(*) AS calls
---   FROM analytics.platform_cost_log
---   WHERE "userId" IS NOT NULL
---   GROUP BY 1, 2 ORDER BY total_usd DESC LIMIT 20;
---
---   -- Daily spend trend
---   SELECT DATE_TRUNC('day', "createdAt") AS day,
---          SUM("costUsd") AS daily_usd,
---          COUNT(*) AS calls
---   FROM analytics.platform_cost_log
---   GROUP BY 1 ORDER BY 1;
---
---   -- Cache hit rate for Anthropic (cache reads vs total reads)
---   SELECT DATE_TRUNC('day', "createdAt") AS day,
---          SUM("cacheReadTokens")::float /
---            NULLIF(SUM("inputTokens" + COALESCE("cacheReadTokens", 0)), 0) AS cache_hit_rate
---   FROM analytics.platform_cost_log
---   WHERE provider = 'anthropic'
---   GROUP BY 1 ORDER BY 1;
--- =============================================================
-
-SELECT
-    p."id"                                                        AS id,
-    p."createdAt"                                                 AS createdAt,
-    p."userId"                                                    AS userId,
-    u."email"                                                     AS email,
-    p."graphExecId"                                               AS graphExecId,
-    p."nodeExecId"                                                AS nodeExecId,
-    p."blockName"                                                 AS blockName,
-    p."provider"                                                  AS provider,
-    p."model"                                                     AS model,
-    p."trackingType"                                              AS trackingType,
-    p."costMicrodollars"                                          AS costMicrodollars,
-    p."costMicrodollars"::float / 1000000.0                       AS costUsd,
-    p."inputTokens"                                               AS inputTokens,
-    p."outputTokens"                                              AS outputTokens,
-    p."cacheReadTokens"                                           AS cacheReadTokens,
-    p."cacheCreationTokens"                                       AS cacheCreationTokens,
-    CASE
-        WHEN p."inputTokens" IS NOT NULL AND p."outputTokens" IS NOT NULL
-        THEN p."inputTokens" + p."outputTokens"
-        ELSE NULL
-    END                                                           AS totalTokens,
-    p."duration"                                                  AS duration
-FROM platform."PlatformCostLog" p
-LEFT JOIN platform."User" u ON u."id" = p."userId"
-WHERE p."createdAt" > CURRENT_DATE - INTERVAL '90 days'

autogpt_platform/analytics/queries/retention_agent.sql

@@ -1,97 +0,0 @@
--- =============================================================
--- View: analytics.retention_agent
--- Looker source alias: ds35  |  Charts: 2
--- =============================================================
--- DESCRIPTION
---   Weekly cohort retention broken down per individual agent.
---   Cohort = week of a user's first use of THAT specific agent.
---   Tells you which agents keep users coming back vs. one-shot
---   use. Only includes cohorts from the last 180 days.
---
--- SOURCE TABLES
---   platform.AgentGraphExecution  — Execution records (user × agent × time)
---   platform.AgentGraph           — Agent names
---
--- OUTPUT COLUMNS
---   agent_id            TEXT   Agent graph UUID
---   agent_label         TEXT   'AgentName [first8chars]'
---   agent_label_n       TEXT   'AgentName [first8chars] (n=total_users)'
---   cohort_week_start   DATE   Week users first ran this agent
---   cohort_label        TEXT   ISO week label
---   cohort_label_n      TEXT   ISO week label with cohort size
---   user_lifetime_week  INT    Weeks since first use of this agent
---   cohort_users        BIGINT Users in this cohort for this agent
---   active_users        BIGINT Users who ran the agent again in week k
---   retention_rate      FLOAT  active_users / cohort_users
---   cohort_users_w0     BIGINT cohort_users only at week 0 (safe to SUM)
---   agent_total_users   BIGINT Total users across all cohorts for this agent
---
--- EXAMPLE QUERIES
---   -- Best-retained agents at week 2
---   SELECT agent_label, AVG(retention_rate) AS w2_retention
---   FROM analytics.retention_agent
---   WHERE user_lifetime_week = 2 AND cohort_users >= 10
---   GROUP BY 1 ORDER BY w2_retention DESC LIMIT 10;
---
---   -- Agents with most unique users
---   SELECT DISTINCT agent_label, agent_total_users
---   FROM analytics.retention_agent
---   ORDER BY agent_total_users DESC LIMIT 20;
--- =============================================================
-
-WITH params AS (SELECT 12::int AS max_weeks, (CURRENT_DATE - INTERVAL '180 days') AS cohort_start),
-events AS (
-  SELECT e."userId"::text AS user_id, e."agentGraphId" AS agent_id,
-         e."createdAt"::timestamptz AS created_at,
-         DATE_TRUNC('week', e."createdAt")::date AS week_start
-  FROM platform."AgentGraphExecution" e
-),
-first_use AS (
-  SELECT user_id, agent_id, MIN(created_at) AS first_use_at,
-         DATE_TRUNC('week', MIN(created_at))::date AS cohort_week_start
-  FROM events GROUP BY 1,2
-  HAVING MIN(created_at) >= (SELECT cohort_start FROM params)
-),
-activity_weeks AS (SELECT DISTINCT user_id, agent_id, week_start FROM events),
-user_week_age AS (
-  SELECT aw.user_id, aw.agent_id, fu.cohort_week_start,
-         ((aw.week_start - DATE_TRUNC('week',fu.first_use_at)::date)/7)::int AS user_lifetime_week
-  FROM activity_weeks aw JOIN first_use fu USING (user_id, agent_id)
-  WHERE aw.week_start >= DATE_TRUNC('week',fu.first_use_at)::date
-),
-active_counts AS (
-  SELECT agent_id, cohort_week_start, user_lifetime_week, COUNT(DISTINCT user_id) AS active_users
-  FROM user_week_age WHERE user_lifetime_week >= 0 GROUP BY 1,2,3
-),
-cohort_sizes AS (
-  SELECT agent_id, cohort_week_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_use GROUP BY 1,2
-),
-cohort_caps AS (
-  SELECT cs.agent_id, cs.cohort_week_start, cs.cohort_users,
-         LEAST((SELECT max_weeks FROM params),
-               GREATEST(0,((DATE_TRUNC('week',CURRENT_DATE)::date-cs.cohort_week_start)/7)::int)) AS cap_weeks
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.agent_id, cc.cohort_week_start, gs AS user_lifetime_week, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_weeks) gs
-),
-agent_names AS (SELECT DISTINCT ON (g."id") g."id" AS agent_id, g."name" AS agent_name FROM platform."AgentGraph" g ORDER BY g."id", g."version" DESC),
-agent_total_users AS (SELECT agent_id, SUM(cohort_users) AS agent_total_users FROM cohort_sizes GROUP BY 1)
-SELECT
-  g.agent_id,
-  COALESCE(an.agent_name,'(unnamed)')||' ['||LEFT(g.agent_id::text,8)||']'  AS agent_label,
-  COALESCE(an.agent_name,'(unnamed)')||' ['||LEFT(g.agent_id::text,8)||'] (n='||COALESCE(atu.agent_total_users,0)||')' AS agent_label_n,
-  g.cohort_week_start,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')                               AS cohort_label,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')||' (n='||g.cohort_users||')'  AS cohort_label_n,
-  g.user_lifetime_week, g.cohort_users,
-  COALESCE(ac.active_users,0)                                              AS active_users,
-  COALESCE(ac.active_users,0)::float / NULLIF(g.cohort_users,0)           AS retention_rate,
-  CASE WHEN g.user_lifetime_week=0 THEN g.cohort_users ELSE 0 END         AS cohort_users_w0,
-  COALESCE(atu.agent_total_users,0)                                        AS agent_total_users
-FROM grid g
-LEFT JOIN active_counts     ac  ON ac.agent_id=g.agent_id AND ac.cohort_week_start=g.cohort_week_start AND ac.user_lifetime_week=g.user_lifetime_week
-LEFT JOIN agent_names       an  ON an.agent_id=g.agent_id
-LEFT JOIN agent_total_users atu ON atu.agent_id=g.agent_id
-ORDER BY agent_label, g.cohort_week_start, g.user_lifetime_week;

autogpt_platform/analytics/queries/retention_execution_daily.sql

@@ -1,81 +0,0 @@
--- =============================================================
--- View: analytics.retention_execution_daily
--- Looker source alias: ds111  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Daily cohort retention based on agent executions.
---   Cohort anchor = day of user's FIRST ever execution.
---   Only includes cohorts from the last 90 days, up to day 30.
---   Great for early engagement analysis (did users run another
---   agent the next day?).
---
--- SOURCE TABLES
---   platform.AgentGraphExecution  — Execution records
---
--- OUTPUT COLUMNS
---   Same pattern as retention_login_daily.
---   cohort_day_start = day of first execution (not first login)
---
--- EXAMPLE QUERIES
---   -- Day-3 execution retention
---   SELECT cohort_label, retention_rate_bounded AS d3_retention
---   FROM analytics.retention_execution_daily
---   WHERE user_lifetime_day = 3 ORDER BY cohort_day_start;
--- =============================================================
-
-WITH params AS (SELECT 30::int AS max_days, (CURRENT_DATE - INTERVAL '90 days') AS cohort_start),
-events AS (
-  SELECT e."userId"::text AS user_id, e."createdAt"::timestamptz AS created_at,
-         DATE_TRUNC('day', e."createdAt")::date AS day_start
-  FROM platform."AgentGraphExecution" e WHERE e."userId" IS NOT NULL
-),
-first_exec AS (
-  SELECT user_id, MIN(created_at) AS first_exec_at,
-         DATE_TRUNC('day', MIN(created_at))::date AS cohort_day_start
-  FROM events GROUP BY 1
-  HAVING MIN(created_at) >= (SELECT cohort_start FROM params)
-),
-activity_days AS (SELECT DISTINCT user_id, day_start FROM events),
-user_day_age AS (
-  SELECT ad.user_id, fe.cohort_day_start,
-         (ad.day_start - DATE_TRUNC('day',fe.first_exec_at)::date)::int AS user_lifetime_day
-  FROM activity_days ad JOIN first_exec fe USING (user_id)
-  WHERE ad.day_start >= DATE_TRUNC('day',fe.first_exec_at)::date
-),
-bounded_counts AS (
-  SELECT cohort_day_start, user_lifetime_day, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_day_age WHERE user_lifetime_day >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_day_start, user_id, MAX(user_lifetime_day) AS last_active_day FROM user_day_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_day_start, gs AS user_lifetime_day, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_day,(SELECT max_days FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_day_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_exec GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_day_start, cs.cohort_users,
-         LEAST((SELECT max_days FROM params), GREATEST(0,(CURRENT_DATE-cs.cohort_day_start)::int)) AS cap_days
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_day_start, gs AS user_lifetime_day, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_days) gs
-)
-SELECT
-  g.cohort_day_start,
-  TO_CHAR(g.cohort_day_start,'YYYY-MM-DD')                                AS cohort_label,
-  TO_CHAR(g.cohort_day_start,'YYYY-MM-DD')||' (n='||g.cohort_users||')'   AS cohort_label_n,
-  g.user_lifetime_day, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_day=0 THEN g.cohort_users ELSE 0 END          AS cohort_users_d0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_day_start=g.cohort_day_start AND b.user_lifetime_day=g.user_lifetime_day
-LEFT JOIN unbounded_counts u ON u.cohort_day_start=g.cohort_day_start AND u.user_lifetime_day=g.user_lifetime_day
-ORDER BY g.cohort_day_start, g.user_lifetime_day;

autogpt_platform/analytics/queries/retention_execution_weekly.sql

@@ -1,81 +0,0 @@
--- =============================================================
--- View: analytics.retention_execution_weekly
--- Looker source alias: ds92  |  Charts: 2
--- =============================================================
--- DESCRIPTION
---   Weekly cohort retention based on agent executions.
---   Cohort anchor = week of user's FIRST ever agent execution
---   (not first login). Only includes cohorts from the last 180 days.
---   Useful when you care about product engagement, not just visits.
---
--- SOURCE TABLES
---   platform.AgentGraphExecution  — Execution records
---
--- OUTPUT COLUMNS
---   Same pattern as retention_login_weekly.
---   cohort_week_start = week of first execution (not first login)
---
--- EXAMPLE QUERIES
---   -- Week-2 execution retention
---   SELECT cohort_label, retention_rate_bounded
---   FROM analytics.retention_execution_weekly
---   WHERE user_lifetime_week = 2 ORDER BY cohort_week_start;
--- =============================================================
-
-WITH params AS (SELECT 12::int AS max_weeks, (CURRENT_DATE - INTERVAL '180 days') AS cohort_start),
-events AS (
-  SELECT e."userId"::text AS user_id, e."createdAt"::timestamptz AS created_at,
-         DATE_TRUNC('week', e."createdAt")::date AS week_start
-  FROM platform."AgentGraphExecution" e WHERE e."userId" IS NOT NULL
-),
-first_exec AS (
-  SELECT user_id, MIN(created_at) AS first_exec_at,
-         DATE_TRUNC('week', MIN(created_at))::date AS cohort_week_start
-  FROM events GROUP BY 1
-  HAVING MIN(created_at) >= (SELECT cohort_start FROM params)
-),
-activity_weeks AS (SELECT DISTINCT user_id, week_start FROM events),
-user_week_age AS (
-  SELECT aw.user_id, fe.cohort_week_start,
-         ((aw.week_start - DATE_TRUNC('week',fe.first_exec_at)::date)/7)::int AS user_lifetime_week
-  FROM activity_weeks aw JOIN first_exec fe USING (user_id)
-  WHERE aw.week_start >= DATE_TRUNC('week',fe.first_exec_at)::date
-),
-bounded_counts AS (
-  SELECT cohort_week_start, user_lifetime_week, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_week_age WHERE user_lifetime_week >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_week_start, user_id, MAX(user_lifetime_week) AS last_active_week FROM user_week_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_week_start, gs AS user_lifetime_week, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_week,(SELECT max_weeks FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_week_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_exec GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_week_start, cs.cohort_users,
-         LEAST((SELECT max_weeks FROM params),
-               GREATEST(0,((DATE_TRUNC('week',CURRENT_DATE)::date-cs.cohort_week_start)/7)::int)) AS cap_weeks
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_week_start, gs AS user_lifetime_week, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_weeks) gs
-)
-SELECT
-  g.cohort_week_start,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')                               AS cohort_label,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')||' (n='||g.cohort_users||')'  AS cohort_label_n,
-  g.user_lifetime_week, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_week=0 THEN g.cohort_users ELSE 0 END         AS cohort_users_w0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_week_start=g.cohort_week_start AND b.user_lifetime_week=g.user_lifetime_week
-LEFT JOIN unbounded_counts u ON u.cohort_week_start=g.cohort_week_start AND u.user_lifetime_week=g.user_lifetime_week
-ORDER BY g.cohort_week_start, g.user_lifetime_week;

autogpt_platform/analytics/queries/retention_login_daily.sql

@@ -1,94 +0,0 @@
--- =============================================================
--- View: analytics.retention_login_daily
--- Looker source alias: ds112  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Daily cohort retention based on login sessions.
---   Same logic as retention_login_weekly but at day granularity,
---   showing up to day 30 for cohorts from the last 90 days.
---   Useful for analysing early activation (days 1-7) in detail.
---
--- SOURCE TABLES
---   auth.sessions  — Login session records
---
--- OUTPUT COLUMNS (same pattern as retention_login_weekly)
---   cohort_day_start          DATE     First day the cohort logged in
---   cohort_label              TEXT     Date string (e.g. '2025-03-01')
---   cohort_label_n            TEXT     Date + cohort size (e.g. '2025-03-01 (n=12)')
---   user_lifetime_day         INT      Days since first login (0 = signup day)
---   cohort_users              BIGINT   Total users in cohort
---   active_users_bounded      BIGINT   Users active on exactly day k
---   retained_users_unbounded  BIGINT   Users active any time on/after day k
---   retention_rate_bounded    FLOAT    bounded / cohort_users
---   retention_rate_unbounded  FLOAT    unbounded / cohort_users
---   cohort_users_d0           BIGINT   cohort_users only at day 0, else 0 (safe to SUM)
---
--- EXAMPLE QUERIES
---   -- Day-1 retention rate (came back next day)
---   SELECT cohort_label, retention_rate_bounded AS d1_retention
---   FROM analytics.retention_login_daily
---   WHERE user_lifetime_day = 1 ORDER BY cohort_day_start;
---
---   -- Average retention curve across all cohorts
---   SELECT user_lifetime_day,
---          SUM(active_users_bounded)::float / NULLIF(SUM(cohort_users_d0), 0) AS avg_retention
---   FROM analytics.retention_login_daily
---   GROUP BY 1 ORDER BY 1;
--- =============================================================
-
-WITH params AS (SELECT 30::int AS max_days, (CURRENT_DATE - INTERVAL '90 days')::date AS cohort_start),
-events AS (
-  SELECT s.user_id::text AS user_id, s.created_at::timestamptz AS created_at,
-         DATE_TRUNC('day', s.created_at)::date AS day_start
-  FROM auth.sessions s WHERE s.user_id IS NOT NULL
-),
-first_login AS (
-  SELECT user_id, MIN(created_at) AS first_login_time,
-         DATE_TRUNC('day', MIN(created_at))::date AS cohort_day_start
-  FROM events GROUP BY 1
-  HAVING MIN(created_at) >= (SELECT cohort_start FROM params)
-),
-activity_days AS (SELECT DISTINCT user_id, day_start FROM events),
-user_day_age AS (
-  SELECT ad.user_id, fl.cohort_day_start,
-         (ad.day_start - DATE_TRUNC('day', fl.first_login_time)::date)::int AS user_lifetime_day
-  FROM activity_days ad JOIN first_login fl USING (user_id)
-  WHERE ad.day_start >= DATE_TRUNC('day', fl.first_login_time)::date
-),
-bounded_counts AS (
-  SELECT cohort_day_start, user_lifetime_day, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_day_age WHERE user_lifetime_day >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_day_start, user_id, MAX(user_lifetime_day) AS last_active_day FROM user_day_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_day_start, gs AS user_lifetime_day, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_day,(SELECT max_days FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_day_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_login GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_day_start, cs.cohort_users,
-         LEAST((SELECT max_days FROM params), GREATEST(0,(CURRENT_DATE-cs.cohort_day_start)::int)) AS cap_days
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_day_start, gs AS user_lifetime_day, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_days) gs
-)
-SELECT
-  g.cohort_day_start,
-  TO_CHAR(g.cohort_day_start,'YYYY-MM-DD')                                  AS cohort_label,
-  TO_CHAR(g.cohort_day_start,'YYYY-MM-DD')||' (n='||g.cohort_users||')'     AS cohort_label_n,
-  g.user_lifetime_day, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_day=0 THEN g.cohort_users ELSE 0 END            AS cohort_users_d0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_day_start=g.cohort_day_start AND b.user_lifetime_day=g.user_lifetime_day
-LEFT JOIN unbounded_counts u ON u.cohort_day_start=g.cohort_day_start AND u.user_lifetime_day=g.user_lifetime_day
-ORDER BY g.cohort_day_start, g.user_lifetime_day;

autogpt_platform/analytics/queries/retention_login_onboarded_weekly.sql

@@ -1,96 +0,0 @@
--- =============================================================
--- View: analytics.retention_login_onboarded_weekly
--- Looker source alias: ds101  |  Charts: 2
--- =============================================================
--- DESCRIPTION
---   Weekly cohort retention from login sessions, restricted to
---   users who "onboarded" — defined as running at least one
---   agent within 365 days of their first login.
---   Filters out users who signed up but never activated,
---   giving a cleaner view of engaged-user retention.
---
--- SOURCE TABLES
---   auth.sessions                  — Login session records
---   platform.AgentGraphExecution   — Used to identify onboarders
---
--- OUTPUT COLUMNS
---   Same as retention_login_weekly (cohort_week_start, user_lifetime_week,
---   retention_rate_bounded, retention_rate_unbounded, etc.)
---   Only difference: cohort is filtered to onboarded users only.
---
--- EXAMPLE QUERIES
---   -- Compare week-4 retention: all users vs onboarded only
---   SELECT 'all_users' AS segment, AVG(retention_rate_bounded) AS w4_retention
---   FROM analytics.retention_login_weekly WHERE user_lifetime_week = 4
---   UNION ALL
---   SELECT 'onboarded', AVG(retention_rate_bounded)
---   FROM analytics.retention_login_onboarded_weekly WHERE user_lifetime_week = 4;
--- =============================================================
-
-WITH params AS (SELECT 12::int AS max_weeks, 365::int AS onboarding_window_days),
-events AS (
-  SELECT s.user_id::text AS user_id, s.created_at::timestamptz AS created_at,
-         DATE_TRUNC('week', s.created_at)::date AS week_start
-  FROM auth.sessions s WHERE s.user_id IS NOT NULL
-),
-first_login_all AS (
-  SELECT user_id, MIN(created_at) AS first_login_time,
-         DATE_TRUNC('week', MIN(created_at))::date AS cohort_week_start
-  FROM events GROUP BY 1
-),
-onboarders AS (
-  SELECT fl.user_id FROM first_login_all fl
-  WHERE EXISTS (
-    SELECT 1 FROM platform."AgentGraphExecution" e
-    WHERE e."userId"::text = fl.user_id
-      AND e."createdAt" >= fl.first_login_time
-      AND e."createdAt" < fl.first_login_time
-          + make_interval(days => (SELECT onboarding_window_days FROM params))
-  )
-),
-first_login AS (SELECT * FROM first_login_all WHERE user_id IN (SELECT user_id FROM onboarders)),
-activity_weeks AS (SELECT DISTINCT user_id, week_start FROM events),
-user_week_age AS (
-  SELECT aw.user_id, fl.cohort_week_start,
-         ((aw.week_start - DATE_TRUNC('week',fl.first_login_time)::date)/7)::int AS user_lifetime_week
-  FROM activity_weeks aw JOIN first_login fl USING (user_id)
-  WHERE aw.week_start >= DATE_TRUNC('week',fl.first_login_time)::date
-),
-bounded_counts AS (
-  SELECT cohort_week_start, user_lifetime_week, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_week_age WHERE user_lifetime_week >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_week_start, user_id, MAX(user_lifetime_week) AS last_active_week FROM user_week_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_week_start, gs AS user_lifetime_week, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_week,(SELECT max_weeks FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_week_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_login GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_week_start, cs.cohort_users,
-         LEAST((SELECT max_weeks FROM params),
-               GREATEST(0,((DATE_TRUNC('week',CURRENT_DATE)::date-cs.cohort_week_start)/7)::int)) AS cap_weeks
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_week_start, gs AS user_lifetime_week, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_weeks) gs
-)
-SELECT
-  g.cohort_week_start,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')                               AS cohort_label,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')||' (n='||g.cohort_users||')'  AS cohort_label_n,
-  g.user_lifetime_week, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_week=0 THEN g.cohort_users ELSE 0 END         AS cohort_users_w0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_week_start=g.cohort_week_start AND b.user_lifetime_week=g.user_lifetime_week
-LEFT JOIN unbounded_counts u ON u.cohort_week_start=g.cohort_week_start AND u.user_lifetime_week=g.user_lifetime_week
-ORDER BY g.cohort_week_start, g.user_lifetime_week;

autogpt_platform/analytics/queries/retention_login_weekly.sql

@@ -1,103 +0,0 @@
--- =============================================================
--- View: analytics.retention_login_weekly
--- Looker source alias: ds83  |  Charts: 2
--- =============================================================
--- DESCRIPTION
---   Weekly cohort retention based on login sessions.
---   Users are grouped by the ISO week of their first ever login.
---   For each cohort × lifetime-week combination, outputs both:
---     - bounded rate: % active in exactly that week
---     - unbounded rate: % who were ever active on or after that week
---   Weeks are capped to the cohort's actual age (no future data points).
---
--- SOURCE TABLES
---   auth.sessions  — Login session records
---
--- HOW TO READ THE OUTPUT
---   cohort_week_start   The Monday of the week users first logged in
---   user_lifetime_week  0 = signup week, 1 = one week later, etc.
---   retention_rate_bounded   = active_users_bounded / cohort_users
---   retention_rate_unbounded = retained_users_unbounded / cohort_users
---
--- OUTPUT COLUMNS
---   cohort_week_start         DATE     First day of the cohort's signup week
---   cohort_label              TEXT     ISO week label (e.g. '2025-W01')
---   cohort_label_n            TEXT     ISO week label with cohort size (e.g. '2025-W01 (n=42)')
---   user_lifetime_week        INT      Weeks since first login (0 = signup week)
---   cohort_users              BIGINT   Total users in this cohort (denominator)
---   active_users_bounded      BIGINT   Users active in exactly week k
---   retained_users_unbounded  BIGINT   Users active any time on/after week k
---   retention_rate_bounded    FLOAT    bounded active / cohort_users
---   retention_rate_unbounded  FLOAT    unbounded retained / cohort_users
---   cohort_users_w0           BIGINT   cohort_users only at week 0, else 0 (safe to SUM in pivot tables)
---
--- EXAMPLE QUERIES
---   -- Week-1 retention rate per cohort
---   SELECT cohort_label, retention_rate_bounded AS w1_retention
---   FROM analytics.retention_login_weekly
---   WHERE user_lifetime_week = 1
---   ORDER BY cohort_week_start;
---
---   -- Overall average retention curve (all cohorts combined)
---   SELECT user_lifetime_week,
---          SUM(active_users_bounded)::float / NULLIF(SUM(cohort_users_w0), 0) AS avg_retention
---   FROM analytics.retention_login_weekly
---   GROUP BY 1 ORDER BY 1;
--- =============================================================
-
-WITH params AS (SELECT 12::int AS max_weeks),
-events AS (
-  SELECT s.user_id::text AS user_id, s.created_at::timestamptz AS created_at,
-         DATE_TRUNC('week', s.created_at)::date AS week_start
-  FROM auth.sessions s WHERE s.user_id IS NOT NULL
-),
-first_login AS (
-  SELECT user_id, MIN(created_at) AS first_login_time,
-         DATE_TRUNC('week', MIN(created_at))::date AS cohort_week_start
-  FROM events GROUP BY 1
-),
-activity_weeks AS (SELECT DISTINCT user_id, week_start FROM events),
-user_week_age AS (
-  SELECT aw.user_id, fl.cohort_week_start,
-         ((aw.week_start - DATE_TRUNC('week', fl.first_login_time)::date) / 7)::int AS user_lifetime_week
-  FROM activity_weeks aw JOIN first_login fl USING (user_id)
-  WHERE aw.week_start >= DATE_TRUNC('week', fl.first_login_time)::date
-),
-bounded_counts AS (
-  SELECT cohort_week_start, user_lifetime_week, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_week_age WHERE user_lifetime_week >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_week_start, user_id, MAX(user_lifetime_week) AS last_active_week FROM user_week_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_week_start, gs AS user_lifetime_week, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_week,(SELECT max_weeks FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_week_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_login GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_week_start, cs.cohort_users,
-         LEAST((SELECT max_weeks FROM params),
-               GREATEST(0,((DATE_TRUNC('week',CURRENT_DATE)::date - cs.cohort_week_start)/7)::int)) AS cap_weeks
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_week_start, gs AS user_lifetime_week, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_weeks) gs
-)
-SELECT
-  g.cohort_week_start,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')                                    AS cohort_label,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')||' (n='||g.cohort_users||')'       AS cohort_label_n,
-  g.user_lifetime_week, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_week=0 THEN g.cohort_users ELSE 0 END               AS cohort_users_w0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_week_start=g.cohort_week_start AND b.user_lifetime_week=g.user_lifetime_week
-LEFT JOIN unbounded_counts u ON u.cohort_week_start=g.cohort_week_start AND u.user_lifetime_week=g.user_lifetime_week
-ORDER BY g.cohort_week_start, g.user_lifetime_week

autogpt_platform/analytics/queries/user_block_spending.sql

@@ -1,71 +0,0 @@
--- =============================================================
--- View: analytics.user_block_spending
--- Looker source alias: ds6  |  Charts: 5
--- =============================================================
--- DESCRIPTION
---   One row per credit transaction (last 90 days).
---   Shows how users spend credits broken down by block type,
---   LLM provider and model.  Joins node execution stats for
---   token-level detail.
---
--- SOURCE TABLES
---   platform.CreditTransaction   — Credit debit/credit records
---   platform.AgentNodeExecution  — Node execution stats (for token counts)
---
--- OUTPUT COLUMNS
---   transactionKey        TEXT         Unique transaction identifier
---   userId                TEXT         User who was charged
---   amount                DECIMAL      Credit amount (positive = credit, negative = debit)
---   negativeAmount        DECIMAL      amount * -1 (convenience for spend charts)
---   transactionType       TEXT         Transaction type (e.g. 'USAGE', 'REFUND', 'TOP_UP')
---   transactionTime       TIMESTAMPTZ  When the transaction was recorded
---   blockId               TEXT         Block UUID that triggered the spend
---   blockName             TEXT         Human-readable block name
---   llm_provider          TEXT         LLM provider (e.g. 'openai', 'anthropic')
---   llm_model             TEXT         Model name (e.g. 'gpt-4o', 'claude-3-5-sonnet')
---   node_exec_id          TEXT         Linked node execution UUID
---   llm_call_count        INT          LLM API calls made in that execution
---   llm_retry_count       INT          LLM retries in that execution
---   llm_input_token_count INT          Input tokens consumed
---   llm_output_token_count INT         Output tokens produced
---
--- WINDOW
---   Rolling 90 days (createdAt > CURRENT_DATE - 90 days)
---
--- EXAMPLE QUERIES
---   -- Total spend per user (last 90 days)
---   SELECT "userId", SUM("negativeAmount") AS total_spent
---   FROM analytics.user_block_spending
---   WHERE "transactionType" = 'USAGE'
---   GROUP BY 1 ORDER BY total_spent DESC;
---
---   -- Spend by LLM provider + model
---   SELECT "llm_provider", "llm_model",
---          SUM("negativeAmount") AS total_cost,
---          SUM("llm_input_token_count") AS input_tokens,
---          SUM("llm_output_token_count") AS output_tokens
---   FROM analytics.user_block_spending
---   WHERE "llm_provider" IS NOT NULL
---   GROUP BY 1, 2 ORDER BY total_cost DESC;
--- =============================================================
-
-SELECT
-    c."transactionKey"                                        AS transactionKey,
-    c."userId"                                                AS userId,
-    c."amount"                                                AS amount,
-    c."amount" * -1                                           AS negativeAmount,
-    c."type"                                                  AS transactionType,
-    c."createdAt"                                             AS transactionTime,
-    c.metadata->>'block_id'                                   AS blockId,
-    c.metadata->>'block'                                      AS blockName,
-    c.metadata->'input'->'credentials'->>'provider'           AS llm_provider,
-    c.metadata->'input'->>'model'                             AS llm_model,
-    c.metadata->>'node_exec_id'                               AS node_exec_id,
-    (ne."stats"->>'llm_call_count')::int                       AS llm_call_count,
-    (ne."stats"->>'llm_retry_count')::int                      AS llm_retry_count,
-    (ne."stats"->>'input_token_count')::int                    AS llm_input_token_count,
-    (ne."stats"->>'output_token_count')::int                   AS llm_output_token_count
-FROM platform."CreditTransaction" c
-LEFT JOIN platform."AgentNodeExecution" ne
-       ON (c.metadata->>'node_exec_id') = ne."id"::text
-WHERE c."createdAt" > CURRENT_DATE - INTERVAL '90 days'

autogpt_platform/analytics/queries/user_onboarding.sql

@@ -1,45 +0,0 @@
--- =============================================================
--- View: analytics.user_onboarding
--- Looker source alias: ds68  |  Charts: 3
--- =============================================================
--- DESCRIPTION
---   One row per user onboarding record.  Contains the user's
---   stated usage reason, selected integrations, completed
---   onboarding steps and optional first agent selection.
---   Full history (no date filter) since onboarding happens
---   once per user.
---
--- SOURCE TABLES
---   platform.UserOnboarding  — Onboarding state per user
---
--- OUTPUT COLUMNS
---   id                            TEXT         Onboarding record UUID
---   createdAt                     TIMESTAMPTZ  When onboarding started
---   updatedAt                     TIMESTAMPTZ  Last update to onboarding state
---   usageReason                   TEXT         Why user signed up (e.g. 'work', 'personal')
---   integrations                  TEXT[]       Array of integration names the user selected
---   userId                        TEXT         User UUID
---   completedSteps                TEXT[]       Array of onboarding step enums completed
---   selectedStoreListingVersionId TEXT         First marketplace agent the user chose (if any)
---
--- EXAMPLE QUERIES
---   -- Usage reason breakdown
---   SELECT "usageReason", COUNT(*) FROM analytics.user_onboarding GROUP BY 1;
---
---   -- Completion rate per step
---   SELECT step, COUNT(*) AS users_completed
---   FROM analytics.user_onboarding
---   CROSS JOIN LATERAL UNNEST("completedSteps") AS step
---   GROUP BY 1 ORDER BY users_completed DESC;
--- =============================================================
-
-SELECT
-    id,
-    "createdAt",
-    "updatedAt",
-    "usageReason",
-    integrations,
-    "userId",
-    "completedSteps",
-    "selectedStoreListingVersionId"
-FROM platform."UserOnboarding"

autogpt_platform/analytics/queries/user_onboarding_funnel.sql

@@ -1,100 +0,0 @@
--- =============================================================
--- View: analytics.user_onboarding_funnel
--- Looker source alias: ds74  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Pre-aggregated onboarding funnel showing how many users
---   completed each step and the drop-off percentage from the
---   previous step.  One row per onboarding step (all 22 steps
---   always present, even with 0 completions — prevents sparse
---   gaps from making LAG compare the wrong predecessors).
---
--- SOURCE TABLES
---   platform.UserOnboarding  — Onboarding records with completedSteps array
---
--- OUTPUT COLUMNS
---   step             TEXT     Onboarding step enum name (e.g. 'WELCOME', 'CONGRATS')
---   step_order       INT      Numeric position in the funnel (1=first, 22=last)
---   users_completed  BIGINT   Distinct users who completed this step
---   pct_from_prev    NUMERIC  % of users from the previous step who reached this one
---
--- STEP ORDER
---   1  WELCOME               9  MARKETPLACE_VISIT     17  SCHEDULE_AGENT
---   2  USAGE_REASON         10  MARKETPLACE_ADD_AGENT  18  RUN_AGENTS
---   3  INTEGRATIONS         11  MARKETPLACE_RUN_AGENT  19  RUN_3_DAYS
---   4  AGENT_CHOICE         12  BUILDER_OPEN           20  TRIGGER_WEBHOOK
---   5  AGENT_NEW_RUN        13  BUILDER_SAVE_AGENT     21  RUN_14_DAYS
---   6  AGENT_INPUT          14  BUILDER_RUN_AGENT      22  RUN_AGENTS_100
---   7  CONGRATS             15  VISIT_COPILOT
---   8  GET_RESULTS          16  RE_RUN_AGENT
---
--- WINDOW
---   Users who started onboarding in the last 90 days
---
--- EXAMPLE QUERIES
---   -- Full funnel
---   SELECT * FROM analytics.user_onboarding_funnel ORDER BY step_order;
---
---   -- Biggest drop-off point
---   SELECT step, pct_from_prev FROM analytics.user_onboarding_funnel
---   ORDER BY pct_from_prev ASC LIMIT 3;
--- =============================================================
-
-WITH all_steps AS (
-  -- Complete ordered grid of all 22 steps so zero-completion steps
-  -- are always present, keeping LAG comparisons correct.
-  SELECT step_name, step_order
-  FROM (VALUES
-    ('WELCOME',               1),
-    ('USAGE_REASON',          2),
-    ('INTEGRATIONS',          3),
-    ('AGENT_CHOICE',          4),
-    ('AGENT_NEW_RUN',         5),
-    ('AGENT_INPUT',           6),
-    ('CONGRATS',              7),
-    ('GET_RESULTS',           8),
-    ('MARKETPLACE_VISIT',     9),
-    ('MARKETPLACE_ADD_AGENT', 10),
-    ('MARKETPLACE_RUN_AGENT', 11),
-    ('BUILDER_OPEN',          12),
-    ('BUILDER_SAVE_AGENT',    13),
-    ('BUILDER_RUN_AGENT',     14),
-    ('VISIT_COPILOT',         15),
-    ('RE_RUN_AGENT',          16),
-    ('SCHEDULE_AGENT',        17),
-    ('RUN_AGENTS',            18),
-    ('RUN_3_DAYS',            19),
-    ('TRIGGER_WEBHOOK',       20),
-    ('RUN_14_DAYS',           21),
-    ('RUN_AGENTS_100',        22)
-  ) AS t(step_name, step_order)
-),
-raw AS (
-  SELECT
-      u."userId",
-      step_txt::text AS step
-  FROM platform."UserOnboarding" u
-  CROSS JOIN LATERAL UNNEST(u."completedSteps") AS step_txt
-  WHERE u."createdAt" >= CURRENT_DATE - INTERVAL '90 days'
-),
-step_counts AS (
-  SELECT step, COUNT(DISTINCT "userId") AS users_completed
-  FROM raw GROUP BY step
-),
-funnel AS (
-  SELECT
-      a.step_name                          AS step,
-      a.step_order,
-      COALESCE(sc.users_completed, 0)      AS users_completed,
-      ROUND(
-        100.0 * COALESCE(sc.users_completed, 0)
-        / NULLIF(
-            LAG(COALESCE(sc.users_completed, 0)) OVER (ORDER BY a.step_order),
-            0
-          ),
-        2
-      )                                    AS pct_from_prev
-  FROM all_steps a
-  LEFT JOIN step_counts sc ON sc.step = a.step_name
-)
-SELECT * FROM funnel ORDER BY step_order

autogpt_platform/analytics/queries/user_onboarding_integration.sql

@@ -1,41 +0,0 @@
--- =============================================================
--- View: analytics.user_onboarding_integration
--- Looker source alias: ds75  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Pre-aggregated count of users who selected each integration
---   during onboarding.  One row per integration type, sorted
---   by popularity.
---
--- SOURCE TABLES
---   platform.UserOnboarding  — integrations array column
---
--- OUTPUT COLUMNS
---   integration            TEXT    Integration name (e.g. 'github', 'slack', 'notion')
---   users_with_integration BIGINT  Distinct users who selected this integration
---
--- WINDOW
---   Users who started onboarding in the last 90 days
---
--- EXAMPLE QUERIES
---   -- Full integration popularity ranking
---   SELECT * FROM analytics.user_onboarding_integration;
---
---   -- Top 5 integrations
---   SELECT * FROM analytics.user_onboarding_integration LIMIT 5;
--- =============================================================
-
-WITH exploded AS (
-  SELECT
-      u."userId" AS user_id,
-      UNNEST(u."integrations") AS integration
-  FROM platform."UserOnboarding" u
-  WHERE u."createdAt" >= CURRENT_DATE - INTERVAL '90 days'
-)
-SELECT
-    integration,
-    COUNT(DISTINCT user_id) AS users_with_integration
-FROM exploded
-WHERE integration IS NOT NULL AND integration <> ''
-GROUP BY integration
-ORDER BY users_with_integration DESC

autogpt_platform/analytics/queries/users_activities.sql

@@ -1,145 +0,0 @@
--- =============================================================
--- View: analytics.users_activities
--- Looker source alias: ds56  |  Charts: 5
--- =============================================================
--- DESCRIPTION
---   One row per user with lifetime activity summary.
---   Joins login sessions with agent graphs, executions and
---   node-level runs to give a full picture of how engaged
---   each user is.  Includes a convenience flag for 7-day
---   activation (did the user return at least 7 days after
---   their first login?).
---
--- SOURCE TABLES
---   auth.sessions                    — Login/session records
---   platform.AgentGraph              — Graphs (agents) built by the user
---   platform.AgentGraphExecution     — Agent run history
---   platform.AgentNodeExecution      — Individual block execution history
---
--- PERFORMANCE NOTE
---   Each CTE aggregates its own table independently by userId.
---   This avoids the fan-out that occurs when driving every join
---   from user_logins across the two largest tables
---   (AgentGraphExecution and AgentNodeExecution).
---
--- OUTPUT COLUMNS
---   user_id                   TEXT         Supabase user UUID
---   first_login_time          TIMESTAMPTZ  First ever session created_at
---   last_login_time           TIMESTAMPTZ  Most recent session created_at
---   last_visit_time           TIMESTAMPTZ  Max of last refresh or login
---   last_agent_save_time      TIMESTAMPTZ  Last time user saved an agent graph
---   agent_count               BIGINT       Number of distinct active graphs built (0 if none)
---   first_agent_run_time      TIMESTAMPTZ  First ever graph execution
---   last_agent_run_time       TIMESTAMPTZ  Most recent graph execution
---   unique_agent_runs         BIGINT       Distinct agent graphs ever run (0 if none)
---   agent_runs                BIGINT       Total graph execution count (0 if none)
---   node_execution_count      BIGINT       Total node executions across all runs
---   node_execution_failed     BIGINT       Node executions with FAILED status
---   node_execution_completed  BIGINT       Node executions with COMPLETED status
---   node_execution_terminated BIGINT       Node executions with TERMINATED status
---   node_execution_queued     BIGINT       Node executions with QUEUED status
---   node_execution_running    BIGINT       Node executions with RUNNING status
---   is_active_after_7d        INT          1=returned after day 7, 0=did not, NULL=too early to tell
---   node_execution_incomplete BIGINT       Node executions with INCOMPLETE status
---   node_execution_review     BIGINT       Node executions with REVIEW status
---
--- EXAMPLE QUERIES
---   -- Users who ran at least one agent and returned after 7 days
---   SELECT COUNT(*) FROM analytics.users_activities
---   WHERE agent_runs > 0 AND is_active_after_7d = 1;
---
---   -- Top 10 most active users by agent runs
---   SELECT user_id, agent_runs, node_execution_count
---   FROM analytics.users_activities
---   ORDER BY agent_runs DESC LIMIT 10;
---
---   -- 7-day activation rate
---   SELECT
---     SUM(CASE WHEN is_active_after_7d = 1 THEN 1 ELSE 0 END)::float
---     / NULLIF(COUNT(CASE WHEN is_active_after_7d IS NOT NULL THEN 1 END), 0)
---     AS activation_rate
---   FROM analytics.users_activities;
--- =============================================================
-
-WITH user_logins AS (
-  SELECT
-    user_id::text                                    AS user_id,
-    MIN(created_at)                                  AS first_login_time,
-    MAX(created_at)                                  AS last_login_time,
-    GREATEST(
-      MAX(refreshed_at)::timestamptz,
-      MAX(created_at)::timestamptz
-    )                                                AS last_visit_time
-  FROM auth.sessions
-  GROUP BY user_id
-),
-user_agents AS (
-  -- Aggregate AgentGraph directly by userId (no fan-out from user_logins)
-  SELECT
-    "userId"::text                AS user_id,
-    MAX("updatedAt")              AS last_agent_save_time,
-    COUNT(DISTINCT "id")          AS agent_count
-  FROM platform."AgentGraph"
-  WHERE "isActive"
-  GROUP BY "userId"
-),
-user_graph_runs AS (
-  -- Aggregate AgentGraphExecution directly by userId
-  SELECT
-    "userId"::text                        AS user_id,
-    MIN("createdAt")                      AS first_agent_run_time,
-    MAX("createdAt")                      AS last_agent_run_time,
-    COUNT(DISTINCT "agentGraphId")        AS unique_agent_runs,
-    COUNT("id")                           AS agent_runs
-  FROM platform."AgentGraphExecution"
-  GROUP BY "userId"
-),
-user_node_runs AS (
-  -- Aggregate AgentNodeExecution directly; resolve userId via a
-  -- single join to AgentGraphExecution instead of fanning out from
-  -- user_logins through both large tables.
-  SELECT
-    g."userId"::text                                                   AS user_id,
-    COUNT(*)                                                           AS node_execution_count,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'FAILED')             AS node_execution_failed,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'COMPLETED')          AS node_execution_completed,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'TERMINATED')         AS node_execution_terminated,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'QUEUED')             AS node_execution_queued,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'RUNNING')            AS node_execution_running,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'INCOMPLETE')         AS node_execution_incomplete,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'REVIEW')             AS node_execution_review
-  FROM platform."AgentNodeExecution" n
-  JOIN platform."AgentGraphExecution" g
-    ON g."id" = n."agentGraphExecutionId"
-  GROUP BY g."userId"
-)
-SELECT
-  ul.user_id,
-  ul.first_login_time,
-  ul.last_login_time,
-  ul.last_visit_time,
-  ua.last_agent_save_time,
-  COALESCE(ua.agent_count, 0)             AS agent_count,
-  gr.first_agent_run_time,
-  gr.last_agent_run_time,
-  COALESCE(gr.unique_agent_runs, 0)       AS unique_agent_runs,
-  COALESCE(gr.agent_runs, 0)              AS agent_runs,
-  COALESCE(nr.node_execution_count, 0)      AS node_execution_count,
-  COALESCE(nr.node_execution_failed, 0)     AS node_execution_failed,
-  COALESCE(nr.node_execution_completed, 0)  AS node_execution_completed,
-  COALESCE(nr.node_execution_terminated, 0) AS node_execution_terminated,
-  COALESCE(nr.node_execution_queued, 0)     AS node_execution_queued,
-  COALESCE(nr.node_execution_running, 0)    AS node_execution_running,
-  CASE
-    WHEN ul.first_login_time < NOW() - INTERVAL '7 days'
-     AND ul.last_visit_time  >= ul.first_login_time + INTERVAL '7 days' THEN 1
-    WHEN ul.first_login_time < NOW() - INTERVAL '7 days'
-     AND ul.last_visit_time  <  ul.first_login_time + INTERVAL '7 days' THEN 0
-    ELSE NULL
-  END AS is_active_after_7d,
-  COALESCE(nr.node_execution_incomplete, 0) AS node_execution_incomplete,
-  COALESCE(nr.node_execution_review, 0)     AS node_execution_review
-FROM user_logins ul
-LEFT JOIN user_agents     ua ON ul.user_id = ua.user_id
-LEFT JOIN user_graph_runs gr ON ul.user_id = gr.user_id
-LEFT JOIN user_node_runs  nr ON ul.user_id = nr.user_id

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/config.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class RateLimitSettings(BaseSettings):
+    redis_host: str = Field(
+        default="redis://localhost:6379",
+        description="Redis host",
+        validation_alias="REDIS_HOST",
+    )
+
+    redis_port: str = Field(
+        default="6379", description="Redis port", validation_alias="REDIS_PORT"
+    )
+
+    redis_password: Optional[str] = Field(
+        default=None,
+        description="Redis password",
+        validation_alias="REDIS_PASSWORD",
+    )
+
+    requests_per_minute: int = Field(
+        default=60,
+        description="Maximum number of requests allowed per minute per API key",
+        validation_alias="RATE_LIMIT_REQUESTS_PER_MINUTE",
+    )
+
+    model_config = SettingsConfigDict(case_sensitive=True, extra="ignore")
+
+
+RATE_LIMIT_SETTINGS = RateLimitSettings()

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/limiter.py

@@ -0,0 +1,51 @@
+import time
+from typing import Tuple
+
+from redis import Redis
+
+from .config import RATE_LIMIT_SETTINGS
+
+
+class RateLimiter:
+    def __init__(
+        self,
+        redis_host: str = RATE_LIMIT_SETTINGS.redis_host,
+        redis_port: str = RATE_LIMIT_SETTINGS.redis_port,
+        redis_password: str | None = RATE_LIMIT_SETTINGS.redis_password,
+        requests_per_minute: int = RATE_LIMIT_SETTINGS.requests_per_minute,
+    ):
+        self.redis = Redis(
+            host=redis_host,
+            port=int(redis_port),
+            password=redis_password,
+            decode_responses=True,
+        )
+        self.window = 60
+        self.max_requests = requests_per_minute
+
+    async def check_rate_limit(self, api_key_id: str) -> Tuple[bool, int, int]:
+        """
+        Check if request is within rate limits.
+
+        Args:
+            api_key_id: The API key identifier to check
+
+        Returns:
+            Tuple of (is_allowed, remaining_requests, reset_time)
+        """
+        now = time.time()
+        window_start = now - self.window
+        key = f"ratelimit:{api_key_id}:1min"
+
+        pipe = self.redis.pipeline()
+        pipe.zremrangebyscore(key, 0, window_start)
+        pipe.zadd(key, {str(now): now})
+        pipe.zcount(key, window_start, now)
+        pipe.expire(key, self.window)
+
+        _, _, request_count, _ = pipe.execute()
+
+        remaining = max(0, self.max_requests - request_count)
+        reset_time = int(now + self.window)
+
+        return request_count <= self.max_requests, remaining, reset_time

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/middleware.py

@@ -0,0 +1,32 @@
+from fastapi import HTTPException, Request
+from starlette.middleware.base import RequestResponseEndpoint
+
+from .limiter import RateLimiter
+
+
+async def rate_limit_middleware(request: Request, call_next: RequestResponseEndpoint):
+    """FastAPI middleware for rate limiting API requests."""
+    limiter = RateLimiter()
+
+    if not request.url.path.startswith("/api"):
+        return await call_next(request)
+
+    api_key = request.headers.get("Authorization")
+    if not api_key:
+        return await call_next(request)
+
+    api_key = api_key.replace("Bearer ", "")
+
+    is_allowed, remaining, reset_time = await limiter.check_rate_limit(api_key)
+
+    if not is_allowed:
+        raise HTTPException(
+            status_code=429, detail="Rate limit exceeded. Please try again later."
+        )
+
+    response = await call_next(request)
+    response.headers["X-RateLimit-Limit"] = str(limiter.max_requests)
+    response.headers["X-RateLimit-Remaining"] = str(remaining)
+    response.headers["X-RateLimit-Reset"] = str(reset_time)
+
+    return response

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/types.py

@@ -59,8 +59,6 @@ class OAuthState(BaseModel):
     code_verifier: Optional[str] = None
     scopes: list[str]
     """Unix timestamp (seconds) indicating when this OAuth state expires"""
-    credential_id: Optional[str] = None
-    """If set, this OAuth flow upgrades an existing credential's scopes."""
 
 
 class UserMetadata(BaseModel):

autogpt_platform/autogpt_libs/autogpt_libs/utils/synchronize.py

@@ -1,16 +1,13 @@
 import asyncio
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any
 
 from expiringdict import ExpiringDict
 
 if TYPE_CHECKING:
     from redis.asyncio import Redis as AsyncRedis
-    from redis.asyncio.cluster import RedisCluster as AsyncRedisCluster
     from redis.asyncio.lock import Lock as AsyncRedisLock
 
-    AsyncRedisLike = Union[AsyncRedis, AsyncRedisCluster]
-
 
 class AsyncRedisKeyedMutex:
     """
@@ -20,7 +17,7 @@ class AsyncRedisKeyedMutex:
     in case the key is not unlocked for a specified duration, to prevent memory leaks.
     """
 
-    def __init__(self, redis: "AsyncRedisLike", timeout: int | None = 60):
+    def __init__(self, redis: "AsyncRedis", timeout: int | None = 60):
         self.redis = redis
         self.timeout = timeout
         self.locks: dict[Any, "AsyncRedisLock"] = ExpiringDict(

autogpt_platform/autogpt_libs/poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.2.1 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.1.1 and should not be changed by hand.
 
 [[package]]
 name = "annotated-doc"
@@ -67,7 +67,7 @@ description = "Backport of asyncio.Runner, a context manager that controls event
 optional = false
 python-versions = "<3.11,>=3.8"
 groups = ["dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5"},
     {file = "backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162"},
@@ -541,7 +541,7 @@ description = "Backport of PEP 654 (exception groups)"
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10"},
     {file = "exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88"},
@@ -2181,14 +2181,14 @@ testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
 
 [[package]]
 name = "pytest-cov"
-version = "7.1.0"
+version = "7.0.0"
 description = "Pytest plugin for measuring coverage."
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
 files = [
-    {file = "pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678"},
-    {file = "pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2"},
+    {file = "pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861"},
+    {file = "pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1"},
 ]
 
 [package.dependencies]
@@ -2342,30 +2342,30 @@ pyasn1 = ">=0.1.3"
 
 [[package]]
 name = "ruff"
-version = "0.15.7"
+version = "0.15.0"
 description = "An extremely fast Python linter and code formatter, written in Rust."
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
 files = [
-    {file = "ruff-0.15.7-py3-none-linux_armv6l.whl", hash = "sha256:a81cc5b6910fb7dfc7c32d20652e50fa05963f6e13ead3c5915c41ac5d16668e"},
-    {file = "ruff-0.15.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:722d165bd52403f3bdabc0ce9e41fc47070ac56d7a91b4e0d097b516a53a3477"},
-    {file = "ruff-0.15.7-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7fbc2448094262552146cbe1b9643a92f66559d3761f1ad0656d4991491af49e"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b39329b60eba44156d138275323cc726bbfbddcec3063da57caa8a8b1d50adf"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:87768c151808505f2bfc93ae44e5f9e7c8518943e5074f76ac21558ef5627c85"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fb0511670002c6c529ec66c0e30641c976c8963de26a113f3a30456b702468b0"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e0d19644f801849229db8345180a71bee5407b429dd217f853ec515e968a6912"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4806d8e09ef5e84eb19ba833d0442f7e300b23fe3f0981cae159a248a10f0036"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dce0896488562f09a27b9c91b1f58a097457143931f3c4d519690dea54e624c5"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:1852ce241d2bc89e5dc823e03cff4ce73d816b5c6cdadd27dbfe7b03217d2a12"},
-    {file = "ruff-0.15.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5f3e4b221fb4bd293f79912fc5e93a9063ebd6d0dcbd528f91b89172a9b8436c"},
-    {file = "ruff-0.15.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b15e48602c9c1d9bdc504b472e90b90c97dc7d46c7028011ae67f3861ceba7b4"},
-    {file = "ruff-0.15.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1b4705e0e85cedc74b0a23cf6a179dbb3df184cb227761979cc76c0440b5ab0d"},
-    {file = "ruff-0.15.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:112c1fa316a558bb34319282c1200a8bf0495f1b735aeb78bfcb2991e6087580"},
-    {file = "ruff-0.15.7-py3-none-win32.whl", hash = "sha256:6d39e2d3505b082323352f733599f28169d12e891f7dd407f2d4f54b4c2886de"},
-    {file = "ruff-0.15.7-py3-none-win_amd64.whl", hash = "sha256:4d53d712ddebcd7dace1bc395367aec12c057aacfe9adbb6d832302575f4d3a1"},
-    {file = "ruff-0.15.7-py3-none-win_arm64.whl", hash = "sha256:18e8d73f1c3fdf27931497972250340f92e8c861722161a9caeb89a58ead6ed2"},
-    {file = "ruff-0.15.7.tar.gz", hash = "sha256:04f1ae61fc20fe0b148617c324d9d009b5f63412c0b16474f3d5f1a1a665f7ac"},
+    {file = "ruff-0.15.0-py3-none-linux_armv6l.whl", hash = "sha256:aac4ebaa612a82b23d45964586f24ae9bc23ca101919f5590bdb368d74ad5455"},
+    {file = "ruff-0.15.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:dcd4be7cc75cfbbca24a98d04d0b9b36a270d0833241f776b788d59f4142b14d"},
+    {file = "ruff-0.15.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d747e3319b2bce179c7c1eaad3d884dc0a199b5f4d5187620530adf9105268ce"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:650bd9c56ae03102c51a5e4b554d74d825ff3abe4db22b90fd32d816c2e90621"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6664b7eac559e3048223a2da77769c2f92b43a6dfd4720cef42654299a599c9"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f811f97b0f092b35320d1556f3353bf238763420ade5d9e62ebd2b73f2ff179"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:761ec0a66680fab6454236635a39abaf14198818c8cdf691e036f4bc0f406b2d"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:940f11c2604d317e797b289f4f9f3fa5555ffe4fb574b55ed006c3d9b6f0eb78"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcbca3d40558789126da91d7ef9a7c87772ee107033db7191edefa34e2c7f1b4"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:9a121a96db1d75fa3eb39c4539e607f628920dd72ff1f7c5ee4f1b768ac62d6e"},
+    {file = "ruff-0.15.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5298d518e493061f2eabd4abd067c7e4fb89e2f63291c94332e35631c07c3662"},
+    {file = "ruff-0.15.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:afb6e603d6375ff0d6b0cee563fa21ab570fd15e65c852cb24922cef25050cf1"},
+    {file = "ruff-0.15.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:77e515f6b15f828b94dc17d2b4ace334c9ddb7d9468c54b2f9ed2b9c1593ef16"},
+    {file = "ruff-0.15.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6f6e80850a01eb13b3e42ee0ebdf6e4497151b48c35051aab51c101266d187a3"},
+    {file = "ruff-0.15.0-py3-none-win32.whl", hash = "sha256:238a717ef803e501b6d51e0bdd0d2c6e8513fe9eec14002445134d3907cd46c3"},
+    {file = "ruff-0.15.0-py3-none-win_amd64.whl", hash = "sha256:dd5e4d3301dc01de614da3cdffc33d4b1b96fb89e45721f1598e5532ccf78b18"},
+    {file = "ruff-0.15.0-py3-none-win_arm64.whl", hash = "sha256:c480d632cc0ca3f0727acac8b7d053542d9e114a462a145d0b00e7cd658c515a"},
+    {file = "ruff-0.15.0.tar.gz", hash = "sha256:6bdea47cdbea30d40f8f8d7d69c0854ba7c15420ec75a26f463290949d7f7e9a"},
 ]
 
 [[package]]
@@ -2564,7 +2564,7 @@ description = "A lil' TOML parser"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"},
     {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"},
@@ -2912,4 +2912,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<4.0"
-content-hash = "e0936a065565550afed18f6298b7e04e814b44100def7049f1a0d68662624a39"
+content-hash = "9619cae908ad38fa2c48016a58bcf4241f6f5793aa0e6cc140276e91c433cbbb"

autogpt_platform/autogpt_libs/pyproject.toml

@@ -26,8 +26,8 @@ pyright = "^1.1.408"
 pytest = "^8.4.1"
 pytest-asyncio = "^1.3.0"
 pytest-mock = "^3.15.1"
-pytest-cov = "^7.1.0"
-ruff = "^0.15.7"
+pytest-cov = "^7.0.0"
+ruff = "^0.15.0"
 
 [build-system]
 requires = ["poetry-core"]

autogpt_platform/backend/.env.default

@@ -58,17 +58,6 @@ V0_API_KEY=
 OPEN_ROUTER_API_KEY=
 NVIDIA_API_KEY=
 
-# Graphiti Temporal Knowledge Graph Memory
-# Rollout controlled by LaunchDarkly flag "graphiti-memory"
-# LLM key falls back to CHAT_API_KEY (AutoPilot), then OPEN_ROUTER_API_KEY.
-# Embedder key falls back to CHAT_OPENAI_API_KEY (AutoPilot), then OPENAI_API_KEY.
-GRAPHITI_FALKORDB_HOST=localhost
-GRAPHITI_FALKORDB_PORT=6380
-GRAPHITI_FALKORDB_PASSWORD=
-GRAPHITI_LLM_MODEL=gpt-4.1-mini
-GRAPHITI_EMBEDDER_MODEL=text-embedding-3-small
-GRAPHITI_SEMAPHORE_LIMIT=5
-
 # Langfuse Prompt Management
 # Used for managing the CoPilot system prompt externally
 # Get credentials from https://cloud.langfuse.com or your self-hosted instance
@@ -179,9 +168,6 @@ MEM0_API_KEY=
 OPENWEATHERMAP_API_KEY=
 GOOGLE_MAPS_API_KEY=
 
-# Platform Bot Linking
-PLATFORM_LINK_BASE_URL=http://localhost:3000/link
-
 # Communication Services
 DISCORD_BOT_TOKEN=
 MEDIUM_API_KEY=
@@ -192,7 +178,6 @@ SMTP_USERNAME=
 SMTP_PASSWORD=
 
 # Business & Marketing Tools
-AGENTMAIL_API_KEY=
 APOLLO_API_KEY=
 ENRICHLAYER_API_KEY=
 AYRSHARE_API_KEY=

autogpt_platform/backend/AGENTS.md

@@ -1,227 +0,0 @@
-# Backend
-
-This file provides guidance to coding agents when working with the backend.
-
-## Essential Commands
-
-To run something with Python package dependencies you MUST use `poetry run ...`.
-
-```bash
-# Install dependencies
-poetry install
-
-# Run database migrations
-poetry run prisma migrate dev
-
-# Start all services (database, redis, rabbitmq, clamav)
-docker compose up -d
-
-# Run the backend as a whole
-poetry run app
-
-# Run tests
-poetry run test
-
-# Run specific test
-poetry run pytest path/to/test_file.py::test_function_name
-
-# Run block tests (tests that validate all blocks work correctly)
-poetry run pytest backend/blocks/test/test_block.py -xvs
-
-# Run tests for a specific block (e.g., GetCurrentTimeBlock)
-poetry run pytest 'backend/blocks/test/test_block.py::test_available_blocks[GetCurrentTimeBlock]' -xvs
-
-# Lint and format
-# prefer format if you want to just "fix" it and only get the errors that can't be autofixed
-poetry run format  # Black + isort
-poetry run lint    # ruff
-```
-
-More details can be found in @TESTING.md
-
-### Creating/Updating Snapshots
-
-When you first write a test or when the expected output changes:
-
-```bash
-poetry run pytest path/to/test.py --snapshot-update
-```
-
-⚠️ **Important**: Always review snapshot changes before committing! Use `git diff` to verify the changes are expected.
-
-## Architecture
-
-- **API Layer**: FastAPI with REST and WebSocket endpoints
-- **Database**: PostgreSQL with Prisma ORM, includes pgvector for embeddings
-- **Queue System**: RabbitMQ for async task processing
-- **Execution Engine**: Separate executor service processes agent workflows
-- **Authentication**: JWT-based with Supabase integration
-- **Security**: Cache protection middleware prevents sensitive data caching in browsers/proxies
-
-## Code Style
-
-- **Top-level imports only** — no local/inner imports (lazy imports only for heavy optional deps like `openpyxl`)
-- **Absolute imports** — use `from backend.module import ...` for cross-package imports. Single-dot relative (`from .sibling import ...`) is acceptable for sibling modules within the same package (e.g., blocks). Avoid double-dot relative imports (`from ..parent import ...`) — use the absolute path instead
-- **No duck typing** — no `hasattr`/`getattr`/`isinstance` for type dispatch; use typed interfaces/unions/protocols
-- **Pydantic models** over dataclass/namedtuple/dict for structured data
-- **No linter suppressors** — no `# type: ignore`, `# noqa`, `# pyright: ignore`; fix the type/code
-- **List comprehensions** over manual loop-and-append
-- **Early return** — guard clauses first, avoid deep nesting
-- **f-strings vs printf syntax in log statements** — Use `%s` for deferred interpolation in `debug` statements, f-strings elsewhere for readability: `logger.debug("Processing %s items", count)`, `logger.info(f"Processing {count} items")`
-- **Sanitize error paths** — `os.path.basename()` in error messages to avoid leaking directory structure
-- **TOCTOU awareness** — avoid check-then-act patterns for file access and credit charging
-- **`Security()` vs `Depends()`** — use `Security()` for auth deps to get proper OpenAPI security spec
-- **Redis pipelines** — `transaction=True` for atomicity on multi-step operations
-- **`max(0, value)` guards** — for computed values that should never be negative
-- **SSE protocol** — `data:` lines for frontend-parsed events (must match Zod schema), `: comment` lines for heartbeats/status
-- **File length** — keep files under ~300 lines; if a file grows beyond this, split by responsibility (e.g. extract helpers, models, or a sub-module into a new file). Never keep appending to a long file.
-- **Function length** — keep functions under ~40 lines; extract named helpers when a function grows longer. Long functions are a sign of mixed concerns, not complexity.
-- **Top-down ordering** — define the main/public function or class first, then the helpers it uses below. A reader should encounter high-level logic before implementation details.
-
-## Testing Approach
-
-- Uses pytest with snapshot testing for API responses
-- Test files are colocated with source files (`*_test.py`)
-- Mock at boundaries — mock where the symbol is **used**, not where it's **defined**
-- After refactoring, update mock targets to match new module paths
-- Use `AsyncMock` for async functions (`from unittest.mock import AsyncMock`)
-
-### Test-Driven Development (TDD)
-
-When fixing a bug or adding a feature, write the test **before** the implementation:
-
-```python
-# 1. Write a failing test marked xfail
-@pytest.mark.xfail(reason="Bug #1234: widget crashes on empty input")
-def test_widget_handles_empty_input():
-    result = widget.process("")
-    assert result == Widget.EMPTY_RESULT
-
-# 2. Run it — confirm it fails (XFAIL)
-# poetry run pytest path/to/test.py::test_widget_handles_empty_input -xvs
-
-# 3. Implement the fix
-
-# 4. Remove xfail, run again — confirm it passes
-def test_widget_handles_empty_input():
-    result = widget.process("")
-    assert result == Widget.EMPTY_RESULT
-```
-
-This catches regressions and proves the fix actually works. **Every bug fix should include a test that would have caught it.**
-
-## Database Schema
-
-Key models (defined in `schema.prisma`):
-
-- `User`: Authentication and profile data
-- `AgentGraph`: Workflow definitions with version control
-- `AgentGraphExecution`: Execution history and results
-- `AgentNode`: Individual nodes in a workflow
-- `StoreListing`: Marketplace listings for sharing agents
-
-## Environment Configuration
-
-- **Backend**: `.env.default` (defaults) → `.env` (user overrides)
-
-## Common Development Tasks
-
-### Adding a new block
-
-Follow the comprehensive [Block SDK Guide](@../../docs/platform/block-sdk-guide.md) which covers:
-
-- Provider configuration with `ProviderBuilder`
-- Block schema definition
-- Authentication (API keys, OAuth, webhooks)
-- Testing and validation
-- File organization
-
-Quick steps:
-
-1. Create new file in `backend/blocks/`
-2. Configure provider using `ProviderBuilder` in `_config.py`
-3. Inherit from `Block` base class
-4. Define input/output schemas using `BlockSchema`
-5. Implement async `run` method
-6. Generate unique block ID using `uuid.uuid4()`
-7. Test with `poetry run pytest backend/blocks/test/test_block.py`
-
-Note: when making many new blocks analyze the interfaces for each of these blocks and picture if they would go well together in a graph-based editor or would they struggle to connect productively?
-ex: do the inputs and outputs tie well together?
-
-If you get any pushback or hit complex block conditions check the new_blocks guide in the docs.
-
-#### Handling files in blocks with `store_media_file()`
-
-When blocks need to work with files (images, videos, documents), use `store_media_file()` from `backend.util.file`. The `return_format` parameter determines what you get back:
-
-| Format | Use When | Returns |
-|--------|----------|---------|
-| `"for_local_processing"` | Processing with local tools (ffmpeg, MoviePy, PIL) | Local file path (e.g., `"image.png"`) |
-| `"for_external_api"` | Sending content to external APIs (Replicate, OpenAI) | Data URI (e.g., `"data:image/png;base64,..."`) |
-| `"for_block_output"` | Returning output from your block | Smart: `workspace://` in CoPilot, data URI in graphs |
-
-**Examples:**
-
-```python
-# INPUT: Need to process file locally with ffmpeg
-local_path = await store_media_file(
-    file=input_data.video,
-    execution_context=execution_context,
-    return_format="for_local_processing",
-)
-# local_path = "video.mp4" - use with Path/ffmpeg/etc
-
-# INPUT: Need to send to external API like Replicate
-image_b64 = await store_media_file(
-    file=input_data.image,
-    execution_context=execution_context,
-    return_format="for_external_api",
-)
-# image_b64 = "data:image/png;base64,iVBORw0..." - send to API
-
-# OUTPUT: Returning result from block
-result_url = await store_media_file(
-    file=generated_image_url,
-    execution_context=execution_context,
-    return_format="for_block_output",
-)
-yield "image_url", result_url
-# In CoPilot: result_url = "workspace://abc123"
-# In graphs:  result_url = "data:image/png;base64,..."
-```
-
-**Key points:**
-
-- `for_block_output` is the ONLY format that auto-adapts to execution context
-- Always use `for_block_output` for block outputs unless you have a specific reason not to
-- Never hardcode workspace checks - let `for_block_output` handle it
-
-### Modifying the API
-
-1. Update route in `backend/api/features/`
-2. Add/update Pydantic models in same directory
-3. Write tests alongside the route file
-4. Run `poetry run test` to verify
-
-## Workspace & Media Files
-
-**Read [Workspace & Media Architecture](../../docs/platform/workspace-media-architecture.md) when:**
-- Working on CoPilot file upload/download features
-- Building blocks that handle `MediaFileType` inputs/outputs
-- Modifying `WorkspaceManager` or `store_media_file()`
-- Debugging file persistence or virus scanning issues
-
-Covers: `WorkspaceManager` (persistent storage with session scoping), `store_media_file()` (media normalization pipeline), and responsibility boundaries for virus scanning and persistence.
-
-## Security Implementation
-
-### Cache Protection Middleware
-
-- Located in `backend/api/middleware/security.py`
-- Default behavior: Disables caching for ALL endpoints with `Cache-Control: no-store, no-cache, must-revalidate, private`
-- Uses an allow list approach - only explicitly permitted paths can be cached
-- Cacheable paths include: static assets (`static/*`, `_next/static/*`), health checks, public store pages, documentation
-- Prevents sensitive data (auth tokens, API keys, user data) from being cached by browsers/proxies
-- To allow caching for a new endpoint, add it to `CACHEABLE_PATHS` in the middleware
-- Applied to both main API server and external API applications

autogpt_platform/backend/CLAUDE.md

@@ -1 +1,170 @@
-@AGENTS.md
+# CLAUDE.md - Backend
+
+This file provides guidance to Claude Code when working with the backend.
+
+## Essential Commands
+
+To run something with Python package dependencies you MUST use `poetry run ...`.
+
+```bash
+# Install dependencies
+poetry install
+
+# Run database migrations
+poetry run prisma migrate dev
+
+# Start all services (database, redis, rabbitmq, clamav)
+docker compose up -d
+
+# Run the backend as a whole
+poetry run app
+
+# Run tests
+poetry run test
+
+# Run specific test
+poetry run pytest path/to/test_file.py::test_function_name
+
+# Run block tests (tests that validate all blocks work correctly)
+poetry run pytest backend/blocks/test/test_block.py -xvs
+
+# Run tests for a specific block (e.g., GetCurrentTimeBlock)
+poetry run pytest 'backend/blocks/test/test_block.py::test_available_blocks[GetCurrentTimeBlock]' -xvs
+
+# Lint and format
+# prefer format if you want to just "fix" it and only get the errors that can't be autofixed
+poetry run format  # Black + isort
+poetry run lint    # ruff
+```
+
+More details can be found in @TESTING.md
+
+### Creating/Updating Snapshots
+
+When you first write a test or when the expected output changes:
+
+```bash
+poetry run pytest path/to/test.py --snapshot-update
+```
+
+⚠️ **Important**: Always review snapshot changes before committing! Use `git diff` to verify the changes are expected.
+
+## Architecture
+
+- **API Layer**: FastAPI with REST and WebSocket endpoints
+- **Database**: PostgreSQL with Prisma ORM, includes pgvector for embeddings
+- **Queue System**: RabbitMQ for async task processing
+- **Execution Engine**: Separate executor service processes agent workflows
+- **Authentication**: JWT-based with Supabase integration
+- **Security**: Cache protection middleware prevents sensitive data caching in browsers/proxies
+
+## Testing Approach
+
+- Uses pytest with snapshot testing for API responses
+- Test files are colocated with source files (`*_test.py`)
+
+## Database Schema
+
+Key models (defined in `schema.prisma`):
+
+- `User`: Authentication and profile data
+- `AgentGraph`: Workflow definitions with version control
+- `AgentGraphExecution`: Execution history and results
+- `AgentNode`: Individual nodes in a workflow
+- `StoreListing`: Marketplace listings for sharing agents
+
+## Environment Configuration
+
+- **Backend**: `.env.default` (defaults) → `.env` (user overrides)
+
+## Common Development Tasks
+
+### Adding a new block
+
+Follow the comprehensive [Block SDK Guide](@../../docs/content/platform/block-sdk-guide.md) which covers:
+
+- Provider configuration with `ProviderBuilder`
+- Block schema definition
+- Authentication (API keys, OAuth, webhooks)
+- Testing and validation
+- File organization
+
+Quick steps:
+
+1. Create new file in `backend/blocks/`
+2. Configure provider using `ProviderBuilder` in `_config.py`
+3. Inherit from `Block` base class
+4. Define input/output schemas using `BlockSchema`
+5. Implement async `run` method
+6. Generate unique block ID using `uuid.uuid4()`
+7. Test with `poetry run pytest backend/blocks/test/test_block.py`
+
+Note: when making many new blocks analyze the interfaces for each of these blocks and picture if they would go well together in a graph-based editor or would they struggle to connect productively?
+ex: do the inputs and outputs tie well together?
+
+If you get any pushback or hit complex block conditions check the new_blocks guide in the docs.
+
+#### Handling files in blocks with `store_media_file()`
+
+When blocks need to work with files (images, videos, documents), use `store_media_file()` from `backend.util.file`. The `return_format` parameter determines what you get back:
+
+| Format | Use When | Returns |
+|--------|----------|---------|
+| `"for_local_processing"` | Processing with local tools (ffmpeg, MoviePy, PIL) | Local file path (e.g., `"image.png"`) |
+| `"for_external_api"` | Sending content to external APIs (Replicate, OpenAI) | Data URI (e.g., `"data:image/png;base64,..."`) |
+| `"for_block_output"` | Returning output from your block | Smart: `workspace://` in CoPilot, data URI in graphs |
+
+**Examples:**
+
+```python
+# INPUT: Need to process file locally with ffmpeg
+local_path = await store_media_file(
+    file=input_data.video,
+    execution_context=execution_context,
+    return_format="for_local_processing",
+)
+# local_path = "video.mp4" - use with Path/ffmpeg/etc
+
+# INPUT: Need to send to external API like Replicate
+image_b64 = await store_media_file(
+    file=input_data.image,
+    execution_context=execution_context,
+    return_format="for_external_api",
+)
+# image_b64 = "data:image/png;base64,iVBORw0..." - send to API
+
+# OUTPUT: Returning result from block
+result_url = await store_media_file(
+    file=generated_image_url,
+    execution_context=execution_context,
+    return_format="for_block_output",
+)
+yield "image_url", result_url
+# In CoPilot: result_url = "workspace://abc123"
+# In graphs:  result_url = "data:image/png;base64,..."
+```
+
+**Key points:**
+
+- `for_block_output` is the ONLY format that auto-adapts to execution context
+- Always use `for_block_output` for block outputs unless you have a specific reason not to
+- Never hardcode workspace checks - let `for_block_output` handle it
+
+### Modifying the API
+
+1. Update route in `backend/api/features/`
+2. Add/update Pydantic models in same directory
+3. Write tests alongside the route file
+4. Run `poetry run test` to verify
+
+## Security Implementation
+
+### Cache Protection Middleware
+
+- Located in `backend/api/middleware/security.py`
+- Default behavior: Disables caching for ALL endpoints with `Cache-Control: no-store, no-cache, must-revalidate, private`
+- Uses an allow list approach - only explicitly permitted paths can be cached
+- Cacheable paths include: static assets (`static/*`, `_next/static/*`), health checks, public store pages, documentation
+- Prevents sensitive data (auth tokens, API keys, user data) from being cached by browsers/proxies
+- To allow caching for a new endpoint, add it to `CACHEABLE_PATHS` in the middleware
+- Applied to both main API server and external API applications

autogpt_platform/backend/Dockerfile

@@ -50,7 +50,7 @@ RUN poetry install --no-ansi --no-root
 # Generate Prisma client
 COPY autogpt_platform/backend/schema.prisma ./
 COPY autogpt_platform/backend/backend/data/partial_types.py ./backend/data/partial_types.py
-COPY autogpt_platform/backend/scripts/gen_prisma_types_stub.py ./scripts/
+COPY autogpt_platform/backend/gen_prisma_types_stub.py ./
 RUN poetry run prisma generate && poetry run gen-prisma-stub
 
 # =============================== DB MIGRATOR =============================== #
@@ -82,7 +82,7 @@ RUN pip3 install prisma>=0.15.0 --break-system-packages
 
 COPY autogpt_platform/backend/schema.prisma ./
 COPY autogpt_platform/backend/backend/data/partial_types.py ./backend/data/partial_types.py
-COPY autogpt_platform/backend/scripts/gen_prisma_types_stub.py ./scripts/
+COPY autogpt_platform/backend/gen_prisma_types_stub.py ./
 COPY autogpt_platform/backend/migrations ./migrations
 
 # ============================== BACKEND SERVER ============================== #
@@ -121,21 +121,19 @@ RUN ln -s ../lib/node_modules/npm/bin/npm-cli.js /usr/bin/npm \
     && ln -s ../lib/node_modules/npm/bin/npx-cli.js /usr/bin/npx
 COPY --from=builder /root/.cache/prisma-python/binaries /root/.cache/prisma-python/binaries
 
-# Install agent-browser (Copilot browser tool) using the system chromium package.
-# Chrome for Testing (the binary agent-browser downloads via `agent-browser install`)
-# has no ARM64 builds, so we use the distro-packaged chromium instead — verified to
-# work with agent-browser via Docker tests on arm64; amd64 is validated in CI.
-# Note: system chromium tracks the Debian package schedule rather than a pinned
-# Chrome for Testing release. If agent-browser requires a specific Chrome version,
-# verify compatibility against the chromium package version in the base image.
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends chromium fonts-liberation \
+# Install agent-browser (Copilot browser tool) + Chromium runtime dependencies.
+# These are the runtime libraries Chromium/Playwright needs on Debian 13 (trixie).
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libnss3 libnspr4 libatk1.0-0 libatk-bridge2.0-0 libcups2 libdrm2 \
+    libdbus-1-3 libxkbcommon0 libatspi2.0-0t64 libxcomposite1 libxdamage1 \
+    libxfixes3 libxrandr2 libgbm1 libasound2t64 libpango-1.0-0 libcairo2 \
+    libx11-6 libx11-xcb1 libxcb1 libxext6 libglib2.0-0t64 \
+    fonts-liberation libfontconfig1 \
     && rm -rf /var/lib/apt/lists/* \
     && npm install -g agent-browser \
+    && agent-browser install \
     && rm -rf /tmp/* /root/.npm
 
-ENV AGENT_BROWSER_EXECUTABLE_PATH=/usr/bin/chromium
-
 WORKDIR /app/autogpt_platform/backend
 
 # Copy only the .venv from builder (not the entire /app directory)

autogpt_platform/backend/agents/calculator-agent.json

@@ -1,166 +0,0 @@
-{
-  "id": "858e2226-e047-4d19-a832-3be4a134d155",
-  "version": 2,
-  "is_active": true,
-  "name": "Calculator agent",
-  "description": "",
-  "instructions": null,
-  "recommended_schedule_cron": null,
-  "forked_from_id": null,
-  "forked_from_version": null,
-  "user_id": "",
-  "created_at": "2026-04-13T03:45:11.241Z",
-  "nodes": [
-    {
-      "id": "6762da5d-6915-4836-a431-6dcd7d36a54a",
-      "block_id": "c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
-      "input_default": {
-        "name": "Input",
-        "secret": false,
-        "advanced": false
-      },
-      "metadata": {
-        "position": {
-          "x": -188.2244873046875,
-          "y": 95
-        }
-      },
-      "input_links": [],
-      "output_links": [
-        {
-          "id": "432c7caa-49b9-4b70-bd21-2fa33a569601",
-          "source_id": "6762da5d-6915-4836-a431-6dcd7d36a54a",
-          "sink_id": "bf4a15ff-b0c4-4032-a21b-5880224af690",
-          "source_name": "result",
-          "sink_name": "a",
-          "is_static": true
-        }
-      ],
-      "graph_id": "858e2226-e047-4d19-a832-3be4a134d155",
-      "graph_version": 2,
-      "webhook_id": null
-    },
-    {
-      "id": "65429c9e-a0c6-4032-a421-6899c394fa74",
-      "block_id": "363ae599-353e-4804-937e-b2ee3cef3da4",
-      "input_default": {
-        "name": "Output",
-        "secret": false,
-        "advanced": false,
-        "escape_html": false
-      },
-      "metadata": {
-        "position": {
-          "x": 825.198974609375,
-          "y": 123.75
-        }
-      },
-      "input_links": [
-        {
-          "id": "8cdb2f33-5b10-4cc2-8839-f8ccb70083a3",
-          "source_id": "bf4a15ff-b0c4-4032-a21b-5880224af690",
-          "sink_id": "65429c9e-a0c6-4032-a421-6899c394fa74",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "output_links": [],
-      "graph_id": "858e2226-e047-4d19-a832-3be4a134d155",
-      "graph_version": 2,
-      "webhook_id": null
-    },
-    {
-      "id": "bf4a15ff-b0c4-4032-a21b-5880224af690",
-      "block_id": "b1ab9b19-67a6-406d-abf5-2dba76d00c79",
-      "input_default": {
-        "b": 34,
-        "operation": "Add",
-        "round_result": false
-      },
-      "metadata": {
-        "position": {
-          "x": 323.0255126953125,
-          "y": 121.25
-        }
-      },
-      "input_links": [
-        {
-          "id": "432c7caa-49b9-4b70-bd21-2fa33a569601",
-          "source_id": "6762da5d-6915-4836-a431-6dcd7d36a54a",
-          "sink_id": "bf4a15ff-b0c4-4032-a21b-5880224af690",
-          "source_name": "result",
-          "sink_name": "a",
-          "is_static": true
-        }
-      ],
-      "output_links": [
-        {
-          "id": "8cdb2f33-5b10-4cc2-8839-f8ccb70083a3",
-          "source_id": "bf4a15ff-b0c4-4032-a21b-5880224af690",
-          "sink_id": "65429c9e-a0c6-4032-a421-6899c394fa74",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "858e2226-e047-4d19-a832-3be4a134d155",
-      "graph_version": 2,
-      "webhook_id": null
-    }
-  ],
-  "links": [
-    {
-      "id": "8cdb2f33-5b10-4cc2-8839-f8ccb70083a3",
-      "source_id": "bf4a15ff-b0c4-4032-a21b-5880224af690",
-      "sink_id": "65429c9e-a0c6-4032-a421-6899c394fa74",
-      "source_name": "result",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "432c7caa-49b9-4b70-bd21-2fa33a569601",
-      "source_id": "6762da5d-6915-4836-a431-6dcd7d36a54a",
-      "sink_id": "bf4a15ff-b0c4-4032-a21b-5880224af690",
-      "source_name": "result",
-      "sink_name": "a",
-      "is_static": true
-    }
-  ],
-  "sub_graphs": [],
-  "input_schema": {
-    "type": "object",
-    "properties": {
-      "Input": {
-        "advanced": false,
-        "secret": false,
-        "title": "Input"
-      }
-    },
-    "required": [
-      "Input"
-    ]
-  },
-  "output_schema": {
-    "type": "object",
-    "properties": {
-      "Output": {
-        "advanced": false,
-        "secret": false,
-        "title": "Output"
-      }
-    },
-    "required": [
-      "Output"
-    ]
-  },
-  "has_external_trigger": false,
-  "has_human_in_the_loop": false,
-  "has_sensitive_action": false,
-  "trigger_setup_info": null,
-  "credentials_input_schema": {
-    "type": "object",
-    "properties": {},
-    "required": []
-  }
-}

autogpt_platform/backend/backend/api/conn_manager.py

@@ -1,44 +1,14 @@
 import asyncio
-import json
-import logging
-import time
-from typing import Awaitable, Callable, Dict, Optional, Set
+from typing import Dict, Set
 
-from fastapi import WebSocket, WebSocketDisconnect
-from redis.asyncio import Redis as AsyncRedis
-from redis.asyncio.client import PubSub as AsyncPubSub
-from redis.exceptions import MovedError, RedisError, ResponseError
-from starlette.websockets import WebSocketState
+from fastapi import WebSocket
 
-from backend.api.model import WSMessage, WSMethod
-from backend.data import redis_client as redis
-from backend.data.event_bus import _assert_no_wildcard
+from backend.api.model import NotificationPayload, WSMessage, WSMethod
 from backend.data.execution import (
     ExecutionEventType,
-    exec_channel,
-    get_graph_execution_meta,
-    graph_all_channel,
+    GraphExecutionEvent,
+    NodeExecutionEvent,
 )
-from backend.data.notification_bus import NotificationEvent
-from backend.util.settings import Settings
-
-logger = logging.getLogger(__name__)
-_settings = Settings()
-
-
-def _is_ws_close_race(exc: BaseException, websocket: WebSocket) -> bool:
-    """A SPUBLISH→WS send racing with WS close — benign, drop quietly."""
-    if isinstance(exc, WebSocketDisconnect):
-        return True
-    if (
-        getattr(websocket, "application_state", None) == WebSocketState.DISCONNECTED
-        or getattr(websocket, "client_state", None) == WebSocketState.DISCONNECTED
-    ):
-        return True
-    if isinstance(exc, RuntimeError) and "close message has been sent" in str(exc):
-        return True
-    return False
-
 
 _EVENT_TYPE_TO_METHOD_MAP: dict[ExecutionEventType, WSMethod] = {
     ExecutionEventType.GRAPH_EXEC_UPDATE: WSMethod.GRAPH_EXECUTION_EVENT,
@@ -46,379 +16,128 @@ _EVENT_TYPE_TO_METHOD_MAP: dict[ExecutionEventType, WSMethod] = {
 }
 
 
-def event_bus_channel(channel_key: str) -> str:
-    """Prefix a channel key with the execution event bus name."""
-    return f"{_settings.config.execution_event_bus_name}/{channel_key}"
-
-
-def _notification_bus_channel(user_id: str) -> str:
-    """Return the full sharded channel name for a user's notifications."""
-    return f"{_settings.config.notification_event_bus_name}/{user_id}"
-
-
-MessageHandler = Callable[[Optional[bytes | str]], Awaitable[None]]
-
-
-def _is_moved_error(exc: BaseException) -> bool:
-    """A MOVED redirect — slot migration mid-stream; pump should reconnect."""
-    if isinstance(exc, MovedError):
-        return True
-    if isinstance(exc, ResponseError) and str(exc).startswith("MOVED "):
-        return True
-    return False
-
-
-# Reconnect tunables for shard-failover during pubsub.listen().
-_PUMP_RECONNECT_DEADLINE_S = 60.0
-_PUMP_RECONNECT_BACKOFF_INITIAL_S = 0.5
-_PUMP_RECONNECT_BACKOFF_MAX_S = 8.0
-
-
-class _Subscription:
-    """One SSUBSCRIBE lifecycle bound to a WebSocket, pinned to the owning shard."""
-
-    def __init__(self, full_channel: str) -> None:
-        _assert_no_wildcard(full_channel)
-        self.full_channel = full_channel
-        self._client: AsyncRedis | None = None
-        self._pubsub: AsyncPubSub | None = None
-        self._task: asyncio.Task | None = None
-
-    async def start(self, on_message: MessageHandler) -> None:
-        await self._open_pubsub()
-        self._task = asyncio.create_task(self._pump(on_message))
-
-    async def _open_pubsub(self) -> None:
-        """(Re)establish the sharded pubsub connection + SSUBSCRIBE."""
-        self._client = await redis.connect_sharded_pubsub_async(self.full_channel)
-        self._pubsub = self._client.pubsub()
-        await self._pubsub.execute_command("SSUBSCRIBE", self.full_channel)
-        # redis-py 6.x async PubSub.listen() exits when ``channels`` is
-        # empty; raw SSUBSCRIBE doesn't populate it, so do it ourselves.
-        self._pubsub.channels[self.full_channel] = None  # type: ignore[index]
-
-    async def _close_pubsub_quietly(self) -> None:
-        """Best-effort teardown before reconnect — never raises."""
-        if self._pubsub is not None:
-            try:
-                await self._pubsub.aclose()
-            except Exception:
-                pass
-            self._pubsub = None
-        if self._client is not None:
-            try:
-                await self._client.aclose()
-            except Exception:
-                pass
-            self._client = None
-
-    async def _pump(self, on_message: MessageHandler) -> None:
-        if self._pubsub is None:
-            return
-        backoff = _PUMP_RECONNECT_BACKOFF_INITIAL_S
-        deadline = time.monotonic() + _PUMP_RECONNECT_DEADLINE_S
-        while True:
-            pubsub = self._pubsub
-            if pubsub is None:
-                return
-            needs_reconnect = False
-            try:
-                async for message in pubsub.listen():
-                    msg_type = message.get("type")
-                    # Server-pushed sunsubscribe: slot ownership changed and
-                    # Redis revoked our SSUBSCRIBE without dropping the TCP.
-                    # Treat as a reconnect trigger so we re-resolve the shard.
-                    if msg_type == "sunsubscribe":
-                        needs_reconnect = True
-                        break
-                    if msg_type not in ("smessage", "message", "pmessage"):
-                        continue
-                    # Successful read resets the reconnect budget.
-                    backoff = _PUMP_RECONNECT_BACKOFF_INITIAL_S
-                    deadline = time.monotonic() + _PUMP_RECONNECT_DEADLINE_S
-                    try:
-                        await on_message(message.get("data"))
-                    except Exception:
-                        logger.exception(
-                            "Websocket message-handler failed for channel %s",
-                            self.full_channel,
-                        )
-                if not needs_reconnect:
-                    # listen() exited cleanly (channels emptied) — pump is done.
-                    return
-            except asyncio.CancelledError:
-                raise
-            except (ConnectionError, RedisError) as exc:
-                if isinstance(exc, ResponseError) and not _is_moved_error(exc):
-                    logger.exception(
-                        "Pubsub pump crashed on non-retryable ResponseError for %s",
-                        self.full_channel,
-                    )
-                    return
-                if time.monotonic() > deadline:
-                    logger.exception(
-                        "Pubsub pump giving up after reconnect deadline for %s",
-                        self.full_channel,
-                    )
-                    return
-                logger.warning(
-                    "Pubsub pump reconnecting for %s after %s: %s",
-                    self.full_channel,
-                    type(exc).__name__,
-                    exc,
-                )
-            except Exception:
-                logger.exception("Pubsub pump crashed for %s", self.full_channel)
-                return
-
-            # Either a retryable error was raised, or the server pushed a
-            # sunsubscribe — close the stale pubsub and reopen against the
-            # (possibly migrated) shard.
-            await self._close_pubsub_quietly()
-            await asyncio.sleep(backoff)
-            backoff = min(backoff * 2, _PUMP_RECONNECT_BACKOFF_MAX_S)
-            try:
-                await self._open_pubsub()
-            except (ConnectionError, RedisError) as reopen_exc:
-                logger.warning(
-                    "Pubsub pump reopen failed for %s: %s",
-                    self.full_channel,
-                    reopen_exc,
-                )
-                # Loop again — deadline check will eventually exit.
-                continue
-
-    async def stop(self) -> None:
-        if self._task is not None:
-            self._task.cancel()
-            try:
-                await self._task
-            except (asyncio.CancelledError, Exception):
-                pass
-            self._task = None
-        if self._pubsub is not None:
-            try:
-                await self._pubsub.execute_command("SUNSUBSCRIBE", self.full_channel)
-            except Exception:
-                logger.warning(
-                    "SUNSUBSCRIBE failed for %s", self.full_channel, exc_info=True
-                )
-            try:
-                await self._pubsub.aclose()
-            except Exception:
-                pass
-            self._pubsub = None
-        if self._client is not None:
-            try:
-                await self._client.aclose()
-            except Exception:
-                pass
-            self._client = None
-
-
 class ConnectionManager:
     def __init__(self):
         self.active_connections: Set[WebSocket] = set()
-        # channel_key → sockets subscribed (public channel keys, not raw Redis channels)
         self.subscriptions: Dict[str, Set[WebSocket]] = {}
-        # websocket → {channel_key: _Subscription}
-        self._ws_subs: Dict[WebSocket, Dict[str, _Subscription]] = {}
-        # websocket → notification subscription
-        self._ws_notifications: Dict[WebSocket, _Subscription] = {}
+        self.user_connections: Dict[str, Set[WebSocket]] = {}
 
     async def connect_socket(self, websocket: WebSocket, *, user_id: str):
         await websocket.accept()
         self.active_connections.add(websocket)
-        self._ws_subs.setdefault(websocket, {})
-        await self._start_notification_subscription(websocket, user_id=user_id)
+        if user_id not in self.user_connections:
+            self.user_connections[user_id] = set()
+        self.user_connections[user_id].add(websocket)
 
-    async def disconnect_socket(self, websocket: WebSocket, *, user_id: str):
+    def disconnect_socket(self, websocket: WebSocket, *, user_id: str):
         self.active_connections.discard(websocket)
-        # Stop SSUBSCRIBE pumps before dropping bookkeeping to avoid leaks.
-        subs = self._ws_subs.pop(websocket, {})
-        for sub in subs.values():
-            await sub.stop()
-        notif_sub = self._ws_notifications.pop(websocket, None)
-        if notif_sub is not None:
-            await notif_sub.stop()
-        for channel_key, subscribers in list(self.subscriptions.items()):
+        for subscribers in self.subscriptions.values():
             subscribers.discard(websocket)
-            if not subscribers:
-                self.subscriptions.pop(channel_key, None)
+        user_conns = self.user_connections.get(user_id)
+        if user_conns is not None:
+            user_conns.discard(websocket)
+            if not user_conns:
+                self.user_connections.pop(user_id, None)
 
     async def subscribe_graph_exec(
         self, *, user_id: str, graph_exec_id: str, websocket: WebSocket
     ) -> str:
-        # Hash-tagged channel needs graph_id; resolve once per subscribe.
-        meta = await get_graph_execution_meta(user_id, graph_exec_id)
-        if meta is None:
-            raise ValueError(
-                f"graph_exec #{graph_exec_id} not found for user #{user_id}"
-            )
-        channel_key = graph_exec_channel_key(user_id, graph_exec_id=graph_exec_id)
-        full_channel = event_bus_channel(
-            exec_channel(user_id, meta.graph_id, graph_exec_id)
+        return await self._subscribe(
+            _graph_exec_channel_key(user_id, graph_exec_id=graph_exec_id), websocket
         )
-        await self._open_subscription(websocket, channel_key, full_channel)
-        return channel_key
 
     async def subscribe_graph_execs(
         self, *, user_id: str, graph_id: str, websocket: WebSocket
     ) -> str:
-        channel_key = _graph_execs_channel_key(user_id, graph_id=graph_id)
-        full_channel = event_bus_channel(graph_all_channel(user_id, graph_id))
-        await self._open_subscription(websocket, channel_key, full_channel)
-        return channel_key
+        return await self._subscribe(
+            _graph_execs_channel_key(user_id, graph_id=graph_id), websocket
+        )
 
     async def unsubscribe_graph_exec(
         self, *, user_id: str, graph_exec_id: str, websocket: WebSocket
     ) -> str | None:
-        channel_key = graph_exec_channel_key(user_id, graph_exec_id=graph_exec_id)
-        return await self._close_subscription(websocket, channel_key)
+        return await self._unsubscribe(
+            _graph_exec_channel_key(user_id, graph_exec_id=graph_exec_id), websocket
+        )
 
     async def unsubscribe_graph_execs(
         self, *, user_id: str, graph_id: str, websocket: WebSocket
     ) -> str | None:
-        channel_key = _graph_execs_channel_key(user_id, graph_id=graph_id)
-        return await self._close_subscription(websocket, channel_key)
+        return await self._unsubscribe(
+            _graph_execs_channel_key(user_id, graph_id=graph_id), websocket
+        )
 
-    async def _open_subscription(
-        self, websocket: WebSocket, channel_key: str, full_channel: str
-    ) -> None:
-        self.subscriptions.setdefault(channel_key, set()).add(websocket)
-        per_ws = self._ws_subs.setdefault(websocket, {})
-        if channel_key in per_ws:
-            return
-        sub = _Subscription(full_channel)
+    async def send_execution_update(
+        self, exec_event: GraphExecutionEvent | NodeExecutionEvent
+    ) -> int:
+        graph_exec_id = (
+            exec_event.id
+            if isinstance(exec_event, GraphExecutionEvent)
+            else exec_event.graph_exec_id
+        )
 
-        async def on_message(data: Optional[bytes | str]) -> None:
-            await self._forward_exec_event(websocket, channel_key, data)
+        n_sent = 0
 
-        await sub.start(on_message)
-        per_ws[channel_key] = sub
-
-    async def _close_subscription(
-        self, websocket: WebSocket, channel_key: str
-    ) -> str | None:
-        subscribers = self.subscriptions.get(channel_key)
-        if subscribers is None:
-            return None
-        subscribers.discard(websocket)
-        if not subscribers:
-            self.subscriptions.pop(channel_key, None)
-        per_ws = self._ws_subs.get(websocket)
-        if per_ws and channel_key in per_ws:
-            sub = per_ws.pop(channel_key)
-            await sub.stop()
-        return channel_key
-
-    async def _forward_exec_event(
-        self,
-        websocket: WebSocket,
-        channel_key: str,
-        raw_payload: Optional[bytes | str],
-    ) -> None:
-        if raw_payload is None:
-            return
-        # Unwrap the `_EventPayloadWrapper` envelope, then re-wrap as a WS message.
-        try:
-            wrapper = (
-                raw_payload.decode()
-                if isinstance(raw_payload, (bytes, bytearray))
-                else raw_payload
+        channels: set[str] = {
+            # Send update to listeners for this graph execution
+            _graph_exec_channel_key(exec_event.user_id, graph_exec_id=graph_exec_id)
+        }
+        if isinstance(exec_event, GraphExecutionEvent):
+            # Send update to listeners for all executions of this graph
+            channels.add(
+                _graph_execs_channel_key(
+                    exec_event.user_id, graph_id=exec_event.graph_id
+                )
             )
-        except Exception:
-            logger.warning(
-                "Failed to decode pubsub payload on %s", channel_key, exc_info=True
-            )
-            return
 
-        try:
-            parsed = json.loads(wrapper)
-            event_data = parsed.get("payload")
-            if not isinstance(event_data, dict):
-                return
-            event_type = event_data.get("event_type")
-            method = _EVENT_TYPE_TO_METHOD_MAP.get(ExecutionEventType(event_type))
-            if method is None:
-                return
+        for channel in channels.intersection(self.subscriptions.keys()):
             message = WSMessage(
-                method=method,
-                channel=channel_key,
-                data=event_data,
+                method=_EVENT_TYPE_TO_METHOD_MAP[exec_event.event_type],
+                channel=channel,
+                data=exec_event.model_dump(),
             ).model_dump_json()
-            await websocket.send_text(message)
-        except Exception as e:
-            if _is_ws_close_race(e, websocket):
-                logger.debug("Dropped exec event on closed WS for %s", channel_key)
-                return
-            logger.exception("Failed to forward exec event on %s", channel_key)
+            for connection in self.subscriptions[channel]:
+                await connection.send_text(message)
+                n_sent += 1
 
-    async def _start_notification_subscription(
-        self, websocket: WebSocket, *, user_id: str
-    ) -> None:
-        full_channel = _notification_bus_channel(user_id)
-        sub = _Subscription(full_channel)
+        return n_sent
 
-        async def on_message(data: Optional[bytes | str]) -> None:
-            await self._forward_notification(websocket, user_id, data)
-
-        try:
-            await sub.start(on_message)
-        except Exception:
-            logger.exception(
-                "Failed to open notification SSUBSCRIBE for user=%s", user_id
-            )
-            return
-        self._ws_notifications[websocket] = sub
-
-    async def _forward_notification(
-        self,
-        websocket: WebSocket,
-        user_id: str,
-        raw_payload: Optional[bytes | str],
-    ) -> None:
-        if raw_payload is None:
-            return
-        try:
-            wrapper_json = (
-                raw_payload.decode()
-                if isinstance(raw_payload, (bytes, bytearray))
-                else raw_payload
-            )
-            parsed = json.loads(wrapper_json)
-            inner = parsed.get("payload") if isinstance(parsed, dict) else None
-            if not isinstance(inner, dict):
-                return
-            event = NotificationEvent.model_validate(inner)
-        except Exception:
-            logger.warning(
-                "Failed to parse notification payload for user=%s",
-                user_id,
-                exc_info=True,
-            )
-            return
-        # Defense in depth against cross-user payloads.
-        if event.user_id != user_id:
-            return
+    async def send_notification(
+        self, *, user_id: str, payload: NotificationPayload
+    ) -> int:
+        """Send a notification to all websocket connections belonging to a user."""
         message = WSMessage(
             method=WSMethod.NOTIFICATION,
-            data=event.payload.model_dump(),
+            data=payload.model_dump(),
         ).model_dump_json()
-        try:
-            await websocket.send_text(message)
-        except Exception as e:
-            if _is_ws_close_race(e, websocket):
-                logger.debug("Dropped notification on closed WS for user=%s", user_id)
-                return
-            logger.warning(
-                "Failed to deliver notification to WS for user=%s",
-                user_id,
-                exc_info=True,
-            )
+
+        connections = tuple(self.user_connections.get(user_id, set()))
+        if not connections:
+            return 0
+
+        await asyncio.gather(
+            *(connection.send_text(message) for connection in connections),
+            return_exceptions=True,
+        )
+
+        return len(connections)
+
+    async def _subscribe(self, channel_key: str, websocket: WebSocket) -> str:
+        if channel_key not in self.subscriptions:
+            self.subscriptions[channel_key] = set()
+        self.subscriptions[channel_key].add(websocket)
+        return channel_key
+
+    async def _unsubscribe(self, channel_key: str, websocket: WebSocket) -> str | None:
+        if channel_key in self.subscriptions:
+            self.subscriptions[channel_key].discard(websocket)
+            if not self.subscriptions[channel_key]:
+                del self.subscriptions[channel_key]
+            return channel_key
+        return None
 
 
-def graph_exec_channel_key(user_id: str, *, graph_exec_id: str) -> str:
+def _graph_exec_channel_key(user_id: str, *, graph_exec_id: str) -> str:
     return f"{user_id}|graph_exec#{graph_exec_id}"
 
 

autogpt_platform/backend/backend/api/conn_manager_integration_test.py

@@ -1,386 +0,0 @@
-"""ConnectionManager integration over the live 3-shard Redis cluster:
-SSUBSCRIBE → SPUBLISH → WebSocket forwarding with no Redis mocks. Skips
-when the cluster is unreachable."""
-
-import asyncio
-import json
-from datetime import datetime, timezone
-from unittest.mock import AsyncMock
-from uuid import uuid4
-
-import pytest
-from fastapi import WebSocket
-
-import backend.data.redis_client as redis_client
-from backend.api.conn_manager import (
-    ConnectionManager,
-    _graph_execs_channel_key,
-    event_bus_channel,
-    graph_exec_channel_key,
-)
-from backend.api.model import WSMethod
-from backend.data.execution import (
-    ExecutionStatus,
-    GraphExecutionEvent,
-    GraphExecutionMeta,
-    NodeExecutionEvent,
-    exec_channel,
-    graph_all_channel,
-)
-
-
-def _has_live_cluster() -> bool:
-    try:
-        c = redis_client.connect()
-    except Exception:  # noqa: BLE001 — any connect failure → skip
-        return False
-    try:
-        c.close()
-    except Exception:
-        pass
-    return True
-
-
-pytestmark = pytest.mark.skipif(
-    not _has_live_cluster(),
-    reason="local redis cluster not reachable; skip conn_manager integration",
-)
-
-
-def _meta(user_id: str, graph_id: str, graph_exec_id: str) -> GraphExecutionMeta:
-    """Build a minimal GraphExecutionMeta for ``subscribe_graph_exec`` to use."""
-    return GraphExecutionMeta(
-        id=graph_exec_id,
-        user_id=user_id,
-        graph_id=graph_id,
-        graph_version=1,
-        inputs=None,
-        credential_inputs=None,
-        nodes_input_masks=None,
-        preset_id=None,
-        status=ExecutionStatus.RUNNING,
-        started_at=datetime.now(tz=timezone.utc),
-        ended_at=None,
-        stats=GraphExecutionMeta.Stats(),
-    )
-
-
-def _node_event_payload(
-    *, user_id: str, graph_id: str, graph_exec_id: str, marker: str
-) -> bytes:
-    """Wire-format a NodeExecutionEvent the way RedisExecutionEventBus would."""
-    inner = NodeExecutionEvent(
-        user_id=user_id,
-        graph_id=graph_id,
-        graph_version=1,
-        graph_exec_id=graph_exec_id,
-        node_exec_id=f"node-exec-{marker}",
-        node_id="node-1",
-        block_id="block-1",
-        status=ExecutionStatus.COMPLETED,
-        input_data={"in": marker},
-        output_data={"out": [marker]},
-        add_time=datetime.now(tz=timezone.utc),
-        queue_time=None,
-        start_time=datetime.now(tz=timezone.utc),
-        end_time=datetime.now(tz=timezone.utc),
-    ).model_dump(mode="json")
-    return json.dumps({"payload": inner}).encode()
-
-
-def _graph_event_payload(
-    *, user_id: str, graph_id: str, graph_exec_id: str, marker: str
-) -> bytes:
-    inner = GraphExecutionEvent(
-        id=graph_exec_id,
-        user_id=user_id,
-        graph_id=graph_id,
-        graph_version=1,
-        preset_id=None,
-        status=ExecutionStatus.COMPLETED,
-        started_at=datetime.now(tz=timezone.utc),
-        ended_at=datetime.now(tz=timezone.utc),
-        stats=GraphExecutionEvent.Stats(
-            cost=0,
-            duration=1.0,
-            node_exec_time=0.5,
-            node_exec_count=1,
-        ),
-        inputs={"x": marker},
-        credential_inputs=None,
-        nodes_input_masks=None,
-        outputs={"y": [marker]},
-    ).model_dump(mode="json")
-    return json.dumps({"payload": inner}).encode()
-
-
-async def _wait_until(predicate, timeout: float = 5.0, interval: float = 0.05) -> bool:
-    """Poll ``predicate()`` until truthy or timeout — used to wait for pubsub."""
-    deadline = asyncio.get_event_loop().time() + timeout
-    while asyncio.get_event_loop().time() < deadline:
-        if predicate():
-            return True
-        await asyncio.sleep(interval)
-    return False
-
-
-@pytest.mark.asyncio
-async def test_two_clients_get_independent_ssubscribes_on_right_shards(
-    monkeypatch,
-) -> None:
-    """Two WS clients on different graph_exec_ids each receive ONLY their
-    own publish, even when the channels land on different shards."""
-    user_id = "user-conn-int-1"
-    graph_a = f"graph-a-{uuid4().hex[:8]}"
-    graph_b = f"graph-b-{uuid4().hex[:8]}"
-    exec_a = f"exec-a-{uuid4().hex[:8]}"
-    exec_b = f"exec-b-{uuid4().hex[:8]}"
-
-    # Stub Prisma lookup so tests don't need a DB.
-    async def _fake_meta(_uid, gex_id):
-        return _meta(user_id, graph_a if gex_id == exec_a else graph_b, gex_id)
-
-    monkeypatch.setattr("backend.api.conn_manager.get_graph_execution_meta", _fake_meta)
-
-    cm = ConnectionManager()
-    ws_a: AsyncMock = AsyncMock(spec=WebSocket)
-    ws_b: AsyncMock = AsyncMock(spec=WebSocket)
-    sent_a: list[str] = []
-    sent_b: list[str] = []
-    ws_a.send_text = AsyncMock(side_effect=lambda m: sent_a.append(m))
-    ws_b.send_text = AsyncMock(side_effect=lambda m: sent_b.append(m))
-
-    redis_client.get_redis.cache_clear()
-    cluster = redis_client.get_redis()
-
-    try:
-        await cm.subscribe_graph_exec(
-            user_id=user_id, graph_exec_id=exec_a, websocket=ws_a
-        )
-        await cm.subscribe_graph_exec(
-            user_id=user_id, graph_exec_id=exec_b, websocket=ws_b
-        )
-        # Let SSUBSCRIBE settle on each shard.
-        await asyncio.sleep(0.2)
-
-        # Publish to each per-exec channel.
-        chan_a = event_bus_channel(exec_channel(user_id, graph_a, exec_a))
-        chan_b = event_bus_channel(exec_channel(user_id, graph_b, exec_b))
-        cluster.spublish(
-            chan_a,
-            _node_event_payload(
-                user_id=user_id,
-                graph_id=graph_a,
-                graph_exec_id=exec_a,
-                marker="A",
-            ).decode(),
-        )
-        cluster.spublish(
-            chan_b,
-            _node_event_payload(
-                user_id=user_id,
-                graph_id=graph_b,
-                graph_exec_id=exec_b,
-                marker="B",
-            ).decode(),
-        )
-
-        delivered = await _wait_until(lambda: sent_a and sent_b, timeout=5.0)
-        assert delivered, f"timeout: sent_a={sent_a!r} sent_b={sent_b!r}"
-
-        msg_a = json.loads(sent_a[0])
-        msg_b = json.loads(sent_b[0])
-        assert msg_a["channel"] == graph_exec_channel_key(user_id, graph_exec_id=exec_a)
-        assert msg_b["channel"] == graph_exec_channel_key(user_id, graph_exec_id=exec_b)
-        assert msg_a["data"]["graph_exec_id"] == exec_a
-        assert msg_b["data"]["graph_exec_id"] == exec_b
-        # No cross-talk: each socket got exactly one message.
-        assert len(sent_a) == 1 and len(sent_b) == 1
-    finally:
-        await cm.disconnect_socket(ws_a, user_id=user_id)
-        await cm.disconnect_socket(ws_b, user_id=user_id)
-        redis_client.disconnect()
-
-
-@pytest.mark.asyncio
-async def test_aggregate_channel_receives_per_exec_publishes(monkeypatch) -> None:
-    """A subscriber on the ``graph_execs`` aggregate channel must receive the
-    GraphExecutionEvent published to the ``/all`` channel — even though
-    per-exec events go to a different channel."""
-    user_id = "user-conn-int-2"
-    graph_id = f"graph-{uuid4().hex[:8]}"
-    exec_id = f"exec-{uuid4().hex[:8]}"
-
-    async def _fake_meta(_uid, gex_id):
-        return _meta(user_id, graph_id, gex_id)
-
-    monkeypatch.setattr("backend.api.conn_manager.get_graph_execution_meta", _fake_meta)
-
-    cm = ConnectionManager()
-    ws_agg: AsyncMock = AsyncMock(spec=WebSocket)
-    ws_per: AsyncMock = AsyncMock(spec=WebSocket)
-    sent_agg: list[str] = []
-    sent_per: list[str] = []
-    ws_agg.send_text = AsyncMock(side_effect=lambda m: sent_agg.append(m))
-    ws_per.send_text = AsyncMock(side_effect=lambda m: sent_per.append(m))
-
-    redis_client.get_redis.cache_clear()
-    cluster = redis_client.get_redis()
-
-    try:
-        await cm.subscribe_graph_execs(
-            user_id=user_id, graph_id=graph_id, websocket=ws_agg
-        )
-        await cm.subscribe_graph_exec(
-            user_id=user_id, graph_exec_id=exec_id, websocket=ws_per
-        )
-        await asyncio.sleep(0.2)
-
-        # The eventbus publishes the same event to both channels — replicate.
-        chan_per = event_bus_channel(exec_channel(user_id, graph_id, exec_id))
-        chan_all = event_bus_channel(graph_all_channel(user_id, graph_id))
-        payload = _graph_event_payload(
-            user_id=user_id,
-            graph_id=graph_id,
-            graph_exec_id=exec_id,
-            marker="agg",
-        ).decode()
-        cluster.spublish(chan_per, payload)
-        cluster.spublish(chan_all, payload)
-
-        delivered = await _wait_until(lambda: sent_agg and sent_per, timeout=5.0)
-        assert delivered, f"sent_agg={sent_agg!r} sent_per={sent_per!r}"
-        agg_msg = json.loads(sent_agg[0])
-        per_msg = json.loads(sent_per[0])
-        # Aggregate subscriber's channel key is the per-graph executions key.
-        assert agg_msg["channel"] == _graph_execs_channel_key(
-            user_id, graph_id=graph_id
-        )
-        assert per_msg["channel"] == graph_exec_channel_key(
-            user_id, graph_exec_id=exec_id
-        )
-        assert agg_msg["method"] == WSMethod.GRAPH_EXECUTION_EVENT.value
-    finally:
-        await cm.disconnect_socket(ws_agg, user_id=user_id)
-        await cm.disconnect_socket(ws_per, user_id=user_id)
-        redis_client.disconnect()
-
-
-@pytest.mark.asyncio
-async def test_disconnect_unsubscribes_and_drops_future_publishes(monkeypatch) -> None:
-    """After ``disconnect_socket`` runs, a subsequent SPUBLISH must NOT reach
-    the dead websocket — exercises the SUNSUBSCRIBE + bookkeeping cleanup."""
-    user_id = "user-conn-int-3"
-    graph_id = f"graph-{uuid4().hex[:8]}"
-    exec_id = f"exec-{uuid4().hex[:8]}"
-
-    async def _fake_meta(_uid, gex_id):
-        return _meta(user_id, graph_id, gex_id)
-
-    monkeypatch.setattr("backend.api.conn_manager.get_graph_execution_meta", _fake_meta)
-
-    cm = ConnectionManager()
-    ws: AsyncMock = AsyncMock(spec=WebSocket)
-    sent: list[str] = []
-    ws.send_text = AsyncMock(side_effect=lambda m: sent.append(m))
-
-    redis_client.get_redis.cache_clear()
-    cluster = redis_client.get_redis()
-    chan = event_bus_channel(exec_channel(user_id, graph_id, exec_id))
-    payload = _node_event_payload(
-        user_id=user_id, graph_id=graph_id, graph_exec_id=exec_id, marker="live"
-    ).decode()
-
-    try:
-        await cm.subscribe_graph_exec(
-            user_id=user_id, graph_exec_id=exec_id, websocket=ws
-        )
-        await asyncio.sleep(0.15)
-
-        # First publish — must reach the socket.
-        cluster.spublish(chan, payload)
-        delivered = await _wait_until(lambda: bool(sent), timeout=5.0)
-        assert delivered
-        assert len(sent) == 1
-
-        # Disconnect → SUNSUBSCRIBE + bookkeeping cleared.
-        await cm.disconnect_socket(ws, user_id=user_id)
-        # Pump cancellation may drain in-flight messages; wait for it.
-        await asyncio.sleep(0.2)
-
-        # Channel bookkeeping must be gone.
-        assert (
-            graph_exec_channel_key(user_id, graph_exec_id=exec_id)
-            not in cm.subscriptions
-        )
-        assert ws not in cm._ws_subs
-
-        # Second publish — must NOT reach the (already-disconnected) socket.
-        cluster.spublish(
-            chan,
-            _node_event_payload(
-                user_id=user_id,
-                graph_id=graph_id,
-                graph_exec_id=exec_id,
-                marker="post-disconnect",
-            ).decode(),
-        )
-        await asyncio.sleep(0.5)
-        # Still only the one pre-disconnect message.
-        assert len(sent) == 1
-    finally:
-        redis_client.disconnect()
-
-
-@pytest.mark.asyncio
-async def test_slow_consumer_receives_all_events_without_loss(monkeypatch) -> None:
-    """Burst-publish many SPUBLISHes; assert every one reaches the subscriber
-    in order — guards against drops/reorderings in the pubsub pump."""
-    user_id = "user-conn-int-4"
-    graph_id = f"graph-{uuid4().hex[:8]}"
-    exec_id = f"exec-{uuid4().hex[:8]}"
-    n_events = 100
-
-    async def _fake_meta(_uid, gex_id):
-        return _meta(user_id, graph_id, gex_id)
-
-    monkeypatch.setattr("backend.api.conn_manager.get_graph_execution_meta", _fake_meta)
-
-    cm = ConnectionManager()
-    ws: AsyncMock = AsyncMock(spec=WebSocket)
-    sent: list[str] = []
-    ws.send_text = AsyncMock(side_effect=lambda m: sent.append(m))
-
-    redis_client.get_redis.cache_clear()
-    cluster = redis_client.get_redis()
-    chan = event_bus_channel(exec_channel(user_id, graph_id, exec_id))
-
-    try:
-        await cm.subscribe_graph_exec(
-            user_id=user_id, graph_exec_id=exec_id, websocket=ws
-        )
-        await asyncio.sleep(0.2)
-
-        # Burst-publish n_events without yielding to the pump.
-        for i in range(n_events):
-            cluster.spublish(
-                chan,
-                _node_event_payload(
-                    user_id=user_id,
-                    graph_id=graph_id,
-                    graph_exec_id=exec_id,
-                    marker=f"m{i}",
-                ).decode(),
-            )
-
-        delivered = await _wait_until(
-            lambda: len(sent) >= n_events, timeout=15.0, interval=0.1
-        )
-        assert delivered, f"only delivered {len(sent)}/{n_events}"
-
-        # Validate ordering — Redis pub/sub is FIFO per channel.
-        markers = [json.loads(m)["data"]["input_data"]["in"] for m in sent[:n_events]]
-        assert markers == [f"m{i}" for i in range(n_events)]
-    finally:
-        await cm.disconnect_socket(ws, user_id=user_id)
-        redis_client.disconnect()

autogpt_platform/backend/backend/api/external/v1/integrations.py

@@ -18,22 +18,14 @@ from pydantic import BaseModel, Field, SecretStr
 
 from backend.api.external.middleware import require_permission
 from backend.api.features.integrations.models import get_all_provider_names
-from backend.api.features.integrations.router import (
-    CredentialsMetaResponse,
-    to_meta_response,
-)
 from backend.data.auth.base import APIAuthorizationInfo
 from backend.data.model import (
     APIKeyCredentials,
     Credentials,
     CredentialsType,
     HostScopedCredentials,
+    OAuth2Credentials,
     UserPasswordCredentials,
-    is_sdk_default,
-)
-from backend.integrations.credentials_store import (
-    is_system_credential,
-    provider_matches,
 )
 from backend.integrations.creds_manager import IntegrationCredentialsManager
 from backend.integrations.oauth import CREDENTIALS_BY_PROVIDER, HANDLERS_BY_NAME
@@ -99,6 +91,18 @@ class OAuthCompleteResponse(BaseModel):
     )
 
 
+class CredentialSummary(BaseModel):
+    """Summary of a credential without sensitive data."""
+
+    id: str
+    provider: str
+    type: CredentialsType
+    title: Optional[str] = None
+    scopes: Optional[list[str]] = None
+    username: Optional[str] = None
+    host: Optional[str] = None
+
+
 class ProviderInfo(BaseModel):
     """Information about an integration provider."""
 
@@ -469,12 +473,12 @@ async def complete_oauth(
     )
 
 
-@integrations_router.get("/credentials", response_model=list[CredentialsMetaResponse])
+@integrations_router.get("/credentials", response_model=list[CredentialSummary])
 async def list_credentials(
     auth: APIAuthorizationInfo = Security(
         require_permission(APIKeyPermission.READ_INTEGRATIONS)
     ),
-) -> list[CredentialsMetaResponse]:
+) -> list[CredentialSummary]:
     """
     List all credentials for the authenticated user.
 
@@ -482,19 +486,28 @@ async def list_credentials(
     """
     credentials = await creds_manager.store.get_all_creds(auth.user_id)
     return [
-        to_meta_response(cred) for cred in credentials if not is_sdk_default(cred.id)
+        CredentialSummary(
+            id=cred.id,
+            provider=cred.provider,
+            type=cred.type,
+            title=cred.title,
+            scopes=cred.scopes if isinstance(cred, OAuth2Credentials) else None,
+            username=cred.username if isinstance(cred, OAuth2Credentials) else None,
+            host=cred.host if isinstance(cred, HostScopedCredentials) else None,
+        )
+        for cred in credentials
     ]
 
 
 @integrations_router.get(
-    "/{provider}/credentials", response_model=list[CredentialsMetaResponse]
+    "/{provider}/credentials", response_model=list[CredentialSummary]
 )
 async def list_credentials_by_provider(
     provider: Annotated[str, Path(title="The provider to list credentials for")],
     auth: APIAuthorizationInfo = Security(
         require_permission(APIKeyPermission.READ_INTEGRATIONS)
     ),
-) -> list[CredentialsMetaResponse]:
+) -> list[CredentialSummary]:
     """
     List credentials for a specific provider.
     """
@@ -502,7 +515,16 @@ async def list_credentials_by_provider(
         auth.user_id, provider
     )
     return [
-        to_meta_response(cred) for cred in credentials if not is_sdk_default(cred.id)
+        CredentialSummary(
+            id=cred.id,
+            provider=cred.provider,
+            type=cred.type,
+            title=cred.title,
+            scopes=cred.scopes if isinstance(cred, OAuth2Credentials) else None,
+            username=cred.username if isinstance(cred, OAuth2Credentials) else None,
+            host=cred.host if isinstance(cred, HostScopedCredentials) else None,
+        )
+        for cred in credentials
     ]
 
 
@@ -575,11 +597,11 @@ async def create_credential(
     # Store credentials
     try:
         await creds_manager.create(auth.user_id, credentials)
-    except Exception:
-        logger.exception("Failed to store credentials")
+    except Exception as e:
+        logger.error(f"Failed to store credentials: {e}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to store credentials",
+            detail=f"Failed to store credentials: {str(e)}",
         )
 
     logger.info(f"Created {request.type} credentials for provider {provider}")
@@ -617,23 +639,15 @@ async def delete_credential(
     use the main API's delete endpoint which handles webhook cleanup and
     token revocation.
     """
-    if is_sdk_default(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
-    if is_system_credential(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="System-managed credentials cannot be deleted",
-        )
     creds = await creds_manager.store.get_creds_by_id(auth.user_id, cred_id)
     if not creds:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
         )
-    if not provider_matches(creds.provider, provider):
+    if creds.provider != provider:
         raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Credentials do not match the specified provider",
         )
 
     await creds_manager.delete(auth.user_id, cred_id)

autogpt_platform/backend/backend/api/external/v1/routes.py

@@ -1,7 +1,7 @@
 import logging
 import urllib.parse
 from collections import defaultdict
-from typing import Annotated, Any, Optional, Sequence
+from typing import Annotated, Any, Literal, Optional, Sequence
 
 from fastapi import APIRouter, Body, HTTPException, Security
 from prisma.enums import AgentExecutionStatus, APIKeyPermission
@@ -9,10 +9,9 @@ from pydantic import BaseModel, Field
 from typing_extensions import TypedDict
 
 import backend.api.features.store.cache as store_cache
-import backend.api.features.store.db as store_db
 import backend.api.features.store.model as store_model
 import backend.blocks
-from backend.api.external.middleware import require_auth, require_permission
+from backend.api.external.middleware import require_permission
 from backend.data import execution as execution_db
 from backend.data import graph as graph_db
 from backend.data import user as user_db
@@ -231,13 +230,13 @@ async def get_graph_execution_results(
 @v1_router.get(
     path="/store/agents",
     tags=["store"],
-    dependencies=[Security(require_auth)],  # data is public; auth required as anti-DDoS
+    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
     response_model=store_model.StoreAgentsResponse,
 )
 async def get_store_agents(
     featured: bool = False,
     creator: str | None = None,
-    sorted_by: store_db.StoreAgentsSortOptions | None = None,
+    sorted_by: Literal["rating", "runs", "name", "updated_at"] | None = None,
     search_query: str | None = None,
     category: str | None = None,
     page: int = 1,
@@ -279,7 +278,7 @@ async def get_store_agents(
 @v1_router.get(
     path="/store/agents/{username}/{agent_name}",
     tags=["store"],
-    dependencies=[Security(require_auth)],  # data is public; auth required as anti-DDoS
+    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
     response_model=store_model.StoreAgentDetails,
 )
 async def get_store_agent(
@@ -307,13 +306,13 @@ async def get_store_agent(
 @v1_router.get(
     path="/store/creators",
     tags=["store"],
-    dependencies=[Security(require_auth)],  # data is public; auth required as anti-DDoS
+    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
     response_model=store_model.CreatorsResponse,
 )
 async def get_store_creators(
     featured: bool = False,
     search_query: str | None = None,
-    sorted_by: store_db.StoreCreatorsSortOptions | None = None,
+    sorted_by: Literal["agent_rating", "agent_runs", "num_agents"] | None = None,
     page: int = 1,
     page_size: int = 20,
 ) -> store_model.CreatorsResponse:
@@ -349,7 +348,7 @@ async def get_store_creators(
 @v1_router.get(
     path="/store/creators/{username}",
     tags=["store"],
-    dependencies=[Security(require_auth)],  # data is public; auth required as anti-DDoS
+    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
     response_model=store_model.CreatorDetails,
 )
 async def get_store_creator(

autogpt_platform/backend/backend/api/external/v1/tools.py

@@ -72,7 +72,7 @@ class RunAgentRequest(BaseModel):
 
 def _create_ephemeral_session(user_id: str) -> ChatSession:
     """Create an ephemeral session for stateless API requests."""
-    return ChatSession.new(user_id, dry_run=False)
+    return ChatSession.new(user_id)
 
 
 @tools_router.post(

autogpt_platform/backend/backend/api/features/admin/diagnostics_admin_routes.py

@@ -1,932 +0,0 @@
-import asyncio
-import logging
-from typing import List
-
-from autogpt_libs.auth import requires_admin_user
-from autogpt_libs.auth.models import User as AuthUser
-from fastapi import APIRouter, HTTPException, Security
-from prisma.enums import AgentExecutionStatus
-from pydantic import BaseModel
-
-from backend.api.features.admin.model import (
-    AgentDiagnosticsResponse,
-    ExecutionDiagnosticsResponse,
-)
-from backend.data.diagnostics import (
-    FailedExecutionDetail,
-    OrphanedScheduleDetail,
-    RunningExecutionDetail,
-    ScheduleDetail,
-    ScheduleHealthMetrics,
-    cleanup_all_stuck_queued_executions,
-    cleanup_orphaned_executions_bulk,
-    cleanup_orphaned_schedules_bulk,
-    get_agent_diagnostics,
-    get_all_orphaned_execution_ids,
-    get_all_schedules_details,
-    get_all_stuck_queued_execution_ids,
-    get_execution_diagnostics,
-    get_failed_executions_count,
-    get_failed_executions_details,
-    get_invalid_executions_details,
-    get_long_running_executions_details,
-    get_orphaned_executions_details,
-    get_orphaned_schedules_details,
-    get_running_executions_details,
-    get_schedule_health_metrics,
-    get_stuck_queued_executions_details,
-    stop_all_long_running_executions,
-)
-from backend.data.execution import get_graph_executions
-from backend.executor.utils import add_graph_execution, stop_graph_execution
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(
-    prefix="/admin",
-    tags=["diagnostics", "admin"],
-    dependencies=[Security(requires_admin_user)],
-)
-
-
-class RunningExecutionsListResponse(BaseModel):
-    """Response model for list of running executions"""
-
-    executions: List[RunningExecutionDetail]
-    total: int
-
-
-class FailedExecutionsListResponse(BaseModel):
-    """Response model for list of failed executions"""
-
-    executions: List[FailedExecutionDetail]
-    total: int
-
-
-class StopExecutionRequest(BaseModel):
-    """Request model for stopping a single execution"""
-
-    execution_id: str
-
-
-class StopExecutionsRequest(BaseModel):
-    """Request model for stopping multiple executions"""
-
-    execution_ids: List[str]
-
-
-class StopExecutionResponse(BaseModel):
-    """Response model for stop execution operations"""
-
-    success: bool
-    stopped_count: int = 0
-    message: str
-
-
-class RequeueExecutionResponse(BaseModel):
-    """Response model for requeue execution operations"""
-
-    success: bool
-    requeued_count: int = 0
-    message: str
-
-
-@router.get(
-    "/diagnostics/executions",
-    response_model=ExecutionDiagnosticsResponse,
-    summary="Get Execution Diagnostics",
-)
-async def get_execution_diagnostics_endpoint():
-    """
-    Get comprehensive diagnostic information about execution status.
-
-    Returns all execution metrics including:
-    - Current state (running, queued)
-    - Orphaned executions (>24h old, likely not in executor)
-    - Failure metrics (1h, 24h, rate)
-    - Long-running detection (stuck >1h, >24h)
-    - Stuck queued detection
-    - Throughput metrics (completions/hour)
-    - RabbitMQ queue depths
-    """
-    logger.info("Getting execution diagnostics")
-
-    diagnostics = await get_execution_diagnostics()
-
-    response = ExecutionDiagnosticsResponse(
-        running_executions=diagnostics.running_count,
-        queued_executions_db=diagnostics.queued_db_count,
-        queued_executions_rabbitmq=diagnostics.rabbitmq_queue_depth,
-        cancel_queue_depth=diagnostics.cancel_queue_depth,
-        orphaned_running=diagnostics.orphaned_running,
-        orphaned_queued=diagnostics.orphaned_queued,
-        failed_count_1h=diagnostics.failed_count_1h,
-        failed_count_24h=diagnostics.failed_count_24h,
-        failure_rate_24h=diagnostics.failure_rate_24h,
-        stuck_running_24h=diagnostics.stuck_running_24h,
-        stuck_running_1h=diagnostics.stuck_running_1h,
-        oldest_running_hours=diagnostics.oldest_running_hours,
-        stuck_queued_1h=diagnostics.stuck_queued_1h,
-        queued_never_started=diagnostics.queued_never_started,
-        invalid_queued_with_start=diagnostics.invalid_queued_with_start,
-        invalid_running_without_start=diagnostics.invalid_running_without_start,
-        completed_1h=diagnostics.completed_1h,
-        completed_24h=diagnostics.completed_24h,
-        throughput_per_hour=diagnostics.throughput_per_hour,
-        timestamp=diagnostics.timestamp,
-    )
-
-    logger.info(
-        f"Execution diagnostics: running={diagnostics.running_count}, "
-        f"queued_db={diagnostics.queued_db_count}, "
-        f"orphaned={diagnostics.orphaned_running + diagnostics.orphaned_queued}, "
-        f"failed_24h={diagnostics.failed_count_24h}"
-    )
-
-    return response
-
-
-@router.get(
-    "/diagnostics/agents",
-    response_model=AgentDiagnosticsResponse,
-    summary="Get Agent Diagnostics",
-)
-async def get_agent_diagnostics_endpoint():
-    """
-    Get diagnostic information about agents.
-
-    Returns:
-        - agents_with_active_executions: Number of unique agents with running/queued executions
-        - timestamp: Current timestamp
-    """
-    logger.info("Getting agent diagnostics")
-
-    diagnostics = await get_agent_diagnostics()
-
-    response = AgentDiagnosticsResponse(
-        agents_with_active_executions=diagnostics.agents_with_active_executions,
-        timestamp=diagnostics.timestamp,
-    )
-
-    logger.info(
-        f"Agent diagnostics: with_active_executions={diagnostics.agents_with_active_executions}"
-    )
-
-    return response
-
-
-@router.get(
-    "/diagnostics/executions/running",
-    response_model=RunningExecutionsListResponse,
-    summary="List Running Executions",
-)
-async def list_running_executions(
-    limit: int = 100,
-    offset: int = 0,
-):
-    """
-    Get detailed list of running and queued executions (recent, likely active).
-
-    Args:
-        limit: Maximum number of executions to return (default 100)
-        offset: Number of executions to skip (default 0)
-
-    Returns:
-        List of running executions with details
-    """
-    logger.info(f"Listing running executions (limit={limit}, offset={offset})")
-
-    executions = await get_running_executions_details(limit=limit, offset=offset)
-
-    # Get total count for pagination
-    diagnostics = await get_execution_diagnostics()
-    total = diagnostics.running_count + diagnostics.queued_db_count
-
-    return RunningExecutionsListResponse(executions=executions, total=total)
-
-
-@router.get(
-    "/diagnostics/executions/orphaned",
-    response_model=RunningExecutionsListResponse,
-    summary="List Orphaned Executions",
-)
-async def list_orphaned_executions(
-    limit: int = 100,
-    offset: int = 0,
-):
-    """
-    Get detailed list of orphaned executions (>24h old, likely not in executor).
-
-    Args:
-        limit: Maximum number of executions to return (default 100)
-        offset: Number of executions to skip (default 0)
-
-    Returns:
-        List of orphaned executions with details
-    """
-    logger.info(f"Listing orphaned executions (limit={limit}, offset={offset})")
-
-    executions = await get_orphaned_executions_details(limit=limit, offset=offset)
-
-    # Get total count for pagination
-    diagnostics = await get_execution_diagnostics()
-    total = diagnostics.orphaned_running + diagnostics.orphaned_queued
-
-    return RunningExecutionsListResponse(executions=executions, total=total)
-
-
-@router.get(
-    "/diagnostics/executions/failed",
-    response_model=FailedExecutionsListResponse,
-    summary="List Failed Executions",
-)
-async def list_failed_executions(
-    limit: int = 100,
-    offset: int = 0,
-    hours: int = 24,
-):
-    """
-    Get detailed list of failed executions.
-
-    Args:
-        limit: Maximum number of executions to return (default 100)
-        offset: Number of executions to skip (default 0)
-        hours: Number of hours to look back (default 24)
-
-    Returns:
-        List of failed executions with error details
-    """
-    logger.info(
-        f"Listing failed executions (limit={limit}, offset={offset}, hours={hours})"
-    )
-
-    executions = await get_failed_executions_details(
-        limit=limit, offset=offset, hours=hours
-    )
-
-    # Get total count for pagination
-    # Always count actual total for given hours parameter
-    total = await get_failed_executions_count(hours=hours)
-
-    return FailedExecutionsListResponse(executions=executions, total=total)
-
-
-@router.get(
-    "/diagnostics/executions/long-running",
-    response_model=RunningExecutionsListResponse,
-    summary="List Long-Running Executions",
-)
-async def list_long_running_executions(
-    limit: int = 100,
-    offset: int = 0,
-):
-    """
-    Get detailed list of long-running executions (RUNNING status >24h).
-
-    Args:
-        limit: Maximum number of executions to return (default 100)
-        offset: Number of executions to skip (default 0)
-
-    Returns:
-        List of long-running executions with details
-    """
-    logger.info(f"Listing long-running executions (limit={limit}, offset={offset})")
-
-    executions = await get_long_running_executions_details(limit=limit, offset=offset)
-
-    # Get total count for pagination
-    diagnostics = await get_execution_diagnostics()
-    total = diagnostics.stuck_running_24h
-
-    return RunningExecutionsListResponse(executions=executions, total=total)
-
-
-@router.get(
-    "/diagnostics/executions/stuck-queued",
-    response_model=RunningExecutionsListResponse,
-    summary="List Stuck Queued Executions",
-)
-async def list_stuck_queued_executions(
-    limit: int = 100,
-    offset: int = 0,
-):
-    """
-    Get detailed list of stuck queued executions (QUEUED >1h, never started).
-
-    Args:
-        limit: Maximum number of executions to return (default 100)
-        offset: Number of executions to skip (default 0)
-
-    Returns:
-        List of stuck queued executions with details
-    """
-    logger.info(f"Listing stuck queued executions (limit={limit}, offset={offset})")
-
-    executions = await get_stuck_queued_executions_details(limit=limit, offset=offset)
-
-    # Get total count for pagination
-    diagnostics = await get_execution_diagnostics()
-    total = diagnostics.stuck_queued_1h
-
-    return RunningExecutionsListResponse(executions=executions, total=total)
-
-
-@router.get(
-    "/diagnostics/executions/invalid",
-    response_model=RunningExecutionsListResponse,
-    summary="List Invalid Executions",
-)
-async def list_invalid_executions(
-    limit: int = 100,
-    offset: int = 0,
-):
-    """
-    Get detailed list of executions in invalid states (READ-ONLY).
-
-    Invalid states indicate data corruption and require manual investigation:
-    - QUEUED but has startedAt (impossible - can't start while queued)
-    - RUNNING but no startedAt (impossible - can't run without starting)
-
-    ⚠️ NO BULK ACTIONS PROVIDED - These need case-by-case investigation.
-
-    Each invalid execution likely has a different root cause (crashes, race conditions,
-    DB corruption). Investigate the execution history and logs to determine appropriate
-    action (manual cleanup, status fix, or leave as-is if system recovered).
-
-    Args:
-        limit: Maximum number of executions to return (default 100)
-        offset: Number of executions to skip (default 0)
-
-    Returns:
-        List of invalid state executions with details
-    """
-    logger.info(f"Listing invalid state executions (limit={limit}, offset={offset})")
-
-    executions = await get_invalid_executions_details(limit=limit, offset=offset)
-
-    # Get total count for pagination
-    diagnostics = await get_execution_diagnostics()
-    total = (
-        diagnostics.invalid_queued_with_start
-        + diagnostics.invalid_running_without_start
-    )
-
-    return RunningExecutionsListResponse(executions=executions, total=total)
-
-
-@router.post(
-    "/diagnostics/executions/requeue",
-    response_model=RequeueExecutionResponse,
-    summary="Requeue Stuck Execution",
-)
-async def requeue_single_execution(
-    request: StopExecutionRequest,  # Reuse same request model (has execution_id)
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Requeue a stuck QUEUED execution (admin only).
-
-    Uses add_graph_execution with existing graph_exec_id to requeue.
-
-    ⚠️ WARNING: Only use for stuck executions. This will re-execute and may cost credits.
-
-    Args:
-        request: Contains execution_id to requeue
-
-    Returns:
-        Success status and message
-    """
-    logger.info(f"Admin {user.user_id} requeueing execution {request.execution_id}")
-
-    # Get the execution (validation - must be QUEUED)
-    executions = await get_graph_executions(
-        graph_exec_id=request.execution_id,
-        statuses=[AgentExecutionStatus.QUEUED],
-    )
-
-    if not executions:
-        raise HTTPException(
-            status_code=404,
-            detail="Execution not found or not in QUEUED status",
-        )
-
-    execution = executions[0]
-
-    # Use add_graph_execution in requeue mode
-    await add_graph_execution(
-        graph_id=execution.graph_id,
-        user_id=execution.user_id,
-        graph_version=execution.graph_version,
-        graph_exec_id=request.execution_id,  # Requeue existing execution
-    )
-
-    return RequeueExecutionResponse(
-        success=True,
-        requeued_count=1,
-        message="Execution requeued successfully",
-    )
-
-
-@router.post(
-    "/diagnostics/executions/requeue-bulk",
-    response_model=RequeueExecutionResponse,
-    summary="Requeue Multiple Stuck Executions",
-)
-async def requeue_multiple_executions(
-    request: StopExecutionsRequest,  # Reuse same request model (has execution_ids)
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Requeue multiple stuck QUEUED executions (admin only).
-
-    Uses add_graph_execution with existing graph_exec_id to requeue.
-
-    ⚠️ WARNING: Only use for stuck executions. This will re-execute and may cost credits.
-
-    Args:
-        request: Contains list of execution_ids to requeue
-
-    Returns:
-        Number of executions requeued and success message
-    """
-    logger.info(
-        f"Admin {user.user_id} requeueing {len(request.execution_ids)} executions"
-    )
-
-    # Get executions by ID list (must be QUEUED)
-    executions = await get_graph_executions(
-        execution_ids=request.execution_ids,
-        statuses=[AgentExecutionStatus.QUEUED],
-    )
-
-    if not executions:
-        return RequeueExecutionResponse(
-            success=False,
-            requeued_count=0,
-            message="No QUEUED executions found to requeue",
-        )
-
-    # Requeue all executions in parallel using add_graph_execution
-    async def requeue_one(exec) -> bool:
-        try:
-            await add_graph_execution(
-                graph_id=exec.graph_id,
-                user_id=exec.user_id,
-                graph_version=exec.graph_version,
-                graph_exec_id=exec.id,  # Requeue existing
-            )
-            return True
-        except Exception as e:
-            logger.error(f"Failed to requeue {exec.id}: {e}")
-            return False
-
-    results = await asyncio.gather(
-        *[requeue_one(exec) for exec in executions], return_exceptions=False
-    )
-
-    requeued_count = sum(1 for success in results if success)
-
-    return RequeueExecutionResponse(
-        success=requeued_count > 0,
-        requeued_count=requeued_count,
-        message=f"Requeued {requeued_count} of {len(request.execution_ids)} executions",
-    )
-
-
-@router.post(
-    "/diagnostics/executions/stop",
-    response_model=StopExecutionResponse,
-    summary="Stop Single Execution",
-)
-async def stop_single_execution(
-    request: StopExecutionRequest,
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Stop a single execution (admin only).
-
-    Uses robust stop_graph_execution which cascades to children and waits for termination.
-
-    Args:
-        request: Contains execution_id to stop
-
-    Returns:
-        Success status and message
-    """
-    logger.info(f"Admin {user.user_id} stopping execution {request.execution_id}")
-
-    # Get the execution to find its owner user_id (required by stop_graph_execution)
-    executions = await get_graph_executions(
-        graph_exec_id=request.execution_id,
-    )
-
-    if not executions:
-        raise HTTPException(status_code=404, detail="Execution not found")
-
-    execution = executions[0]
-
-    # Use robust stop_graph_execution (cascades to children, waits for termination)
-    await stop_graph_execution(
-        user_id=execution.user_id,
-        graph_exec_id=request.execution_id,
-        wait_timeout=15.0,
-        cascade=True,
-    )
-
-    return StopExecutionResponse(
-        success=True,
-        stopped_count=1,
-        message="Execution stopped successfully",
-    )
-
-
-@router.post(
-    "/diagnostics/executions/stop-bulk",
-    response_model=StopExecutionResponse,
-    summary="Stop Multiple Executions",
-)
-async def stop_multiple_executions(
-    request: StopExecutionsRequest,
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Stop multiple active executions (admin only).
-
-    Uses robust stop_graph_execution which cascades to children and waits for termination.
-
-    Args:
-        request: Contains list of execution_ids to stop
-
-    Returns:
-        Number of executions stopped and success message
-    """
-
-    logger.info(
-        f"Admin {user.user_id} stopping {len(request.execution_ids)} executions"
-    )
-
-    # Get executions by ID list
-    executions = await get_graph_executions(
-        execution_ids=request.execution_ids,
-    )
-
-    if not executions:
-        return StopExecutionResponse(
-            success=False,
-            stopped_count=0,
-            message="No executions found",
-        )
-
-    # Stop all executions in parallel using robust stop_graph_execution
-    async def stop_one(exec) -> bool:
-        try:
-            await stop_graph_execution(
-                user_id=exec.user_id,
-                graph_exec_id=exec.id,
-                wait_timeout=15.0,
-                cascade=True,
-            )
-            return True
-        except Exception as e:
-            logger.error(f"Failed to stop execution {exec.id}: {e}")
-            return False
-
-    results = await asyncio.gather(
-        *[stop_one(exec) for exec in executions], return_exceptions=False
-    )
-
-    stopped_count = sum(1 for success in results if success)
-
-    return StopExecutionResponse(
-        success=stopped_count > 0,
-        stopped_count=stopped_count,
-        message=f"Stopped {stopped_count} of {len(request.execution_ids)} executions",
-    )
-
-
-@router.post(
-    "/diagnostics/executions/cleanup-orphaned",
-    response_model=StopExecutionResponse,
-    summary="Cleanup Orphaned Executions",
-)
-async def cleanup_orphaned_executions(
-    request: StopExecutionsRequest,
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Cleanup orphaned executions by directly updating DB status (admin only).
-    For executions in DB but not actually running in executor (old/stale records).
-
-    Args:
-        request: Contains list of execution_ids to cleanup
-
-    Returns:
-        Number of executions cleaned up and success message
-    """
-    logger.info(
-        f"Admin {user.user_id} cleaning up {len(request.execution_ids)} orphaned executions"
-    )
-
-    cleaned_count = await cleanup_orphaned_executions_bulk(
-        request.execution_ids, user.user_id
-    )
-
-    return StopExecutionResponse(
-        success=cleaned_count > 0,
-        stopped_count=cleaned_count,
-        message=f"Cleaned up {cleaned_count} of {len(request.execution_ids)} orphaned executions",
-    )
-
-
-# ============================================================================
-# SCHEDULE DIAGNOSTICS ENDPOINTS
-# ============================================================================
-
-
-class SchedulesListResponse(BaseModel):
-    """Response model for list of schedules"""
-
-    schedules: List[ScheduleDetail]
-    total: int
-
-
-class OrphanedSchedulesListResponse(BaseModel):
-    """Response model for list of orphaned schedules"""
-
-    schedules: List[OrphanedScheduleDetail]
-    total: int
-
-
-class ScheduleCleanupRequest(BaseModel):
-    """Request model for cleaning up schedules"""
-
-    schedule_ids: List[str]
-
-
-class ScheduleCleanupResponse(BaseModel):
-    """Response model for schedule cleanup operations"""
-
-    success: bool
-    deleted_count: int = 0
-    message: str
-
-
-@router.get(
-    "/diagnostics/schedules",
-    response_model=ScheduleHealthMetrics,
-    summary="Get Schedule Diagnostics",
-)
-async def get_schedule_diagnostics_endpoint():
-    """
-    Get comprehensive diagnostic information about schedule health.
-
-    Returns schedule metrics including:
-    - Total schedules (user vs system)
-    - Orphaned schedules by category
-    - Upcoming executions
-    """
-    logger.info("Getting schedule diagnostics")
-
-    diagnostics = await get_schedule_health_metrics()
-
-    logger.info(
-        f"Schedule diagnostics: total={diagnostics.total_schedules}, "
-        f"user={diagnostics.user_schedules}, "
-        f"orphaned={diagnostics.total_orphaned}"
-    )
-
-    return diagnostics
-
-
-@router.get(
-    "/diagnostics/schedules/all",
-    response_model=SchedulesListResponse,
-    summary="List All User Schedules",
-)
-async def list_all_schedules(
-    limit: int = 100,
-    offset: int = 0,
-):
-    """
-    Get detailed list of all user schedules (excludes system monitoring jobs).
-
-    Args:
-        limit: Maximum number of schedules to return (default 100)
-        offset: Number of schedules to skip (default 0)
-
-    Returns:
-        List of schedules with details
-    """
-    logger.info(f"Listing all schedules (limit={limit}, offset={offset})")
-
-    schedules = await get_all_schedules_details(limit=limit, offset=offset)
-
-    # Get total count
-    diagnostics = await get_schedule_health_metrics()
-    total = diagnostics.user_schedules
-
-    return SchedulesListResponse(schedules=schedules, total=total)
-
-
-@router.get(
-    "/diagnostics/schedules/orphaned",
-    response_model=OrphanedSchedulesListResponse,
-    summary="List Orphaned Schedules",
-)
-async def list_orphaned_schedules():
-    """
-    Get detailed list of orphaned schedules with orphan reasons.
-
-    Returns:
-        List of orphaned schedules categorized by orphan type
-    """
-    logger.info("Listing orphaned schedules")
-
-    schedules = await get_orphaned_schedules_details()
-
-    return OrphanedSchedulesListResponse(schedules=schedules, total=len(schedules))
-
-
-@router.post(
-    "/diagnostics/schedules/cleanup-orphaned",
-    response_model=ScheduleCleanupResponse,
-    summary="Cleanup Orphaned Schedules",
-)
-async def cleanup_orphaned_schedules(
-    request: ScheduleCleanupRequest,
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Cleanup orphaned schedules by deleting from scheduler (admin only).
-
-    Args:
-        request: Contains list of schedule_ids to delete
-
-    Returns:
-        Number of schedules deleted and success message
-    """
-    logger.info(
-        f"Admin {user.user_id} cleaning up {len(request.schedule_ids)} orphaned schedules"
-    )
-
-    deleted_count = await cleanup_orphaned_schedules_bulk(
-        request.schedule_ids, user.user_id
-    )
-
-    return ScheduleCleanupResponse(
-        success=deleted_count > 0,
-        deleted_count=deleted_count,
-        message=f"Deleted {deleted_count} of {len(request.schedule_ids)} orphaned schedules",
-    )
-
-
-@router.post(
-    "/diagnostics/executions/stop-all-long-running",
-    response_model=StopExecutionResponse,
-    summary="Stop ALL Long-Running Executions",
-)
-async def stop_all_long_running_executions_endpoint(
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Stop ALL long-running executions (RUNNING >24h) by sending cancel signals (admin only).
-    Operates on entire dataset, not limited to pagination.
-
-    Returns:
-        Number of executions stopped and success message
-    """
-    logger.info(f"Admin {user.user_id} stopping ALL long-running executions")
-
-    stopped_count = await stop_all_long_running_executions(user.user_id)
-
-    return StopExecutionResponse(
-        success=stopped_count > 0,
-        stopped_count=stopped_count,
-        message=f"Stopped {stopped_count} long-running executions",
-    )
-
-
-@router.post(
-    "/diagnostics/executions/cleanup-all-orphaned",
-    response_model=StopExecutionResponse,
-    summary="Cleanup ALL Orphaned Executions",
-)
-async def cleanup_all_orphaned_executions(
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Cleanup ALL orphaned executions (>24h old) by directly updating DB status.
-    Operates on all executions, not just paginated results.
-
-    Returns:
-        Number of executions cleaned up and success message
-    """
-    logger.info(f"Admin {user.user_id} cleaning up ALL orphaned executions")
-
-    # Fetch all orphaned execution IDs
-    execution_ids = await get_all_orphaned_execution_ids()
-
-    if not execution_ids:
-        return StopExecutionResponse(
-            success=True,
-            stopped_count=0,
-            message="No orphaned executions to cleanup",
-        )
-
-    cleaned_count = await cleanup_orphaned_executions_bulk(execution_ids, user.user_id)
-
-    return StopExecutionResponse(
-        success=cleaned_count > 0,
-        stopped_count=cleaned_count,
-        message=f"Cleaned up {cleaned_count} orphaned executions",
-    )
-
-
-@router.post(
-    "/diagnostics/executions/cleanup-all-stuck-queued",
-    response_model=StopExecutionResponse,
-    summary="Cleanup ALL Stuck Queued Executions",
-)
-async def cleanup_all_stuck_queued_executions_endpoint(
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Cleanup ALL stuck queued executions (QUEUED >1h) by updating DB status (admin only).
-    Operates on entire dataset, not limited to pagination.
-
-    Returns:
-        Number of executions cleaned up and success message
-    """
-    logger.info(f"Admin {user.user_id} cleaning up ALL stuck queued executions")
-
-    cleaned_count = await cleanup_all_stuck_queued_executions(user.user_id)
-
-    return StopExecutionResponse(
-        success=cleaned_count > 0,
-        stopped_count=cleaned_count,
-        message=f"Cleaned up {cleaned_count} stuck queued executions",
-    )
-
-
-@router.post(
-    "/diagnostics/executions/requeue-all-stuck",
-    response_model=RequeueExecutionResponse,
-    summary="Requeue ALL Stuck Queued Executions",
-)
-async def requeue_all_stuck_executions(
-    user: AuthUser = Security(requires_admin_user),
-):
-    """
-    Requeue ALL stuck queued executions (QUEUED >1h) by publishing to RabbitMQ.
-    Operates on all executions, not just paginated results.
-
-    Uses add_graph_execution with existing graph_exec_id to requeue.
-
-    ⚠️ WARNING: This will re-execute ALL stuck executions and may cost significant credits.
-
-    Returns:
-        Number of executions requeued and success message
-    """
-    logger.info(f"Admin {user.user_id} requeueing ALL stuck queued executions")
-
-    # Fetch all stuck queued execution IDs
-    execution_ids = await get_all_stuck_queued_execution_ids()
-
-    if not execution_ids:
-        return RequeueExecutionResponse(
-            success=True,
-            requeued_count=0,
-            message="No stuck queued executions to requeue",
-        )
-
-    # Get stuck executions by ID list (must be QUEUED)
-    executions = await get_graph_executions(
-        execution_ids=execution_ids,
-        statuses=[AgentExecutionStatus.QUEUED],
-    )
-
-    # Requeue all in parallel using add_graph_execution
-    async def requeue_one(exec) -> bool:
-        try:
-            await add_graph_execution(
-                graph_id=exec.graph_id,
-                user_id=exec.user_id,
-                graph_version=exec.graph_version,
-                graph_exec_id=exec.id,  # Requeue existing
-            )
-            return True
-        except Exception as e:
-            logger.error(f"Failed to requeue {exec.id}: {e}")
-            return False
-
-    results = await asyncio.gather(
-        *[requeue_one(exec) for exec in executions], return_exceptions=False
-    )
-
-    requeued_count = sum(1 for success in results if success)
-
-    return RequeueExecutionResponse(
-        success=requeued_count > 0,
-        requeued_count=requeued_count,
-        message=f"Requeued {requeued_count} stuck executions",
-    )

autogpt_platform/backend/backend/api/features/admin/diagnostics_admin_routes_test.py

@@ -1,889 +0,0 @@
-from datetime import datetime, timezone
-from unittest.mock import AsyncMock
-
-import fastapi
-import fastapi.testclient
-import pytest
-import pytest_mock
-from autogpt_libs.auth.jwt_utils import get_jwt_payload
-from prisma.enums import AgentExecutionStatus
-
-import backend.api.features.admin.diagnostics_admin_routes as diagnostics_admin_routes
-from backend.data.diagnostics import (
-    AgentDiagnosticsSummary,
-    ExecutionDiagnosticsSummary,
-    FailedExecutionDetail,
-    OrphanedScheduleDetail,
-    RunningExecutionDetail,
-    ScheduleDetail,
-    ScheduleHealthMetrics,
-)
-from backend.data.execution import GraphExecutionMeta
-
-app = fastapi.FastAPI()
-app.include_router(diagnostics_admin_routes.router)
-
-client = fastapi.testclient.TestClient(app)
-
-
-@pytest.fixture(autouse=True)
-def setup_app_admin_auth(mock_jwt_admin):
-    """Setup admin auth overrides for all tests in this module"""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
-
-
-def test_get_execution_diagnostics_success(
-    mocker: pytest_mock.MockFixture,
-):
-    """Test fetching execution diagnostics with invalid state detection"""
-    mock_diagnostics = ExecutionDiagnosticsSummary(
-        running_count=10,
-        queued_db_count=5,
-        rabbitmq_queue_depth=3,
-        cancel_queue_depth=0,
-        orphaned_running=2,
-        orphaned_queued=1,
-        failed_count_1h=5,
-        failed_count_24h=20,
-        failure_rate_24h=0.83,
-        stuck_running_24h=1,
-        stuck_running_1h=3,
-        oldest_running_hours=26.5,
-        stuck_queued_1h=2,
-        queued_never_started=1,
-        invalid_queued_with_start=1,  # New invalid state
-        invalid_running_without_start=1,  # New invalid state
-        completed_1h=50,
-        completed_24h=1200,
-        throughput_per_hour=50.0,
-        timestamp=datetime.now(timezone.utc).isoformat(),
-    )
-
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
-        return_value=mock_diagnostics,
-    )
-
-    response = client.get("/admin/diagnostics/executions")
-
-    assert response.status_code == 200
-    data = response.json()
-
-    # Verify new invalid state fields are included
-    assert data["invalid_queued_with_start"] == 1
-    assert data["invalid_running_without_start"] == 1
-    # Verify all expected fields present
-    assert "running_executions" in data
-    assert "orphaned_running" in data
-    assert "failed_count_24h" in data
-
-
-def test_list_invalid_executions(
-    mocker: pytest_mock.MockFixture,
-):
-    """Test listing executions in invalid states (read-only endpoint)"""
-    mock_invalid_executions = [
-        RunningExecutionDetail(
-            execution_id="exec-invalid-1",
-            graph_id="graph-123",
-            graph_name="Test Graph",
-            graph_version=1,
-            user_id="user-123",
-            user_email="test@example.com",
-            status="QUEUED",
-            created_at=datetime.now(timezone.utc),
-            started_at=datetime.now(
-                timezone.utc
-            ),  # QUEUED but has startedAt - INVALID!
-            queue_status=None,
-        ),
-        RunningExecutionDetail(
-            execution_id="exec-invalid-2",
-            graph_id="graph-456",
-            graph_name="Another Graph",
-            graph_version=2,
-            user_id="user-456",
-            user_email="user@example.com",
-            status="RUNNING",
-            created_at=datetime.now(timezone.utc),
-            started_at=None,  # RUNNING but no startedAt - INVALID!
-            queue_status=None,
-        ),
-    ]
-
-    mock_diagnostics = ExecutionDiagnosticsSummary(
-        running_count=10,
-        queued_db_count=5,
-        rabbitmq_queue_depth=3,
-        cancel_queue_depth=0,
-        orphaned_running=0,
-        orphaned_queued=0,
-        failed_count_1h=0,
-        failed_count_24h=0,
-        failure_rate_24h=0.0,
-        stuck_running_24h=0,
-        stuck_running_1h=0,
-        oldest_running_hours=None,
-        stuck_queued_1h=0,
-        queued_never_started=0,
-        invalid_queued_with_start=1,
-        invalid_running_without_start=1,
-        completed_1h=0,
-        completed_24h=0,
-        throughput_per_hour=0.0,
-        timestamp=datetime.now(timezone.utc).isoformat(),
-    )
-
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_invalid_executions_details",
-        return_value=mock_invalid_executions,
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
-        return_value=mock_diagnostics,
-    )
-
-    response = client.get("/admin/diagnostics/executions/invalid?limit=100&offset=0")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total"] == 2  # Sum of both invalid state types
-    assert len(data["executions"]) == 2
-    # Verify both types of invalid states are returned
-    assert data["executions"][0]["execution_id"] in [
-        "exec-invalid-1",
-        "exec-invalid-2",
-    ]
-    assert data["executions"][1]["execution_id"] in [
-        "exec-invalid-1",
-        "exec-invalid-2",
-    ]
-
-
-def test_requeue_single_execution_with_add_graph_execution(
-    mocker: pytest_mock.MockFixture,
-    admin_user_id: str,
-):
-    """Test requeueing uses add_graph_execution in requeue mode"""
-    mock_exec_meta = GraphExecutionMeta(
-        id="exec-stuck-123",
-        user_id="user-123",
-        graph_id="graph-456",
-        graph_version=1,
-        inputs=None,
-        credential_inputs=None,
-        nodes_input_masks=None,
-        preset_id=None,
-        status=AgentExecutionStatus.QUEUED,
-        started_at=datetime.now(timezone.utc),
-        ended_at=datetime.now(timezone.utc),
-        stats=None,
-    )
-
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
-        return_value=[mock_exec_meta],
-    )
-
-    mock_add_graph_execution = mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.add_graph_execution",
-        return_value=AsyncMock(),
-    )
-
-    response = client.post(
-        "/admin/diagnostics/executions/requeue",
-        json={"execution_id": "exec-stuck-123"},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["requeued_count"] == 1
-
-    # Verify it used add_graph_execution in requeue mode
-    mock_add_graph_execution.assert_called_once()
-    call_kwargs = mock_add_graph_execution.call_args.kwargs
-    assert call_kwargs["graph_exec_id"] == "exec-stuck-123"  # Requeue mode!
-    assert call_kwargs["graph_id"] == "graph-456"
-    assert call_kwargs["user_id"] == "user-123"
-
-
-def test_stop_single_execution_with_stop_graph_execution(
-    mocker: pytest_mock.MockFixture,
-    admin_user_id: str,
-):
-    """Test stopping uses robust stop_graph_execution"""
-    mock_exec_meta = GraphExecutionMeta(
-        id="exec-running-123",
-        user_id="user-789",
-        graph_id="graph-999",
-        graph_version=2,
-        inputs=None,
-        credential_inputs=None,
-        nodes_input_masks=None,
-        preset_id=None,
-        status=AgentExecutionStatus.RUNNING,
-        started_at=datetime.now(timezone.utc),
-        ended_at=datetime.now(timezone.utc),
-        stats=None,
-    )
-
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
-        return_value=[mock_exec_meta],
-    )
-
-    mock_stop_graph_execution = mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.stop_graph_execution",
-        return_value=AsyncMock(),
-    )
-
-    response = client.post(
-        "/admin/diagnostics/executions/stop",
-        json={"execution_id": "exec-running-123"},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["stopped_count"] == 1
-
-    # Verify it used stop_graph_execution with cascade
-    mock_stop_graph_execution.assert_called_once()
-    call_kwargs = mock_stop_graph_execution.call_args.kwargs
-    assert call_kwargs["graph_exec_id"] == "exec-running-123"
-    assert call_kwargs["user_id"] == "user-789"
-    assert call_kwargs["cascade"] is True  # Stops children too!
-    assert call_kwargs["wait_timeout"] == 15.0
-
-
-def test_requeue_not_queued_execution_fails(
-    mocker: pytest_mock.MockFixture,
-):
-    """Test that requeue fails if execution is not in QUEUED status"""
-    # Mock an execution that's RUNNING (not QUEUED)
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
-        return_value=[],  # No QUEUED executions found
-    )
-
-    response = client.post(
-        "/admin/diagnostics/executions/requeue",
-        json={"execution_id": "exec-running-123"},
-    )
-
-    assert response.status_code == 404
-    assert "not found or not in QUEUED status" in response.json()["detail"]
-
-
-def test_list_invalid_executions_no_bulk_actions(
-    mocker: pytest_mock.MockFixture,
-):
-    """Verify invalid executions endpoint is read-only (no bulk actions)"""
-    # This is a documentation test - the endpoint exists but should not
-    # have corresponding cleanup/stop/requeue endpoints
-
-    # These endpoints should NOT exist for invalid states:
-    invalid_bulk_endpoints = [
-        "/admin/diagnostics/executions/cleanup-invalid",
-        "/admin/diagnostics/executions/stop-invalid",
-        "/admin/diagnostics/executions/requeue-invalid",
-    ]
-
-    for endpoint in invalid_bulk_endpoints:
-        response = client.post(endpoint, json={"execution_ids": ["test"]})
-        assert response.status_code == 404, f"{endpoint} should not exist (read-only)"
-
-
-def test_execution_ids_filter_efficiency(
-    mocker: pytest_mock.MockFixture,
-):
-    """Test that bulk operations use efficient execution_ids filter"""
-    mock_exec_metas = [
-        GraphExecutionMeta(
-            id=f"exec-{i}",
-            user_id=f"user-{i}",
-            graph_id="graph-123",
-            graph_version=1,
-            inputs=None,
-            credential_inputs=None,
-            nodes_input_masks=None,
-            preset_id=None,
-            status=AgentExecutionStatus.QUEUED,
-            started_at=datetime.now(timezone.utc),
-            ended_at=datetime.now(timezone.utc),
-            stats=None,
-        )
-        for i in range(3)
-    ]
-
-    mock_get_graph_executions = mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
-        return_value=mock_exec_metas,
-    )
-
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.add_graph_execution",
-        return_value=AsyncMock(),
-    )
-
-    response = client.post(
-        "/admin/diagnostics/executions/requeue-bulk",
-        json={"execution_ids": ["exec-0", "exec-1", "exec-2"]},
-    )
-
-    assert response.status_code == 200
-
-    # Verify it used execution_ids filter (not fetching all queued)
-    mock_get_graph_executions.assert_called_once()
-    call_kwargs = mock_get_graph_executions.call_args.kwargs
-    assert "execution_ids" in call_kwargs
-    assert call_kwargs["execution_ids"] == ["exec-0", "exec-1", "exec-2"]
-    assert call_kwargs["statuses"] == [AgentExecutionStatus.QUEUED]
-
-
-# ---------------------------------------------------------------------------
-# Helper: reusable mock diagnostics summary
-# ---------------------------------------------------------------------------
-
-
-def _make_mock_diagnostics(**overrides) -> ExecutionDiagnosticsSummary:
-    defaults = dict(
-        running_count=10,
-        queued_db_count=5,
-        rabbitmq_queue_depth=3,
-        cancel_queue_depth=0,
-        orphaned_running=2,
-        orphaned_queued=1,
-        failed_count_1h=5,
-        failed_count_24h=20,
-        failure_rate_24h=0.83,
-        stuck_running_24h=3,
-        stuck_running_1h=5,
-        oldest_running_hours=26.5,
-        stuck_queued_1h=2,
-        queued_never_started=1,
-        invalid_queued_with_start=1,
-        invalid_running_without_start=1,
-        completed_1h=50,
-        completed_24h=1200,
-        throughput_per_hour=50.0,
-        timestamp=datetime.now(timezone.utc).isoformat(),
-    )
-    defaults.update(overrides)
-    return ExecutionDiagnosticsSummary(**defaults)
-
-
-_SENTINEL = object()
-
-
-def _make_mock_execution(
-    exec_id: str = "exec-1",
-    status: str = "RUNNING",
-    started_at: datetime | None | object = _SENTINEL,
-) -> RunningExecutionDetail:
-    return RunningExecutionDetail(
-        execution_id=exec_id,
-        graph_id="graph-123",
-        graph_name="Test Graph",
-        graph_version=1,
-        user_id="user-123",
-        user_email="test@example.com",
-        status=status,
-        created_at=datetime.now(timezone.utc),
-        started_at=(
-            datetime.now(timezone.utc) if started_at is _SENTINEL else started_at
-        ),
-        queue_status=None,
-    )
-
-
-def _make_mock_failed_execution(
-    exec_id: str = "exec-fail-1",
-) -> FailedExecutionDetail:
-    return FailedExecutionDetail(
-        execution_id=exec_id,
-        graph_id="graph-123",
-        graph_name="Test Graph",
-        graph_version=1,
-        user_id="user-123",
-        user_email="test@example.com",
-        status="FAILED",
-        created_at=datetime.now(timezone.utc),
-        started_at=datetime.now(timezone.utc),
-        failed_at=datetime.now(timezone.utc),
-        error_message="Something went wrong",
-    )
-
-
-def _make_mock_schedule_health(**overrides) -> ScheduleHealthMetrics:
-    defaults = dict(
-        total_schedules=15,
-        user_schedules=10,
-        system_schedules=5,
-        orphaned_deleted_graph=2,
-        orphaned_no_library_access=1,
-        orphaned_invalid_credentials=0,
-        orphaned_validation_failed=0,
-        total_orphaned=3,
-        schedules_next_hour=4,
-        schedules_next_24h=8,
-        total_runs_next_hour=12,
-        total_runs_next_24h=48,
-        timestamp=datetime.now(timezone.utc).isoformat(),
-    )
-    defaults.update(overrides)
-    return ScheduleHealthMetrics(**defaults)
-
-
-# ---------------------------------------------------------------------------
-# GET endpoints: execution list variants
-# ---------------------------------------------------------------------------
-
-
-def test_list_running_executions(mocker: pytest_mock.MockFixture):
-    mock_execs = [
-        _make_mock_execution("exec-run-1"),
-        _make_mock_execution("exec-run-2"),
-    ]
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_running_executions_details",
-        return_value=mock_execs,
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
-        return_value=_make_mock_diagnostics(),
-    )
-
-    response = client.get("/admin/diagnostics/executions/running?limit=50&offset=0")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total"] == 15  # running_count(10) + queued_db_count(5)
-    assert len(data["executions"]) == 2
-    assert data["executions"][0]["execution_id"] == "exec-run-1"
-
-
-def test_list_orphaned_executions(mocker: pytest_mock.MockFixture):
-    mock_execs = [_make_mock_execution("exec-orphan-1", status="RUNNING")]
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_orphaned_executions_details",
-        return_value=mock_execs,
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
-        return_value=_make_mock_diagnostics(),
-    )
-
-    response = client.get("/admin/diagnostics/executions/orphaned?limit=50&offset=0")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total"] == 3  # orphaned_running(2) + orphaned_queued(1)
-    assert len(data["executions"]) == 1
-
-
-def test_list_failed_executions(mocker: pytest_mock.MockFixture):
-    mock_execs = [_make_mock_failed_execution("exec-fail-1")]
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_failed_executions_details",
-        return_value=mock_execs,
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_failed_executions_count",
-        return_value=42,
-    )
-
-    response = client.get(
-        "/admin/diagnostics/executions/failed?limit=50&offset=0&hours=24"
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total"] == 42
-    assert len(data["executions"]) == 1
-    assert data["executions"][0]["error_message"] == "Something went wrong"
-
-
-def test_list_long_running_executions(mocker: pytest_mock.MockFixture):
-    mock_execs = [_make_mock_execution("exec-long-1")]
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_long_running_executions_details",
-        return_value=mock_execs,
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
-        return_value=_make_mock_diagnostics(),
-    )
-
-    response = client.get(
-        "/admin/diagnostics/executions/long-running?limit=50&offset=0"
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total"] == 3  # stuck_running_24h
-    assert len(data["executions"]) == 1
-
-
-def test_list_stuck_queued_executions(mocker: pytest_mock.MockFixture):
-    mock_execs = [
-        _make_mock_execution("exec-stuck-1", status="QUEUED", started_at=None)
-    ]
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_stuck_queued_executions_details",
-        return_value=mock_execs,
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
-        return_value=_make_mock_diagnostics(),
-    )
-
-    response = client.get(
-        "/admin/diagnostics/executions/stuck-queued?limit=50&offset=0"
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total"] == 2  # stuck_queued_1h
-    assert len(data["executions"]) == 1
-
-
-# ---------------------------------------------------------------------------
-# GET endpoints: agent + schedule diagnostics
-# ---------------------------------------------------------------------------
-
-
-def test_get_agent_diagnostics(mocker: pytest_mock.MockFixture):
-    mock_diag = AgentDiagnosticsSummary(
-        agents_with_active_executions=7,
-        timestamp=datetime.now(timezone.utc).isoformat(),
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_agent_diagnostics",
-        return_value=mock_diag,
-    )
-
-    response = client.get("/admin/diagnostics/agents")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["agents_with_active_executions"] == 7
-
-
-def test_get_schedule_diagnostics(mocker: pytest_mock.MockFixture):
-    mock_metrics = _make_mock_schedule_health()
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_schedule_health_metrics",
-        return_value=mock_metrics,
-    )
-
-    response = client.get("/admin/diagnostics/schedules")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_schedules"] == 10
-    assert data["total_orphaned"] == 3
-    assert data["total_runs_next_hour"] == 12
-
-
-def test_list_all_schedules(mocker: pytest_mock.MockFixture):
-    mock_schedules = [
-        ScheduleDetail(
-            schedule_id="sched-1",
-            schedule_name="Daily Run",
-            graph_id="graph-1",
-            graph_name="My Agent",
-            graph_version=1,
-            user_id="user-1",
-            user_email="alice@example.com",
-            cron="0 9 * * *",
-            timezone="UTC",
-            next_run_time=datetime.now(timezone.utc).isoformat(),
-        ),
-    ]
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_all_schedules_details",
-        return_value=mock_schedules,
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_schedule_health_metrics",
-        return_value=_make_mock_schedule_health(),
-    )
-
-    response = client.get("/admin/diagnostics/schedules/all?limit=50&offset=0")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total"] == 10
-    assert len(data["schedules"]) == 1
-    assert data["schedules"][0]["schedule_name"] == "Daily Run"
-
-
-def test_list_orphaned_schedules(mocker: pytest_mock.MockFixture):
-    mock_orphans = [
-        OrphanedScheduleDetail(
-            schedule_id="sched-orphan-1",
-            schedule_name="Ghost Schedule",
-            graph_id="graph-deleted",
-            graph_version=1,
-            user_id="user-1",
-            orphan_reason="deleted_graph",
-            error_detail=None,
-            next_run_time=datetime.now(timezone.utc).isoformat(),
-        ),
-    ]
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_orphaned_schedules_details",
-        return_value=mock_orphans,
-    )
-
-    response = client.get("/admin/diagnostics/schedules/orphaned")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total"] == 1
-    assert data["schedules"][0]["orphan_reason"] == "deleted_graph"
-
-
-# ---------------------------------------------------------------------------
-# POST endpoints: bulk stop, cleanup, requeue
-# ---------------------------------------------------------------------------
-
-
-def test_stop_multiple_executions(mocker: pytest_mock.MockFixture):
-    mock_exec_metas = [
-        GraphExecutionMeta(
-            id=f"exec-{i}",
-            user_id=f"user-{i}",
-            graph_id="graph-123",
-            graph_version=1,
-            inputs=None,
-            credential_inputs=None,
-            nodes_input_masks=None,
-            preset_id=None,
-            status=AgentExecutionStatus.RUNNING,
-            started_at=datetime.now(timezone.utc),
-            ended_at=None,
-            stats=None,
-        )
-        for i in range(2)
-    ]
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
-        return_value=mock_exec_metas,
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.stop_graph_execution",
-        return_value=AsyncMock(),
-    )
-
-    response = client.post(
-        "/admin/diagnostics/executions/stop-bulk",
-        json={"execution_ids": ["exec-0", "exec-1"]},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["stopped_count"] == 2
-
-
-def test_stop_multiple_executions_none_found(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
-        return_value=[],
-    )
-
-    response = client.post(
-        "/admin/diagnostics/executions/stop-bulk",
-        json={"execution_ids": ["nonexistent"]},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is False
-    assert data["stopped_count"] == 0
-
-
-def test_cleanup_orphaned_executions(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.cleanup_orphaned_executions_bulk",
-        return_value=3,
-    )
-
-    response = client.post(
-        "/admin/diagnostics/executions/cleanup-orphaned",
-        json={"execution_ids": ["exec-1", "exec-2", "exec-3"]},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["stopped_count"] == 3
-
-
-def test_cleanup_orphaned_schedules(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.cleanup_orphaned_schedules_bulk",
-        return_value=2,
-    )
-
-    response = client.post(
-        "/admin/diagnostics/schedules/cleanup-orphaned",
-        json={"schedule_ids": ["sched-1", "sched-2"]},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["deleted_count"] == 2
-
-
-def test_stop_all_long_running_executions(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.stop_all_long_running_executions",
-        return_value=5,
-    )
-
-    response = client.post("/admin/diagnostics/executions/stop-all-long-running")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["stopped_count"] == 5
-
-
-def test_cleanup_all_orphaned_executions(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_all_orphaned_execution_ids",
-        return_value=["exec-1", "exec-2"],
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.cleanup_orphaned_executions_bulk",
-        return_value=2,
-    )
-
-    response = client.post("/admin/diagnostics/executions/cleanup-all-orphaned")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["stopped_count"] == 2
-
-
-def test_cleanup_all_orphaned_executions_none(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_all_orphaned_execution_ids",
-        return_value=[],
-    )
-
-    response = client.post("/admin/diagnostics/executions/cleanup-all-orphaned")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["stopped_count"] == 0
-    assert "No orphaned" in data["message"]
-
-
-def test_cleanup_all_stuck_queued_executions(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.cleanup_all_stuck_queued_executions",
-        return_value=4,
-    )
-
-    response = client.post("/admin/diagnostics/executions/cleanup-all-stuck-queued")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["stopped_count"] == 4
-
-
-def test_requeue_all_stuck_executions(mocker: pytest_mock.MockFixture):
-    mock_exec_metas = [
-        GraphExecutionMeta(
-            id=f"exec-stuck-{i}",
-            user_id=f"user-{i}",
-            graph_id="graph-123",
-            graph_version=1,
-            inputs=None,
-            credential_inputs=None,
-            nodes_input_masks=None,
-            preset_id=None,
-            status=AgentExecutionStatus.QUEUED,
-            started_at=None,
-            ended_at=None,
-            stats=None,
-        )
-        for i in range(3)
-    ]
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_all_stuck_queued_execution_ids",
-        return_value=["exec-stuck-0", "exec-stuck-1", "exec-stuck-2"],
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
-        return_value=mock_exec_metas,
-    )
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.add_graph_execution",
-        return_value=AsyncMock(),
-    )
-
-    response = client.post("/admin/diagnostics/executions/requeue-all-stuck")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["requeued_count"] == 3
-
-
-def test_requeue_all_stuck_executions_none(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_all_stuck_queued_execution_ids",
-        return_value=[],
-    )
-
-    response = client.post("/admin/diagnostics/executions/requeue-all-stuck")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["requeued_count"] == 0
-    assert "No stuck" in data["message"]
-
-
-def test_requeue_bulk_none_found(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
-        return_value=[],
-    )
-
-    response = client.post(
-        "/admin/diagnostics/executions/requeue-bulk",
-        json={"execution_ids": ["nonexistent"]},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is False
-    assert data["requeued_count"] == 0
-
-
-def test_stop_single_execution_not_found(mocker: pytest_mock.MockFixture):
-    mocker.patch(
-        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
-        return_value=[],
-    )
-
-    response = client.post(
-        "/admin/diagnostics/executions/stop",
-        json={"execution_id": "nonexistent"},
-    )
-
-    assert response.status_code == 404
-    assert "not found" in response.json()["detail"]

autogpt_platform/backend/backend/api/features/admin/model.py

@@ -14,70 +14,3 @@ class UserHistoryResponse(BaseModel):
 class AddUserCreditsResponse(BaseModel):
     new_balance: int
     transaction_key: str
-
-
-class ExecutionDiagnosticsResponse(BaseModel):
-    """Response model for execution diagnostics"""
-
-    # Current execution state
-    running_executions: int
-    queued_executions_db: int
-    queued_executions_rabbitmq: int
-    cancel_queue_depth: int
-
-    # Orphaned execution detection
-    orphaned_running: int
-    orphaned_queued: int
-
-    # Failure metrics
-    failed_count_1h: int
-    failed_count_24h: int
-    failure_rate_24h: float
-
-    # Long-running detection
-    stuck_running_24h: int
-    stuck_running_1h: int
-    oldest_running_hours: float | None
-
-    # Stuck queued detection
-    stuck_queued_1h: int
-    queued_never_started: int
-
-    # Invalid state detection (data corruption - no auto-actions)
-    invalid_queued_with_start: int
-    invalid_running_without_start: int
-
-    # Throughput metrics
-    completed_1h: int
-    completed_24h: int
-    throughput_per_hour: float
-
-    timestamp: str
-
-
-class AgentDiagnosticsResponse(BaseModel):
-    """Response model for agent diagnostics"""
-
-    agents_with_active_executions: int
-    timestamp: str
-
-
-class ScheduleHealthMetrics(BaseModel):
-    """Response model for schedule diagnostics"""
-
-    total_schedules: int
-    user_schedules: int
-    system_schedules: int
-
-    # Orphan detection
-    orphaned_deleted_graph: int
-    orphaned_no_library_access: int
-    orphaned_invalid_credentials: int
-    orphaned_validation_failed: int
-    total_orphaned: int
-
-    # Upcoming
-    schedules_next_hour: int
-    schedules_next_24h: int
-
-    timestamp: str

autogpt_platform/backend/backend/api/features/admin/platform_cost_routes.py

@@ -1,141 +0,0 @@
-import logging
-from datetime import datetime
-
-from autogpt_libs.auth import get_user_id, requires_admin_user
-from fastapi import APIRouter, Query, Security
-from pydantic import BaseModel
-
-from backend.data.platform_cost import (
-    CostLogRow,
-    PlatformCostDashboard,
-    get_platform_cost_dashboard,
-    get_platform_cost_logs,
-    get_platform_cost_logs_for_export,
-)
-from backend.util.models import Pagination
-
-logger = logging.getLogger(__name__)
-
-
-router = APIRouter(
-    prefix="/platform-costs",
-    tags=["platform-cost", "admin"],
-    dependencies=[Security(requires_admin_user)],
-)
-
-
-class PlatformCostLogsResponse(BaseModel):
-    logs: list[CostLogRow]
-    pagination: Pagination
-
-
-@router.get(
-    "/dashboard",
-    response_model=PlatformCostDashboard,
-    summary="Get Platform Cost Dashboard",
-)
-async def get_cost_dashboard(
-    admin_user_id: str = Security(get_user_id),
-    start: datetime | None = Query(None),
-    end: datetime | None = Query(None),
-    provider: str | None = Query(None),
-    user_id: str | None = Query(None),
-    model: str | None = Query(None),
-    block_name: str | None = Query(None),
-    tracking_type: str | None = Query(None),
-    graph_exec_id: str | None = Query(None),
-):
-    logger.info("Admin %s fetching platform cost dashboard", admin_user_id)
-    return await get_platform_cost_dashboard(
-        start=start,
-        end=end,
-        provider=provider,
-        user_id=user_id,
-        model=model,
-        block_name=block_name,
-        tracking_type=tracking_type,
-        graph_exec_id=graph_exec_id,
-    )
-
-
-@router.get(
-    "/logs",
-    response_model=PlatformCostLogsResponse,
-    summary="Get Platform Cost Logs",
-)
-async def get_cost_logs(
-    admin_user_id: str = Security(get_user_id),
-    start: datetime | None = Query(None),
-    end: datetime | None = Query(None),
-    provider: str | None = Query(None),
-    user_id: str | None = Query(None),
-    page: int = Query(1, ge=1),
-    page_size: int = Query(50, ge=1, le=200),
-    model: str | None = Query(None),
-    block_name: str | None = Query(None),
-    tracking_type: str | None = Query(None),
-    graph_exec_id: str | None = Query(None),
-):
-    logger.info("Admin %s fetching platform cost logs", admin_user_id)
-    logs, total = await get_platform_cost_logs(
-        start=start,
-        end=end,
-        provider=provider,
-        user_id=user_id,
-        page=page,
-        page_size=page_size,
-        model=model,
-        block_name=block_name,
-        tracking_type=tracking_type,
-        graph_exec_id=graph_exec_id,
-    )
-    total_pages = (total + page_size - 1) // page_size
-    return PlatformCostLogsResponse(
-        logs=logs,
-        pagination=Pagination(
-            total_items=total,
-            total_pages=total_pages,
-            current_page=page,
-            page_size=page_size,
-        ),
-    )
-
-
-class PlatformCostExportResponse(BaseModel):
-    logs: list[CostLogRow]
-    total_rows: int
-    truncated: bool
-
-
-@router.get(
-    "/logs/export",
-    response_model=PlatformCostExportResponse,
-    summary="Export Platform Cost Logs",
-)
-async def export_cost_logs(
-    admin_user_id: str = Security(get_user_id),
-    start: datetime | None = Query(None),
-    end: datetime | None = Query(None),
-    provider: str | None = Query(None),
-    user_id: str | None = Query(None),
-    model: str | None = Query(None),
-    block_name: str | None = Query(None),
-    tracking_type: str | None = Query(None),
-    graph_exec_id: str | None = Query(None),
-):
-    logger.info("Admin %s exporting platform cost logs", admin_user_id)
-    logs, truncated = await get_platform_cost_logs_for_export(
-        start=start,
-        end=end,
-        provider=provider,
-        user_id=user_id,
-        model=model,
-        block_name=block_name,
-        tracking_type=tracking_type,
-        graph_exec_id=graph_exec_id,
-    )
-    return PlatformCostExportResponse(
-        logs=logs,
-        total_rows=len(logs),
-        truncated=truncated,
-    )

autogpt_platform/backend/backend/api/features/admin/platform_cost_routes_test.py

@@ -1,291 +0,0 @@
-from datetime import datetime, timezone
-from unittest.mock import AsyncMock
-
-import fastapi
-import fastapi.testclient
-import pytest
-import pytest_mock
-from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-from backend.data.platform_cost import CostLogRow, PlatformCostDashboard
-
-from .platform_cost_routes import router as platform_cost_router
-
-app = fastapi.FastAPI()
-app.include_router(platform_cost_router)
-
-client = fastapi.testclient.TestClient(app)
-
-
-@pytest.fixture(autouse=True)
-def setup_app_admin_auth(mock_jwt_admin):
-    """Setup admin auth overrides for all tests in this module"""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
-
-
-def test_get_dashboard_success(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    real_dashboard = PlatformCostDashboard(
-        by_provider=[],
-        by_user=[],
-        total_cost_microdollars=0,
-        total_requests=0,
-        total_users=0,
-    )
-    mocker.patch(
-        "backend.api.features.admin.platform_cost_routes.get_platform_cost_dashboard",
-        AsyncMock(return_value=real_dashboard),
-    )
-
-    response = client.get("/platform-costs/dashboard")
-    assert response.status_code == 200
-    data = response.json()
-    assert "by_provider" in data
-    assert "by_user" in data
-    assert data["total_cost_microdollars"] == 0
-
-
-def test_get_logs_success(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    mocker.patch(
-        "backend.api.features.admin.platform_cost_routes.get_platform_cost_logs",
-        AsyncMock(return_value=([], 0)),
-    )
-
-    response = client.get("/platform-costs/logs")
-    assert response.status_code == 200
-    data = response.json()
-    assert data["logs"] == []
-    assert data["pagination"]["total_items"] == 0
-
-
-def test_get_dashboard_with_filters(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    real_dashboard = PlatformCostDashboard(
-        by_provider=[],
-        by_user=[],
-        total_cost_microdollars=0,
-        total_requests=0,
-        total_users=0,
-    )
-    mock_dashboard = AsyncMock(return_value=real_dashboard)
-    mocker.patch(
-        "backend.api.features.admin.platform_cost_routes.get_platform_cost_dashboard",
-        mock_dashboard,
-    )
-
-    response = client.get(
-        "/platform-costs/dashboard",
-        params={
-            "start": "2026-01-01T00:00:00",
-            "end": "2026-04-01T00:00:00",
-            "provider": "openai",
-            "user_id": "test-user-123",
-        },
-    )
-    assert response.status_code == 200
-    mock_dashboard.assert_called_once()
-    call_kwargs = mock_dashboard.call_args.kwargs
-    assert call_kwargs["provider"] == "openai"
-    assert call_kwargs["user_id"] == "test-user-123"
-    assert call_kwargs["start"] is not None
-    assert call_kwargs["end"] is not None
-
-
-def test_get_logs_with_pagination(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    mocker.patch(
-        "backend.api.features.admin.platform_cost_routes.get_platform_cost_logs",
-        AsyncMock(return_value=([], 0)),
-    )
-
-    response = client.get(
-        "/platform-costs/logs",
-        params={"page": 2, "page_size": 25, "provider": "anthropic"},
-    )
-    assert response.status_code == 200
-    data = response.json()
-    assert data["pagination"]["current_page"] == 2
-    assert data["pagination"]["page_size"] == 25
-
-
-def test_get_dashboard_requires_admin() -> None:
-    import fastapi
-    from fastapi import HTTPException
-
-    def reject_jwt(request: fastapi.Request):
-        raise HTTPException(status_code=401, detail="Not authenticated")
-
-    app.dependency_overrides[get_jwt_payload] = reject_jwt
-    try:
-        response = client.get("/platform-costs/dashboard")
-        assert response.status_code == 401
-        response = client.get("/platform-costs/logs")
-        assert response.status_code == 401
-    finally:
-        app.dependency_overrides.clear()
-
-
-def test_get_dashboard_rejects_non_admin(mock_jwt_user, mock_jwt_admin) -> None:
-    """Non-admin JWT must be rejected with 403 by requires_admin_user."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    try:
-        response = client.get("/platform-costs/dashboard")
-        assert response.status_code == 403
-        response = client.get("/platform-costs/logs")
-        assert response.status_code == 403
-    finally:
-        app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
-
-
-def test_get_logs_invalid_page_size_too_large() -> None:
-    """page_size > 200 must be rejected with 422."""
-    response = client.get("/platform-costs/logs", params={"page_size": 201})
-    assert response.status_code == 422
-
-
-def test_get_logs_invalid_page_size_zero() -> None:
-    """page_size = 0 (below ge=1) must be rejected with 422."""
-    response = client.get("/platform-costs/logs", params={"page_size": 0})
-    assert response.status_code == 422
-
-
-def test_get_logs_invalid_page_negative() -> None:
-    """page < 1 must be rejected with 422."""
-    response = client.get("/platform-costs/logs", params={"page": 0})
-    assert response.status_code == 422
-
-
-def test_get_dashboard_invalid_date_format() -> None:
-    """Malformed start date must be rejected with 422."""
-    response = client.get("/platform-costs/dashboard", params={"start": "not-a-date"})
-    assert response.status_code == 422
-
-
-def test_get_dashboard_repeated_requests(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    """Repeated requests to the dashboard route both return 200."""
-    real_dashboard = PlatformCostDashboard(
-        by_provider=[],
-        by_user=[],
-        total_cost_microdollars=42,
-        total_requests=1,
-        total_users=1,
-    )
-    mocker.patch(
-        "backend.api.features.admin.platform_cost_routes.get_platform_cost_dashboard",
-        AsyncMock(return_value=real_dashboard),
-    )
-
-    r1 = client.get("/platform-costs/dashboard")
-    r2 = client.get("/platform-costs/dashboard")
-
-    assert r1.status_code == 200
-    assert r2.status_code == 200
-    assert r1.json()["total_cost_microdollars"] == 42
-    assert r2.json()["total_cost_microdollars"] == 42
-
-
-def _make_cost_log_row() -> CostLogRow:
-    return CostLogRow(
-        id="log-1",
-        created_at=datetime(2026, 1, 1, tzinfo=timezone.utc),
-        user_id="user-1",
-        email="u***@example.com",
-        graph_exec_id="graph-1",
-        node_exec_id="node-1",
-        block_name="LlmCallBlock",
-        provider="anthropic",
-        tracking_type="token",
-        cost_microdollars=500,
-        input_tokens=100,
-        output_tokens=50,
-        cache_read_tokens=10,
-        cache_creation_tokens=5,
-        duration=1.5,
-        model="claude-3-5-sonnet-20241022",
-    )
-
-
-def test_export_logs_success(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    row = _make_cost_log_row()
-    mocker.patch(
-        "backend.api.features.admin.platform_cost_routes.get_platform_cost_logs_for_export",
-        AsyncMock(return_value=([row], False)),
-    )
-
-    response = client.get("/platform-costs/logs/export")
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total_rows"] == 1
-    assert data["truncated"] is False
-    assert len(data["logs"]) == 1
-    assert data["logs"][0]["cache_read_tokens"] == 10
-    assert data["logs"][0]["cache_creation_tokens"] == 5
-
-
-def test_export_logs_truncated(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    rows = [_make_cost_log_row() for _ in range(3)]
-    mocker.patch(
-        "backend.api.features.admin.platform_cost_routes.get_platform_cost_logs_for_export",
-        AsyncMock(return_value=(rows, True)),
-    )
-
-    response = client.get("/platform-costs/logs/export")
-    assert response.status_code == 200
-    data = response.json()
-    assert data["total_rows"] == 3
-    assert data["truncated"] is True
-
-
-def test_export_logs_with_filters(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    mock_export = AsyncMock(return_value=([], False))
-    mocker.patch(
-        "backend.api.features.admin.platform_cost_routes.get_platform_cost_logs_for_export",
-        mock_export,
-    )
-
-    response = client.get(
-        "/platform-costs/logs/export",
-        params={
-            "provider": "anthropic",
-            "model": "claude-3-5-sonnet-20241022",
-            "block_name": "LlmCallBlock",
-            "tracking_type": "token",
-        },
-    )
-    assert response.status_code == 200
-    mock_export.assert_called_once()
-    call_kwargs = mock_export.call_args.kwargs
-    assert call_kwargs["provider"] == "anthropic"
-    assert call_kwargs["model"] == "claude-3-5-sonnet-20241022"
-    assert call_kwargs["block_name"] == "LlmCallBlock"
-    assert call_kwargs["tracking_type"] == "token"
-
-
-def test_export_logs_requires_admin() -> None:
-    import fastapi
-    from fastapi import HTTPException
-
-    def reject_jwt(request: fastapi.Request):
-        raise HTTPException(status_code=401, detail="Not authenticated")
-
-    app.dependency_overrides[get_jwt_payload] = reject_jwt
-    try:
-        response = client.get("/platform-costs/logs/export")
-        assert response.status_code == 401
-    finally:
-        app.dependency_overrides.clear()

autogpt_platform/backend/backend/api/features/admin/rate_limit_admin_routes.py

@@ -1,263 +0,0 @@
-"""Admin endpoints for checking and resetting user CoPilot rate limit usage."""
-
-import logging
-from typing import Optional
-
-from autogpt_libs.auth import get_user_id, requires_admin_user
-from fastapi import APIRouter, Body, HTTPException, Security
-from pydantic import BaseModel
-
-from backend.copilot.config import ChatConfig
-from backend.copilot.rate_limit import (
-    SubscriptionTier,
-    get_global_rate_limits,
-    get_usage_status,
-    get_user_tier,
-    reset_user_usage,
-    set_user_tier,
-)
-from backend.data.user import get_user_by_email, get_user_email_by_id, search_users
-
-logger = logging.getLogger(__name__)
-
-config = ChatConfig()
-
-router = APIRouter(
-    prefix="/admin",
-    tags=["copilot", "admin"],
-    dependencies=[Security(requires_admin_user)],
-)
-
-
-class UserRateLimitResponse(BaseModel):
-    user_id: str
-    user_email: Optional[str] = None
-    daily_cost_limit_microdollars: int
-    weekly_cost_limit_microdollars: int
-    daily_cost_used_microdollars: int
-    weekly_cost_used_microdollars: int
-    tier: SubscriptionTier
-
-
-class UserTierResponse(BaseModel):
-    user_id: str
-    tier: SubscriptionTier
-
-
-class SetUserTierRequest(BaseModel):
-    user_id: str
-    tier: SubscriptionTier
-
-
-async def _resolve_user_id(
-    user_id: Optional[str], email: Optional[str]
-) -> tuple[str, Optional[str]]:
-    """Resolve a user_id and email from the provided parameters.
-
-    Returns (user_id, email). Accepts either user_id or email; at least one
-    must be provided.  When both are provided, ``email`` takes precedence.
-    """
-    if email:
-        user = await get_user_by_email(email)
-        if not user:
-            raise HTTPException(
-                status_code=404, detail="No user found with the provided email."
-            )
-        return user.id, email
-
-    if not user_id:
-        raise HTTPException(
-            status_code=400,
-            detail="Either user_id or email query parameter is required.",
-        )
-
-    # We have a user_id; try to look up their email for display purposes.
-    # This is non-critical -- a failure should not block the response.
-    try:
-        resolved_email = await get_user_email_by_id(user_id)
-    except Exception:
-        logger.warning("Failed to resolve email for user %s", user_id, exc_info=True)
-        resolved_email = None
-    return user_id, resolved_email
-
-
-@router.get(
-    "/rate_limit",
-    response_model=UserRateLimitResponse,
-    summary="Get User Rate Limit",
-)
-async def get_user_rate_limit(
-    user_id: Optional[str] = None,
-    email: Optional[str] = None,
-    admin_user_id: str = Security(get_user_id),
-) -> UserRateLimitResponse:
-    """Get a user's current usage and effective rate limits. Admin-only.
-
-    Accepts either ``user_id`` or ``email`` as a query parameter.
-    When ``email`` is provided the user is looked up by email first.
-    """
-    resolved_id, resolved_email = await _resolve_user_id(user_id, email)
-
-    logger.info("Admin %s checking rate limit for user %s", admin_user_id, resolved_id)
-
-    daily_limit, weekly_limit, tier = await get_global_rate_limits(
-        resolved_id,
-        config.daily_cost_limit_microdollars,
-        config.weekly_cost_limit_microdollars,
-    )
-    usage = await get_usage_status(resolved_id, daily_limit, weekly_limit, tier=tier)
-
-    return UserRateLimitResponse(
-        user_id=resolved_id,
-        user_email=resolved_email,
-        daily_cost_limit_microdollars=daily_limit,
-        weekly_cost_limit_microdollars=weekly_limit,
-        daily_cost_used_microdollars=usage.daily.used,
-        weekly_cost_used_microdollars=usage.weekly.used,
-        tier=tier,
-    )
-
-
-@router.post(
-    "/rate_limit/reset",
-    response_model=UserRateLimitResponse,
-    summary="Reset User Rate Limit Usage",
-)
-async def reset_user_rate_limit(
-    user_id: str = Body(embed=True),
-    reset_weekly: bool = Body(False, embed=True),
-    admin_user_id: str = Security(get_user_id),
-) -> UserRateLimitResponse:
-    """Reset a user's daily usage counter (and optionally weekly). Admin-only."""
-    logger.info(
-        "Admin %s resetting rate limit for user %s (reset_weekly=%s)",
-        admin_user_id,
-        user_id,
-        reset_weekly,
-    )
-
-    try:
-        await reset_user_usage(user_id, reset_weekly=reset_weekly)
-    except Exception as e:
-        logger.exception("Failed to reset user usage")
-        raise HTTPException(status_code=500, detail="Failed to reset usage") from e
-
-    daily_limit, weekly_limit, tier = await get_global_rate_limits(
-        user_id,
-        config.daily_cost_limit_microdollars,
-        config.weekly_cost_limit_microdollars,
-    )
-    usage = await get_usage_status(user_id, daily_limit, weekly_limit, tier=tier)
-
-    try:
-        resolved_email = await get_user_email_by_id(user_id)
-    except Exception:
-        logger.warning("Failed to resolve email for user %s", user_id, exc_info=True)
-        resolved_email = None
-
-    return UserRateLimitResponse(
-        user_id=user_id,
-        user_email=resolved_email,
-        daily_cost_limit_microdollars=daily_limit,
-        weekly_cost_limit_microdollars=weekly_limit,
-        daily_cost_used_microdollars=usage.daily.used,
-        weekly_cost_used_microdollars=usage.weekly.used,
-        tier=tier,
-    )
-
-
-@router.get(
-    "/rate_limit/tier",
-    response_model=UserTierResponse,
-    summary="Get User Rate Limit Tier",
-)
-async def get_user_rate_limit_tier(
-    user_id: str,
-    admin_user_id: str = Security(get_user_id),
-) -> UserTierResponse:
-    """Get a user's current rate-limit tier. Admin-only.
-
-    Returns 404 if the user does not exist in the database.
-    """
-    logger.info("Admin %s checking tier for user %s", admin_user_id, user_id)
-
-    resolved_email = await get_user_email_by_id(user_id)
-    if resolved_email is None:
-        raise HTTPException(status_code=404, detail=f"User {user_id} not found")
-
-    tier = await get_user_tier(user_id)
-    return UserTierResponse(user_id=user_id, tier=tier)
-
-
-@router.post(
-    "/rate_limit/tier",
-    response_model=UserTierResponse,
-    summary="Set User Rate Limit Tier",
-)
-async def set_user_rate_limit_tier(
-    request: SetUserTierRequest,
-    admin_user_id: str = Security(get_user_id),
-) -> UserTierResponse:
-    """Set a user's rate-limit tier. Admin-only.
-
-    Returns 404 if the user does not exist in the database.
-    """
-    try:
-        resolved_email = await get_user_email_by_id(request.user_id)
-    except Exception:
-        logger.warning(
-            "Failed to resolve email for user %s",
-            request.user_id,
-            exc_info=True,
-        )
-        resolved_email = None
-
-    if resolved_email is None:
-        raise HTTPException(status_code=404, detail=f"User {request.user_id} not found")
-
-    old_tier = await get_user_tier(request.user_id)
-    logger.info(
-        "Admin %s changing tier for user %s (%s): %s -> %s",
-        admin_user_id,
-        request.user_id,
-        resolved_email,
-        old_tier.value,
-        request.tier.value,
-    )
-    try:
-        await set_user_tier(request.user_id, request.tier)
-    except Exception as e:
-        logger.exception("Failed to set user tier")
-        raise HTTPException(status_code=500, detail="Failed to set tier") from e
-
-    return UserTierResponse(user_id=request.user_id, tier=request.tier)
-
-
-class UserSearchResult(BaseModel):
-    user_id: str
-    user_email: Optional[str] = None
-
-
-@router.get(
-    "/rate_limit/search_users",
-    response_model=list[UserSearchResult],
-    summary="Search Users by Name or Email",
-)
-async def admin_search_users(
-    query: str,
-    limit: int = 20,
-    admin_user_id: str = Security(get_user_id),
-) -> list[UserSearchResult]:
-    """Search users by partial email or name. Admin-only.
-
-    Queries the User table directly — returns results even for users
-    without credit transaction history.
-    """
-    if len(query.strip()) < 3:
-        raise HTTPException(
-            status_code=400,
-            detail="Search query must be at least 3 characters.",
-        )
-    logger.info("Admin %s searching users with query=%r", admin_user_id, query)
-    results = await search_users(query, limit=max(1, min(limit, 50)))
-    return [UserSearchResult(user_id=uid, user_email=email) for uid, email in results]

autogpt_platform/backend/backend/api/features/admin/rate_limit_admin_routes_test.py

@@ -1,566 +0,0 @@
-import json
-from types import SimpleNamespace
-from unittest.mock import AsyncMock
-
-import fastapi
-import fastapi.testclient
-import pytest
-import pytest_mock
-from autogpt_libs.auth.jwt_utils import get_jwt_payload
-from pytest_snapshot.plugin import Snapshot
-
-from backend.copilot.rate_limit import CoPilotUsageStatus, SubscriptionTier, UsageWindow
-
-from .rate_limit_admin_routes import router as rate_limit_admin_router
-
-app = fastapi.FastAPI()
-app.include_router(rate_limit_admin_router)
-
-client = fastapi.testclient.TestClient(app)
-
-_MOCK_MODULE = "backend.api.features.admin.rate_limit_admin_routes"
-
-_TARGET_EMAIL = "target@example.com"
-
-
-@pytest.fixture(autouse=True)
-def setup_app_admin_auth(mock_jwt_admin):
-    """Setup admin auth overrides for all tests in this module"""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
-
-
-def _mock_usage_status(
-    daily_used: int = 500_000, weekly_used: int = 3_000_000
-) -> CoPilotUsageStatus:
-    from datetime import UTC, datetime, timedelta
-
-    now = datetime.now(UTC)
-    return CoPilotUsageStatus(
-        daily=UsageWindow(
-            used=daily_used, limit=2_500_000, resets_at=now + timedelta(hours=6)
-        ),
-        weekly=UsageWindow(
-            used=weekly_used, limit=12_500_000, resets_at=now + timedelta(days=3)
-        ),
-    )
-
-
-def _patch_rate_limit_deps(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-    daily_used: int = 500_000,
-    weekly_used: int = 3_000_000,
-):
-    """Patch the common rate-limit + user-lookup dependencies."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_global_rate_limits",
-        new_callable=AsyncMock,
-        return_value=(2_500_000, 12_500_000, SubscriptionTier.BASIC),
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_usage_status",
-        new_callable=AsyncMock,
-        return_value=_mock_usage_status(daily_used=daily_used, weekly_used=weekly_used),
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        return_value=_TARGET_EMAIL,
-    )
-
-
-def test_get_rate_limit(
-    mocker: pytest_mock.MockerFixture,
-    configured_snapshot: Snapshot,
-    target_user_id: str,
-) -> None:
-    """Test getting rate limit and usage for a user."""
-    _patch_rate_limit_deps(mocker, target_user_id)
-
-    response = client.get("/admin/rate_limit", params={"user_id": target_user_id})
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == target_user_id
-    assert data["user_email"] == _TARGET_EMAIL
-    assert data["daily_cost_limit_microdollars"] == 2_500_000
-    assert data["weekly_cost_limit_microdollars"] == 12_500_000
-    assert data["daily_cost_used_microdollars"] == 500_000
-    assert data["weekly_cost_used_microdollars"] == 3_000_000
-    assert data["tier"] == "BASIC"
-
-    configured_snapshot.assert_match(
-        json.dumps(data, indent=2, sort_keys=True) + "\n",
-        "get_rate_limit",
-    )
-
-
-def test_get_rate_limit_by_email(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test looking up rate limits via email instead of user_id."""
-    _patch_rate_limit_deps(mocker, target_user_id)
-
-    mock_user = SimpleNamespace(id=target_user_id, email=_TARGET_EMAIL)
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_by_email",
-        new_callable=AsyncMock,
-        return_value=mock_user,
-    )
-
-    response = client.get("/admin/rate_limit", params={"email": _TARGET_EMAIL})
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == target_user_id
-    assert data["user_email"] == _TARGET_EMAIL
-    assert data["daily_cost_limit_microdollars"] == 2_500_000
-
-
-def test_get_rate_limit_by_email_not_found(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    """Test that looking up a non-existent email returns 404."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_by_email",
-        new_callable=AsyncMock,
-        return_value=None,
-    )
-
-    response = client.get("/admin/rate_limit", params={"email": "nobody@example.com"})
-
-    assert response.status_code == 404
-
-
-def test_get_rate_limit_no_params() -> None:
-    """Test that omitting both user_id and email returns 400."""
-    response = client.get("/admin/rate_limit")
-    assert response.status_code == 400
-
-
-def test_reset_user_usage_daily_only(
-    mocker: pytest_mock.MockerFixture,
-    configured_snapshot: Snapshot,
-    target_user_id: str,
-) -> None:
-    """Test resetting only daily usage (default behaviour)."""
-    mock_reset = mocker.patch(
-        f"{_MOCK_MODULE}.reset_user_usage",
-        new_callable=AsyncMock,
-    )
-    _patch_rate_limit_deps(mocker, target_user_id, daily_used=0, weekly_used=3_000_000)
-
-    response = client.post(
-        "/admin/rate_limit/reset",
-        json={"user_id": target_user_id},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["daily_cost_used_microdollars"] == 0
-    # Weekly is untouched
-    assert data["weekly_cost_used_microdollars"] == 3_000_000
-    assert data["tier"] == "BASIC"
-
-    mock_reset.assert_awaited_once_with(target_user_id, reset_weekly=False)
-
-    configured_snapshot.assert_match(
-        json.dumps(data, indent=2, sort_keys=True) + "\n",
-        "reset_user_usage_daily_only",
-    )
-
-
-def test_reset_user_usage_daily_and_weekly(
-    mocker: pytest_mock.MockerFixture,
-    configured_snapshot: Snapshot,
-    target_user_id: str,
-) -> None:
-    """Test resetting both daily and weekly usage."""
-    mock_reset = mocker.patch(
-        f"{_MOCK_MODULE}.reset_user_usage",
-        new_callable=AsyncMock,
-    )
-    _patch_rate_limit_deps(mocker, target_user_id, daily_used=0, weekly_used=0)
-
-    response = client.post(
-        "/admin/rate_limit/reset",
-        json={"user_id": target_user_id, "reset_weekly": True},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["daily_cost_used_microdollars"] == 0
-    assert data["weekly_cost_used_microdollars"] == 0
-    assert data["tier"] == "BASIC"
-
-    mock_reset.assert_awaited_once_with(target_user_id, reset_weekly=True)
-
-    configured_snapshot.assert_match(
-        json.dumps(data, indent=2, sort_keys=True) + "\n",
-        "reset_user_usage_daily_and_weekly",
-    )
-
-
-def test_reset_user_usage_redis_failure(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test that Redis failure on reset returns 500."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.reset_user_usage",
-        new_callable=AsyncMock,
-        side_effect=Exception("Redis connection refused"),
-    )
-
-    response = client.post(
-        "/admin/rate_limit/reset",
-        json={"user_id": target_user_id},
-    )
-
-    assert response.status_code == 500
-
-
-def test_get_rate_limit_email_lookup_failure(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test that failing to resolve a user email degrades gracefully."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_global_rate_limits",
-        new_callable=AsyncMock,
-        return_value=(2_500_000, 12_500_000, SubscriptionTier.BASIC),
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_usage_status",
-        new_callable=AsyncMock,
-        return_value=_mock_usage_status(),
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        side_effect=Exception("DB connection lost"),
-    )
-
-    response = client.get("/admin/rate_limit", params={"user_id": target_user_id})
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == target_user_id
-    assert data["user_email"] is None
-
-
-def test_admin_endpoints_require_admin_role(mock_jwt_user) -> None:
-    """Test that rate limit admin endpoints require admin role."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-
-    response = client.get("/admin/rate_limit", params={"user_id": "test"})
-    assert response.status_code == 403
-
-    response = client.post(
-        "/admin/rate_limit/reset",
-        json={"user_id": "test"},
-    )
-    assert response.status_code == 403
-
-
-# ---------------------------------------------------------------------------
-# Tier management endpoints
-# ---------------------------------------------------------------------------
-
-
-def test_get_user_tier(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test getting a user's rate-limit tier."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        return_value=_TARGET_EMAIL,
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_tier",
-        new_callable=AsyncMock,
-        return_value=SubscriptionTier.PRO,
-    )
-
-    response = client.get("/admin/rate_limit/tier", params={"user_id": target_user_id})
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == target_user_id
-    assert data["tier"] == "PRO"
-
-
-def test_get_user_tier_user_not_found(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test that getting tier for a non-existent user returns 404."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        return_value=None,
-    )
-
-    response = client.get("/admin/rate_limit/tier", params={"user_id": target_user_id})
-
-    assert response.status_code == 404
-
-
-def test_set_user_tier(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test setting a user's rate-limit tier (upgrade)."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        return_value=_TARGET_EMAIL,
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_tier",
-        new_callable=AsyncMock,
-        return_value=SubscriptionTier.BASIC,
-    )
-    mock_set = mocker.patch(
-        f"{_MOCK_MODULE}.set_user_tier",
-        new_callable=AsyncMock,
-    )
-
-    response = client.post(
-        "/admin/rate_limit/tier",
-        json={"user_id": target_user_id, "tier": "ENTERPRISE"},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == target_user_id
-    assert data["tier"] == "ENTERPRISE"
-    mock_set.assert_awaited_once_with(target_user_id, SubscriptionTier.ENTERPRISE)
-
-
-def test_set_user_tier_downgrade(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test downgrading a user's tier from PRO to BASIC."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        return_value=_TARGET_EMAIL,
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_tier",
-        new_callable=AsyncMock,
-        return_value=SubscriptionTier.PRO,
-    )
-    mock_set = mocker.patch(
-        f"{_MOCK_MODULE}.set_user_tier",
-        new_callable=AsyncMock,
-    )
-
-    response = client.post(
-        "/admin/rate_limit/tier",
-        json={"user_id": target_user_id, "tier": "BASIC"},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == target_user_id
-    assert data["tier"] == "BASIC"
-    mock_set.assert_awaited_once_with(target_user_id, SubscriptionTier.BASIC)
-
-
-def test_set_user_tier_invalid_tier(
-    target_user_id: str,
-) -> None:
-    """Test that setting an invalid tier returns 422."""
-    response = client.post(
-        "/admin/rate_limit/tier",
-        json={"user_id": target_user_id, "tier": "invalid"},
-    )
-
-    assert response.status_code == 422
-
-
-def test_set_user_tier_invalid_tier_uppercase(
-    target_user_id: str,
-) -> None:
-    """Test that setting an unrecognised uppercase tier (e.g. 'INVALID') returns 422.
-
-    Regression: ensures Pydantic enum validation rejects values that are not
-    members of SubscriptionTier, even when they look like valid enum names.
-    """
-    response = client.post(
-        "/admin/rate_limit/tier",
-        json={"user_id": target_user_id, "tier": "INVALID"},
-    )
-
-    assert response.status_code == 422
-    body = response.json()
-    assert "detail" in body
-
-
-def test_set_user_tier_email_lookup_failure_returns_404(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test that email lookup failure returns 404 (user unverifiable)."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        side_effect=Exception("DB connection failed"),
-    )
-
-    response = client.post(
-        "/admin/rate_limit/tier",
-        json={"user_id": target_user_id, "tier": "PRO"},
-    )
-
-    assert response.status_code == 404
-
-
-def test_set_user_tier_user_not_found(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test that setting tier for a non-existent user returns 404."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        return_value=None,
-    )
-
-    response = client.post(
-        "/admin/rate_limit/tier",
-        json={"user_id": target_user_id, "tier": "PRO"},
-    )
-
-    assert response.status_code == 404
-
-
-def test_set_user_tier_db_failure(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test that DB failure on set tier returns 500."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        return_value=_TARGET_EMAIL,
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_tier",
-        new_callable=AsyncMock,
-        return_value=SubscriptionTier.BASIC,
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.set_user_tier",
-        new_callable=AsyncMock,
-        side_effect=Exception("DB connection refused"),
-    )
-
-    response = client.post(
-        "/admin/rate_limit/tier",
-        json={"user_id": target_user_id, "tier": "PRO"},
-    )
-
-    assert response.status_code == 500
-
-
-def test_tier_endpoints_require_admin_role(mock_jwt_user) -> None:
-    """Test that tier admin endpoints require admin role."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-
-    response = client.get("/admin/rate_limit/tier", params={"user_id": "test"})
-    assert response.status_code == 403
-
-    response = client.post(
-        "/admin/rate_limit/tier",
-        json={"user_id": "test", "tier": "PRO"},
-    )
-    assert response.status_code == 403
-
-
-# ─── search_users endpoint ──────────────────────────────────────────
-
-
-def test_search_users_returns_matching_users(
-    mocker: pytest_mock.MockerFixture,
-    admin_user_id: str,
-) -> None:
-    """Partial search should return all matching users from the User table."""
-    mocker.patch(
-        _MOCK_MODULE + ".search_users",
-        new_callable=AsyncMock,
-        return_value=[
-            ("user-1", "zamil.majdy@gmail.com"),
-            ("user-2", "zamil.majdy@agpt.co"),
-        ],
-    )
-
-    response = client.get("/admin/rate_limit/search_users", params={"query": "zamil"})
-
-    assert response.status_code == 200
-    results = response.json()
-    assert len(results) == 2
-    assert results[0]["user_email"] == "zamil.majdy@gmail.com"
-    assert results[1]["user_email"] == "zamil.majdy@agpt.co"
-
-
-def test_search_users_empty_results(
-    mocker: pytest_mock.MockerFixture,
-    admin_user_id: str,
-) -> None:
-    """Search with no matches returns empty list."""
-    mocker.patch(
-        _MOCK_MODULE + ".search_users",
-        new_callable=AsyncMock,
-        return_value=[],
-    )
-
-    response = client.get(
-        "/admin/rate_limit/search_users", params={"query": "nonexistent"}
-    )
-
-    assert response.status_code == 200
-    assert response.json() == []
-
-
-def test_search_users_short_query_rejected(
-    admin_user_id: str,
-) -> None:
-    """Query shorter than 3 characters should return 400."""
-    response = client.get("/admin/rate_limit/search_users", params={"query": "ab"})
-    assert response.status_code == 400
-
-
-def test_search_users_negative_limit_clamped(
-    mocker: pytest_mock.MockerFixture,
-    admin_user_id: str,
-) -> None:
-    """Negative limit should be clamped to 1, not passed through."""
-    mock_search = mocker.patch(
-        _MOCK_MODULE + ".search_users",
-        new_callable=AsyncMock,
-        return_value=[],
-    )
-
-    response = client.get(
-        "/admin/rate_limit/search_users", params={"query": "test", "limit": -1}
-    )
-
-    assert response.status_code == 200
-    mock_search.assert_awaited_once_with("test", limit=1)
-
-
-def test_search_users_requires_admin_role(mock_jwt_user) -> None:
-    """Test that the search_users endpoint requires admin role."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-
-    response = client.get("/admin/rate_limit/search_users", params={"query": "test"})
-    assert response.status_code == 403

autogpt_platform/backend/backend/api/features/admin/store_admin_routes.py

@@ -7,8 +7,6 @@ import fastapi
 import fastapi.responses
 import prisma.enums
 
-import backend.api.features.library.db as library_db
-import backend.api.features.library.model as library_model
 import backend.api.features.store.cache as store_cache
 import backend.api.features.store.db as store_db
 import backend.api.features.store.model as store_model
@@ -26,13 +24,14 @@ router = fastapi.APIRouter(
 @router.get(
     "/listings",
     summary="Get Admin Listings History",
+    response_model=store_model.StoreListingsWithVersionsResponse,
 )
 async def get_admin_listings_with_versions(
     status: typing.Optional[prisma.enums.SubmissionStatus] = None,
     search: typing.Optional[str] = None,
     page: int = 1,
     page_size: int = 20,
-) -> store_model.StoreListingsWithVersionsAdminViewResponse:
+):
     """
     Get store listings with their version history for admins.
 
@@ -46,26 +45,36 @@ async def get_admin_listings_with_versions(
         page_size: Number of items per page
 
     Returns:
-        Paginated listings with their versions
+        StoreListingsWithVersionsResponse with listings and their versions
     """
-    listings = await store_db.get_admin_listings_with_versions(
-        status=status,
-        search_query=search,
-        page=page,
-        page_size=page_size,
-    )
-    return listings
+    try:
+        listings = await store_db.get_admin_listings_with_versions(
+            status=status,
+            search_query=search,
+            page=page,
+            page_size=page_size,
+        )
+        return listings
+    except Exception as e:
+        logger.exception("Error getting admin listings with versions: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={
+                "detail": "An error occurred while retrieving listings with versions"
+            },
+        )
 
 
 @router.post(
     "/submissions/{store_listing_version_id}/review",
     summary="Review Store Submission",
+    response_model=store_model.StoreSubmission,
 )
 async def review_submission(
     store_listing_version_id: str,
     request: store_model.ReviewSubmissionRequest,
     user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
-) -> store_model.StoreSubmissionAdminView:
+):
     """
     Review a store listing submission.
 
@@ -75,24 +84,31 @@ async def review_submission(
         user_id: Authenticated admin user performing the review
 
     Returns:
-        StoreSubmissionAdminView with updated review information
+        StoreSubmission with updated review information
     """
-    already_approved = await store_db.check_submission_already_approved(
-        store_listing_version_id=store_listing_version_id,
-    )
-    submission = await store_db.review_store_submission(
-        store_listing_version_id=store_listing_version_id,
-        is_approved=request.is_approved,
-        external_comments=request.comments,
-        internal_comments=request.internal_comments or "",
-        reviewer_id=user_id,
-    )
+    try:
+        already_approved = await store_db.check_submission_already_approved(
+            store_listing_version_id=store_listing_version_id,
+        )
+        submission = await store_db.review_store_submission(
+            store_listing_version_id=store_listing_version_id,
+            is_approved=request.is_approved,
+            external_comments=request.comments,
+            internal_comments=request.internal_comments or "",
+            reviewer_id=user_id,
+        )
 
-    state_changed = already_approved != request.is_approved
-    # Clear caches whenever approval state changes, since store visibility can change
-    if state_changed:
-        store_cache.clear_all_caches()
-    return submission
+        state_changed = already_approved != request.is_approved
+        # Clear caches when the request is approved as it updates what is shown on the store
+        if state_changed:
+            store_cache.clear_all_caches()
+        return submission
+    except Exception as e:
+        logger.exception("Error reviewing submission: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={"detail": "An error occurred while reviewing the submission"},
+        )
 
 
 @router.get(
@@ -134,40 +150,3 @@ async def admin_download_agent_file(
         return fastapi.responses.FileResponse(
             tmp_file.name, filename=file_name, media_type="application/json"
         )
-
-
-@router.get(
-    "/submissions/{store_listing_version_id}/preview",
-    summary="Admin Preview Submission Listing",
-)
-async def admin_preview_submission(
-    store_listing_version_id: str,
-) -> store_model.StoreAgentDetails:
-    """
-    Preview a marketplace submission as it would appear on the listing page.
-    Bypasses the APPROVED-only StoreAgent view so admins can preview pending
-    submissions before approving.
-    """
-    return await store_db.get_store_agent_details_as_admin(store_listing_version_id)
-
-
-@router.post(
-    "/submissions/{store_listing_version_id}/add-to-library",
-    summary="Admin Add Pending Agent to Library",
-    status_code=201,
-)
-async def admin_add_agent_to_library(
-    store_listing_version_id: str,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
-) -> library_model.LibraryAgent:
-    """
-    Add a pending marketplace agent to the admin's library for review.
-    Uses admin-level access to bypass marketplace APPROVED-only checks.
-
-    The builder can load the graph because get_graph() checks library
-    membership as a fallback: "you added it, you keep it."
-    """
-    return await library_db.add_store_agent_to_library_as_admin(
-        store_listing_version_id=store_listing_version_id,
-        user_id=user_id,
-    )

autogpt_platform/backend/backend/api/features/admin/store_admin_routes_test.py

@@ -1,335 +0,0 @@
-"""Tests for admin store routes and the bypass logic they depend on.
-
-Tests are organized by what they protect:
-- SECRT-2162: get_graph_as_admin bypasses ownership/marketplace checks
-- SECRT-2167 security: admin endpoints reject non-admin users
-- SECRT-2167 bypass: preview queries StoreListingVersion (not StoreAgent view),
-  and add-to-library uses get_graph_as_admin (not get_graph)
-"""
-
-from datetime import datetime, timezone
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import fastapi
-import fastapi.responses
-import fastapi.testclient
-import pytest
-import pytest_mock
-from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-from backend.data.graph import get_graph_as_admin
-from backend.util.exceptions import NotFoundError
-
-from .store_admin_routes import router as store_admin_router
-
-# Shared constants
-ADMIN_USER_ID = "admin-user-id"
-CREATOR_USER_ID = "other-creator-id"
-GRAPH_ID = "test-graph-id"
-GRAPH_VERSION = 3
-SLV_ID = "test-store-listing-version-id"
-
-
-def _make_mock_graph(user_id: str = CREATOR_USER_ID) -> MagicMock:
-    graph = MagicMock()
-    graph.userId = user_id
-    graph.id = GRAPH_ID
-    graph.version = GRAPH_VERSION
-    graph.Nodes = []
-    return graph
-
-
-# ---- SECRT-2162: get_graph_as_admin bypasses ownership checks ---- #
-
-
-@pytest.mark.asyncio
-async def test_admin_can_access_pending_agent_not_owned() -> None:
-    """get_graph_as_admin must return a graph even when the admin doesn't own
-    it and it's not APPROVED in the marketplace."""
-    mock_graph = _make_mock_graph()
-    mock_graph_model = MagicMock(name="GraphModel")
-
-    with (
-        patch("backend.data.graph.AgentGraph.prisma") as mock_prisma,
-        patch(
-            "backend.data.graph.GraphModel.from_db",
-            return_value=mock_graph_model,
-        ),
-    ):
-        mock_prisma.return_value.find_first = AsyncMock(return_value=mock_graph)
-
-        result = await get_graph_as_admin(
-            graph_id=GRAPH_ID,
-            version=GRAPH_VERSION,
-            user_id=ADMIN_USER_ID,
-            for_export=False,
-        )
-
-    assert result is mock_graph_model
-
-
-@pytest.mark.asyncio
-async def test_admin_download_pending_agent_with_subagents() -> None:
-    """get_graph_as_admin with for_export=True must call get_sub_graphs
-    and pass sub_graphs to GraphModel.from_db."""
-    mock_graph = _make_mock_graph()
-    mock_sub_graph = MagicMock(name="SubGraph")
-    mock_graph_model = MagicMock(name="GraphModel")
-
-    with (
-        patch("backend.data.graph.AgentGraph.prisma") as mock_prisma,
-        patch(
-            "backend.data.graph.get_sub_graphs",
-            new_callable=AsyncMock,
-            return_value=[mock_sub_graph],
-        ) as mock_get_sub,
-        patch(
-            "backend.data.graph.GraphModel.from_db",
-            return_value=mock_graph_model,
-        ) as mock_from_db,
-    ):
-        mock_prisma.return_value.find_first = AsyncMock(return_value=mock_graph)
-
-        result = await get_graph_as_admin(
-            graph_id=GRAPH_ID,
-            version=GRAPH_VERSION,
-            user_id=ADMIN_USER_ID,
-            for_export=True,
-        )
-
-    assert result is mock_graph_model
-    mock_get_sub.assert_awaited_once_with(mock_graph)
-    mock_from_db.assert_called_once_with(
-        graph=mock_graph,
-        sub_graphs=[mock_sub_graph],
-        for_export=True,
-    )
-
-
-# ---- SECRT-2167 security: admin endpoints reject non-admin users ---- #
-
-app = fastapi.FastAPI()
-app.include_router(store_admin_router)
-
-
-@app.exception_handler(NotFoundError)
-async def _not_found_handler(
-    request: fastapi.Request, exc: NotFoundError
-) -> fastapi.responses.JSONResponse:
-    return fastapi.responses.JSONResponse(status_code=404, content={"detail": str(exc)})
-
-
-client = fastapi.testclient.TestClient(app)
-
-
-@pytest.fixture(autouse=True)
-def setup_app_admin_auth(mock_jwt_admin):
-    """Setup admin auth overrides for all route tests in this module."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
-
-
-def test_preview_requires_admin(mock_jwt_user) -> None:
-    """Non-admin users must get 403 on the preview endpoint."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    response = client.get(f"/admin/submissions/{SLV_ID}/preview")
-    assert response.status_code == 403
-
-
-def test_add_to_library_requires_admin(mock_jwt_user) -> None:
-    """Non-admin users must get 403 on the add-to-library endpoint."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    response = client.post(f"/admin/submissions/{SLV_ID}/add-to-library")
-    assert response.status_code == 403
-
-
-def test_preview_nonexistent_submission(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    """Preview of a nonexistent submission returns 404."""
-    mocker.patch(
-        "backend.api.features.admin.store_admin_routes.store_db"
-        ".get_store_agent_details_as_admin",
-        side_effect=NotFoundError("not found"),
-    )
-    response = client.get(f"/admin/submissions/{SLV_ID}/preview")
-    assert response.status_code == 404
-
-
-# ---- SECRT-2167 bypass: verify the right data sources are used ---- #
-
-
-@pytest.mark.asyncio
-async def test_preview_queries_store_listing_version_not_store_agent() -> None:
-    """get_store_agent_details_as_admin must query StoreListingVersion
-    directly (not the APPROVED-only StoreAgent view). This is THE test that
-    prevents the bypass from being accidentally reverted."""
-    from backend.api.features.store.db import get_store_agent_details_as_admin
-
-    mock_slv = MagicMock()
-    mock_slv.id = SLV_ID
-    mock_slv.name = "Test Agent"
-    mock_slv.subHeading = "Short desc"
-    mock_slv.description = "Long desc"
-    mock_slv.videoUrl = None
-    mock_slv.agentOutputDemoUrl = None
-    mock_slv.imageUrls = ["https://example.com/img.png"]
-    mock_slv.instructions = None
-    mock_slv.categories = ["productivity"]
-    mock_slv.version = 1
-    mock_slv.agentGraphId = GRAPH_ID
-    mock_slv.agentGraphVersion = GRAPH_VERSION
-    mock_slv.updatedAt = datetime(2026, 3, 24, tzinfo=timezone.utc)
-    mock_slv.recommendedScheduleCron = "0 9 * * *"
-
-    mock_listing = MagicMock()
-    mock_listing.id = "listing-id"
-    mock_listing.slug = "test-agent"
-    mock_listing.activeVersionId = SLV_ID
-    mock_listing.hasApprovedVersion = False
-    mock_listing.CreatorProfile = MagicMock(username="creator", avatarUrl="")
-    mock_slv.StoreListing = mock_listing
-
-    with (
-        patch(
-            "backend.api.features.store.db.prisma.models" ".StoreListingVersion.prisma",
-        ) as mock_slv_prisma,
-        patch(
-            "backend.api.features.store.db.prisma.models.StoreAgent.prisma",
-        ) as mock_store_agent_prisma,
-    ):
-        mock_slv_prisma.return_value.find_unique = AsyncMock(return_value=mock_slv)
-
-        result = await get_store_agent_details_as_admin(SLV_ID)
-
-    # Verify it queried StoreListingVersion (not the APPROVED-only StoreAgent)
-    mock_slv_prisma.return_value.find_unique.assert_awaited_once()
-    await_args = mock_slv_prisma.return_value.find_unique.await_args
-    assert await_args is not None
-    assert await_args.kwargs["where"] == {"id": SLV_ID}
-
-    # Verify the APPROVED-only StoreAgent view was NOT touched
-    mock_store_agent_prisma.assert_not_called()
-
-    # Verify the result has the right data
-    assert result.agent_name == "Test Agent"
-    assert result.agent_image == ["https://example.com/img.png"]
-    assert result.has_approved_version is False
-    assert result.runs == 0
-    assert result.rating == 0.0
-
-
-@pytest.mark.asyncio
-async def test_resolve_graph_admin_uses_get_graph_as_admin() -> None:
-    """resolve_graph_for_library(admin=True) must call get_graph_as_admin,
-    not get_graph. This is THE test that prevents the add-to-library bypass
-    from being accidentally reverted."""
-    from backend.api.features.library._add_to_library import resolve_graph_for_library
-
-    mock_slv = MagicMock()
-    mock_slv.AgentGraph = MagicMock(id=GRAPH_ID, version=GRAPH_VERSION)
-    mock_graph_model = MagicMock(name="GraphModel")
-
-    with (
-        patch(
-            "backend.api.features.library._add_to_library.prisma.models"
-            ".StoreListingVersion.prisma",
-        ) as mock_prisma,
-        patch(
-            "backend.api.features.library._add_to_library.graph_db"
-            ".get_graph_as_admin",
-            new_callable=AsyncMock,
-            return_value=mock_graph_model,
-        ) as mock_admin,
-        patch(
-            "backend.api.features.library._add_to_library.graph_db.get_graph",
-            new_callable=AsyncMock,
-        ) as mock_regular,
-    ):
-        mock_prisma.return_value.find_unique = AsyncMock(return_value=mock_slv)
-
-        result = await resolve_graph_for_library(SLV_ID, ADMIN_USER_ID, admin=True)
-
-    assert result is mock_graph_model
-    mock_admin.assert_awaited_once_with(
-        graph_id=GRAPH_ID, version=GRAPH_VERSION, user_id=ADMIN_USER_ID
-    )
-    mock_regular.assert_not_awaited()
-
-
-@pytest.mark.asyncio
-async def test_resolve_graph_regular_uses_get_graph() -> None:
-    """resolve_graph_for_library(admin=False) must call get_graph,
-    not get_graph_as_admin. Ensures the non-admin path is preserved."""
-    from backend.api.features.library._add_to_library import resolve_graph_for_library
-
-    mock_slv = MagicMock()
-    mock_slv.AgentGraph = MagicMock(id=GRAPH_ID, version=GRAPH_VERSION)
-    mock_graph_model = MagicMock(name="GraphModel")
-
-    with (
-        patch(
-            "backend.api.features.library._add_to_library.prisma.models"
-            ".StoreListingVersion.prisma",
-        ) as mock_prisma,
-        patch(
-            "backend.api.features.library._add_to_library.graph_db"
-            ".get_graph_as_admin",
-            new_callable=AsyncMock,
-        ) as mock_admin,
-        patch(
-            "backend.api.features.library._add_to_library.graph_db.get_graph",
-            new_callable=AsyncMock,
-            return_value=mock_graph_model,
-        ) as mock_regular,
-    ):
-        mock_prisma.return_value.find_unique = AsyncMock(return_value=mock_slv)
-
-        result = await resolve_graph_for_library(SLV_ID, "regular-user-id", admin=False)
-
-    assert result is mock_graph_model
-    mock_regular.assert_awaited_once_with(
-        graph_id=GRAPH_ID, version=GRAPH_VERSION, user_id="regular-user-id"
-    )
-    mock_admin.assert_not_awaited()
-
-
-# ---- Library membership grants graph access (product decision) ---- #
-
-
-@pytest.mark.asyncio
-async def test_library_member_can_view_pending_agent_in_builder() -> None:
-    """After adding a pending agent to their library, the user should be
-    able to load the graph in the builder via get_graph()."""
-    mock_graph = _make_mock_graph()
-    mock_graph_model = MagicMock(name="GraphModel")
-    mock_library_agent = MagicMock()
-    mock_library_agent.AgentGraph = mock_graph
-
-    with (
-        patch("backend.data.graph.AgentGraph.prisma") as mock_ag_prisma,
-        patch(
-            "backend.data.graph.StoreListingVersion.prisma",
-        ) as mock_slv_prisma,
-        patch("backend.data.graph.LibraryAgent.prisma") as mock_lib_prisma,
-        patch(
-            "backend.data.graph.GraphModel.from_db",
-            return_value=mock_graph_model,
-        ),
-    ):
-        mock_ag_prisma.return_value.find_first = AsyncMock(return_value=None)
-        mock_slv_prisma.return_value.find_first = AsyncMock(return_value=None)
-        mock_lib_prisma.return_value.find_first = AsyncMock(
-            return_value=mock_library_agent
-        )
-
-        from backend.data.graph import get_graph
-
-        result = await get_graph(
-            graph_id=GRAPH_ID,
-            version=GRAPH_VERSION,
-            user_id=ADMIN_USER_ID,
-        )
-
-    assert result is mock_graph_model, "Library membership should grant graph access"

autogpt_platform/backend/backend/api/features/builder/db.py

@@ -4,12 +4,14 @@ from difflib import SequenceMatcher
 from typing import Any, Sequence, get_args, get_origin
 
 import prisma
+from prisma.enums import ContentType
 from prisma.models import mv_suggested_blocks
 
 import backend.api.features.library.db as library_db
 import backend.api.features.library.model as library_model
 import backend.api.features.store.db as store_db
 import backend.api.features.store.model as store_model
+from backend.api.features.store.hybrid_search import unified_hybrid_search
 from backend.blocks import load_all_blocks
 from backend.blocks._base import (
     AnyBlockSchema,
@@ -22,7 +24,6 @@ from backend.blocks.llm import LlmModel
 from backend.integrations.providers import ProviderName
 from backend.util.cache import cached
 from backend.util.models import Pagination
-from backend.util.text import split_camelcase
 
 from .model import (
     BlockCategoryResponse,
@@ -270,7 +271,7 @@ async def _build_cached_search_results(
 
     # Use hybrid search when query is present, otherwise list all blocks
     if (include_blocks or include_integrations) and normalized_query:
-        block_results, block_total, integration_total = await _text_search_blocks(
+        block_results, block_total, integration_total = await _hybrid_search_blocks(
             query=search_query,
             include_blocks=include_blocks,
             include_integrations=include_integrations,
@@ -382,75 +383,117 @@ def _collect_block_results(
     return results, block_count, integration_count
 
 
-async def _text_search_blocks(
+async def _hybrid_search_blocks(
     *,
     query: str,
     include_blocks: bool,
     include_integrations: bool,
 ) -> tuple[list[_ScoredItem], int, int]:
     """
-    Search blocks using in-memory text matching over the block registry.
+    Search blocks using hybrid search with builder-specific filtering.
 
-    All blocks are already loaded in memory, so this is fast and reliable
-    regardless of whether OpenAI embeddings are available.
+    Uses unified_hybrid_search for semantic + lexical search, then applies
+    post-filtering for block/integration types and scoring adjustments.
 
     Scoring:
-        - Base: text relevance via _score_primary_fields, plus BLOCK_SCORE_BOOST
+        - Base: hybrid relevance score (0-1) scaled to 0-100, plus BLOCK_SCORE_BOOST
           to prioritize blocks over marketplace agents in combined results
+        - +30 for exact name match, +15 for prefix name match
         - +20 if the block has an LlmModel field and the query matches an LLM model name
+
+    Args:
+        query: The search query string
+        include_blocks: Whether to include regular blocks
+        include_integrations: Whether to include integration blocks
+
+    Returns:
+        Tuple of (scored_items, block_count, integration_count)
     """
     results: list[_ScoredItem] = []
+    block_count = 0
+    integration_count = 0
 
     if not include_blocks and not include_integrations:
-        return results, 0, 0
+        return results, block_count, integration_count
 
     normalized_query = query.strip().lower()
 
-    all_results, _, _ = _collect_block_results(
-        include_blocks=include_blocks,
-        include_integrations=include_integrations,
+    # Fetch more results to account for post-filtering
+    search_results, _ = await unified_hybrid_search(
+        query=query,
+        content_types=[ContentType.BLOCK],
+        page=1,
+        page_size=150,
+        min_score=0.10,
     )
 
+    # Load all blocks for getting BlockInfo
     all_blocks = load_all_blocks()
 
-    for item in all_results:
-        block_info = item.item
-        assert isinstance(block_info, BlockInfo)
-        name = split_camelcase(block_info.name).lower()
+    for result in search_results:
+        block_id = result["content_id"]
 
-        # Build rich description including input field descriptions,
-        # matching the searchable text that the embedding pipeline uses
-        desc_parts = [block_info.description or ""]
-        block_cls = all_blocks.get(block_info.id)
-        if block_cls is not None:
-            block: AnyBlockSchema = block_cls()
-            desc_parts += [
-                f"{f}: {info.description}"
-                for f, info in block.input_schema.model_fields.items()
-                if info.description
-            ]
-        description = " ".join(desc_parts).lower()
+        # Skip excluded blocks
+        if block_id in EXCLUDED_BLOCK_IDS:
+            continue
 
-        score = _score_primary_fields(name, description, normalized_query)
+        metadata = result.get("metadata", {})
+        hybrid_score = result.get("relevance", 0.0)
+
+        # Get the actual block class
+        if block_id not in all_blocks:
+            continue
+
+        block_cls = all_blocks[block_id]
+        block: AnyBlockSchema = block_cls()
+
+        if block.disabled:
+            continue
+
+        # Check block/integration filter using metadata
+        is_integration = metadata.get("is_integration", False)
+
+        if is_integration and not include_integrations:
+            continue
+        if not is_integration and not include_blocks:
+            continue
+
+        # Get block info
+        block_info = block.get_info()
+
+        # Calculate final score: scale hybrid score and add builder-specific bonuses
+        # Hybrid scores are 0-1, builder scores were 0-200+
+        # Add BLOCK_SCORE_BOOST to prioritize blocks over marketplace agents
+        final_score = hybrid_score * 100 + BLOCK_SCORE_BOOST
 
         # Add LLM model match bonus
-        if block_cls is not None and _matches_llm_model(
-            block_cls().input_schema, normalized_query
-        ):
-            score += 20
+        has_llm_field = metadata.get("has_llm_model_field", False)
+        if has_llm_field and _matches_llm_model(block.input_schema, normalized_query):
+            final_score += 20
 
-        if score >= MIN_SCORE_FOR_FILTERED_RESULTS:
-            results.append(
-                _ScoredItem(
-                    item=block_info,
-                    filter_type=item.filter_type,
-                    score=score + BLOCK_SCORE_BOOST,
-                    sort_key=name,
-                )
+        # Add exact/prefix match bonus for deterministic tie-breaking
+        name = block_info.name.lower()
+        if name == normalized_query:
+            final_score += 30
+        elif name.startswith(normalized_query):
+            final_score += 15
+
+        # Track counts
+        filter_type: FilterType = "integrations" if is_integration else "blocks"
+        if is_integration:
+            integration_count += 1
+        else:
+            block_count += 1
+
+        results.append(
+            _ScoredItem(
+                item=block_info,
+                filter_type=filter_type,
+                score=final_score,
+                sort_key=name,
             )
+        )
 
-    block_count = sum(1 for r in results if r.filter_type == "blocks")
-    integration_count = sum(1 for r in results if r.filter_type == "integrations")
     return results, block_count, integration_count
 
 

autogpt_platform/backend/backend/api/features/executions/review/review_routes_test.py

@@ -638,7 +638,7 @@ async def test_process_review_action_auto_approve_creates_auto_approval_records(
 
     # Mock get_node_executions to return node_id mapping
     mock_get_node_executions = mocker.patch(
-        "backend.api.features.executions.review.routes.get_node_executions"
+        "backend.data.execution.get_node_executions"
     )
     mock_node_exec = mocker.Mock(spec=NodeExecutionResult)
     mock_node_exec.node_exec_id = "test_node_123"
@@ -936,7 +936,7 @@ async def test_process_review_action_auto_approve_only_applies_to_approved_revie
 
     # Mock get_node_executions to return node_id mapping
     mock_get_node_executions = mocker.patch(
-        "backend.api.features.executions.review.routes.get_node_executions"
+        "backend.data.execution.get_node_executions"
     )
     mock_node_exec = mocker.Mock(spec=NodeExecutionResult)
     mock_node_exec.node_exec_id = "node_exec_approved"
@@ -1148,7 +1148,7 @@ async def test_process_review_action_per_review_auto_approve_granularity(
 
     # Mock get_node_executions to return batch node data
     mock_get_node_executions = mocker.patch(
-        "backend.api.features.executions.review.routes.get_node_executions"
+        "backend.data.execution.get_node_executions"
     )
     # Create mock node executions for each review
     mock_node_execs = []

autogpt_platform/backend/backend/api/features/executions/review/routes.py

@@ -6,15 +6,10 @@ import autogpt_libs.auth as autogpt_auth_lib
 from fastapi import APIRouter, HTTPException, Query, Security, status
 from prisma.enums import ReviewStatus
 
-from backend.copilot.constants import (
-    is_copilot_synthetic_id,
-    parse_node_id_from_exec_id,
-)
 from backend.data.execution import (
     ExecutionContext,
     ExecutionStatus,
     get_graph_execution_meta,
-    get_node_executions,
 )
 from backend.data.graph import get_graph_settings
 from backend.data.human_review import (
@@ -41,38 +36,6 @@ router = APIRouter(
 )
 
 
-async def _resolve_node_ids(
-    node_exec_ids: list[str],
-    graph_exec_id: str,
-    is_copilot: bool,
-) -> dict[str, str]:
-    """Resolve node_exec_id -> node_id for auto-approval records.
-
-    CoPilot synthetic IDs encode node_id in the format "{node_id}:{random}".
-    Graph executions look up node_id from NodeExecution records.
-    """
-    if not node_exec_ids:
-        return {}
-
-    if is_copilot:
-        return {neid: parse_node_id_from_exec_id(neid) for neid in node_exec_ids}
-
-    node_execs = await get_node_executions(
-        graph_exec_id=graph_exec_id, include_exec_data=False
-    )
-    node_exec_map = {ne.node_exec_id: ne.node_id for ne in node_execs}
-
-    result = {}
-    for neid in node_exec_ids:
-        if neid in node_exec_map:
-            result[neid] = node_exec_map[neid]
-        else:
-            logger.error(
-                f"Failed to resolve node_id for {neid}: Node execution not found."
-            )
-    return result
-
-
 @router.get(
     "/pending",
     summary="Get Pending Reviews",
@@ -147,16 +110,14 @@ async def list_pending_reviews_for_execution(
     """
 
     # Verify user owns the graph execution before returning reviews
-    # (CoPilot synthetic IDs don't have graph execution records)
-    if not is_copilot_synthetic_id(graph_exec_id):
-        graph_exec = await get_graph_execution_meta(
-            user_id=user_id, execution_id=graph_exec_id
+    graph_exec = await get_graph_execution_meta(
+        user_id=user_id, execution_id=graph_exec_id
+    )
+    if not graph_exec:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Graph execution #{graph_exec_id} not found",
         )
-        if not graph_exec:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Graph execution #{graph_exec_id} not found",
-            )
 
     return await get_pending_reviews_for_execution(graph_exec_id, user_id)
 
@@ -199,26 +160,30 @@ async def process_review_action(
         )
 
     graph_exec_id = next(iter(graph_exec_ids))
-    is_copilot = is_copilot_synthetic_id(graph_exec_id)
 
-    # Validate execution status for graph executions (skip for CoPilot synthetic IDs)
-    if not is_copilot:
-        graph_exec_meta = await get_graph_execution_meta(
-            user_id=user_id, execution_id=graph_exec_id
+    # Validate execution status before processing reviews
+    graph_exec_meta = await get_graph_execution_meta(
+        user_id=user_id, execution_id=graph_exec_id
+    )
+
+    if not graph_exec_meta:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Graph execution #{graph_exec_id} not found",
+        )
+
+    # Only allow processing reviews if execution is paused for review
+    # or incomplete (partial execution with some reviews already processed)
+    if graph_exec_meta.status not in (
+        ExecutionStatus.REVIEW,
+        ExecutionStatus.INCOMPLETE,
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Cannot process reviews while execution status is {graph_exec_meta.status}. "
+            f"Reviews can only be processed when execution is paused (REVIEW status). "
+            f"Current status: {graph_exec_meta.status}",
         )
-        if not graph_exec_meta:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Graph execution #{graph_exec_id} not found",
-            )
-        if graph_exec_meta.status not in (
-            ExecutionStatus.REVIEW,
-            ExecutionStatus.INCOMPLETE,
-        ):
-            raise HTTPException(
-                status_code=status.HTTP_409_CONFLICT,
-                detail=f"Cannot process reviews while execution status is {graph_exec_meta.status}",
-            )
 
     # Build review decisions map and track which reviews requested auto-approval
     # Auto-approved reviews use original data (no modifications allowed)
@@ -271,7 +236,7 @@ async def process_review_action(
             )
             return (node_id, False)
 
-    # Collect node_exec_ids that need auto-approval and resolve their node_ids
+    # Collect node_exec_ids that need auto-approval
     node_exec_ids_needing_auto_approval = [
         node_exec_id
         for node_exec_id, review_result in updated_reviews.items()
@@ -279,16 +244,29 @@ async def process_review_action(
         and auto_approve_requests.get(node_exec_id, False)
     ]
 
-    node_id_map = await _resolve_node_ids(
-        node_exec_ids_needing_auto_approval, graph_exec_id, is_copilot
-    )
-
-    # Deduplicate by node_id — one auto-approval per node
+    # Batch-fetch node executions to get node_ids
     nodes_needing_auto_approval: dict[str, Any] = {}
-    for node_exec_id in node_exec_ids_needing_auto_approval:
-        node_id = node_id_map.get(node_exec_id)
-        if node_id and node_id not in nodes_needing_auto_approval:
-            nodes_needing_auto_approval[node_id] = updated_reviews[node_exec_id]
+    if node_exec_ids_needing_auto_approval:
+        from backend.data.execution import get_node_executions
+
+        node_execs = await get_node_executions(
+            graph_exec_id=graph_exec_id, include_exec_data=False
+        )
+        node_exec_map = {node_exec.node_exec_id: node_exec for node_exec in node_execs}
+
+        for node_exec_id in node_exec_ids_needing_auto_approval:
+            node_exec = node_exec_map.get(node_exec_id)
+            if node_exec:
+                review_result = updated_reviews[node_exec_id]
+                # Use the first approved review for this node (deduplicate by node_id)
+                if node_exec.node_id not in nodes_needing_auto_approval:
+                    nodes_needing_auto_approval[node_exec.node_id] = review_result
+            else:
+                logger.error(
+                    f"Failed to create auto-approval record for {node_exec_id}: "
+                    f"Node execution not found. This may indicate a race condition "
+                    f"or data inconsistency."
+                )
 
     # Execute all auto-approval creations in parallel (deduplicated by node_id)
     auto_approval_results = await asyncio.gather(
@@ -303,11 +281,13 @@ async def process_review_action(
     auto_approval_failed_count = 0
     for result in auto_approval_results:
         if isinstance(result, Exception):
+            # Unexpected exception during auto-approval creation
             auto_approval_failed_count += 1
             logger.error(
                 f"Unexpected exception during auto-approval creation: {result}"
             )
         elif isinstance(result, tuple) and len(result) == 2 and not result[1]:
+            # Auto-approval creation failed (returned False)
             auto_approval_failed_count += 1
 
     # Count results
@@ -322,20 +302,22 @@ async def process_review_action(
         if review.status == ReviewStatus.REJECTED
     )
 
-    # Resume graph execution only for real graph executions (not CoPilot)
-    # CoPilot sessions are resumed by the LLM retrying run_block with review_id
-    if not is_copilot and updated_reviews:
+    # Resume execution only if ALL pending reviews for this execution have been processed
+    if updated_reviews:
         still_has_pending = await has_pending_reviews_for_graph_exec(graph_exec_id)
 
         if not still_has_pending:
+            # Get the graph_id from any processed review
             first_review = next(iter(updated_reviews.values()))
 
             try:
+                # Fetch user and settings to build complete execution context
                 user = await get_user_by_id(user_id)
                 settings = await get_graph_settings(
                     user_id=user_id, graph_id=first_review.graph_id
                 )
 
+                # Preserve user's timezone preference when resuming execution
                 user_timezone = (
                     user.timezone if user.timezone != USER_TIMEZONE_NOT_SET else "UTC"
                 )

autogpt_platform/backend/backend/api/features/integrations/conftest.py

@@ -1,13 +0,0 @@
-"""Override session-scoped fixtures so unit tests run without the server."""
-
-import pytest
-
-
-@pytest.fixture(scope="session")
-def server():
-    yield None
-
-
-@pytest.fixture(scope="session", autouse=True)
-def graph_cleanup():
-    yield

autogpt_platform/backend/backend/api/features/integrations/models.py

@@ -7,7 +7,6 @@ allowing frontend code generators like Orval to create corresponding TypeScript
 
 from pydantic import BaseModel, Field
 
-from backend.data.model import CredentialsType
 from backend.integrations.providers import ProviderName
 from backend.sdk.registry import AutoRegistry
 
@@ -48,57 +47,6 @@ class ProviderNamesResponse(BaseModel):
     )
 
 
-class ProviderMetadata(BaseModel):
-    """Display metadata for a provider, shown in the settings integrations UI."""
-
-    name: str = Field(description="Provider slug (e.g. ``github``)")
-    description: str | None = Field(
-        default=None,
-        description=(
-            "One-line human-readable summary of what the provider does. "
-            "Declared via ``ProviderBuilder.with_description(...)`` in the "
-            "provider's ``_config.py``. ``None`` if not set."
-        ),
-    )
-    supported_auth_types: list[CredentialsType] = Field(
-        default_factory=list,
-        description=(
-            "Credential types this provider accepts. Drives which connection "
-            "tabs the settings UI renders for the provider. Empty list means "
-            "no auth types declared."
-        ),
-    )
-
-
-def get_supported_auth_types(name: str) -> list[CredentialsType]:
-    """Return the provider's supported credential types from :class:`AutoRegistry`.
-
-    Populated by :meth:`ProviderBuilder.with_supported_auth_types` (or by
-    ``with_oauth`` / ``with_api_key`` / ``with_user_password`` when the provider
-    uses the full builder chain). Returns an empty list for providers with no
-    auth types declared.
-    """
-    provider = AutoRegistry.get_provider(name)
-    if provider is None:
-        return []
-    return sorted(provider.supported_auth_types)
-
-
-def get_provider_description(name: str) -> str | None:
-    """Return the provider's description from :class:`AutoRegistry`.
-
-    Descriptions are declared via ``ProviderBuilder.with_description(...)`` in
-    the provider's ``_config.py`` (SDK path) or in
-    ``blocks/_static_provider_configs.py`` (for providers that don't yet have
-    their own directory). Returns ``None`` for providers with no registered
-    description.
-    """
-    provider = AutoRegistry.get_provider(name)
-    if provider is None:
-        return None
-    return provider.description
-
-
 class ProviderConstants(BaseModel):
     """
     Model that exposes all provider names as a constant in the OpenAPI schema.

autogpt_platform/backend/backend/api/features/integrations/router.py

@@ -14,7 +14,7 @@ from fastapi import (
     Security,
     status,
 )
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, Field, SecretStr, model_validator
 from starlette.status import HTTP_500_INTERNAL_SERVER_ERROR, HTTP_502_BAD_GATEWAY
 
 from backend.api.features.library.db import set_preset_webhook, update_preset
@@ -29,32 +29,21 @@ from backend.data.integrations import (
     wait_for_webhook_event,
 )
 from backend.data.model import (
-    APIKeyCredentials,
     Credentials,
     CredentialsType,
     HostScopedCredentials,
     OAuth2Credentials,
-    is_sdk_default,
+    UserIntegrations,
 )
 from backend.data.onboarding import OnboardingStep, complete_onboarding_step
+from backend.data.user import get_user_integrations
 from backend.executor.utils import add_graph_execution
 from backend.integrations.ayrshare import AyrshareClient, SocialPlatform
-from backend.integrations.credentials_store import (
-    is_system_credential,
-    provider_matches,
-)
+from backend.integrations.credentials_store import provider_matches
 from backend.integrations.creds_manager import (
     IntegrationCredentialsManager,
     create_mcp_oauth_handler,
 )
-from backend.integrations.managed_credentials import (
-    ensure_managed_credential,
-    ensure_managed_credentials,
-)
-from backend.integrations.managed_providers.ayrshare import AyrshareManagedProvider
-from backend.integrations.managed_providers.ayrshare import (
-    settings_available as ayrshare_settings_available,
-)
 from backend.integrations.oauth import CREDENTIALS_BY_PROVIDER, HANDLERS_BY_NAME
 from backend.integrations.providers import ProviderName
 from backend.integrations.webhooks import get_webhook_manager
@@ -66,14 +55,7 @@ from backend.util.exceptions import (
 )
 from backend.util.settings import Settings
 
-from .models import (
-    ProviderConstants,
-    ProviderMetadata,
-    ProviderNamesResponse,
-    get_all_provider_names,
-    get_provider_description,
-    get_supported_auth_types,
-)
+from .models import ProviderConstants, ProviderNamesResponse, get_all_provider_names
 
 if TYPE_CHECKING:
     from backend.integrations.oauth import BaseOAuthHandler
@@ -100,23 +82,14 @@ async def login(
     scopes: Annotated[
         str, Query(title="Comma-separated list of authorization scopes")
     ] = "",
-    credential_id: Annotated[
-        str | None,
-        Query(title="ID of existing credential to upgrade scopes for"),
-    ] = None,
 ) -> LoginResponse:
     handler = _get_provider_oauth_handler(request, provider)
 
     requested_scopes = scopes.split(",") if scopes else []
 
-    if credential_id:
-        requested_scopes = await _prepare_scope_upgrade(
-            user_id, provider, credential_id, requested_scopes
-        )
-
     # Generate and store a secure random state token along with the scopes
     state_token, code_challenge = await creds_manager.store.store_state_token(
-        user_id, provider, requested_scopes, credential_id=credential_id
+        user_id, provider, requested_scopes
     )
     login_url = handler.get_login_url(
         requested_scopes, state_token, code_challenge=code_challenge
@@ -136,7 +109,6 @@ class CredentialsMetaResponse(BaseModel):
         default=None,
         description="Host pattern for host-scoped or MCP server URL for MCP credentials",
     )
-    is_managed: bool = False
 
     @model_validator(mode="before")
     @classmethod
@@ -166,19 +138,6 @@ class CredentialsMetaResponse(BaseModel):
         return None
 
 
-def to_meta_response(cred: Credentials) -> CredentialsMetaResponse:
-    return CredentialsMetaResponse(
-        id=cred.id,
-        provider=cred.provider,
-        type=cred.type,
-        title=cred.title,
-        scopes=cred.scopes if isinstance(cred, OAuth2Credentials) else None,
-        username=cred.username if isinstance(cred, OAuth2Credentials) else None,
-        host=CredentialsMetaResponse.get_host(cred),
-        is_managed=cred.is_managed,
-    )
-
-
 @router.post("/{provider}/callback", summary="Exchange OAuth code for tokens")
 async def callback(
     provider: Annotated[
@@ -238,54 +197,41 @@ async def callback(
         )
 
     # TODO: Allow specifying `title` to set on `credentials`
-    credentials = await _merge_or_create_credential(
-        user_id, provider, credentials, valid_state.credential_id
-    )
+    await creds_manager.create(user_id, credentials)
 
     logger.debug(
         f"Successfully processed OAuth callback for user {user_id} "
         f"and provider {provider.value}"
     )
 
-    return to_meta_response(credentials)
-
-
-# Bound the first-time sweep so a slow upstream (e.g. Ayrshare) can't hang
-# the credential-list endpoint.  On timeout we still kick off a fire-and-
-# forget sweep so provisioning eventually completes; the user just won't
-# see the managed cred until the next refresh.
-_MANAGED_PROVISION_TIMEOUT_S = 10.0
-
-
-async def _ensure_managed_credentials_bounded(user_id: str) -> None:
-    try:
-        await asyncio.wait_for(
-            ensure_managed_credentials(user_id, creds_manager.store),
-            timeout=_MANAGED_PROVISION_TIMEOUT_S,
-        )
-    except asyncio.TimeoutError:
-        logger.warning(
-            "Managed credential sweep exceeded %.1fs for user=%s; "
-            "continuing without it — provisioning will complete in background",
-            _MANAGED_PROVISION_TIMEOUT_S,
-            user_id,
-        )
-        asyncio.create_task(ensure_managed_credentials(user_id, creds_manager.store))
+    return CredentialsMetaResponse(
+        id=credentials.id,
+        provider=credentials.provider,
+        type=credentials.type,
+        title=credentials.title,
+        scopes=credentials.scopes,
+        username=credentials.username,
+        host=(CredentialsMetaResponse.get_host(credentials)),
+    )
 
 
 @router.get("/credentials", summary="List Credentials")
 async def list_credentials(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
-    # Block on provisioning so managed credentials appear on the first load
-    # instead of after a refresh, but with a timeout so a slow upstream
-    # can't hang the endpoint.  `_provisioned_users` short-circuits on
-    # repeat calls.
-    await _ensure_managed_credentials_bounded(user_id)
     credentials = await creds_manager.store.get_all_creds(user_id)
 
     return [
-        to_meta_response(cred) for cred in credentials if not is_sdk_default(cred.id)
+        CredentialsMetaResponse(
+            id=cred.id,
+            provider=cred.provider,
+            type=cred.type,
+            title=cred.title,
+            scopes=cred.scopes if isinstance(cred, OAuth2Credentials) else None,
+            username=cred.username if isinstance(cred, OAuth2Credentials) else None,
+            host=CredentialsMetaResponse.get_host(cred),
+        )
+        for cred in credentials
     ]
 
 
@@ -296,11 +242,19 @@ async def list_credentials_by_provider(
     ],
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
-    await _ensure_managed_credentials_bounded(user_id)
     credentials = await creds_manager.store.get_creds_by_provider(user_id, provider)
 
     return [
-        to_meta_response(cred) for cred in credentials if not is_sdk_default(cred.id)
+        CredentialsMetaResponse(
+            id=cred.id,
+            provider=cred.provider,
+            type=cred.type,
+            title=cred.title,
+            scopes=cred.scopes if isinstance(cred, OAuth2Credentials) else None,
+            username=cred.username if isinstance(cred, OAuth2Credentials) else None,
+            host=CredentialsMetaResponse.get_host(cred),
+        )
+        for cred in credentials
     ]
 
 
@@ -313,130 +267,18 @@ async def get_credential(
     ],
     cred_id: Annotated[str, Path(title="The ID of the credentials to retrieve")],
     user_id: Annotated[str, Security(get_user_id)],
-) -> CredentialsMetaResponse:
-    if is_sdk_default(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
+) -> Credentials:
     credential = await creds_manager.get(user_id, cred_id)
     if not credential:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
         )
-    if not provider_matches(credential.provider, provider):
+    if credential.provider != provider:
         raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Credentials do not match the specified provider",
         )
-    return to_meta_response(credential)
-
-
-class PickerTokenResponse(BaseModel):
-    """Short-lived OAuth access token shipped to the browser for rendering a
-    provider-hosted picker UI (e.g. Google Drive Picker). Deliberately narrow:
-    only the fields the client needs to initialize the picker widget. Issued
-    from the user's own stored credential so ownership and scope gating are
-    enforced by the credential lookup."""
-
-    access_token: str = Field(
-        description="OAuth access token suitable for the picker SDK call."
-    )
-    access_token_expires_at: int | None = Field(
-        default=None,
-        description="Unix timestamp at which the access token expires, if known.",
-    )
-
-
-# Allowlist of (provider, scopes) tuples that may mint picker tokens. Only
-# Drive-picker-capable scopes qualify so a caller can't use this endpoint to
-# extract a GitHub / other-provider OAuth token for unrelated purposes. If a
-# future provider integrates a hosted picker that needs a raw access token,
-# add its specific picker-relevant scopes here.
-_PICKER_TOKEN_ALLOWED_SCOPES: dict[ProviderName, frozenset[str]] = {
-    ProviderName.GOOGLE: frozenset(
-        [
-            "https://www.googleapis.com/auth/drive.file",
-            "https://www.googleapis.com/auth/drive.readonly",
-            "https://www.googleapis.com/auth/drive",
-        ]
-    ),
-}
-
-
-@router.post(
-    "/{provider}/credentials/{cred_id}/picker-token",
-    summary="Issue a short-lived access token for a provider-hosted picker",
-    operation_id="postV1GetPickerToken",
-)
-async def get_picker_token(
-    provider: Annotated[
-        ProviderName, Path(title="The provider that owns the credentials")
-    ],
-    cred_id: Annotated[
-        str, Path(title="The ID of the OAuth2 credentials to mint a token from")
-    ],
-    user_id: Annotated[str, Security(get_user_id)],
-) -> PickerTokenResponse:
-    """Return the raw access token for an OAuth2 credential so the frontend
-    can initialize a provider-hosted picker (e.g. Google Drive Picker).
-
-    `GET /{provider}/credentials/{cred_id}` deliberately strips secrets (see
-    `CredentialsMetaResponse` + `TestGetCredentialReturnsMetaOnly` in
-    `router_test.py`). That hardening broke the Drive picker, which needs the
-    raw access token to call `google.picker.Builder.setOAuthToken(...)`. This
-    endpoint carves a narrow, explicit hole: the caller must own the
-    credential, it must be OAuth2, and the endpoint returns only the access
-    token + its expiry — nothing else about the credential. SDK-default
-    credentials are excluded for the same reason as `get_credential`.
-    """
-    if is_sdk_default(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
-
-    credential = await creds_manager.get(user_id, cred_id)
-    if not credential:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
-    if not provider_matches(credential.provider, provider):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
-    if not isinstance(credential, OAuth2Credentials):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Picker tokens are only available for OAuth2 credentials",
-        )
-    if not credential.access_token:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Credential has no access token; reconnect the account",
-        )
-
-    # Gate on provider+scope: only credentials that actually grant access to
-    # a provider-hosted picker flow may mint a token through this endpoint.
-    # Prevents using this path to extract bearer tokens for unrelated OAuth
-    # integrations (e.g. GitHub) that happen to be stored under the same user.
-    allowed_scopes = _PICKER_TOKEN_ALLOWED_SCOPES.get(provider)
-    if not allowed_scopes:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=(f"Picker tokens are not available for provider '{provider.value}'"),
-        )
-    cred_scopes = set(credential.scopes or [])
-    if cred_scopes.isdisjoint(allowed_scopes):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=(
-                "Credential does not grant any scope eligible for the picker. "
-                "Reconnect with the appropriate scope."
-            ),
-        )
-
-    return PickerTokenResponse(
-        access_token=credential.access_token.get_secret_value(),
-        access_token_expires_at=credential.access_token_expires_at,
-    )
+    return credential
 
 
 @router.post("/{provider}/credentials", status_code=201, summary="Create Credentials")
@@ -446,22 +288,16 @@ async def create_credentials(
         ProviderName, Path(title="The provider to create credentials for")
     ],
     credentials: Credentials,
-) -> CredentialsMetaResponse:
-    if is_sdk_default(credentials.id):
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Cannot create credentials with a reserved ID",
-        )
+) -> Credentials:
     credentials.provider = provider
     try:
         await creds_manager.create(user_id, credentials)
-    except Exception:
-        logger.exception("Failed to store credentials")
+    except Exception as e:
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to store credentials",
+            detail=f"Failed to store credentials: {str(e)}",
         )
-    return to_meta_response(credentials)
+    return credentials
 
 
 class CredentialsDeletionResponse(BaseModel):
@@ -496,29 +332,15 @@ async def delete_credentials(
         bool, Query(title="Whether to proceed if any linked webhooks are still in use")
     ] = False,
 ) -> CredentialsDeletionResponse | CredentialsDeletionNeedsConfirmationResponse:
-    if is_sdk_default(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
-    if is_system_credential(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="System-managed credentials cannot be deleted",
-        )
     creds = await creds_manager.store.get_creds_by_id(user_id, cred_id)
     if not creds:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
         )
-    if not provider_matches(creds.provider, provider):
+    if creds.provider != provider:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
-            detail="Credentials not found",
-        )
-    if creds.is_managed:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="AutoGPT-managed credentials cannot be deleted",
+            detail="Credentials do not match the specified provider",
         )
 
     try:
@@ -732,186 +554,6 @@ async def _execute_webhook_preset_trigger(
         # Continue processing - webhook should be resilient to individual failures
 
 
-# -------------------- INCREMENTAL AUTH HELPERS -------------------- #
-
-
-async def _prepare_scope_upgrade(
-    user_id: str,
-    provider: ProviderName,
-    credential_id: str,
-    requested_scopes: list[str],
-) -> list[str]:
-    """Validate an existing credential for scope upgrade and compute scopes.
-
-    For providers without native incremental auth (e.g. GitHub), returns the
-    union of existing + requested scopes.  For providers that handle merging
-    server-side (e.g. Google with ``include_granted_scopes``), returns the
-    requested scopes unchanged.
-
-    Raises HTTPException on validation failure.
-    """
-    # Platform-owned system credentials must never be upgraded — scope
-    # changes here would leak across every user that shares them.
-    if is_system_credential(credential_id):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="System credentials cannot be upgraded",
-        )
-
-    existing = await creds_manager.store.get_creds_by_id(user_id, credential_id)
-    if not existing:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Credential to upgrade not found",
-        )
-    if not isinstance(existing, OAuth2Credentials):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Only OAuth2 credentials can be upgraded",
-        )
-    if not provider_matches(existing.provider, provider.value):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Credential provider does not match the requested provider",
-        )
-    if existing.is_managed:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Managed credentials cannot be upgraded",
-        )
-
-    # Google handles scope merging via include_granted_scopes; others need
-    # the union of existing + new scopes in the login URL.
-    if provider != ProviderName.GOOGLE:
-        requested_scopes = list(set(requested_scopes) | set(existing.scopes))
-
-    return requested_scopes
-
-
-async def _merge_or_create_credential(
-    user_id: str,
-    provider: ProviderName,
-    credentials: OAuth2Credentials,
-    credential_id: str | None,
-) -> OAuth2Credentials:
-    """Either upgrade an existing credential or create a new one.
-
-    When *credential_id* is set (explicit upgrade), merges scopes and updates
-    the existing credential.  Otherwise, checks for an implicit merge (same
-    provider + username) before falling back to creating a new credential.
-    """
-    if credential_id:
-        return await _upgrade_existing_credential(user_id, credential_id, credentials)
-
-    # Implicit merge: check for existing credential with same provider+username.
-    # Skip managed/system credentials and require a non-None username on both
-    # sides so we never accidentally merge unrelated credentials.
-    if credentials.username is None:
-        await creds_manager.create(user_id, credentials)
-        return credentials
-
-    existing_creds = await creds_manager.store.get_creds_by_provider(user_id, provider)
-    matching = next(
-        (
-            c
-            for c in existing_creds
-            if isinstance(c, OAuth2Credentials)
-            and not c.is_managed
-            and not is_system_credential(c.id)
-            and c.username is not None
-            and c.username == credentials.username
-        ),
-        None,
-    )
-    if matching:
-        # Only merge into the existing credential when the new token
-        # already covers every scope we're about to advertise on it.
-        # Without this guard we'd overwrite ``matching.access_token`` with
-        # a narrower token while storing a wider ``scopes`` list — the
-        # record would claim authorizations the token does not grant, and
-        # blocks using the lost scopes would fail with opaque 401/403s
-        # until the user hits re-auth.  On a narrowing login, keep the
-        # two credentials separate instead.
-        if set(credentials.scopes).issuperset(set(matching.scopes)):
-            return await _upgrade_existing_credential(user_id, matching.id, credentials)
-
-    await creds_manager.create(user_id, credentials)
-    return credentials
-
-
-async def _upgrade_existing_credential(
-    user_id: str,
-    existing_cred_id: str,
-    new_credentials: OAuth2Credentials,
-) -> OAuth2Credentials:
-    """Merge scopes from *new_credentials* into an existing credential."""
-    # Defense-in-depth: re-check system and provider invariants right before
-    # the write.  The login-time check in `_prepare_scope_upgrade` can go stale
-    # by the time the callback runs, and the implicit-merge path bypasses
-    # login-time validation entirely, so every write-path must enforce these
-    # on its own.
-    if is_system_credential(existing_cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="System credentials cannot be upgraded",
-        )
-    existing = await creds_manager.store.get_creds_by_id(user_id, existing_cred_id)
-    if not existing or not isinstance(existing, OAuth2Credentials):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Credential to upgrade not found",
-        )
-    if existing.is_managed:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Managed credentials cannot be upgraded",
-        )
-    if not provider_matches(existing.provider, new_credentials.provider):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Credential provider does not match the requested provider",
-        )
-
-    if (
-        existing.username
-        and new_credentials.username
-        and existing.username != new_credentials.username
-    ):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Username mismatch: authenticated as a different user",
-        )
-
-    # Operate on a copy so the caller's ``new_credentials`` object is not
-    # mutated out from under them.  Every caller today immediately discards
-    # or replaces its reference, but the implicit-merge path in
-    # ``_merge_or_create_credential`` reads ``credentials.scopes`` before
-    # calling into us — a future reader after the call would otherwise
-    # silently see the overwritten values.
-    merged = new_credentials.model_copy(deep=True)
-    merged.id = existing.id
-    merged.title = existing.title
-    merged.scopes = list(set(existing.scopes) | set(new_credentials.scopes))
-    merged.metadata = {
-        **(existing.metadata or {}),
-        **(new_credentials.metadata or {}),
-    }
-    # Preserve the existing refresh_token and username if the incremental
-    # response doesn't carry them.  Providers like Google only return a
-    # refresh_token on first authorization — dropping it here would orphan
-    # the credential on the next access-token expiry, forcing the user to
-    # re-auth from scratch. Username is similarly sticky: if we've already
-    # resolved it for this credential, keep it rather than silently
-    # blanking it on an incremental upgrade.
-    if not merged.refresh_token and existing.refresh_token:
-        merged.refresh_token = existing.refresh_token
-        merged.refresh_token_expires_at = existing.refresh_token_expires_at
-    if not merged.username and existing.username:
-        merged.username = existing.username
-    await creds_manager.update(user_id, merged)
-    return merged
-
-
 # --------------------------- UTILITIES ---------------------------- #
 
 
@@ -1122,21 +764,12 @@ def _get_provider_oauth_handler(
 async def get_ayrshare_sso_url(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> AyrshareSSOResponse:
-    """Generate a JWT SSO URL so the user can link their social accounts.
-
-    The per-user Ayrshare profile key is provisioned and persisted as a
-    standard ``is_managed=True`` credential by
-    :class:`~backend.integrations.managed_providers.ayrshare.AyrshareManagedProvider`.
-    This endpoint only signs a short-lived JWT pointing at the Ayrshare-
-    hosted social-linking page; all profile lifecycle logic lives with the
-    managed provider.
     """
-    if not ayrshare_settings_available():
-        raise HTTPException(
-            status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Ayrshare integration is not configured",
-        )
+    Generate an SSO URL for Ayrshare social media integration.
 
+    Returns:
+        dict: Contains the SSO URL for Ayrshare integration
+    """
     try:
         client = AyrshareClient()
     except MissingConfigError:
@@ -1145,63 +778,66 @@ async def get_ayrshare_sso_url(
             detail="Ayrshare integration is not configured",
         )
 
-    # On-demand provisioning: AyrshareManagedProvider opts out of the
-    # credentials sweep (profile quota is per-user subscription-bound).  This
-    # endpoint is the only trigger that provisions a profile — one Ayrshare
-    # profile per user who actually opens the connect flow, not one per
-    # every authenticated user.
-    provisioned = await ensure_managed_credential(
-        user_id, creds_manager.store, AyrshareManagedProvider()
-    )
-    if not provisioned:
-        raise HTTPException(
-            status_code=HTTP_502_BAD_GATEWAY,
-            detail="Failed to provision Ayrshare profile",
-        )
+    # Ayrshare profile key is stored in the credentials store
+    # It is generated when creating a new profile, if there is no profile key,
+    # we create a new profile and store the profile key in the credentials store
 
-    ayrshare_creds = [
-        c
-        for c in await creds_manager.store.get_creds_by_provider(user_id, "ayrshare")
-        if c.is_managed and isinstance(c, APIKeyCredentials)
-    ]
-    if not ayrshare_creds:
-        logger.error(
-            "Ayrshare credential provisioning did not produce a credential "
-            "for user %s",
-            user_id,
-        )
-        raise HTTPException(
-            status_code=HTTP_502_BAD_GATEWAY,
-            detail="Failed to provision Ayrshare profile",
-        )
-    profile_key_str = ayrshare_creds[0].api_key.get_secret_value()
+    user_integrations: UserIntegrations = await get_user_integrations(user_id)
+    profile_key = user_integrations.managed_credentials.ayrshare_profile_key
+
+    if not profile_key:
+        logger.debug(f"Creating new Ayrshare profile for user {user_id}")
+        try:
+            profile = await client.create_profile(
+                title=f"User {user_id}", messaging_active=True
+            )
+            profile_key = profile.profileKey
+            await creds_manager.store.set_ayrshare_profile_key(user_id, profile_key)
+        except Exception as e:
+            logger.error(f"Error creating Ayrshare profile for user {user_id}: {e}")
+            raise HTTPException(
+                status_code=HTTP_502_BAD_GATEWAY,
+                detail="Failed to create Ayrshare profile",
+            )
+    else:
+        logger.debug(f"Using existing Ayrshare profile for user {user_id}")
+
+    profile_key_str = (
+        profile_key.get_secret_value()
+        if isinstance(profile_key, SecretStr)
+        else str(profile_key)
+    )
 
     private_key = settings.secrets.ayrshare_jwt_key
-    # Ayrshare JWT max lifetime is 2880 minutes (48 h).
+    # Ayrshare JWT expiry is 2880 minutes (48 hours)
     max_expiry_minutes = 2880
     try:
+        logger.debug(f"Generating Ayrshare JWT for user {user_id}")
         jwt_response = await client.generate_jwt(
             private_key=private_key,
             profile_key=profile_key_str,
-            # `allowed_social` is the set of networks the Ayrshare-hosted
-            # social-linking page will *offer* the user to connect.  Blocks
-            # exist for more platforms than are listed here; the list is
-            # deliberately narrower so the rollout can verify each network
-            # end-to-end before widening the user-visible surface.  Keep
-            # in sync with tested platforms — extend as each is verified
-            # against the block + Ayrshare's network-specific quirks.
             allowed_social=[
+                # NOTE: We are enabling platforms one at a time
+                # to speed up the development process
+                # SocialPlatform.FACEBOOK,
                 SocialPlatform.TWITTER,
                 SocialPlatform.LINKEDIN,
                 SocialPlatform.INSTAGRAM,
                 SocialPlatform.YOUTUBE,
+                # SocialPlatform.REDDIT,
+                # SocialPlatform.TELEGRAM,
+                # SocialPlatform.GOOGLE_MY_BUSINESS,
+                # SocialPlatform.PINTEREST,
                 SocialPlatform.TIKTOK,
+                # SocialPlatform.BLUESKY,
+                # SocialPlatform.SNAPCHAT,
+                # SocialPlatform.THREADS,
             ],
             expires_in=max_expiry_minutes,
             verify=True,
         )
-    except Exception as exc:
-        logger.error("Error generating Ayrshare JWT for user %s: %s", user_id, exc)
+    except Exception as e:
+        logger.error(f"Error generating Ayrshare JWT for user {user_id}: {e}")
         raise HTTPException(
             status_code=HTTP_502_BAD_GATEWAY, detail="Failed to generate JWT"
         )
@@ -1211,37 +847,20 @@ async def get_ayrshare_sso_url(
 
 
 # === PROVIDER DISCOVERY ENDPOINTS ===
-@router.get("/providers", response_model=List[ProviderMetadata])
-async def list_providers() -> List[ProviderMetadata]:
+@router.get("/providers", response_model=List[str])
+async def list_providers() -> List[str]:
     """
-    Get metadata for every available provider.
+    Get a list of all available provider names.
 
-    Returns both statically defined providers (from ``ProviderName`` enum) and
-    dynamically registered providers (from SDK decorators). Each entry includes
-    a ``description`` declared via ``ProviderBuilder.with_description(...)`` in
-    the provider's ``_config.py``.
+    Returns both statically defined providers (from ProviderName enum)
+    and dynamically registered providers (from SDK decorators).
 
     Note: The complete list of provider names is also available as a constant
     in the generated TypeScript client via PROVIDER_NAMES.
     """
-    # Ensure all block modules (and therefore every provider's _config.py) are
-    # imported before we read from AutoRegistry. Cached on first call.
-    try:
-        from backend.blocks import load_all_blocks
-
-        load_all_blocks()
-    except Exception as e:
-        logger.warning(f"Failed to load blocks for provider metadata: {e}")
-
+    # Get all providers at runtime
     all_providers = get_all_provider_names()
-    return [
-        ProviderMetadata(
-            name=name,
-            description=get_provider_description(name),
-            supported_auth_types=get_supported_auth_types(name),
-        )
-        for name in all_providers
-    ]
+    return all_providers
 
 
 @router.get("/providers/system", response_model=List[str])

autogpt_platform/backend/backend/api/features/integrations/router_test.py

@@ -1,748 +0,0 @@
-"""Tests for credentials API security: no secret leakage, SDK defaults filtered."""
-
-from contextlib import asynccontextmanager
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import fastapi
-import fastapi.testclient
-import pytest
-from pydantic import SecretStr
-
-from backend.api.features.integrations.router import router
-from backend.data.model import (
-    APIKeyCredentials,
-    HostScopedCredentials,
-    OAuth2Credentials,
-    UserPasswordCredentials,
-)
-
-app = fastapi.FastAPI()
-app.include_router(router)
-client = fastapi.testclient.TestClient(app)
-
-TEST_USER_ID = "test-user-id"
-
-
-def _make_api_key_cred(cred_id: str = "cred-123", provider: str = "openai"):
-    return APIKeyCredentials(
-        id=cred_id,
-        provider=provider,
-        title="My API Key",
-        api_key=SecretStr("sk-secret-key-value"),
-    )
-
-
-def _make_oauth2_cred(cred_id: str = "cred-456", provider: str = "github"):
-    return OAuth2Credentials(
-        id=cred_id,
-        provider=provider,
-        title="My OAuth",
-        access_token=SecretStr("ghp_secret_token"),
-        refresh_token=SecretStr("ghp_refresh_secret"),
-        scopes=["repo", "user"],
-        username="testuser",
-    )
-
-
-def _make_user_password_cred(cred_id: str = "cred-789", provider: str = "openai"):
-    return UserPasswordCredentials(
-        id=cred_id,
-        provider=provider,
-        title="My Login",
-        username=SecretStr("admin"),
-        password=SecretStr("s3cret-pass"),
-    )
-
-
-def _make_host_scoped_cred(cred_id: str = "cred-host", provider: str = "openai"):
-    return HostScopedCredentials(
-        id=cred_id,
-        provider=provider,
-        title="Host Cred",
-        host="https://api.example.com",
-        headers={"Authorization": SecretStr("Bearer top-secret")},
-    )
-
-
-def _make_sdk_default_cred(provider: str = "openai"):
-    return APIKeyCredentials(
-        id=f"{provider}-default",
-        provider=provider,
-        title=f"{provider} (default)",
-        api_key=SecretStr("sk-platform-secret-key"),
-    )
-
-
-@pytest.fixture(autouse=True)
-def setup_auth(mock_jwt_user):
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
-
-
-class TestGetCredentialReturnsMetaOnly:
-    """GET /{provider}/credentials/{cred_id} must not return secrets."""
-
-    def test_api_key_credential_no_secret(self):
-        cred = _make_api_key_cred()
-        with (
-            patch.object(router, "dependencies", []),
-            patch("backend.api.features.integrations.router.creds_manager") as mock_mgr,
-        ):
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/openai/credentials/cred-123")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["id"] == "cred-123"
-        assert data["provider"] == "openai"
-        assert data["type"] == "api_key"
-        assert "api_key" not in data
-        assert "sk-secret-key-value" not in str(data)
-
-    def test_oauth2_credential_no_secret(self):
-        cred = _make_oauth2_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/github/credentials/cred-456")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["id"] == "cred-456"
-        assert data["scopes"] == ["repo", "user"]
-        assert data["username"] == "testuser"
-        assert "access_token" not in data
-        assert "refresh_token" not in data
-        assert "ghp_" not in str(data)
-
-    def test_user_password_credential_no_secret(self):
-        cred = _make_user_password_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/openai/credentials/cred-789")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["id"] == "cred-789"
-        assert "password" not in data
-        assert "username" not in data or data["username"] is None
-        assert "s3cret-pass" not in str(data)
-        assert "admin" not in str(data)
-
-    def test_host_scoped_credential_no_secret(self):
-        cred = _make_host_scoped_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/openai/credentials/cred-host")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["id"] == "cred-host"
-        assert data["host"] == "https://api.example.com"
-        assert "headers" not in data
-        assert "top-secret" not in str(data)
-
-    def test_get_credential_wrong_provider_returns_404(self):
-        """Provider mismatch should return generic 404, not leak credential existence."""
-        cred = _make_api_key_cred(provider="openai")
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/github/credentials/cred-123")
-
-        assert resp.status_code == 404
-        assert resp.json()["detail"] == "Credentials not found"
-
-    def test_list_credentials_no_secrets(self):
-        """List endpoint must not leak secrets in any credential."""
-        creds = [_make_api_key_cred(), _make_oauth2_cred()]
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_all_creds = AsyncMock(return_value=creds)
-            resp = client.get("/credentials")
-
-        assert resp.status_code == 200
-        raw = str(resp.json())
-        assert "sk-secret-key-value" not in raw
-        assert "ghp_secret_token" not in raw
-        assert "ghp_refresh_secret" not in raw
-
-
-class TestSdkDefaultCredentialsNotAccessible:
-    """SDK default credentials (ID ending in '-default') must be hidden."""
-
-    def test_get_sdk_default_returns_404(self):
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock()
-            resp = client.get("/openai/credentials/openai-default")
-
-        assert resp.status_code == 404
-        mock_mgr.get.assert_not_called()
-
-    def test_list_credentials_excludes_sdk_defaults(self):
-        user_cred = _make_api_key_cred()
-        sdk_cred = _make_sdk_default_cred("openai")
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_all_creds = AsyncMock(return_value=[user_cred, sdk_cred])
-            resp = client.get("/credentials")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        ids = [c["id"] for c in data]
-        assert "cred-123" in ids
-        assert "openai-default" not in ids
-
-    def test_list_by_provider_excludes_sdk_defaults(self):
-        user_cred = _make_api_key_cred()
-        sdk_cred = _make_sdk_default_cred("openai")
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_creds_by_provider = AsyncMock(
-                return_value=[user_cred, sdk_cred]
-            )
-            resp = client.get("/openai/credentials")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        ids = [c["id"] for c in data]
-        assert "cred-123" in ids
-        assert "openai-default" not in ids
-
-    def test_delete_sdk_default_returns_404(self):
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_creds_by_id = AsyncMock()
-            resp = client.request("DELETE", "/openai/credentials/openai-default")
-
-        assert resp.status_code == 404
-        mock_mgr.store.get_creds_by_id.assert_not_called()
-
-
-class TestCreateCredentialNoSecretInResponse:
-    """POST /{provider}/credentials must not return secrets."""
-
-    def test_create_api_key_no_secret_in_response(self):
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.create = AsyncMock()
-            resp = client.post(
-                "/openai/credentials",
-                json={
-                    "id": "new-cred",
-                    "provider": "openai",
-                    "type": "api_key",
-                    "title": "New Key",
-                    "api_key": "sk-newsecret",
-                },
-            )
-
-        assert resp.status_code == 201
-        data = resp.json()
-        assert data["id"] == "new-cred"
-        assert "api_key" not in data
-        assert "sk-newsecret" not in str(data)
-
-    def test_create_with_sdk_default_id_rejected(self):
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.create = AsyncMock()
-            resp = client.post(
-                "/openai/credentials",
-                json={
-                    "id": "openai-default",
-                    "provider": "openai",
-                    "type": "api_key",
-                    "title": "Sneaky",
-                    "api_key": "sk-evil",
-                },
-            )
-
-        assert resp.status_code == 403
-        mock_mgr.create.assert_not_called()
-
-
-class TestManagedCredentials:
-    """AutoGPT-managed credentials cannot be deleted by users."""
-
-    def test_delete_is_managed_returns_403(self):
-        cred = APIKeyCredentials(
-            id="managed-cred-1",
-            provider="agent_mail",
-            title="AgentMail (managed by AutoGPT)",
-            api_key=SecretStr("sk-managed-key"),
-            is_managed=True,
-        )
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_creds_by_id = AsyncMock(return_value=cred)
-            resp = client.request("DELETE", "/agent_mail/credentials/managed-cred-1")
-
-        assert resp.status_code == 403
-        assert "AutoGPT-managed" in resp.json()["detail"]
-
-    def test_list_credentials_includes_is_managed_field(self):
-        managed = APIKeyCredentials(
-            id="managed-1",
-            provider="agent_mail",
-            title="AgentMail (managed)",
-            api_key=SecretStr("sk-key"),
-            is_managed=True,
-        )
-        regular = APIKeyCredentials(
-            id="regular-1",
-            provider="openai",
-            title="My Key",
-            api_key=SecretStr("sk-key"),
-        )
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_all_creds = AsyncMock(return_value=[managed, regular])
-            resp = client.get("/credentials")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        managed_cred = next(c for c in data if c["id"] == "managed-1")
-        regular_cred = next(c for c in data if c["id"] == "regular-1")
-        assert managed_cred["is_managed"] is True
-        assert regular_cred["is_managed"] is False
-
-
-# ---------------------------------------------------------------------------
-# Managed credential provisioning infrastructure
-# ---------------------------------------------------------------------------
-
-
-def _make_managed_cred(
-    provider: str = "agent_mail", pod_id: str = "pod-abc"
-) -> APIKeyCredentials:
-    return APIKeyCredentials(
-        id="managed-auto",
-        provider=provider,
-        title="AgentMail (managed by AutoGPT)",
-        api_key=SecretStr("sk-pod-key"),
-        is_managed=True,
-        metadata={"pod_id": pod_id},
-    )
-
-
-def _make_store_mock(**kwargs) -> MagicMock:
-    """Create a store mock with a working async ``locks()`` context manager."""
-
-    @asynccontextmanager
-    async def _noop_locked(key):
-        yield
-
-    locks_obj = MagicMock()
-    locks_obj.locked = _noop_locked
-
-    store = MagicMock(**kwargs)
-    store.locks = AsyncMock(return_value=locks_obj)
-    return store
-
-
-class TestEnsureManagedCredentials:
-    """Unit tests for the ensure/cleanup helpers in managed_credentials.py."""
-
-    @pytest.mark.asyncio
-    async def test_provisions_when_missing(self):
-        """Provider.provision() is called when no managed credential exists."""
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            _provisioned_users,
-            ensure_managed_credentials,
-        )
-
-        cred = _make_managed_cred()
-        provider = MagicMock()
-        provider.provider_name = "test_provider"
-        provider.is_available = AsyncMock(return_value=True)
-        provider.provision = AsyncMock(return_value=cred)
-
-        store = _make_store_mock()
-        store.has_managed_credential = AsyncMock(return_value=False)
-        store.add_managed_credential = AsyncMock()
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["test_provider"] = provider
-        _provisioned_users.pop("user-1", None)
-        try:
-            await ensure_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-            _provisioned_users.pop("user-1", None)
-
-        provider.provision.assert_awaited_once_with("user-1", store)
-        store.add_managed_credential.assert_awaited_once_with("user-1", cred)
-
-    @pytest.mark.asyncio
-    async def test_skips_when_already_exists(self):
-        """Provider.provision() is NOT called when managed credential exists."""
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            _provisioned_users,
-            ensure_managed_credentials,
-        )
-
-        provider = MagicMock()
-        provider.provider_name = "test_provider"
-        provider.is_available = AsyncMock(return_value=True)
-        provider.provision = AsyncMock()
-
-        store = _make_store_mock()
-        store.has_managed_credential = AsyncMock(return_value=True)
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["test_provider"] = provider
-        _provisioned_users.pop("user-1", None)
-        try:
-            await ensure_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-            _provisioned_users.pop("user-1", None)
-
-        provider.provision.assert_not_awaited()
-
-    @pytest.mark.asyncio
-    async def test_skips_when_unavailable(self):
-        """Provider.provision() is NOT called when provider is not available."""
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            _provisioned_users,
-            ensure_managed_credentials,
-        )
-
-        provider = MagicMock()
-        provider.provider_name = "test_provider"
-        provider.is_available = AsyncMock(return_value=False)
-        provider.provision = AsyncMock()
-
-        store = _make_store_mock()
-        store.has_managed_credential = AsyncMock()
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["test_provider"] = provider
-        _provisioned_users.pop("user-1", None)
-        try:
-            await ensure_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-            _provisioned_users.pop("user-1", None)
-
-        provider.provision.assert_not_awaited()
-        store.has_managed_credential.assert_not_awaited()
-
-    @pytest.mark.asyncio
-    async def test_provision_failure_does_not_propagate(self):
-        """A failed provision is logged but does not raise."""
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            _provisioned_users,
-            ensure_managed_credentials,
-        )
-
-        provider = MagicMock()
-        provider.provider_name = "test_provider"
-        provider.is_available = AsyncMock(return_value=True)
-        provider.provision = AsyncMock(side_effect=RuntimeError("boom"))
-
-        store = _make_store_mock()
-        store.has_managed_credential = AsyncMock(return_value=False)
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["test_provider"] = provider
-        _provisioned_users.pop("user-1", None)
-        try:
-            await ensure_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-            _provisioned_users.pop("user-1", None)
-
-        # No exception raised — provisioning failure is swallowed.
-
-
-class TestCleanupManagedCredentials:
-    """Unit tests for cleanup_managed_credentials."""
-
-    @pytest.mark.asyncio
-    async def test_calls_deprovision_for_managed_creds(self):
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            cleanup_managed_credentials,
-        )
-
-        cred = _make_managed_cred()
-        provider = MagicMock()
-        provider.provider_name = "agent_mail"
-        provider.deprovision = AsyncMock()
-
-        store = MagicMock()
-        store.get_all_creds = AsyncMock(return_value=[cred])
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["agent_mail"] = provider
-        try:
-            await cleanup_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-
-        provider.deprovision.assert_awaited_once_with("user-1", cred)
-
-    @pytest.mark.asyncio
-    async def test_skips_non_managed_creds(self):
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            cleanup_managed_credentials,
-        )
-
-        regular = _make_api_key_cred()
-        provider = MagicMock()
-        provider.provider_name = "openai"
-        provider.deprovision = AsyncMock()
-
-        store = MagicMock()
-        store.get_all_creds = AsyncMock(return_value=[regular])
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["openai"] = provider
-        try:
-            await cleanup_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-
-        provider.deprovision.assert_not_awaited()
-
-    @pytest.mark.asyncio
-    async def test_deprovision_failure_does_not_propagate(self):
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            cleanup_managed_credentials,
-        )
-
-        cred = _make_managed_cred()
-        provider = MagicMock()
-        provider.provider_name = "agent_mail"
-        provider.deprovision = AsyncMock(side_effect=RuntimeError("boom"))
-
-        store = MagicMock()
-        store.get_all_creds = AsyncMock(return_value=[cred])
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["agent_mail"] = provider
-        try:
-            await cleanup_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-
-        # No exception raised — cleanup failure is swallowed.
-
-
-class TestGetPickerToken:
-    """POST /{provider}/credentials/{cred_id}/picker-token must:
-    1. Return the access token for OAuth2 creds the caller owns.
-    2. 404 for non-owned, non-existent, or wrong-provider creds.
-    3. 400 for non-OAuth2 creds (API key, host-scoped, user/password).
-    4. 404 for SDK default creds (same hardening as get_credential).
-    5. Preserve the `TestGetCredentialReturnsMetaOnly` contract — the
-       existing meta-only endpoint must still strip secrets even after
-       this picker-token endpoint exists."""
-
-    def test_oauth2_owner_gets_access_token(self):
-        # Use a Google cred with a drive.file scope — only picker-eligible
-        # (provider, scope) pairs can mint a token. GitHub-style creds are
-        # explicitly rejected; see `test_non_picker_provider_rejected_as_400`.
-        cred = _make_oauth2_cred(
-            cred_id="cred-gdrive",
-            provider="google",
-        )
-        cred.scopes = ["https://www.googleapis.com/auth/drive.file"]
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.post("/google/credentials/cred-gdrive/picker-token")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        # The whole point of this endpoint: the access token IS returned here.
-        assert data["access_token"] == "ghp_secret_token"
-        # Only the two declared fields come back — nothing else leaks.
-        assert set(data.keys()) <= {"access_token", "access_token_expires_at"}
-
-    def test_non_picker_provider_rejected_as_400(self):
-        """Provider allowlist: even with a valid OAuth2 credential, a
-        non-picker provider (GitHub, etc.) cannot mint a picker token.
-        Stops this endpoint from being used as a generic bearer-token
-        extraction path for any stored OAuth cred under the same user."""
-        cred = _make_oauth2_cred(provider="github")
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.post("/github/credentials/cred-456/picker-token")
-
-        assert resp.status_code == 400
-        assert "not available for provider" in resp.json()["detail"]
-        assert "ghp_secret_token" not in str(resp.json())
-
-    def test_google_oauth_without_drive_scope_rejected(self):
-        """Scope allowlist: a Google OAuth2 cred that only carries non-picker
-        scopes (e.g. gmail.readonly, calendar) cannot mint a picker token.
-        Forces the frontend to reconnect with a Drive scope before the
-        picker is available."""
-        cred = _make_oauth2_cred(provider="google")
-        cred.scopes = [
-            "https://www.googleapis.com/auth/gmail.readonly",
-            "https://www.googleapis.com/auth/calendar",
-        ]
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.post("/google/credentials/cred-456/picker-token")
-
-        assert resp.status_code == 400
-        assert "picker" in resp.json()["detail"].lower()
-
-    def test_api_key_credential_rejected_as_400(self):
-        cred = _make_api_key_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.post("/openai/credentials/cred-123/picker-token")
-
-        assert resp.status_code == 400
-        # API keys must not silently fall through to a 200 response of some
-        # other shape — the client should see a clear shape rejection.
-        body = str(resp.json())
-        assert "sk-secret-key-value" not in body
-
-    def test_user_password_credential_rejected_as_400(self):
-        cred = _make_user_password_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.post("/openai/credentials/cred-789/picker-token")
-
-        assert resp.status_code == 400
-        body = str(resp.json())
-        assert "s3cret-pass" not in body
-        assert "admin" not in body
-
-    def test_host_scoped_credential_rejected_as_400(self):
-        cred = _make_host_scoped_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.post("/openai/credentials/cred-host/picker-token")
-
-        assert resp.status_code == 400
-        assert "top-secret" not in str(resp.json())
-
-    def test_missing_credential_returns_404(self):
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=None)
-            resp = client.post("/github/credentials/nonexistent/picker-token")
-
-        assert resp.status_code == 404
-        assert resp.json()["detail"] == "Credentials not found"
-
-    def test_wrong_provider_returns_404(self):
-        """Symmetric with get_credential: provider mismatch is a generic
-        404, not a 400, so we don't leak existence of a credential the
-        caller doesn't own on that provider."""
-        cred = _make_oauth2_cred(provider="github")
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.post("/google/credentials/cred-456/picker-token")
-
-        assert resp.status_code == 404
-        assert resp.json()["detail"] == "Credentials not found"
-
-    def test_sdk_default_returns_404(self):
-        """SDK defaults are invisible to the user-facing API — picker-token
-        must not mint a token for them either."""
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock()
-            resp = client.post("/openai/credentials/openai-default/picker-token")
-
-        assert resp.status_code == 404
-        mock_mgr.get.assert_not_called()
-
-    def test_oauth2_without_access_token_returns_400(self):
-        """A stored OAuth2 cred whose access_token is missing can't satisfy
-        a picker init. Surface a clear reconnect instruction rather than
-        returning an empty string."""
-        cred = _make_oauth2_cred()
-        # Simulate a cred that lost its access token
-        object.__setattr__(cred, "access_token", None)
-
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.post("/github/credentials/cred-456/picker-token")
-
-        assert resp.status_code == 400
-        assert "reconnect" in resp.json()["detail"].lower()
-
-    def test_meta_only_endpoint_still_strips_access_token(self):
-        """Regression guard for the coexistence contract: the new
-        picker-token endpoint must NOT accidentally leak the token through
-        the meta-only GET endpoint. TestGetCredentialReturnsMetaOnly
-        covers this more broadly; this is a fast sanity check co-located
-        with the new endpoint's tests."""
-        cred = _make_oauth2_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/github/credentials/cred-456")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert "access_token" not in body
-        assert "refresh_token" not in body
-        assert "ghp_secret_token" not in str(body)

autogpt_platform/backend/backend/api/features/library/_add_to_library.py

@@ -1,122 +0,0 @@
-"""Shared logic for adding store agents to a user's library.
-
-Both `add_store_agent_to_library` and `add_store_agent_to_library_as_admin`
-delegate to these helpers so the duplication-prone create/restore/dedup
-logic lives in exactly one place.
-"""
-
-import logging
-
-import prisma.errors
-import prisma.models
-
-import backend.api.features.library.model as library_model
-import backend.data.graph as graph_db
-from backend.api.features.library.db import _fetch_schedule_info
-from backend.data.graph import GraphModel, GraphSettings
-from backend.data.includes import library_agent_include
-from backend.util.exceptions import NotFoundError
-from backend.util.json import SafeJson
-
-logger = logging.getLogger(__name__)
-
-
-async def resolve_graph_for_library(
-    store_listing_version_id: str,
-    user_id: str,
-    *,
-    admin: bool,
-) -> GraphModel:
-    """Look up a StoreListingVersion and resolve its graph.
-
-    When ``admin=True``, uses ``get_graph_as_admin`` to bypass the marketplace
-    APPROVED-only check.  Otherwise uses the regular ``get_graph``.
-    """
-    slv = await prisma.models.StoreListingVersion.prisma().find_unique(
-        where={"id": store_listing_version_id}, include={"AgentGraph": True}
-    )
-    if not slv or not slv.AgentGraph:
-        raise NotFoundError(
-            f"Store listing version {store_listing_version_id} not found or invalid"
-        )
-
-    ag = slv.AgentGraph
-    if admin:
-        graph_model = await graph_db.get_graph_as_admin(
-            graph_id=ag.id, version=ag.version, user_id=user_id
-        )
-    else:
-        graph_model = await graph_db.get_graph(
-            graph_id=ag.id, version=ag.version, user_id=user_id
-        )
-
-    if not graph_model:
-        raise NotFoundError(f"Graph #{ag.id} v{ag.version} not found or accessible")
-    return graph_model
-
-
-async def add_graph_to_library(
-    store_listing_version_id: str,
-    graph_model: GraphModel,
-    user_id: str,
-) -> library_model.LibraryAgent:
-    """Check existing / restore soft-deleted / create new LibraryAgent.
-
-    Uses a create-then-catch-UniqueViolationError-then-update pattern on
-    the (userId, agentGraphId, agentGraphVersion) composite unique constraint.
-    This is more robust than ``upsert`` because Prisma's upsert atomicity
-    guarantees are not well-documented for all versions.
-    """
-    settings_json = SafeJson(GraphSettings.from_graph(graph_model).model_dump())
-    _include = library_agent_include(
-        user_id, include_nodes=False, include_executions=False
-    )
-
-    try:
-        added_agent = await prisma.models.LibraryAgent.prisma().create(
-            data={
-                "User": {"connect": {"id": user_id}},
-                "AgentGraph": {
-                    "connect": {
-                        "graphVersionId": {
-                            "id": graph_model.id,
-                            "version": graph_model.version,
-                        }
-                    }
-                },
-                "isCreatedByUser": False,
-                "useGraphIsActiveVersion": False,
-                "settings": settings_json,
-            },
-            include=_include,
-        )
-    except prisma.errors.UniqueViolationError:
-        # Already exists — update to restore if previously soft-deleted/archived
-        added_agent = await prisma.models.LibraryAgent.prisma().update(
-            where={
-                "userId_agentGraphId_agentGraphVersion": {
-                    "userId": user_id,
-                    "agentGraphId": graph_model.id,
-                    "agentGraphVersion": graph_model.version,
-                }
-            },
-            data={
-                "isDeleted": False,
-                "isArchived": False,
-                "settings": settings_json,
-            },
-            include=_include,
-        )
-        if added_agent is None:
-            raise NotFoundError(
-                f"LibraryAgent for graph #{graph_model.id} "
-                f"v{graph_model.version} not found after UniqueViolationError"
-            )
-
-    logger.debug(
-        f"Added graph #{graph_model.id} v{graph_model.version} "
-        f"for store listing version #{store_listing_version_id} "
-        f"to library for user #{user_id}"
-    )
-    schedule_info = await _fetch_schedule_info(user_id, graph_id=graph_model.id)
-    return library_model.LibraryAgent.from_db(added_agent, schedule_info=schedule_info)

autogpt_platform/backend/backend/api/features/library/_add_to_library_test.py

@@ -1,88 +0,0 @@
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import prisma.errors
-import pytest
-
-from ._add_to_library import add_graph_to_library
-
-
-@pytest.mark.asyncio
-async def test_add_graph_to_library_create_new_agent() -> None:
-    """When no matching LibraryAgent exists, create inserts a new one."""
-    graph_model = MagicMock(id="graph-id", version=2, nodes=[])
-    created_agent = MagicMock(name="CreatedLibraryAgent")
-    converted_agent = MagicMock(name="ConvertedLibraryAgent")
-
-    with (
-        patch(
-            "backend.api.features.library._add_to_library.prisma.models.LibraryAgent.prisma"
-        ) as mock_prisma,
-        patch(
-            "backend.api.features.library._add_to_library.library_model.LibraryAgent.from_db",
-            return_value=converted_agent,
-        ) as mock_from_db,
-        patch(
-            "backend.api.features.library._add_to_library._fetch_schedule_info",
-            new=AsyncMock(return_value={}),
-        ),
-    ):
-        mock_prisma.return_value.create = AsyncMock(return_value=created_agent)
-
-        result = await add_graph_to_library("slv-id", graph_model, "user-id")
-
-    assert result is converted_agent
-    mock_from_db.assert_called_once_with(created_agent, schedule_info={})
-    # Verify create was called with correct data
-    create_call = mock_prisma.return_value.create.call_args
-    create_data = create_call.kwargs["data"]
-    assert create_data["User"] == {"connect": {"id": "user-id"}}
-    assert create_data["AgentGraph"] == {
-        "connect": {"graphVersionId": {"id": "graph-id", "version": 2}}
-    }
-    assert create_data["isCreatedByUser"] is False
-    assert create_data["useGraphIsActiveVersion"] is False
-
-
-@pytest.mark.asyncio
-async def test_add_graph_to_library_unique_violation_updates_existing() -> None:
-    """UniqueViolationError on create falls back to update."""
-    graph_model = MagicMock(id="graph-id", version=2, nodes=[])
-    updated_agent = MagicMock(name="UpdatedLibraryAgent")
-    converted_agent = MagicMock(name="ConvertedLibraryAgent")
-
-    with (
-        patch(
-            "backend.api.features.library._add_to_library.prisma.models.LibraryAgent.prisma"
-        ) as mock_prisma,
-        patch(
-            "backend.api.features.library._add_to_library.library_model.LibraryAgent.from_db",
-            return_value=converted_agent,
-        ) as mock_from_db,
-        patch(
-            "backend.api.features.library._add_to_library._fetch_schedule_info",
-            new=AsyncMock(return_value={}),
-        ),
-    ):
-        mock_prisma.return_value.create = AsyncMock(
-            side_effect=prisma.errors.UniqueViolationError(
-                MagicMock(), message="unique constraint"
-            )
-        )
-        mock_prisma.return_value.update = AsyncMock(return_value=updated_agent)
-
-        result = await add_graph_to_library("slv-id", graph_model, "user-id")
-
-    assert result is converted_agent
-    mock_from_db.assert_called_once_with(updated_agent, schedule_info={})
-    # Verify update was called with correct where and data
-    update_call = mock_prisma.return_value.update.call_args
-    assert update_call.kwargs["where"] == {
-        "userId_agentGraphId_agentGraphVersion": {
-            "userId": "user-id",
-            "agentGraphId": "graph-id",
-            "agentGraphVersion": 2,
-        }
-    }
-    update_data = update_call.kwargs["data"]
-    assert update_data["isDeleted"] is False
-    assert update_data["isArchived"] is False

autogpt_platform/backend/backend/api/features/library/db.py

@@ -1,7 +1,6 @@
 import asyncio
 import itertools
 import logging
-from datetime import datetime, timezone
 from typing import Literal, Optional
 
 import fastapi
@@ -9,6 +8,7 @@ import prisma.errors
 import prisma.models
 import prisma.types
 
+import backend.api.features.store.exceptions as store_exceptions
 import backend.api.features.store.image_gen as store_image_gen
 import backend.api.features.store.media as store_media
 import backend.data.graph as graph_db
@@ -44,65 +44,6 @@ config = Config()
 integration_creds_manager = IntegrationCredentialsManager()
 
 
-async def _fetch_execution_counts(user_id: str, graph_ids: list[str]) -> dict[str, int]:
-    """Fetch execution counts per graph in a single batched query."""
-    if not graph_ids:
-        return {}
-    rows = await prisma.models.AgentGraphExecution.prisma().group_by(
-        by=["agentGraphId"],
-        where={
-            "userId": user_id,
-            "agentGraphId": {"in": graph_ids},
-            "isDeleted": False,
-        },
-        count=True,
-    )
-    return {
-        row["agentGraphId"]: int((row.get("_count") or {}).get("_all") or 0)
-        for row in rows
-    }
-
-
-async def _fetch_schedule_info(
-    user_id: str, graph_id: Optional[str] = None
-) -> dict[str, str]:
-    """Fetch a map of graph_id → earliest next_run_time ISO string.
-
-    When `graph_id` is provided, the scheduler query is narrowed to that graph,
-    which is cheaper for single-agent lookups (detail page, post-update, etc.).
-    """
-    try:
-        scheduler_client = get_scheduler_client()
-        schedules = await scheduler_client.get_execution_schedules(
-            graph_id=graph_id,
-            user_id=user_id,
-        )
-        earliest: dict[str, tuple[datetime, str]] = {}
-        for s in schedules:
-            parsed = _parse_iso_datetime(s.next_run_time)
-            if parsed is None:
-                continue
-            current = earliest.get(s.graph_id)
-            if current is None or parsed < current[0]:
-                earliest[s.graph_id] = (parsed, s.next_run_time)
-        return {graph_id: iso for graph_id, (_, iso) in earliest.items()}
-    except Exception:
-        logger.warning("Failed to fetch schedules for library agents", exc_info=True)
-        return {}
-
-
-def _parse_iso_datetime(value: str) -> Optional[datetime]:
-    """Parse an ISO 8601 datetime, tolerating `Z` and naive forms (assumed UTC)."""
-    try:
-        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
-    except ValueError:
-        logger.warning("Failed to parse schedule next_run_time: %s", value)
-        return None
-    if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=timezone.utc)
-    return parsed
-
-
 async def list_library_agents(
     user_id: str,
     search_term: Optional[str] = None,
@@ -197,22 +138,12 @@ async def list_library_agents(
 
     logger.debug(f"Retrieved {len(library_agents)} library agents for user #{user_id}")
 
-    graph_ids = [a.agentGraphId for a in library_agents if a.agentGraphId]
-    execution_counts, schedule_info = await asyncio.gather(
-        _fetch_execution_counts(user_id, graph_ids),
-        _fetch_schedule_info(user_id),
-    )
-
     # Only pass valid agents to the response
     valid_library_agents: list[library_model.LibraryAgent] = []
 
     for agent in library_agents:
         try:
-            library_agent = library_model.LibraryAgent.from_db(
-                agent,
-                execution_count_override=execution_counts.get(agent.agentGraphId),
-                schedule_info=schedule_info,
-            )
+            library_agent = library_model.LibraryAgent.from_db(agent)
             valid_library_agents.append(library_agent)
         except Exception as e:
             # Skip this agent if there was an error
@@ -284,22 +215,12 @@ async def list_favorite_library_agents(
         f"Retrieved {len(library_agents)} favorite library agents for user #{user_id}"
     )
 
-    graph_ids = [a.agentGraphId for a in library_agents if a.agentGraphId]
-    execution_counts, schedule_info = await asyncio.gather(
-        _fetch_execution_counts(user_id, graph_ids),
-        _fetch_schedule_info(user_id),
-    )
-
     # Only pass valid agents to the response
     valid_library_agents: list[library_model.LibraryAgent] = []
 
     for agent in library_agents:
         try:
-            library_agent = library_model.LibraryAgent.from_db(
-                agent,
-                execution_count_override=execution_counts.get(agent.agentGraphId),
-                schedule_info=schedule_info,
-            )
+            library_agent = library_model.LibraryAgent.from_db(agent)
             valid_library_agents.append(library_agent)
         except Exception as e:
             # Skip this agent if there was an error
@@ -330,7 +251,7 @@ async def get_library_agent(id: str, user_id: str) -> library_model.LibraryAgent
         The requested LibraryAgent.
 
     Raises:
-        NotFoundError: If the specified agent does not exist.
+        AgentNotFoundError: If the specified agent does not exist.
         DatabaseError: If there's an error during retrieval.
     """
     library_agent = await prisma.models.LibraryAgent.prisma().find_first(
@@ -365,12 +286,6 @@ async def get_library_agent(id: str, user_id: str) -> library_model.LibraryAgent
                 where={"userId": store_listing.owningUserId}
             )
 
-    schedule_info = (
-        await _fetch_schedule_info(user_id, graph_id=library_agent.AgentGraph.id)
-        if library_agent.AgentGraph
-        else {}
-    )
-
     return library_model.LibraryAgent.from_db(
         library_agent,
         sub_graphs=(
@@ -380,7 +295,6 @@ async def get_library_agent(id: str, user_id: str) -> library_model.LibraryAgent
         ),
         store_listing=store_listing,
         profile=profile,
-        schedule_info=schedule_info,
     )
 
 
@@ -416,25 +330,19 @@ async def get_library_agent_by_store_version_id(
         },
         include=library_agent_include(user_id),
     )
-    if not agent:
-        return None
-    schedule_info = await _fetch_schedule_info(user_id, graph_id=agent.agentGraphId)
-    return library_model.LibraryAgent.from_db(agent, schedule_info=schedule_info)
+    return library_model.LibraryAgent.from_db(agent) if agent else None
 
 
 async def get_library_agent_by_graph_id(
     user_id: str,
     graph_id: str,
     graph_version: Optional[int] = None,
-    include_archived: bool = False,
 ) -> library_model.LibraryAgent | None:
     filter: prisma.types.LibraryAgentWhereInput = {
         "agentGraphId": graph_id,
         "userId": user_id,
         "isDeleted": False,
     }
-    if not include_archived:
-        filter["isArchived"] = False
     if graph_version is not None:
         filter["agentGraphVersion"] = graph_version
 
@@ -448,10 +356,7 @@ async def get_library_agent_by_graph_id(
     assert agent.AgentGraph  # make type checker happy
     # Include sub-graphs so we can make a full credentials input schema
     sub_graphs = await graph_db.get_sub_graphs(agent.AgentGraph)
-    schedule_info = await _fetch_schedule_info(user_id, graph_id=agent.agentGraphId)
-    return library_model.LibraryAgent.from_db(
-        agent, sub_graphs=sub_graphs, schedule_info=schedule_info
-    )
+    return library_model.LibraryAgent.from_db(agent, sub_graphs=sub_graphs)
 
 
 async def add_generated_agent_image(
@@ -493,7 +398,6 @@ async def create_library_agent(
     hitl_safe_mode: bool = True,
     sensitive_action_safe_mode: bool = False,
     create_library_agents_for_sub_graphs: bool = True,
-    folder_id: str | None = None,
 ) -> list[library_model.LibraryAgent]:
     """
     Adds an agent to the user's library (LibraryAgent table).
@@ -510,18 +414,12 @@ async def create_library_agent(
         If the graph has sub-graphs, the parent graph will always be the first entry in the list.
 
     Raises:
-        NotFoundError: If the specified agent does not exist.
+        AgentNotFoundError: If the specified agent does not exist.
         DatabaseError: If there's an error during creation or if image generation fails.
     """
     logger.info(
         f"Creating library agent for graph #{graph.id} v{graph.version}; user:<redacted>"
     )
-
-    # Authorization: FK only checks existence, not ownership.
-    # Verify the folder belongs to this user to prevent cross-user nesting.
-    if folder_id:
-        await get_folder(folder_id, user_id)
-
     graph_entries = (
         [graph, *graph.sub_graphs] if create_library_agents_for_sub_graphs else [graph]
     )
@@ -529,58 +427,28 @@ async def create_library_agent(
     async with transaction() as tx:
         library_agents = await asyncio.gather(
             *(
-                prisma.models.LibraryAgent.prisma(tx).upsert(
-                    where={
-                        "userId_agentGraphId_agentGraphVersion": {
-                            "userId": user_id,
-                            "agentGraphId": graph_entry.id,
-                            "agentGraphVersion": graph_entry.version,
-                        }
-                    },
-                    data={
-                        "create": prisma.types.LibraryAgentCreateInput(
-                            isCreatedByUser=(user_id == graph.user_id),
-                            useGraphIsActiveVersion=True,
-                            User={"connect": {"id": user_id}},
-                            AgentGraph={
-                                "connect": {
-                                    "graphVersionId": {
-                                        "id": graph_entry.id,
-                                        "version": graph_entry.version,
-                                    }
+                prisma.models.LibraryAgent.prisma(tx).create(
+                    data=prisma.types.LibraryAgentCreateInput(
+                        isCreatedByUser=(user_id == user_id),
+                        useGraphIsActiveVersion=True,
+                        User={"connect": {"id": user_id}},
+                        # Creator={"connect": {"id": user_id}},
+                        AgentGraph={
+                            "connect": {
+                                "graphVersionId": {
+                                    "id": graph_entry.id,
+                                    "version": graph_entry.version,
                                 }
-                            },
-                            settings=SafeJson(
-                                GraphSettings.from_graph(
-                                    graph_entry,
-                                    hitl_safe_mode=hitl_safe_mode,
-                                    sensitive_action_safe_mode=sensitive_action_safe_mode,
-                                ).model_dump()
-                            ),
-                            **(
-                                {"Folder": {"connect": {"id": folder_id}}}
-                                if folder_id and graph_entry is graph
-                                else {}
-                            ),
-                        ),
-                        "update": {
-                            "isDeleted": False,
-                            "isArchived": False,
-                            "useGraphIsActiveVersion": True,
-                            "settings": SafeJson(
-                                GraphSettings.from_graph(
-                                    graph_entry,
-                                    hitl_safe_mode=hitl_safe_mode,
-                                    sensitive_action_safe_mode=sensitive_action_safe_mode,
-                                ).model_dump()
-                            ),
-                            **(
-                                {"Folder": {"connect": {"id": folder_id}}}
-                                if folder_id and graph_entry is graph
-                                else {}
-                            ),
+                            }
                         },
-                    },
+                        settings=SafeJson(
+                            GraphSettings.from_graph(
+                                graph_entry,
+                                hitl_safe_mode=hitl_safe_mode,
+                                sensitive_action_safe_mode=sensitive_action_safe_mode,
+                            ).model_dump()
+                        ),
+                    ),
                     include=library_agent_include(
                         user_id, include_nodes=False, include_executions=False
                     ),
@@ -593,11 +461,7 @@ async def create_library_agent(
     for agent, graph in zip(library_agents, graph_entries):
         asyncio.create_task(add_generated_agent_image(graph, user_id, agent.id))
 
-    schedule_info = await _fetch_schedule_info(user_id)
-    return [
-        library_model.LibraryAgent.from_db(agent, schedule_info=schedule_info)
-        for agent in library_agents
-    ]
+    return [library_model.LibraryAgent.from_db(agent) for agent in library_agents]
 
 
 async def update_agent_version_in_library(
@@ -659,14 +523,12 @@ async def update_agent_version_in_library(
             f"Failed to update library agent for {agent_graph_id} v{agent_graph_version}"
         )
 
-    schedule_info = await _fetch_schedule_info(user_id, graph_id=agent_graph_id)
-    return library_model.LibraryAgent.from_db(lib, schedule_info=schedule_info)
+    return library_model.LibraryAgent.from_db(lib)
 
 
 async def create_graph_in_library(
     graph: graph_db.Graph,
     user_id: str,
-    folder_id: str | None = None,
 ) -> tuple[graph_db.GraphModel, library_model.LibraryAgent]:
     """Create a new graph and add it to the user's library."""
     graph.version = 1
@@ -680,7 +542,6 @@ async def create_graph_in_library(
         user_id=user_id,
         sensitive_action_safe_mode=True,
         create_library_agents_for_sub_graphs=False,
-        folder_id=folder_id,
     )
 
     if created_graph.is_active:
@@ -709,9 +570,7 @@ async def update_graph_in_library(
 
     created_graph = await graph_db.create_graph(graph_model, user_id)
 
-    library_agent = await get_library_agent_by_graph_id(
-        user_id, created_graph.id, include_archived=True
-    )
+    library_agent = await get_library_agent_by_graph_id(user_id, created_graph.id)
     if not library_agent:
         raise NotFoundError(f"Library agent not found for graph {created_graph.id}")
 
@@ -743,7 +602,6 @@ async def update_library_agent_version_and_settings(
         graph=agent_graph,
         hitl_safe_mode=library.settings.human_in_the_loop_safe_mode,
         sensitive_action_safe_mode=library.settings.sensitive_action_safe_mode,
-        builder_chat_session_id=library.settings.builder_chat_session_id,
     )
     if updated_settings != library.settings:
         library = await update_library_agent(
@@ -948,38 +806,92 @@ async def delete_library_agent_by_graph_id(graph_id: str, user_id: str) -> None:
 async def add_store_agent_to_library(
     store_listing_version_id: str, user_id: str
 ) -> library_model.LibraryAgent:
-    """Adds a marketplace agent to the user’s library.
-
-    See also: `add_store_agent_to_library_as_admin()` which uses
-    `get_graph_as_admin` to bypass marketplace status checks for admin review.
     """
-    from ._add_to_library import add_graph_to_library, resolve_graph_for_library
+    Adds an agent from a store listing version to the user's library if they don't already have it.
 
+    Args:
+        store_listing_version_id: The ID of the store listing version containing the agent.
+        user_id: The user’s library to which the agent is being added.
+
+    Returns:
+        The newly created LibraryAgent if successfully added, the existing corresponding one if any.
+
+    Raises:
+        AgentNotFoundError: If the store listing or associated agent is not found.
+        DatabaseError: If there's an issue creating the LibraryAgent record.
+    """
     logger.debug(
         f"Adding agent from store listing version #{store_listing_version_id} "
         f"to library for user #{user_id}"
     )
-    graph_model = await resolve_graph_for_library(
-        store_listing_version_id, user_id, admin=False
-    )
-    return await add_graph_to_library(store_listing_version_id, graph_model, user_id)
 
-
-async def add_store_agent_to_library_as_admin(
-    store_listing_version_id: str, user_id: str
-) -> library_model.LibraryAgent:
-    """Admin variant that uses `get_graph_as_admin` to bypass marketplace
-    APPROVED-only checks, allowing admins to add pending agents for review."""
-    from ._add_to_library import add_graph_to_library, resolve_graph_for_library
-
-    logger.warning(
-        f"ADMIN adding agent from store listing version "
-        f"#{store_listing_version_id} to library for user #{user_id}"
+    store_listing_version = (
+        await prisma.models.StoreListingVersion.prisma().find_unique(
+            where={"id": store_listing_version_id}, include={"AgentGraph": True}
+        )
     )
-    graph_model = await resolve_graph_for_library(
-        store_listing_version_id, user_id, admin=True
+    if not store_listing_version or not store_listing_version.AgentGraph:
+        logger.warning(f"Store listing version not found: {store_listing_version_id}")
+        raise store_exceptions.AgentNotFoundError(
+            f"Store listing version {store_listing_version_id} not found or invalid"
+        )
+
+    graph = store_listing_version.AgentGraph
+
+    # Convert to GraphModel to check for HITL blocks
+    graph_model = await graph_db.get_graph(
+        graph_id=graph.id,
+        version=graph.version,
+        user_id=user_id,
+        include_subgraphs=False,
     )
-    return await add_graph_to_library(store_listing_version_id, graph_model, user_id)
+    if not graph_model:
+        raise store_exceptions.AgentNotFoundError(
+            f"Graph #{graph.id} v{graph.version} not found or accessible"
+        )
+
+    # Check if user already has this agent (non-deleted)
+    if existing := await get_library_agent_by_graph_id(
+        user_id, graph.id, graph.version
+    ):
+        return existing
+
+    # Check for soft-deleted version and restore it
+    deleted_agent = await prisma.models.LibraryAgent.prisma().find_unique(
+        where={
+            "userId_agentGraphId_agentGraphVersion": {
+                "userId": user_id,
+                "agentGraphId": graph.id,
+                "agentGraphVersion": graph.version,
+            }
+        },
+    )
+    if deleted_agent and deleted_agent.isDeleted:
+        return await update_library_agent(deleted_agent.id, user_id, is_deleted=False)
+
+    # Create LibraryAgent entry
+    added_agent = await prisma.models.LibraryAgent.prisma().create(
+        data={
+            "User": {"connect": {"id": user_id}},
+            "AgentGraph": {
+                "connect": {
+                    "graphVersionId": {"id": graph.id, "version": graph.version}
+                }
+            },
+            "isCreatedByUser": False,
+            "useGraphIsActiveVersion": False,
+            "settings": SafeJson(GraphSettings.from_graph(graph_model).model_dump()),
+        },
+        include=library_agent_include(
+            user_id, include_nodes=False, include_executions=False
+        ),
+    )
+    logger.debug(
+        f"Added graph #{graph.id} v{graph.version}"
+        f"for store listing version #{store_listing_version.id} "
+        f"to library for user #{user_id}"
+    )
+    return library_model.LibraryAgent.from_db(added_agent)
 
 
 ##############################################
@@ -1566,72 +1478,7 @@ async def bulk_move_agents_to_folder(
         ),
     )
 
-    schedule_info = await _fetch_schedule_info(user_id)
-    return [
-        library_model.LibraryAgent.from_db(agent, schedule_info=schedule_info)
-        for agent in agents
-    ]
-
-
-def collect_tree_ids(
-    nodes: list[library_model.LibraryFolderTree],
-    visited: set[str] | None = None,
-) -> list[str]:
-    """Collect all folder IDs from a folder tree."""
-    if visited is None:
-        visited = set()
-    ids: list[str] = []
-    for n in nodes:
-        if n.id in visited:
-            continue
-        visited.add(n.id)
-        ids.append(n.id)
-        ids.extend(collect_tree_ids(n.children, visited))
-    return ids
-
-
-async def get_folder_agent_summaries(
-    user_id: str, folder_id: str
-) -> list[dict[str, str | None]]:
-    """Get a lightweight list of agents in a folder (id, name, description)."""
-    all_agents: list[library_model.LibraryAgent] = []
-    for page in itertools.count(1):
-        resp = await list_library_agents(
-            user_id=user_id, folder_id=folder_id, page=page
-        )
-        all_agents.extend(resp.agents)
-        if page >= resp.pagination.total_pages:
-            break
-    return [
-        {"id": a.id, "name": a.name, "description": a.description} for a in all_agents
-    ]
-
-
-async def get_root_agent_summaries(
-    user_id: str,
-) -> list[dict[str, str | None]]:
-    """Get a lightweight list of root-level agents (folderId IS NULL)."""
-    all_agents: list[library_model.LibraryAgent] = []
-    for page in itertools.count(1):
-        resp = await list_library_agents(
-            user_id=user_id, include_root_only=True, page=page
-        )
-        all_agents.extend(resp.agents)
-        if page >= resp.pagination.total_pages:
-            break
-    return [
-        {"id": a.id, "name": a.name, "description": a.description} for a in all_agents
-    ]
-
-
-async def get_folder_agents_map(
-    user_id: str, folder_ids: list[str]
-) -> dict[str, list[dict[str, str | None]]]:
-    """Get agent summaries for multiple folders concurrently."""
-    results = await asyncio.gather(
-        *(get_folder_agent_summaries(user_id, fid) for fid in folder_ids)
-    )
-    return dict(zip(folder_ids, results))
+    return [library_model.LibraryAgent.from_db(agent) for agent in agents]
 
 
 ##############################################
@@ -1804,7 +1651,7 @@ async def create_preset_from_graph_execution(
             raise NotFoundError(
                 f"Graph #{graph_execution.graph_id} not found or accessible"
             )
-        elif len(graph.regular_credentials_inputs) > 0:
+        elif len(graph.aggregate_credentials_inputs()) > 0:
             raise ValueError(
                 f"Graph execution #{graph_exec_id} can't be turned into a preset "
                 "because it was run before this feature existed "

autogpt_platform/backend/backend/api/features/library/db_test.py

@@ -1,11 +1,10 @@
-from contextlib import asynccontextmanager
 from datetime import datetime
-from unittest.mock import AsyncMock, MagicMock, patch
 
 import prisma.enums
 import prisma.models
 import pytest
 
+import backend.api.features.store.exceptions
 from backend.data.db import connect
 from backend.data.includes import library_agent_include
 
@@ -65,11 +64,6 @@ async def test_get_library_agents(mocker):
     )
     mock_library_agent.return_value.count = mocker.AsyncMock(return_value=1)
 
-    mocker.patch(
-        "backend.api.features.library.db._fetch_execution_counts",
-        new=mocker.AsyncMock(return_value={}),
-    )
-
     # Call function
     result = await db.list_library_agents("test-user")
 
@@ -92,6 +86,10 @@ async def test_get_library_agents(mocker):
 async def test_add_agent_to_library(mocker):
     await connect()
 
+    # Mock the transaction context
+    mock_transaction = mocker.patch("backend.api.features.library.db.transaction")
+    mock_transaction.return_value.__aenter__ = mocker.AsyncMock(return_value=None)
+    mock_transaction.return_value.__aexit__ = mocker.AsyncMock(return_value=None)
     # Mock data
     mock_store_listing_data = prisma.models.StoreListingVersion(
         id="version123",
@@ -146,18 +144,15 @@ async def test_add_agent_to_library(mocker):
     )
 
     mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
+    mock_library_agent.return_value.find_first = mocker.AsyncMock(return_value=None)
+    mock_library_agent.return_value.find_unique = mocker.AsyncMock(return_value=None)
     mock_library_agent.return_value.create = mocker.AsyncMock(
         return_value=mock_library_agent_data
     )
 
-    # Mock graph_db.get_graph function that's called in resolve_graph_for_library
-    # (lives in _add_to_library.py after refactor, not db.py)
-    mock_graph_db = mocker.patch(
-        "backend.api.features.library._add_to_library.graph_db"
-    )
+    # Mock graph_db.get_graph function that's called to check for HITL blocks
+    mock_graph_db = mocker.patch("backend.api.features.library.db.graph_db")
     mock_graph_model = mocker.Mock()
-    mock_graph_model.id = "agent1"
-    mock_graph_model.version = 1
     mock_graph_model.nodes = (
         []
     )  # Empty list so _has_human_in_the_loop_blocks returns False
@@ -176,27 +171,37 @@ async def test_add_agent_to_library(mocker):
     mock_store_listing_version.return_value.find_unique.assert_called_once_with(
         where={"id": "version123"}, include={"AgentGraph": True}
     )
+    mock_library_agent.return_value.find_unique.assert_called_once_with(
+        where={
+            "userId_agentGraphId_agentGraphVersion": {
+                "userId": "test-user",
+                "agentGraphId": "agent1",
+                "agentGraphVersion": 1,
+            }
+        },
+    )
     # Check that create was called with the expected data including settings
     create_call_args = mock_library_agent.return_value.create.call_args
     assert create_call_args is not None
 
-    # Verify the create data structure
-    create_data = create_call_args.kwargs["data"]
-    expected_create = {
+    # Verify the main structure
+    expected_data = {
         "User": {"connect": {"id": "test-user"}},
         "AgentGraph": {"connect": {"graphVersionId": {"id": "agent1", "version": 1}}},
         "isCreatedByUser": False,
-        "useGraphIsActiveVersion": False,
     }
-    for key, value in expected_create.items():
-        assert create_data[key] == value
+
+    actual_data = create_call_args[1]["data"]
+    # Check that all expected fields are present
+    for key, value in expected_data.items():
+        assert actual_data[key] == value
 
     # Check that settings field is present and is a SafeJson object
-    assert "settings" in create_data
-    assert hasattr(create_data["settings"], "__class__")  # Should be a SafeJson object
+    assert "settings" in actual_data
+    assert hasattr(actual_data["settings"], "__class__")  # Should be a SafeJson object
 
     # Check include parameter
-    assert create_call_args.kwargs["include"] == library_agent_include(
+    assert create_call_args[1]["include"] == library_agent_include(
         "test-user", include_nodes=False, include_executions=False
     )
 
@@ -213,281 +218,10 @@ async def test_add_agent_to_library_not_found(mocker):
     )
 
     # Call function and verify exception
-    with pytest.raises(db.NotFoundError):
+    with pytest.raises(backend.api.features.store.exceptions.AgentNotFoundError):
         await db.add_store_agent_to_library("version123", "test-user")
 
     # Verify mock called correctly
     mock_store_listing_version.return_value.find_unique.assert_called_once_with(
         where={"id": "version123"}, include={"AgentGraph": True}
     )
-
-
-@pytest.mark.asyncio
-async def test_get_library_agent_by_graph_id_excludes_archived(mocker):
-    mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
-    mock_library_agent.return_value.find_first = mocker.AsyncMock(return_value=None)
-
-    result = await db.get_library_agent_by_graph_id("test-user", "agent1", 7)
-
-    assert result is None
-    mock_library_agent.return_value.find_first.assert_called_once()
-    where = mock_library_agent.return_value.find_first.call_args.kwargs["where"]
-    assert where == {
-        "agentGraphId": "agent1",
-        "userId": "test-user",
-        "isDeleted": False,
-        "isArchived": False,
-        "agentGraphVersion": 7,
-    }
-
-
-@pytest.mark.asyncio
-async def test_get_library_agent_by_graph_id_can_include_archived(mocker):
-    mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
-    mock_library_agent.return_value.find_first = mocker.AsyncMock(return_value=None)
-
-    result = await db.get_library_agent_by_graph_id(
-        "test-user",
-        "agent1",
-        7,
-        include_archived=True,
-    )
-
-    assert result is None
-    mock_library_agent.return_value.find_first.assert_called_once()
-    where = mock_library_agent.return_value.find_first.call_args.kwargs["where"]
-    assert where == {
-        "agentGraphId": "agent1",
-        "userId": "test-user",
-        "isDeleted": False,
-        "agentGraphVersion": 7,
-    }
-
-
-@pytest.mark.asyncio
-async def test_update_graph_in_library_allows_archived_library_agent(mocker):
-    graph = mocker.Mock(id="graph-id")
-    existing_version = mocker.Mock(version=1, is_active=True)
-    graph_model = mocker.Mock()
-    created_graph = mocker.Mock(id="graph-id", version=2, is_active=False)
-    current_library_agent = mocker.Mock()
-    updated_library_agent = mocker.Mock()
-
-    mocker.patch(
-        "backend.api.features.library.db.graph_db.get_graph_all_versions",
-        new=mocker.AsyncMock(return_value=[existing_version]),
-    )
-    mocker.patch(
-        "backend.api.features.library.db.graph_db.make_graph_model",
-        return_value=graph_model,
-    )
-    mocker.patch(
-        "backend.api.features.library.db.graph_db.create_graph",
-        new=mocker.AsyncMock(return_value=created_graph),
-    )
-    mock_get_library_agent = mocker.patch(
-        "backend.api.features.library.db.get_library_agent_by_graph_id",
-        new=mocker.AsyncMock(return_value=current_library_agent),
-    )
-    mock_update_library_agent = mocker.patch(
-        "backend.api.features.library.db.update_library_agent_version_and_settings",
-        new=mocker.AsyncMock(return_value=updated_library_agent),
-    )
-
-    result_graph, result_library_agent = await db.update_graph_in_library(
-        graph,
-        "test-user",
-    )
-
-    assert result_graph is created_graph
-    assert result_library_agent is updated_library_agent
-    assert graph.version == 2
-    graph_model.reassign_ids.assert_called_once_with(
-        user_id="test-user", reassign_graph_id=False
-    )
-    mock_get_library_agent.assert_awaited_once_with(
-        "test-user",
-        "graph-id",
-        include_archived=True,
-    )
-    mock_update_library_agent.assert_awaited_once_with("test-user", created_graph)
-
-
-@pytest.mark.asyncio
-async def test_create_library_agent_uses_upsert():
-    """create_library_agent should use upsert (not create) to handle duplicates."""
-    mock_graph = MagicMock()
-    mock_graph.id = "graph-1"
-    mock_graph.version = 1
-    mock_graph.user_id = "user-1"
-    mock_graph.nodes = []
-    mock_graph.sub_graphs = []
-
-    mock_upserted = MagicMock(name="UpsertedLibraryAgent")
-
-    @asynccontextmanager
-    async def fake_tx():
-        yield None
-
-    with (
-        patch("backend.api.features.library.db.transaction", fake_tx),
-        patch("prisma.models.LibraryAgent.prisma") as mock_prisma,
-        patch(
-            "backend.api.features.library.db.add_generated_agent_image",
-            new=AsyncMock(),
-        ),
-        patch(
-            "backend.api.features.library.model.LibraryAgent.from_db",
-            return_value=MagicMock(),
-        ),
-    ):
-        mock_prisma.return_value.upsert = AsyncMock(return_value=mock_upserted)
-
-        result = await db.create_library_agent(mock_graph, "user-1")
-
-    assert len(result) == 1
-    upsert_call = mock_prisma.return_value.upsert.call_args
-    assert upsert_call is not None
-    # Verify the upsert where clause uses the composite unique key
-    where = upsert_call.kwargs["where"]
-    assert "userId_agentGraphId_agentGraphVersion" in where
-    # Verify the upsert data has both create and update branches
-    data = upsert_call.kwargs["data"]
-    assert "create" in data
-    assert "update" in data
-    # Verify update branch restores soft-deleted/archived agents
-    assert data["update"]["isDeleted"] is False
-    assert data["update"]["isArchived"] is False
-
-
-@pytest.mark.asyncio
-async def test_list_favorite_library_agents(mocker):
-    mock_library_agents = [
-        prisma.models.LibraryAgent(
-            id="fav1",
-            userId="test-user",
-            agentGraphId="agent-fav",
-            settings="{}",  # type: ignore
-            agentGraphVersion=1,
-            isCreatedByUser=False,
-            isDeleted=False,
-            isArchived=False,
-            createdAt=datetime.now(),
-            updatedAt=datetime.now(),
-            isFavorite=True,
-            useGraphIsActiveVersion=True,
-            AgentGraph=prisma.models.AgentGraph(
-                id="agent-fav",
-                version=1,
-                name="Favorite Agent",
-                description="My Favorite",
-                userId="other-user",
-                isActive=True,
-                createdAt=datetime.now(),
-            ),
-        )
-    ]
-
-    mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
-    mock_library_agent.return_value.find_many = mocker.AsyncMock(
-        return_value=mock_library_agents
-    )
-    mock_library_agent.return_value.count = mocker.AsyncMock(return_value=1)
-
-    mocker.patch(
-        "backend.api.features.library.db._fetch_execution_counts",
-        new=mocker.AsyncMock(return_value={"agent-fav": 7}),
-    )
-
-    result = await db.list_favorite_library_agents("test-user")
-
-    assert len(result.agents) == 1
-    assert result.agents[0].id == "fav1"
-    assert result.agents[0].name == "Favorite Agent"
-    assert result.agents[0].graph_id == "agent-fav"
-    assert result.pagination.total_items == 1
-    assert result.pagination.total_pages == 1
-    assert result.pagination.current_page == 1
-    assert result.pagination.page_size == 50
-
-
-@pytest.mark.asyncio
-async def test_list_library_agents_skips_failed_agent(mocker):
-    """Agents that fail parsing should be skipped — covers the except branch."""
-    mock_library_agents = [
-        prisma.models.LibraryAgent(
-            id="ua-bad",
-            userId="test-user",
-            agentGraphId="agent-bad",
-            settings="{}",  # type: ignore
-            agentGraphVersion=1,
-            isCreatedByUser=False,
-            isDeleted=False,
-            isArchived=False,
-            createdAt=datetime.now(),
-            updatedAt=datetime.now(),
-            isFavorite=False,
-            useGraphIsActiveVersion=True,
-            AgentGraph=prisma.models.AgentGraph(
-                id="agent-bad",
-                version=1,
-                name="Bad Agent",
-                description="",
-                userId="other-user",
-                isActive=True,
-                createdAt=datetime.now(),
-            ),
-        )
-    ]
-
-    mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
-    mock_library_agent.return_value.find_many = mocker.AsyncMock(
-        return_value=mock_library_agents
-    )
-    mock_library_agent.return_value.count = mocker.AsyncMock(return_value=1)
-
-    mocker.patch(
-        "backend.api.features.library.db._fetch_execution_counts",
-        new=mocker.AsyncMock(return_value={}),
-    )
-    mocker.patch(
-        "backend.api.features.library.model.LibraryAgent.from_db",
-        side_effect=Exception("parse error"),
-    )
-
-    result = await db.list_library_agents("test-user")
-
-    assert len(result.agents) == 0
-    assert result.pagination.total_items == 1
-
-
-@pytest.mark.asyncio
-async def test_fetch_execution_counts_empty_graph_ids():
-    result = await db._fetch_execution_counts("user-1", [])
-    assert result == {}
-
-
-@pytest.mark.asyncio
-async def test_fetch_execution_counts_uses_group_by(mocker):
-    mock_prisma = mocker.patch("prisma.models.AgentGraphExecution.prisma")
-    mock_prisma.return_value.group_by = mocker.AsyncMock(
-        return_value=[
-            {"agentGraphId": "graph-1", "_count": {"_all": 5}},
-            {"agentGraphId": "graph-2", "_count": {"_all": 2}},
-        ]
-    )
-
-    result = await db._fetch_execution_counts(
-        "user-1", ["graph-1", "graph-2", "graph-3"]
-    )
-
-    assert result == {"graph-1": 5, "graph-2": 2}
-    mock_prisma.return_value.group_by.assert_called_once_with(
-        by=["agentGraphId"],
-        where={
-            "userId": "user-1",
-            "agentGraphId": {"in": ["graph-1", "graph-2", "graph-3"]},
-            "isDeleted": False,
-        },
-        count=True,
-    )