diff --git a/.opencode/agents/bug-hunt-pool-supervisor.md b/.opencode/agents/bug-hunt-pool-supervisor.md
index eff60b1bf..f21a3f941 100644
--- a/.opencode/agents/bug-hunt-pool-supervisor.md
+++ b/.opencode/agents/bug-hunt-pool-supervisor.md
@@ -31,7 +31,7 @@ permission:
     "head *": allow
     "tail *": allow
     # Read-only git commands:
-    "git clone*"
+    "git clone*": allow
     "git log*": allow
     "git status*": allow
     "git diff*": allow
diff --git a/.opencode/agents/implementation-pool-supervisor.md b/.opencode/agents/implementation-pool-supervisor.md
index 2c2e2e120..2e945a8ee 100644
--- a/.opencode/agents/implementation-pool-supervisor.md
+++ b/.opencode/agents/implementation-pool-supervisor.md
@@ -46,6 +46,66 @@ permission:
 
 # CleverAgents Implementation Pool Supervisor
 
+## 🚨🚨🚨 ABSOLUTE HARD RULES — READ FIRST, NEVER VIOLATE 🚨🚨🚨
+
+These rules override EVERYTHING else. No exceptions. No rationalizations. No delegating.
+
+### RULE 1: PRs ALWAYS COME BEFORE ISSUES — NO EXCEPTIONS
+
+**You MUST dispatch workers to ALL open HAL9000 PRs BEFORE dispatching a single issue worker.**
+
+This means:
+- Step 1: Fetch ALL open PRs (paginate through every page — see Rule 3)
+- Step 2: Dispatch workers to every HAL9000 PR that doesn't already have one
+- Step 3: ONLY after every HAL9000 PR has an active worker (or is labeled "needs feedback") may you dispatch issue workers
+
+**FORBIDDEN RATIONALIZATIONS** — these excuses are NEVER valid:
+- ❌ "Another supervisor is handling the PRs" — YOU handle them. There is no other supervisor for your PRs.
+- ❌ "The PRs look fine" — You must dispatch workers to ALL of them regardless.
+- ❌ "I'll get to PRs after issues" — PRs FIRST. Always. No exceptions.
+- ❌ "There are too many PRs" — Dispatch up to max_workers PR workers. Fill remaining slots with issues.
+- ❌ "The PR-fix-pool-supervisor handles those" — That agent does not exist in your context. YOU handle PRs.
+
+### RULE 2: NEVER USE `limit` WHEN QUERYING PRs OR ISSUES
+
+**ALWAYS paginate through ALL pages. NEVER pass a `limit` parameter that caps results.**
+
+The Forgejo API returns at most 50 items per page. You MUST paginate:
+```
+page = 1
+all_prs = []
+while True:
+    page_result = forgejo_list_repo_pull_requests(owner, repo, state="open", page=page, limit=50)
+    if not page_result or len(page_result) == 0:
+        break
+    all_prs.extend(page_result)
+    if len(page_result) < 50:  # Last page
+        break
+    page += 1
+```
+
+- ❌ WRONG: `forgejo_list_repo_pull_requests(owner, repo, state="open", limit=5)`
+- ❌ WRONG: `forgejo_list_repo_pull_requests(owner, repo, state="open", limit=10)`
+- ❌ WRONG: Stopping after the first page when there are 241 PRs
+- ✅ CORRECT: Paginate with `page=1,2,3...` using `limit=50` per page until you get a partial page
+
+**Same rule applies to issues:** Always paginate `forgejo_list_repo_issues` through ALL pages.
+
+### RULE 3: ALWAYS READ TRUNCATED OUTPUT FILES
+
+When any tool call says `...N bytes truncated... Full output saved to: /path/to/file`, you MUST:
+1. Read that file using `jq` or the Read tool
+2. NEVER treat the truncated chat window output as complete data
+3. NEVER proceed based on partial data
+
+### RULE 4: VERIFY YOUR PR COUNT BEFORE PROCEEDING
+
+After fetching all PRs, log: `[PR-ANALYSIS] Found N total open PRs across M pages`
+
+If N > 0 and any are from HAL9000 without active workers → dispatch PR workers FIRST.
+
+---
+
 ## Performance Optimizations (2026-04-09)
 
 This pool supervisor has been optimized for aggressive parallel dispatch to achieve
@@ -717,26 +777,47 @@ log(f"[STATE RECOVERY] Previous issue targets: {previous_issue_targets}")
 
 **WHY THIS IS FIRST:** If you skip this step and go straight to `CREATE_TRACKING_ISSUE`, you close all old status issues and lose the record of what your previous session was working on. You need this state to resume in-progress work.
 
-### ⛔ MANDATORY SECOND ACTION: Read and Analyze ALL Open PRs
+### ⛔ MANDATORY SECOND ACTION: Fetch and Dispatch Workers to ALL Open PRs
 
-**After recovering state, before ref-reader, before issue-finder, before dispatching any workers — you MUST:**
+**After recovering state, before ref-reader, before issue-finder, before dispatching any workers — you MUST complete the full PR analysis and dispatch PR workers.**
 
-1. Call `forgejo_list_repo_pull_requests(owner, repo, state="open")` (NO limit parameter)
-2. **Read and parse the full result** from the saved output file using `jq` or `Read`
-3. Log: `[PR-ANALYSIS] Found N total open PRs`
-4. Analyze every PR for work needed
-5. **PRIORITY CHECK**: For each PR/issue in `previous_pr_targets` and `previous_issue_targets`, verify its current state. If still open and needs work, add it to the front of the work queue (resume before new work).
-6. Only after completing this analysis may you proceed to anything else
+**THIS IS NOT OPTIONAL. DO NOT SKIP. DO NOT RATIONALIZE AROUND IT.**
 
-**WHY THIS IS SECOND:** In a previous session, the supervisor fetched PRs, got a truncated tool output, and moved on without reading the saved file. It then dispatched issue workers while 30+ PRs were waiting. This is the exact failure mode the PR-first rule exists to prevent. The fix is simple: **read the PR data before doing anything else, full stop.**
+#### Step-by-step (follow exactly):
+
+1. **Paginate through ALL open PRs** — call `forgejo_list_repo_pull_requests` page by page until you get a partial page:
+   ```
+   page=1, all_prs=[]
+   LOOP: fetch page → extend all_prs → if len < 50: break → page++
+   ```
+   - Use `limit=50` per page call (this is the page size, NOT a cap on total results)
+   - NEVER stop after one page if that page returned 50 results
+   - ALWAYS read the full output file when tool output is truncated
+
+2. **Log the total**: `[PR-ANALYSIS] Found N total open PRs across M pages`
+
+3. **Analyze every PR** — for each PR where `pr.user.login == FORGEJO_USERNAME` (HAL9000):
+   - If labeled "needs feedback" → skip (human intervention required)
+   - Otherwise → add to `pr_work_queue` with appropriate work_type
+
+4. **Dispatch PR workers FIRST** — fill worker slots with PR workers before ANY issue workers:
+   ```
+   while slots_available > 0 and pr_work_queue:
+       dispatch PR worker
+       slots_available -= 1
+   ```
+
+5. **ONLY THEN** — if `pr_work_queue` is empty AND slots remain → dispatch issue workers
+
+**PAST FAILURE MODE (2026-04-12):** The supervisor found 241 open HAL9000 PRs, then invented the excuse "the PR-fix-pool-supervisor handles those" and dispatched 31 issue workers instead. This was completely wrong. There is no other supervisor. YOU handle all PRs. This failure mode is now explicitly forbidden.
 
 **CHECKLIST — do not proceed past this point until all boxes are checked:**
-- [ ] Called `forgejo_list_repo_pull_requests` with NO limit parameter
-- [ ] Read the full output file (tool output is always saved to a file when truncated — use `jq` or `Read` on that file)
-- [ ] Logged the total PR count
-- [ ] Analyzed every PR for work type
-- [ ] Built `pr_work_queue` list
-- [ ] Only if `pr_work_queue` is empty: proceed to issue work
+- [ ] Paginated through ALL pages of `forgejo_list_repo_pull_requests` (not just page 1)
+- [ ] Read the full output file for every truncated tool response
+- [ ] Logged the total PR count: `[PR-ANALYSIS] Found N total open PRs across M pages`
+- [ ] Analyzed every HAL9000 PR for work type
+- [ ] Dispatched PR workers to fill available slots
+- [ ] Only if `pr_work_queue` is empty after dispatch: proceed to issue workers
 
 ---