diff --git a/.claude/skills/cut-release/SKILL.md b/.agents/skills/cut-release/SKILL.md
similarity index 100%
rename from .claude/skills/cut-release/SKILL.md
rename to .agents/skills/cut-release/SKILL.md
diff --git a/.agents/skills/iterate-pr/SKILL.md b/.agents/skills/iterate-pr/SKILL.md
index 777465ff0..49e0c26d2 100644
--- a/.agents/skills/iterate-pr/SKILL.md
+++ b/.agents/skills/iterate-pr/SKILL.md
@@ -30,9 +30,9 @@ fall back to `python3` only if `uv` is unavailable:
 
 ```bash
 if command -v uv >/dev/null 2>&1; then
-  uv run .claude/skills/iterate-pr/scripts/<script>.py [args]
+  uv run .agents/skills/iterate-pr/scripts/<script>.py [args]
 else
-  python3 .claude/skills/iterate-pr/scripts/<script>.py [args]
+  python3 .agents/skills/iterate-pr/scripts/<script>.py [args]
 fi
 ```
 
@@ -73,7 +73,7 @@ Do not fail because hints are missing or unrecognized; default safely.
 Fetches CI check status and extracts failure snippets from logs.
 
 ```bash
-python3 .claude/skills/iterate-pr/scripts/fetch_pr_checks.py [--pr NUMBER]
+python3 .agents/skills/iterate-pr/scripts/fetch_pr_checks.py [--pr NUMBER]
 ```
 
 Returns JSON:
@@ -93,7 +93,7 @@ Returns JSON:
 Fetches and categorizes PR review feedback using the [LOGAF scale](https://develop.sentry.dev/engineering-practices/code-review/#logaf-scale).
 
 ```bash
-python3 .claude/skills/iterate-pr/scripts/fetch_pr_feedback.py [--pr NUMBER]
+python3 .agents/skills/iterate-pr/scripts/fetch_pr_feedback.py [--pr NUMBER]
 ```
 
 Returns JSON with feedback categorized as:
@@ -113,12 +113,12 @@ Each feedback item may also include:
 Replies to PR review threads. Batches multiple replies into a single GraphQL call.
 
 ```bash
-python3 .claude/skills/iterate-pr/scripts/reply_to_thread.py THREAD_ID "body" [THREAD_ID "body" ...]
+python3 .agents/skills/iterate-pr/scripts/reply_to_thread.py THREAD_ID "body" [THREAD_ID "body" ...]
 ```
 
 Arguments are alternating `(thread_id, body)` pairs. The script sends the reply body without adding signatures, attribution, or sign-off text. Example:
 ```bash
-python3 .claude/skills/iterate-pr/scripts/reply_to_thread.py \
+python3 .agents/skills/iterate-pr/scripts/reply_to_thread.py \
   PRRT_abc "Fixed the null check." \
   PRRT_def "Replaced with path-segment counting."
 ```
@@ -135,7 +135,7 @@ Stop if no PR exists for the current branch.
 
 ### 2. Gather Review Feedback
 
-Run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_feedback.py` to get categorized feedback already posted on the PR.
+Run `python3 .agents/skills/iterate-pr/scripts/fetch_pr_feedback.py` to get categorized feedback already posted on the PR.
 
 ### 3. Handle Feedback by Priority and Mode
 
@@ -192,14 +192,14 @@ After processing feedback, reply to PR comments/threads to acknowledge the actio
 - Full modes: reply to every non-resolved feedback item, including informational bot feedback
 
 **How to reply:**
-- If `thread_id` exists (inline review thread), use `python3 .claude/skills/iterate-pr/scripts/reply_to_thread.py`
+- If `thread_id` exists (inline review thread), use `python3 .agents/skills/iterate-pr/scripts/reply_to_thread.py`
 - If no `thread_id` exists, post a PR comment with `gh pr comment <PR_NUMBER> --body "..."`
 - In full modes, a feedback round is incomplete until every item has a corresponding reply
 
 Batch inline replies for a round into a single call:
 
 ```bash
-python3 .claude/skills/iterate-pr/scripts/reply_to_thread.py \
+python3 .agents/skills/iterate-pr/scripts/reply_to_thread.py \
   PRRT_abc "Fixed — description of change." \
   PRRT_def "Not applicable — reason."
 ```
@@ -212,7 +212,7 @@ python3 .claude/skills/iterate-pr/scripts/reply_to_thread.py \
 
 ### 4. Check CI Status
 
-Run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_checks.py` to get structured failure data.
+Run `python3 .agents/skills/iterate-pr/scripts/fetch_pr_checks.py` to get structured failure data.
 
 **Wait if pending:** If review bot checks (sentry, warden, cursor, bugbot, seer, codeql) are still running, wait before proceeding—they post actionable feedback that must be evaluated. Informational bots (codecov) are not worth waiting for.
 
@@ -248,11 +248,11 @@ Always add exactly one sign-off to each commit for the active authenticated GitH
 
 Poll CI status and review feedback in a loop instead of blocking:
 
-1. Run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_checks.py` to get current CI status
+1. Run `python3 .agents/skills/iterate-pr/scripts/fetch_pr_checks.py` to get current CI status
 2. If all checks passed → proceed to exit conditions
 3. If any checks failed (none pending) → return to step 5
 4. If checks are still pending:
-   a. Run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_feedback.py` for new review feedback
+   a. Run `python3 .agents/skills/iterate-pr/scripts/fetch_pr_feedback.py` for new review feedback
    b. Address feedback based on mode:
       - Default mode: new `high`/`medium`
       - Full modes: every new non-resolved item (`high`/`medium`/`low`/`bot`) and reply to each item
@@ -261,7 +261,7 @@ Poll CI status and review feedback in a loop instead of blocking:
       - Prefer Gemini review command (`/gemini review`) when available
       - Otherwise request Copilot review by commenting `@copilot review` on the PR
    e. Sleep 30 seconds (don't increase on subsequent iterations), then repeat from sub-step 1
-5. After all checks pass, do a final feedback check: `sleep 10`, then run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_feedback.py`.
+5. After all checks pass, do a final feedback check: `sleep 10`, then run `python3 .agents/skills/iterate-pr/scripts/fetch_pr_feedback.py`.
    - Default mode: address any new `high`/`medium` feedback; if changes are needed, return to step 6
    - Full modes: address any new non-resolved item; if changes are needed, return to step 6 and re-request review
 
diff --git a/.claude/skills b/.claude/skills
new file mode 120000
index 000000000..2b7a412b8
--- /dev/null
+++ b/.claude/skills
@@ -0,0 +1 @@
+../.agents/skills
\ No newline at end of file
diff --git a/.claude/skills/chrome-devtools-axi b/.claude/skills/chrome-devtools-axi
deleted file mode 120000
index 6282f891c..000000000
--- a/.claude/skills/chrome-devtools-axi
+++ /dev/null
@@ -1 +0,0 @@
-../../.agents/skills/chrome-devtools-axi
\ No newline at end of file
diff --git a/.claude/skills/gh-axi b/.claude/skills/gh-axi
deleted file mode 120000
index fd36cd077..000000000
--- a/.claude/skills/gh-axi
+++ /dev/null
@@ -1 +0,0 @@
-../../.agents/skills/gh-axi
\ No newline at end of file
diff --git a/.claude/skills/iterate-pr/SKILL.md b/.claude/skills/iterate-pr/SKILL.md
deleted file mode 100644
index 777465ff0..000000000
--- a/.claude/skills/iterate-pr/SKILL.md
+++ /dev/null
@@ -1,324 +0,0 @@
----
-name: iterate-pr
-description: Iterate on a PR until CI passes. Optionally merge or merge and publish a release of the repo. Automates the feedback-fix-push-wait cycle.
-argument-hint: "[--full] [--release]"
-metadata:
-  author: leecalcote
-  version: "2.3.0"
----
-
-# Iterate on PR Until CI Passes
-
-Continuously iterate on the current branch until all CI checks pass and review feedback is addressed.
-
-**Requires**: GitHub CLI (`gh`) authenticated.
-
-**Requires**: Python 3.9+.
-
-**Important**: Run scripts from the repository root directory (where `.git` is located).
-
-### Running the Bundled Scripts
-
-Every script below accepts either runner - they only use the standard library, so no
-dependency installation is needed either way:
-
-- **Preferred**: [`uv`](https://docs.astral.sh/uv/getting-started/installation/) - `uv run <script>`. Faster startup, isolated from system Python.
-- **Fallback**: `python3 <script>` - used automatically when `uv` is not on `PATH`.
-
-Before running any script command shown in this skill, check for `uv` first and prefer it;
-fall back to `python3` only if `uv` is unavailable:
-
-```bash
-if command -v uv >/dev/null 2>&1; then
-  uv run .claude/skills/iterate-pr/scripts/<script>.py [args]
-else
-  python3 .claude/skills/iterate-pr/scripts/<script>.py [args]
-fi
-```
-
-The rest of this document shows invocations in the shorter `python3 <script>` form for
-readability - substitute `uv run` per the rule above whenever `uv` is available.
-
-## Invocation and Modes
-
-Invoke as:
-
-- `/iterate-pr`
-- `/iterate-pr --full`
-- `/iterate-pr --release`
-- `/iterate-pr --full --release`
-
-In Claude Desktop, arguments are **hints**, not strict CLI parsing. Treat whatever follows `/iterate-pr` as a mode hint string.
-
-### Argument Hint Interpretation (Claude Desktop)
-
-Use this deterministic precedence:
-
-1. If hints include `--release` or terms like `release`, `publish`, `ship` → run **release mode**.
-2. Else if hints include `--full` or terms like `full`, `autonomous`, `merge` → run **full mode**.
-3. Else run **default mode**.
-
-Do not fail because hints are missing or unrecognized; default safely.
-
-| Mode | Behavior |
-|---|---|
-| Default (`/iterate-pr`) | Iterates on CI + high/medium feedback, asks user about low-priority items, then exits without merging. |
-| `--full` | Fully autonomous: handles every non-resolved feedback item, replies to every item, re-requests review (Gemini or Copilot) after each push, iterates until no new feedback and CI is green, then administratively merges the PR without waiting for a required-approval status. |
-| `--release` | Does everything in `--full`, then cuts/publishes a release for the repository. |
-
-## Bundled Scripts
-
-### `scripts/fetch_pr_checks.py`
-
-Fetches CI check status and extracts failure snippets from logs.
-
-```bash
-python3 .claude/skills/iterate-pr/scripts/fetch_pr_checks.py [--pr NUMBER]
-```
-
-Returns JSON:
-```json
-{
-  "pr": {"number": 123, "branch": "feat/foo"},
-  "summary": {"total": 5, "passed": 3, "failed": 2, "pending": 0},
-  "checks": [
-    {"name": "tests", "status": "fail", "log_snippet": "...", "run_id": 123},
-    {"name": "lint", "status": "pass"}
-  ]
-}
-```
-
-### `scripts/fetch_pr_feedback.py`
-
-Fetches and categorizes PR review feedback using the [LOGAF scale](https://develop.sentry.dev/engineering-practices/code-review/#logaf-scale).
-
-```bash
-python3 .claude/skills/iterate-pr/scripts/fetch_pr_feedback.py [--pr NUMBER]
-```
-
-Returns JSON with feedback categorized as:
-- `high` - Must address before merge (`h:`, blocker, changes requested)
-- `medium` - Should address (`m:`, standard feedback)
-- `low` - Optional (`l:`, nit, style, suggestion)
-- `bot` - Informational automated comments (Codecov, Dependabot, etc.)
-- `resolved` - Already resolved threads
-
-Review bot feedback (from Sentry, Warden, Cursor, Bugbot, CodeQL, etc.) appears in `high`/`medium`/`low` with `review_bot: true` — it is NOT placed in the `bot` bucket.
-
-Each feedback item may also include:
-- `thread_id` - GraphQL node ID for inline review comments (used for replies via `reply_to_thread.py`)
-
-### `scripts/reply_to_thread.py`
-
-Replies to PR review threads. Batches multiple replies into a single GraphQL call.
-
-```bash
-python3 .claude/skills/iterate-pr/scripts/reply_to_thread.py THREAD_ID "body" [THREAD_ID "body" ...]
-```
-
-Arguments are alternating `(thread_id, body)` pairs. The script sends the reply body without adding signatures, attribution, or sign-off text. Example:
-```bash
-python3 .claude/skills/iterate-pr/scripts/reply_to_thread.py \
-  PRRT_abc "Fixed the null check." \
-  PRRT_def "Replaced with path-segment counting."
-```
-
-## Workflow
-
-### 1. Identify PR
-
-```bash
-gh pr view --json number,url,headRefName
-```
-
-Stop if no PR exists for the current branch.
-
-### 2. Gather Review Feedback
-
-Run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_feedback.py` to get categorized feedback already posted on the PR.
-
-### 3. Handle Feedback by Priority and Mode
-
-Determine mode from invocation (`/iterate-pr`, `/iterate-pr --full`, `/iterate-pr --release`).
-
-#### Default mode (`/iterate-pr`)
-
-**Auto-fix (no prompt):**
-- `high` - must address (blockers, security, changes requested)
-- `medium` - should address (standard feedback)
-
-**Prompt user for selection:**
-- `low` - present numbered list and ask which to address:
-
-```
-Found 3 low-priority suggestions:
-1. [l] "Consider renaming this variable" - @reviewer in api.py:42
-2. [nit] "Could use a list comprehension" - @reviewer in utils.py:18
-3. [style] "Add a docstring" - @reviewer in models.py:55
-
-Which would you like to address? (e.g., "1,3" or "all" or "none")
-```
-
-**Skip silently:**
-- `resolved` threads
-- `bot` comments (informational only — Codecov, Dependabot, etc.)
-
-#### Full modes (`/iterate-pr --full`, `/iterate-pr --full --release`)
-
-Operate autonomously. Process every non-resolved feedback item returned by `fetch_pr_feedback.py` (`high`, `medium`, `low`, and `bot`).
-
-For each item:
-- Decide whether the feedback is justified
-- If justified, implement the change
-- If not justified, reject it with a concise technical reason
-- Never leave an item without an explicit decision
-
-When fixing feedback (all modes):
-- Understand the root cause, not just the surface symptom
-- Check for similar issues in nearby code or related files
-- Fix all instances, not just the one mentioned
-
-This includes review bot feedback (items with `review_bot: true`). Treat it the same as human feedback:
-- Real issue found → fix it
-- False positive → reject with explanation
-- Never silently ignore review bot feedback — always verify the finding
-
-#### Replying to Comments
-
-After processing feedback, reply to PR comments/threads to acknowledge the action taken.
-
-**Scope by mode:**
-- Default mode: reply to `high`/`medium`; reply to `low` only when fixed or declined by the user
-- Full modes: reply to every non-resolved feedback item, including informational bot feedback
-
-**How to reply:**
-- If `thread_id` exists (inline review thread), use `python3 .claude/skills/iterate-pr/scripts/reply_to_thread.py`
-- If no `thread_id` exists, post a PR comment with `gh pr comment <PR_NUMBER> --body "..."`
-- In full modes, a feedback round is incomplete until every item has a corresponding reply
-
-Batch inline replies for a round into a single call:
-
-```bash
-python3 .claude/skills/iterate-pr/scripts/reply_to_thread.py \
-  PRRT_abc "Fixed — description of change." \
-  PRRT_def "Not applicable — reason."
-```
-
-**Reply format:**
-- 1-2 sentences: what was changed, why it's not an issue, or acknowledgment of declined items
-- Never add a signature, attribution line, tag, or vendor/model mention in replies
-- Keep replies tool-agnostic and identity-free
-- If the script fails, log and continue — do not block the workflow
-
-### 4. Check CI Status
-
-Run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_checks.py` to get structured failure data.
-
-**Wait if pending:** If review bot checks (sentry, warden, cursor, bugbot, seer, codeql) are still running, wait before proceeding—they post actionable feedback that must be evaluated. Informational bots (codecov) are not worth waiting for.
-
-### 5. Fix CI Failures
-
-For each failure in the script output:
-1. Read the `log_snippet` and trace backwards from the error to understand WHY it failed — not just what failed
-2. Read the relevant code and check for related issues (e.g., if a type error in one call site, check other call sites)
-3. Fix the root cause with minimal, targeted changes
-4. Find existing tests for the affected code and run them. If the fix introduces behavior not covered by existing tests, extend them to cover it (add a test case, not a whole new test file)
-
-Do NOT assume what failed based on check name alone—always read the logs. Do NOT "quick fix and hope" — understand the failure thoroughly before changing code.
-
-### 6. Verify Locally, Then Commit and Push
-
-Before committing, verify your fixes locally:
-- If you fixed a test failure: re-run that specific test locally
-- If you fixed a lint/type error: re-run the linter or type checker on affected files
-- For any code fix: run existing tests covering the changed code
-
-If local verification fails, fix before proceeding — do not push known-broken code.
-
-```bash
-git add <files>
-gh auth status -a
-git commit --signoff -m "fix: <descriptive message>"
-git push
-```
-
-Always add exactly one sign-off to each commit for the active authenticated GitHub user. Check `gh auth status -a` before committing to confirm the active account, use `git commit --signoff`, and do not add any other trailers, signatures, or tool attribution to commits or PR comments.
-
-### 7. Monitor CI and Address Feedback
-
-Poll CI status and review feedback in a loop instead of blocking:
-
-1. Run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_checks.py` to get current CI status
-2. If all checks passed → proceed to exit conditions
-3. If any checks failed (none pending) → return to step 5
-4. If checks are still pending:
-   a. Run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_feedback.py` for new review feedback
-   b. Address feedback based on mode:
-      - Default mode: new `high`/`medium`
-      - Full modes: every new non-resolved item (`high`/`medium`/`low`/`bot`) and reply to each item
-   c. If changes were needed, commit and push (this restarts CI)
-   d. In full modes, after each push, explicitly re-request review:
-      - Prefer Gemini review command (`/gemini review`) when available
-      - Otherwise request Copilot review by commenting `@copilot review` on the PR
-   e. Sleep 30 seconds (don't increase on subsequent iterations), then repeat from sub-step 1
-5. After all checks pass, do a final feedback check: `sleep 10`, then run `python3 .claude/skills/iterate-pr/scripts/fetch_pr_feedback.py`.
-   - Default mode: address any new `high`/`medium` feedback; if changes are needed, return to step 6
-   - Full modes: address any new non-resolved item; if changes are needed, return to step 6 and re-request review
-
-### 8. Repeat
-
-If step 7 required code changes (from new feedback after CI passed), return to step 2 for a fresh cycle. CI failures during monitoring are already handled within step 7's polling loop.
-
-In full modes, continue looping until both conditions are true:
-- CI checks are green
-- No new non-resolved feedback is returned after the latest review request
-
-### 9. Finish by Mode
-
-- Default mode: stop after success conditions are met (do not merge automatically)
-- `full`: once CI is green and no new feedback remains, merge administratively - do not wait for a required-approval status to clear:
-
-```bash
-gh pr merge <PR_NUMBER> --admin --delete-branch
-```
-
-`--admin` uses the authenticated account's admin/maintainer permissions to bypass the
-required-approving-review branch-protection rule; it does not bypass or skip the CI-green
-and feedback-resolved checks this skill already enforces in steps 4-7, and it never fabricates
-or requests an approving review from another account. If the command fails (e.g. the
-authenticated account lacks admin/maintainer rights on the repo, or a check can't be
-bypassed), stop and surface the `gh` error to the user - do not retry under a different
-identity and do not fall back silently.
-
-- `--release`: complete `--full` mode merge, then cut a release:
-  1. Find the draft release tag:
-     ```bash
-     gh release list --repo layer5io/meshery-cloud --json tagName,isDraft --jq '.[] | select(.isDraft) | .tagName'
-     ```
-  2. Review draft notes:
-     ```bash
-     gh release view vX.Y.Z --repo layer5io/meshery-cloud
-     ```
-  3. Publish the release:
-     ```bash
-     gh release edit vX.Y.Z --repo layer5io/meshery-cloud --draft=false --latest
-     ```
-
-## Exit Conditions
-
-**Success (default):** All checks pass, post-CI feedback re-check is clean (no new unaddressed high/medium feedback including review bot findings), user has decided on low-priority items.
-
-**Success (`full`):** All checks pass, no new non-resolved feedback remains after the latest review request, every feedback item has a reply, and the PR is administratively merged (no wait on a required-approval status).
-
-**Success (`--release`):** `--full` success criteria are met and the draft GitHub release has been published.
-
-**Ask for help:** Same failure after 2 attempts, feedback needs clarification, infrastructure issues, or `gh pr merge --admin` fails (insufficient permissions or an unbypassable check) - surface the error rather than retrying under a different identity or falling back silently.
-
-**Stop:** No PR exists, branch needs rebase.
-
-## Fallback
-
-If scripts fail, use `gh` CLI directly:
-- `gh pr checks --json name,state,bucket,link`
-- `gh run view <run-id> --log-failed`
-- `gh api repos/{owner}/{repo}/pulls/{number}/comments`
diff --git a/.claude/skills/iterate-pr/scripts/__pycache__/fetch_pr_checks.cpython-314.pyc b/.claude/skills/iterate-pr/scripts/__pycache__/fetch_pr_checks.cpython-314.pyc
deleted file mode 100644
index dab126de7..000000000
Binary files a/.claude/skills/iterate-pr/scripts/__pycache__/fetch_pr_checks.cpython-314.pyc and /dev/null differ
diff --git a/.claude/skills/iterate-pr/scripts/__pycache__/fetch_pr_feedback.cpython-314.pyc b/.claude/skills/iterate-pr/scripts/__pycache__/fetch_pr_feedback.cpython-314.pyc
deleted file mode 100644
index c17400972..000000000
Binary files a/.claude/skills/iterate-pr/scripts/__pycache__/fetch_pr_feedback.cpython-314.pyc and /dev/null differ
diff --git a/.claude/skills/iterate-pr/scripts/fetch_pr_checks.py b/.claude/skills/iterate-pr/scripts/fetch_pr_checks.py
deleted file mode 100755
index ba7f4e1ab..000000000
--- a/.claude/skills/iterate-pr/scripts/fetch_pr_checks.py
+++ /dev/null
@@ -1,203 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# requires-python = ">=3.9"
-# ///
-"""
-Fetch PR CI checks and optional failure snippets.
-
-Usage:
-    python fetch_pr_checks.py [--pr PR_NUMBER]
-
-If --pr is not specified, uses the PR for the current branch.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import subprocess
-import sys
-from typing import Any
-
-RUN_ID_PATTERN = re.compile(r"/actions/runs/(\d+)")
-FAILURE_PATTERNS = [
-    re.compile(pattern, re.IGNORECASE)
-    for pattern in (
-        r"\berror[:\s]",
-        r"\bfailed[:\s]",
-        r"\bfailure[:\s]",
-        r"\btraceback\b",
-        r"\bexception\b",
-        r"\bpanic:",
-        r"\bfatal:",
-        r"\bnpm ERR!",
-        r"\bTypeError\b",
-        r"\bSyntaxError\b",
-        r"\bImportError\b",
-        r"\bModuleNotFoundError\b",
-        r"===.*FAILURES.*===",
-    )
-]
-
-
-def fail(message: str) -> None:
-    print(json.dumps({"error": message}))
-    sys.exit(1)
-
-
-def run_gh_json(args: list[str], allowed_exit_codes: tuple[int, ...] = (0,)) -> Any:
-    result = subprocess.run(
-        ["gh", *args],
-        capture_output=True,
-        text=True,
-    )
-
-    if result.returncode not in allowed_exit_codes:
-        stderr = (result.stderr or result.stdout).strip() or "unknown gh error"
-        raise RuntimeError(f"gh {' '.join(args)} failed: {stderr}")
-
-    stdout = result.stdout.strip()
-    if not stdout:
-        return None
-
-    try:
-        return json.loads(stdout)
-    except json.JSONDecodeError as exc:
-        raise RuntimeError(f"gh {' '.join(args)} returned non-JSON output") from exc
-
-
-def get_pr_info(pr_number: int | None = None) -> dict[str, Any] | None:
-    args = ["pr", "view", "--json", "number,url,headRefName,baseRefName"]
-    if pr_number is not None:
-        args.insert(2, str(pr_number))
-    result = run_gh_json(args)
-    if not isinstance(result, dict):
-        raise RuntimeError("unable to determine PR for current branch")
-    return result
-
-
-def get_checks(pr_number: int | None = None) -> list[dict[str, Any]]:
-    args = ["pr", "checks", "--json", "name,bucket,state,link,workflow"]
-    if pr_number is not None:
-        args.insert(2, str(pr_number))
-
-    result = run_gh_json(args, allowed_exit_codes=(0, 8))
-    if not isinstance(result, list):
-        return []
-
-    checks: list[dict[str, Any]] = []
-    for entry in result:
-        if not isinstance(entry, dict):
-            continue
-        checks.append(
-            {
-                "name": str(entry.get("name") or "unknown"),
-                "status": str(entry.get("bucket") or entry.get("state") or "unknown"),
-                "link": str(entry.get("link") or ""),
-                "workflow": str(entry.get("workflow") or ""),
-            }
-        )
-
-    checks.sort(key=lambda check: (check["name"].lower(), check["workflow"].lower(), check["status"], check["link"]))
-    return checks
-
-
-def get_run_id(check_link: str) -> int | None:
-    match = RUN_ID_PATTERN.search(check_link)
-    if not match:
-        return None
-    return int(match.group(1))
-
-
-def extract_failure_snippet(log_text: str, max_lines: int = 50) -> str:
-    lines = log_text.splitlines()
-    if not lines:
-        return ""
-
-    first_failure = None
-    for index, line in enumerate(lines):
-        if any(pattern.search(line) for pattern in FAILURE_PATTERNS):
-            first_failure = index
-            break
-
-    if first_failure is None:
-        return "\n".join(lines[-max_lines:])
-
-    start = max(0, first_failure - 5)
-    end = min(len(lines), start + max_lines)
-    return "\n".join(lines[start:end])
-
-
-def get_run_logs(run_id: int) -> str | None:
-    result = subprocess.run(
-        ["gh", "run", "view", str(run_id), "--log-failed"],
-        capture_output=True,
-        text=True,
-        timeout=60,
-    )
-    if result.returncode != 0:
-        return None
-    return result.stdout if result.stdout.strip() else None
-
-
-def summarize(checks: list[dict[str, Any]]) -> dict[str, int]:
-    return {
-        "total": len(checks),
-        "passed": sum(1 for check in checks if check["status"] == "pass"),
-        "failed": sum(1 for check in checks if check["status"] == "fail"),
-        "pending": sum(1 for check in checks if check["status"] == "pending"),
-        "skipped": sum(1 for check in checks if check["status"] in {"skipping", "cancel"}),
-    }
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Fetch PR CI checks with failure snippets")
-    parser.add_argument("--pr", type=int, help="PR number (defaults to current branch PR)")
-    args = parser.parse_args()
-
-    try:
-        pr_info = get_pr_info(args.pr)
-        checks = get_checks(pr_info["number"])
-    except RuntimeError as error:
-        fail(str(error))
-
-    pr_number = pr_info["number"]
-    branch = pr_info["headRefName"]
-
-    processed_checks = []
-    log_cache: dict[int, str | None] = {}
-
-    for check in checks:
-        processed = dict(check)
-
-        if processed["status"] == "fail":
-            run_id = get_run_id(processed.get("link", ""))
-            if run_id is not None:
-                processed["run_id"] = run_id
-                if run_id not in log_cache:
-                    log_cache[run_id] = get_run_logs(run_id)
-                logs = log_cache[run_id]
-                if logs:
-                    snippet = extract_failure_snippet(logs)
-                    if snippet:
-                        processed["log_snippet"] = snippet
-
-        processed_checks.append(processed)
-
-    output = {
-        "pr": {
-            "number": pr_number,
-            "url": pr_info.get("url", ""),
-            "branch": branch,
-            "base": pr_info.get("baseRefName", ""),
-        },
-        "summary": summarize(processed_checks),
-        "checks": processed_checks,
-    }
-
-    print(json.dumps(output, indent=2))
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.claude/skills/iterate-pr/scripts/fetch_pr_feedback.py b/.claude/skills/iterate-pr/scripts/fetch_pr_feedback.py
deleted file mode 100755
index 8ebc33f24..000000000
--- a/.claude/skills/iterate-pr/scripts/fetch_pr_feedback.py
+++ /dev/null
@@ -1,447 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# requires-python = ">=3.9"
-# ///
-"""
-Fetch and categorize PR review feedback.
-
-Usage:
-    uv run fetch_pr_feedback.py [--pr PR_NUMBER]
-    python3 fetch_pr_feedback.py [--pr PR_NUMBER]
-
-If --pr is not specified, uses the PR for the current branch.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import subprocess
-import sys
-from typing import Any, NoReturn
-
-
-REVIEW_BOT_PATTERNS = [
-    r"(?i)^sentry",
-    r"(?i)^warden",
-    r"(?i)^cursor",
-    r"(?i)^bugbot",
-    r"(?i)^seer",
-    r"(?i)^copilot",
-    r"(?i)^codex",
-    r"(?i)^claude",
-    r"(?i)^codeql",
-]
-
-INFO_BOT_PATTERNS = [
-    r"(?i)^codecov",
-    r"(?i)^dependabot",
-    r"(?i)^renovate",
-    r"(?i)^github-actions",
-    r"(?i)^mergify",
-    r"(?i)^semantic-release",
-    r"(?i)^sonarcloud",
-    r"(?i)^snyk",
-    r"(?i)bot$",
-    r"(?i)\[bot\]$",
-]
-
-LOGAF_PATTERNS = [
-    (re.compile(r"^\s*(?:h:|h\s*:|high:|\[h\])", re.IGNORECASE), "high"),
-    (re.compile(r"^\s*(?:m:|m\s*:|medium:|\[m\])", re.IGNORECASE), "medium"),
-    (re.compile(r"^\s*(?:l:|l\s*:|low:|\[l\])", re.IGNORECASE), "low"),
-]
-
-HIGH_PATTERNS = [
-    re.compile(pattern, re.IGNORECASE)
-    for pattern in (
-        r"must\s+(fix|change|update|address)",
-        r"this\s+(is\s+)?(wrong|incorrect|broken|buggy)",
-        r"security\s+(issue|vulnerability|concern)",
-        r"will\s+(break|cause|fail)",
-        r"\bcritical\b",
-        r"\bblocker\b",
-    )
-]
-
-LOW_PATTERNS = [
-    re.compile(pattern, re.IGNORECASE)
-    for pattern in (
-        r"nit[:\s]",
-        r"nitpick",
-        r"suggestion[:\s]",
-        r"consider\s+",
-        r"could\s+(also\s+)?",
-        r"might\s+(want\s+to|be\s+better)",
-        r"optional[:\s]",
-        r"minor[:\s]",
-        r"style[:\s]",
-        r"prefer\s+",
-        r"what\s+do\s+you\s+think",
-        r"up\s+to\s+you",
-        r"take\s+it\s+or\s+leave",
-        r"\bfwiw\b",
-    )
-]
-
-
-def fail(message: str) -> NoReturn:
-    print(json.dumps({"error": message}))
-    sys.exit(1)
-
-
-def run_gh_json(args: list[str]) -> Any:
-    try:
-        result = subprocess.run(
-            ["gh", *args],
-            capture_output=True,
-            text=True,
-        )
-    except OSError as exc:
-        raise RuntimeError(f"failed to run gh CLI: {exc}") from exc
-    if result.returncode != 0:
-        stderr = (result.stderr or result.stdout).strip() or "unknown gh error"
-        raise RuntimeError(f"gh {' '.join(args)} failed: {stderr}")
-
-    stdout = result.stdout.strip()
-    if not stdout:
-        return None
-
-    try:
-        return json.loads(stdout)
-    except json.JSONDecodeError as exc:
-        raise RuntimeError(f"gh {' '.join(args)} returned non-JSON output") from exc
-
-
-def get_repo_info() -> tuple[str, str]:
-    result = run_gh_json(["repo", "view", "--json", "owner,name"])
-    if not isinstance(result, dict):
-        raise RuntimeError("could not determine repository from current directory")
-    owner = result.get("owner", {}).get("login")
-    repo = result.get("name")
-    if not owner or not repo:
-        raise RuntimeError("could not determine repository owner/name")
-    return str(owner), str(repo)
-
-
-def get_pr_info(pr_number: int | None = None) -> dict[str, Any]:
-    args = ["pr", "view", "--json", "number,url,headRefName,author,reviews,reviewDecision"]
-    if pr_number is not None:
-        args.insert(2, str(pr_number))
-    result = run_gh_json(args)
-    if not isinstance(result, dict):
-        raise RuntimeError("unable to determine PR for current branch")
-    return result
-
-
-def is_review_bot(username: str) -> bool:
-    return any(re.search(p, username) for p in REVIEW_BOT_PATTERNS)
-
-
-def is_info_bot(username: str) -> bool:
-    return any(re.search(p, username) for p in INFO_BOT_PATTERNS)
-
-
-def get_issue_comments(owner: str, repo: str, pr_number: int) -> list[dict[str, Any]]:
-    result = run_gh_json([
-        "api",
-        f"repos/{owner}/{repo}/issues/{pr_number}/comments",
-        "--paginate",
-        "--slurp",
-    ])
-    if not isinstance(result, list):
-        return []
-
-    comments: list[dict[str, Any]] = []
-    for page in result:
-        if isinstance(page, list):
-            comments.extend(entry for entry in page if isinstance(entry, dict))
-        elif isinstance(page, dict):
-            comments.append(page)
-    return comments
-
-
-def get_review_threads(owner: str, repo: str, pr_number: int) -> list[dict[str, Any]]:
-    query = """
-    query($owner: String!, $repo: String!, $pr: Int!, $after: String) {
-      repository(owner: $owner, name: $repo) {
-        pullRequest(number: $pr) {
-          reviewThreads(first: 100, after: $after) {
-            pageInfo {
-              hasNextPage
-              endCursor
-            }
-            nodes {
-              id
-              isResolved
-              isOutdated
-              path
-              line
-              comments(first: 1) {
-                nodes {
-                  body
-                  createdAt
-                  author {
-                    login
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    """
-    threads: list[dict[str, Any]] = []
-    cursor: str | None = None
-    while True:
-        args = [
-            "api",
-            "graphql",
-            "-f",
-            f"query={query}",
-            "-F",
-            f"owner={owner}",
-            "-F",
-            f"repo={repo}",
-            "-F",
-            f"pr={pr_number}",
-        ]
-        if cursor is not None:
-            args.extend(["-F", f"after={cursor}"])
-
-        result = run_gh_json(args)
-        if not isinstance(result, dict):
-            break
-
-        review_threads = (
-            result.get("data", {})
-            .get("repository", {})
-            .get("pullRequest", {})
-            .get("reviewThreads", {})
-        )
-        nodes = review_threads.get("nodes", [])
-        if isinstance(nodes, list):
-            threads.extend(nodes)
-
-        page_info = review_threads.get("pageInfo", {})
-        if not page_info.get("hasNextPage"):
-            break
-        cursor = page_info.get("endCursor")
-        if not cursor:
-            break
-
-    return threads
-
-
-def detect_logaf(body: str) -> str | None:
-    for pattern, level in LOGAF_PATTERNS:
-        if pattern.search(body):
-            return level
-    return None
-
-
-def categorize_comment(author: str, body: str) -> str:
-    if is_info_bot(author) and not is_review_bot(author):
-        return "bot"
-
-    logaf_level = detect_logaf(body)
-    if logaf_level:
-        return logaf_level
-
-    if any(pattern.search(body) for pattern in HIGH_PATTERNS):
-        return "high"
-    if any(pattern.search(body) for pattern in LOW_PATTERNS):
-        return "low"
-    return "medium"
-
-
-def item_sort_key(item: dict[str, Any]) -> str:
-    return item.get("_created_at", "")
-
-
-def extract_feedback_item(
-    body: str,
-    author: str,
-    *,
-    created_at: str = "",
-    path: str | None = None,
-    line: int | None = None,
-    url: str | None = None,
-    is_resolved: bool = False,
-    is_outdated: bool = False,
-    review_bot: bool = False,
-    thread_id: str | None = None,
-) -> dict[str, Any]:
-    summary = body[:200] + "..." if len(body) > 200 else body
-    summary = summary.replace("\n", " ").strip()
-
-    item: dict[str, Any] = {
-        "author": author,
-        "body": summary,
-        "full_body": body,
-        "_created_at": created_at,
-    }
-
-    if path:
-        item["path"] = path
-    if line is not None:
-        item["line"] = line
-    if url:
-        item["url"] = url
-    if is_resolved:
-        item["resolved"] = True
-    if is_outdated:
-        item["outdated"] = True
-    if review_bot:
-        item["review_bot"] = True
-    if thread_id:
-        item["thread_id"] = thread_id
-
-    return item
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Fetch and categorize PR feedback")
-    parser.add_argument("--pr", type=int, help="PR number (defaults to current branch PR)")
-    args = parser.parse_args()
-
-    try:
-        owner, repo = get_repo_info()
-        pr_info = get_pr_info(args.pr)
-    except RuntimeError as error:
-        fail(str(error))
-
-    pr_number = pr_info["number"]
-    pr_author = pr_info.get("author", {}).get("login", "")
-    review_decision = pr_info.get("reviewDecision", "")
-
-    feedback: dict[str, list[dict[str, Any]]] = {
-        "high": [],
-        "medium": [],
-        "low": [],
-        "bot": [],
-        "resolved": [],
-    }
-
-    reviews = pr_info.get("reviews", [])
-    if isinstance(reviews, list):
-        for review in reviews:
-            if not isinstance(review, dict):
-                continue
-            if review.get("state") != "CHANGES_REQUESTED":
-                continue
-            author = review.get("author", {}).get("login", "")
-            body = review.get("body", "")
-            if not author or not body or author == pr_author:
-                continue
-            item = extract_feedback_item(
-                body=body,
-                author=author,
-                created_at=str(review.get("submittedAt", "")),
-            )
-            item["type"] = "changes_requested"
-            feedback["high"].append(item)
-
-    try:
-        threads = get_review_threads(owner, repo, pr_number)
-        issue_comments = get_issue_comments(owner, repo, pr_number)
-    except RuntimeError as error:
-        fail(str(error))
-
-    if isinstance(threads, list):
-        for thread in threads:
-            if not isinstance(thread, dict):
-                continue
-            comments = thread.get("comments", {}).get("nodes", [])
-            if not comments or not isinstance(comments, list):
-                continue
-
-            first_comment = comments[0] if comments and isinstance(comments[0], dict) else {}
-            author = first_comment.get("author", {}).get("login", "")
-            body = first_comment.get("body", "")
-            if not author or not body or author == pr_author or len(body.strip()) < 3:
-                continue
-
-            is_resolved = bool(thread.get("isResolved", False))
-            thread_id = thread.get("id")
-            category = "resolved" if is_resolved else categorize_comment(author, body)
-
-            item = extract_feedback_item(
-                body=body,
-                author=author,
-                created_at=str(first_comment.get("createdAt", "")),
-                path=thread.get("path"),
-                line=thread.get("line"),
-                is_resolved=is_resolved,
-                is_outdated=bool(thread.get("isOutdated", False)),
-                thread_id=thread_id if isinstance(thread_id, str) else None,
-                review_bot=category in {"high", "medium", "low"} and is_review_bot(author),
-            )
-            feedback[category].append(item)
-
-    if isinstance(issue_comments, list):
-        for comment in issue_comments:
-            if not isinstance(comment, dict):
-                continue
-            author = comment.get("user", {}).get("login", "")
-            body = comment.get("body", "")
-            if not author or not body or author == pr_author or len(body.strip()) < 3:
-                continue
-
-            category = categorize_comment(author, body)
-            item = extract_feedback_item(
-                body=body,
-                author=author,
-                created_at=str(comment.get("created_at", "")),
-                url=comment.get("html_url"),
-                review_bot=category in {"high", "medium", "low"} and is_review_bot(author),
-            )
-            feedback[category].append(item)
-
-    for bucket in feedback.values():
-        bucket.sort(key=item_sort_key)
-        for item in bucket:
-            item.pop("_created_at", None)
-
-    review_bot_count = sum(
-        1
-        for bucket in ("high", "medium", "low")
-        for item in feedback[bucket]
-        if item.get("review_bot")
-    )
-
-    output = {
-        "pr": {
-            "number": pr_number,
-            "url": pr_info.get("url", ""),
-            "author": pr_author,
-            "review_decision": review_decision,
-        },
-        "summary": {
-            "high": len(feedback["high"]),
-            "medium": len(feedback["medium"]),
-            "low": len(feedback["low"]),
-            "bot_comments": len(feedback["bot"]),
-            "resolved": len(feedback["resolved"]),
-            "review_bot_feedback": review_bot_count,
-            "needs_attention": len(feedback["high"]) + len(feedback["medium"]),
-        },
-        "feedback": feedback,
-    }
-
-    if feedback["high"]:
-        output["action_required"] = "Address high-priority feedback before merge"
-    elif feedback["medium"]:
-        output["action_required"] = "Address medium-priority feedback"
-    elif feedback["low"]:
-        output["action_required"] = "Review low-priority suggestions - ask user which to address"
-    else:
-        output["action_required"] = None
-
-    print(json.dumps(output, indent=2))
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.claude/skills/iterate-pr/scripts/reply_to_thread.py b/.claude/skills/iterate-pr/scripts/reply_to_thread.py
deleted file mode 100644
index 2b66a0cd5..000000000
--- a/.claude/skills/iterate-pr/scripts/reply_to_thread.py
+++ /dev/null
@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# requires-python = ">=3.9"
-# ///
-"""
-Reply to PR review threads.
-
-Usage:
-    python reply_to_thread.py THREAD_ID BODY [THREAD_ID BODY ...]
-
-Accepts one or more (thread_id, body) pairs as positional arguments.
-Batches all replies into a single GraphQL mutation for efficiency.
-
-Example:
-    python reply_to_thread.py PRRT_abc "Fixed the issue."
-    python reply_to_thread.py PRRT_abc "Fixed." PRRT_def "Also fixed."
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import subprocess
-import sys
-
-PROHIBITED_TERM_PATTERN = re.compile(
-    r"\b(?:claude(?:\s+code)?|cloude\s+code|anthropic)\b",
-    re.IGNORECASE,
-)
-SIGNATURE_PATTERN = re.compile(r"^\*[—-]\s+.+\*$")
-SIGNOFF_PATTERN = re.compile(r"^\s*(?:signed-off-by|co-authored-by)\s*:", re.IGNORECASE)
-
-
-def _normalize_body(body: str) -> str:
-    """Normalize escaped newlines and strip attribution/sign-off text.
-
-    Bash double quotes keep "\\n" literal, but reply bodies should contain
-    actual newlines for readability.
-    """
-    normalized = body.replace("\\r\\n", "\\n").replace("\\n", "\n")
-
-    sanitized_lines: list[str] = []
-    for line in normalized.split("\n"):
-        stripped = line.strip()
-        if SIGNATURE_PATTERN.match(stripped) or SIGNOFF_PATTERN.match(stripped):
-            continue
-
-        had_prohibited_terms = bool(PROHIBITED_TERM_PATTERN.search(line))
-        sanitized = PROHIBITED_TERM_PATTERN.sub("", line)
-        sanitized = re.sub(r"\s{2,}", " ", sanitized).rstrip()
-        if had_prohibited_terms and re.fullmatch(r"[\W_]*(?:and|or|and/or|&)?[\W_]*", sanitized.strip(), re.IGNORECASE):
-            continue
-        sanitized_lines.append(sanitized)
-
-    sanitized = "\n".join(sanitized_lines).strip()
-    sanitized = re.sub(r"\n{3,}", "\n\n", sanitized)
-
-    return sanitized or "Updated."
-
-
-def reply_to_threads(pairs: list[tuple[str, str]]) -> list[tuple[str, bool]]:
-    """Reply to one or more review threads in a single GraphQL call.
-
-    Returns a per-operation list of (thread_id, success) tuples.
-    """
-    # Build aliased mutation
-    mutations = []
-    for i, (thread_id, body) in enumerate(pairs):
-        escaped_thread_id = json.dumps(thread_id)
-        normalized_body = _normalize_body(body)
-        if normalized_body != body.replace("\\r\\n", "\\n").replace("\\n", "\n"):
-            print(
-                f"Sanitized reply body for thread {thread_id} to remove signatures or attribution.",
-                file=sys.stderr,
-            )
-        escaped_body = json.dumps(normalized_body)  # handles newlines, quotes
-        mutations.append(
-            f"  r{i}: addPullRequestReviewThreadReply(input: {{"
-            f"pullRequestReviewThreadId: {escaped_thread_id}, "
-            f"body: {escaped_body}"
-            f"}}) {{ clientMutationId }}"
-        )
-
-    query = "mutation {\n" + "\n".join(mutations) + "\n}"
-
-    try:
-        result = subprocess.run(
-            ["gh", "api", "graphql", "-f", f"query={query}"],
-            capture_output=True,
-            text=True,
-            timeout=30,
-        )
-        if result.returncode != 0:
-            print(f"GraphQL error: {result.stderr}", file=sys.stderr)
-            return [(tid, False) for tid, _ in pairs]
-
-        # Parse response to detect per-alias GraphQL errors
-        try:
-            response = json.loads(result.stdout)
-        except (json.JSONDecodeError, TypeError):
-            print(f"Failed to parse GraphQL response: {result.stdout}", file=sys.stderr)
-            return [(tid, False) for tid, _ in pairs]
-
-        data = response.get("data") or {}
-        errors = response.get("errors") or []
-
-        # Build a set of alias indices that have errors
-        error_paths = set()
-        for err in errors:
-            for segment in err.get("path") or []:
-                if isinstance(segment, str) and segment.startswith("r"):
-                    error_paths.add(segment)
-
-        operation_results = []
-        for i, (tid, _) in enumerate(pairs):
-            alias = f"r{i}"
-            if alias in error_paths or data.get(alias) is None:
-                operation_results.append((tid, False))
-            else:
-                operation_results.append((tid, True))
-
-        if any(not ok for _, ok in operation_results):
-            failed = [tid for tid, ok in operation_results if not ok]
-            print(f"GraphQL partial failure for threads: {failed}", file=sys.stderr)
-
-        return operation_results
-    except subprocess.TimeoutExpired:
-        print("Request timed out", file=sys.stderr)
-        return [(tid, False) for tid, _ in pairs]
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Reply to PR review threads",
-        usage="%(prog)s THREAD_ID BODY [THREAD_ID BODY ...]",
-    )
-    parser.add_argument(
-        "args",
-        nargs="+",
-        help="Alternating thread_id and body pairs",
-    )
-    parsed = parser.parse_args()
-
-    if len(parsed.args) % 2 != 0:
-        print("Error: arguments must be (thread_id, body) pairs", file=sys.stderr)
-        sys.exit(1)
-
-    pairs = []
-    for i in range(0, len(parsed.args), 2):
-        pairs.append((parsed.args[i], parsed.args[i + 1]))
-
-    results = reply_to_threads(pairs)
-
-    # Output results
-    success = all(ok for _, ok in results)
-    by_thread = {}
-    for tid, ok in results:
-        by_thread.setdefault(tid, []).append(ok)
-
-    output = {
-        "replied": sum(1 for _, ok in results if ok),
-        "failed": sum(1 for _, ok in results if not ok),
-        "operations": [
-            {"thread_id": tid, "status": "ok" if ok else "failed"}
-            for tid, ok in results
-        ],
-        "threads": {
-            tid: "ok" if all(statuses) else "failed"
-            for tid, statuses in by_thread.items()
-        },
-    }
-    print(json.dumps(output, indent=2))
-
-    if not success:
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/.claude/skills/lavish b/.claude/skills/lavish
deleted file mode 120000
index 0fa00290a..000000000
--- a/.claude/skills/lavish
+++ /dev/null
@@ -1 +0,0 @@
-../../.agents/skills/lavish
\ No newline at end of file
diff --git a/.claude/skills/quota-axi b/.claude/skills/quota-axi
deleted file mode 120000
index d351b5a36..000000000
--- a/.claude/skills/quota-axi
+++ /dev/null
@@ -1 +0,0 @@
-../../.agents/skills/quota-axi
\ No newline at end of file
diff --git a/.prettierignore b/.prettierignore
index 766b06b91..b2606f8b3 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -8,3 +8,4 @@ site/public
 .yarnrc.yml
 .eslintrc.*js
 .claude/
+.agents/
diff --git a/AGENTS.md b/AGENTS.md
index 63619d5b7..dc104acaf 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -4,11 +4,39 @@ This file is the project's committed home for project-intrinsic agent knowledge:
 
 - Add durable project-specific notes here as they are discovered through real work.
 
+## Skills live in `.agents/skills`, and only there
+
+`.agents/skills` is the single source of truth for this repo's agent skills. `.claude/skills` is a
+relative symlink to it (`../.agents/skills`), because Claude Code does not discover `.agents/skills`
+on its own. Add a new skill under `.agents/skills/<name>/SKILL.md`; never add one under
+`.claude/skills`, which would write through the symlink and land in the wrong place conceptually.
+
+There is deliberately no `.codex/skills` or `.opencode/skills` link: both tools already read
+`.agents/skills` natively (Codex via `repo_agents_skill_roots` in `codex-rs/core-skills/src/loader.rs`;
+OpenCode per its skills docs), so a link would be redundant rather than load-bearing.
+
+That rule is aimed at a human, but the actor that will actually write to `.claude/skills` is a tool:
+the AXI skills installer, which produced commit `5482d046` ("Install AXI agent tooling") and
+maintains the tracked `skills-lock.json`. That lockfile records four installer-managed skills -
+`chrome-devtools-axi`, `gh-axi`, `lavish`, `quota-axi` - and the installer's own layout is content
+under `.agents/skills/<name>/` **plus** a per-skill `.claude/skills/<name>` symlink, which is exactly
+what this change replaced with the single directory-level link. So on its next install or update run
+the installer will try to create `.claude/skills/<name>`; because `.claude/skills` is now itself a
+symlink to `../.agents/skills`, that final path component resolves to `.agents/skills/<name>`, which
+already exists as a real directory. Best case it errors with `EEXIST` and does nothing. Worst case an
+installer that force-replaces its destination (`rm -rf` followed by `symlink`) deletes the canonical
+skill directory and leaves a self-referential `.agents/skills/<name> -> ../../.agents/skills/<name>`
+loop, destroying the skill content.
+
+Which of those happens has **not** been established: no installer CLI managing `skills-lock.json` is
+present in this repo or on `PATH`, and the destructive path was deliberately not tested by running
+it. Establish the installer's replace semantics before re-running it against this layout.
+
 ## Releasing
 
 Automation-driven; do not `npm publish`, `npm version`, or tag by hand. Merge to `master`, let
 Release Drafter update the draft, then publish the draft - `release.yml` does the rest.
-Runbook: [`.claude/skills/cut-release/SKILL.md`](.claude/skills/cut-release/SKILL.md).
+Runbook: [`.agents/skills/cut-release/SKILL.md`](.agents/skills/cut-release/SKILL.md).
 
 Resolve "what is currently released" from the npm `latest` dist-tag and publish timestamps
 (`npm view @sistent/sistent dist-tags time --json`), not by eyeballing semver order.