@agentikos/omega-os 0.2.0 → 0.19.6

package/omega/Agentik_SSOT/skills/perfaudit/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: perfaudit
+description: Forensic performance audit — Is it FAST ENOUGH for humans to care — or does it bleed milliseconds nobody measured?. Runs the gather (deterministic) + falsify (agentic) pipeline, batches fixes, dispatches capped workers, re-audits, and persists scores. Use when the user says "/perfaudit", "audit performance", or asks to verify the performance health of the project.
+when_to_use: User says /perfaudit, audit performance, check performance, verify performance, is performance healthy.
+argument-hint: "[--scope <path>] [--fix] [--max-workers N]"
+arguments: [args]
+allowed-tools: Bash Read Edit Grep Glob Write
+---
+
+# perfaudit — forensic audit (Agentik OS Quality Arsenal)
+
+> Is it FAST ENOUGH for humans to care — or does it bleed milliseconds nobody measured?
+
+You are running the perfaudit forensic audit. Apply the **Gestalt-Popper
+doctrine**: identify the hinge point, scrutinise it 10x, then assume
+every name is a CLAIM and look for the divergence between the claim and
+the reality. Bias toward FAIL. A perfect score is earned by finding zero
+falsifiable claims, never by absence of effort.
+
+## Run
+
+The audit is one engine call — gather (deterministic) + falsify (agentic)
++ optional fix-dispatch (capped) + re-audit. Invoke the unified pipeline:
+
+```bash
+omega audit run perfaudit $args
+```
+
+Common options:
+
+| Flag | Effect |
+|---|---|
+| `--scope <path>` | scope the audit (file or directory) |
+| `--fix` | after analysing, batch findings + dispatch up to N workers + re-audit |
+| `--max-workers N` | cap parallel fix workers (default 3) |
+| `--min-severity high` | only batch + fix findings at or above this severity |
+
+Read-only by default. Add `--fix` to enable the dispatch + re-audit loop.
+
+## Phases under investigation
+
+The agentic pass walks each phase below and emits structured findings
+(claim vs. reality). Every PASS must cite ≥3 concrete checks.
+
+### 1. core-web-vitals
+
+Measure LCP (<2.5s), INP (<200ms), CLS (<0.1), TTFB (<800ms), FCP (<1.8s) on the hinge page; re-run throttled at 3G + 4x CPU and watch the score collapse.
+
+### 2. bundle-bloat
+
+Total initial JS compressed (<200KB target); barrel imports pulling whole libraries; duplicate deps at multiple versions; source maps shipped to prod.
+
+### 3. render-path
+
+Render-blocking CSS/scripts in the critical path; unnecessary React re-renders; layout thrashing (read-write-read); long tasks >50ms blocking interactivity.
+
+### 4. js-execution
+
+Parse cost per bundle; hydration time and mismatch errors; un-throttled scroll/resize handlers; async waterfalls that should be Promise.all.
+
+### 5. image-optimization
+
+PNG/JPEG where WebP/AVIF saves 60-80%; images larger than display size; missing width/height (CLS); missing lazy-loading below the fold; missing fetchpriority on the LCP image.
+
+### 6. font-loading
+
+WOFF2 used and subset to used glyphs; font-display:swap to prevent FOIT; critical fonts preloaded; layout shift when the web font swaps in.
+
+### 7. caching-strategy
+
+Cache-Control + immutable on fingerprinted assets; repeated identical API calls that should be memoized/SWR-cached; deploy invalidates stale CSS/JS hashes.
+
+### 8. ssr-ssg-strategy
+
+Each route uses the right rendering mode (SSR/SSG/ISR/CSR); static pages wrongly rendered per-request; SSR data fetching serial instead of parallel; streaming used for TTFB.
+
+### 9. code-splitting
+
+Route-based and component-based splitting working; vendor/framework chunks separated; heavy components (charts, editors, maps) lazy-loaded behind dynamic import.
+
+### 10. api-response-times
+
+Per-endpoint average <200ms and P95 <1s; over-fetching unused fields; sequential dependent calls on page load; missing pagination on list endpoints.
+
+### 11. n-plus-one
+
+Same query template fired in a loop with different params; ORM relationships lacking eager loading; SELECT * where columns suffice; total queries per page load >10.
+
+### 12. db-query-performance
+
+Queries >100ms; full table scans from missing indexes; joins/sorts without supporting indexes; large result sets without LIMIT; connection pool sized for concurrency.
+
+### 13. memory-leaks
+
+Heap growth over time; detached DOM nodes; event listeners/timers/intervals/sockets never cleaned on unmount; unbounded caches and history stacks.
+
+### 14. resource-hints-third-party
+
+LCP image and critical fonts preloaded; preconnect/dns-prefetch for third-party origins; render-blocking third-party scripts that could be deferred or facade-loaded.
+
+## Falsification rules
+
+Lighthouse scores lie — every green score must be re-verified throttled (3G + 4x CPU, cold cache) and twice to rule out a one-off blip. Categorise findings as SCORE-vs-REALITY, LAB-vs-FIELD, FIRST-vs-REPEAT, or AVERAGE-vs-P95. Every PASS cites ≥3 concrete measurements with actual numbers. "It's fast for me" (warm cache, fast machine) is not evidence. Bias toward FAIL — a 100 is earned, never assumed.
+
+## After the run
+
+The pipeline writes one structured verdict to:
+
+```
+Agentik_Runtime/audits.db    (history — `omega audit history perfaudit`)
+Agentik_Runtime/sessions/${CLAUDE_SESSION_ID}/.done.json   (this turn)
+```
+
+The `.done.json` schema:
+
+```json
+{
+  "status": "done_clean" | "pending" | "failed",
+  "summary": "<one-paragraph verdict>",
+  "artifacts": {
+    "audit": "perfaudit",
+    "score": 0-100,
+    "verified": bool,
+    "findings": [...],
+    "fix_plan": [...],
+    "dispatches": [...],
+    "reaudit_score": 0-100  // only when --fix was used
+  }
+}
+```
+
+## Hard rules (don't break these)
+
+1. **No fake "done".** First Law: only runtime tells the truth. If the
+   gather phase fails or the agentic verdict scores below the threshold,
+   you have NOT verified — set status to `pending` or `failed`.
+2. **Cap parallelism.** ≤ 3 fix workers at a time. The
+   batcher enforces this; do not call out to other dispatch mechanisms.
+3. **No worker per finding.** Findings are clustered by file footprint and
+   severity. One worker handles one disjoint batch.
+4. **Re-audit confirms.** After fixes land, the pipeline re-runs the same
+   gather + agentic phases. If the score did not improve, escalate honestly.
+5. **History is the trend.** `omega audit history perfaudit` shows whether the
+   codebase is improving over time on this dimension. Use it to decide
+   whether to push for `--fix` again.
+
+## Why this audit exists
+
+The 18 forensic audits are the OmegaOS verification layer. Claude's
+"I'm done" claims used to be unverified. With these audits running as
+the gate, completion is **derived from observable facts**, not declared
+by the worker. Run this audit any time someone (human or agent) claims
+the performance dimension is healthy. Insist on the score before you
+accept.
+
+## Reference
+
+Audit definition: `Agentik_SSOT/audits/perfaudit.yaml`
+Engine pipeline:  `omega_engine.audits.pipeline.AuditPipeline`
+Batcher:          `omega_engine.audits.batcher.batch_findings`
+History:          `omega_engine.audits.history`

package/omega/Agentik_SSOT/skills/plan/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: plan
+description: Sequential plan executor v7 — replaces the broken /planner v6 that skipped tasks. FSM-enforced ordering at the engine level: every task carries explicit depends_on; the reducer REFUSES to mark a task in-progress / verified if any dep isn't yet VERIFIED. The agent receives ONE eligible task at a time, never the full backlog (closes the v6 visibility leak). Verify-cmd is run by the engine after every claimed_done; non-zero → state goes to FAILED, not VERIFIED. Designed for multi-day autonomous loops. Use when the user says "/plan", "execute the plan", "run the plan", "lance le plan", "continue execution", "next task".
+when_to_use: Genesis already ran (`docs/GENESIS-COMPLETE.md` exists). The DAG is at `plan/DAG.json`. The user wants to start (or continue) the multi-day execution loop.
+allowed-tools: Bash Read
+argument-hint: "<slug>"
+arguments: [slug]
+---
+
+# /plan — FSM-enforced sequential executor
+
+You are running the v7 plan executor. The pre-v0.19 `/planner` skill
+suffered from three structural failures that this command fixes by
+construction:
+
+| Old failure | New behaviour |
+|---|---|
+| Soft "NEVER skip a step" in the prompt | Engine reducer **rejects** illegal transitions (raises `IllegalTransition`) |
+| Agent saw the entire tracker.json (1500 tasks) | Agent gets ONE task per `omega plan next` call |
+| Dependencies implicit in ordering | Every task carries explicit `depends_on: [F-001, F-003]`; deps must be VERIFIED |
+
+## The FSM
+
+```
+PENDING  →  IN_PROGRESS  →  CLAIMED_DONE  →  VERIFIED       (terminal ok)
+                                          ↘
+                                            FAILED          (terminal bad)
+                              ↘  FAILED (worker abort)
+
+  FAILED  →  PENDING  (operator-issued retry only)
+```
+
+Every transition is enforced by `omega_engine.plan._transition`. There
+is NO other code path that changes `state`. Trying to violate raises
+`PlanError`; the engine refuses the write.
+
+## Multi-day loop
+
+```bash
+# 1. Build the store from plan/DAG.json (idempotent — re-run after
+#    editing the DAG; preserves VERIFIED tasks).
+omega plan build <slug>
+
+# 2. The execution loop (one iteration per task)
+while true; do
+    task_json=$(omega plan next <slug> --json)
+    [ -z "$task_json" ] && break          # no eligible task left
+
+    task_id=$(echo "$task_json" | jq -r .id)
+    title=$(echo "$task_json"   | jq -r .title)
+    skill=$(echo "$task_json"   | jq -r .skill)
+    verify=$(echo "$task_json"  | jq -r .verify_cmd)
+    files=$(echo "$task_json"   | jq -r '.files_owned | join(",")')
+
+    # mark in-progress (FAILS if any dep isn't verified — fail-safe)
+    omega plan start <slug> "$task_id"
+
+    # Dispatch a worker with the SINGLE task. The worker brief reads
+    # docs/30-prd/36-AGENT-PLAYBOOK.md + the feature spec
+    # docs/40-features/${task_id}-*.md, then invokes the skill.
+    omega worker spawn \
+        --task-id "$task_id" \
+        --role worker \
+        --project "$slug" \
+        --skills "$skill" \
+        --verify-cmd "$verify" \
+        --cwd "$OMEGA_HOME/Agentik_Coding/projects/$slug" \
+        "Implement $task_id ($title). Files in scope: $files. \
+         Read docs/30-prd/36-AGENT-PLAYBOOK.md FIRST."
+
+    # Wait for the worker's .done.json
+    omega worker wait "$task_id"
+
+    # Hand the result back to the plan; verify_cmd runs here, the
+    # engine refuses VERIFIED if it fails.
+    omega plan claimed <slug> "$task_id"
+    omega plan done    <slug> "$task_id"  || omega plan fail <slug> "$task_id" --reason "verify failed"
+done
+```
+
+## What the worker sees (closes the v6 visibility leak)
+
+The worker receives ONLY:
+- the single task spec (one file in `docs/40-features/`)
+- the agent playbook (`docs/30-prd/36-AGENT-PLAYBOOK.md`)
+- the design-discipline skills relevant to the task
+- the project root path
+
+It does NOT see the full DAG. It cannot pick "the fun one" because there
+IS no list — just one task to do, then the worker exits and the loop
+asks for the next.
+
+## Adversarial guarantees (proven runtime)
+
+These are not promises in a prompt — they are reducer-enforced:
+
+- ✗ Cannot move F-006 to IN_PROGRESS while F-001 and F-003 are PENDING.
+- ✗ Cannot move any task to VERIFIED from PENDING (must traverse the
+  full FSM).
+- ✗ Cannot fake-verify a task — the `verify_cmd` runs by the engine,
+  not by the worker.
+- ✓ Resume after crash: SQLite + WAL preserves state; re-run `omega
+  plan next <slug>` and the loop continues.
+
+## When `next` returns nothing
+
+Three causes:
+1. **All done.** Run `omega plan status <slug>` — if `verified == total`,
+   the plan is complete. Time to `/prod` ship.
+2. **Stuck — every PENDING task has an unverified dep.** A dep failed.
+   Run `omega plan list <slug> --state failed`, then either `retry` or
+   `fail` the blocker.
+3. **Empty plan.** `omega plan build <slug>` was never run, or the DAG
+   was empty.
+
+## Operator escape hatches
+
+```bash
+omega plan retry <slug> <task_id>     # FAILED → PENDING (try again)
+omega plan fail  <slug> <task_id>     # force-fail (mission abort)
+omega plan list  <slug> --state failed
+omega plan done  <slug> <task_id> --no-verify   # operator override
+```
+
+---
+
+**Argument: `$slug` (kebab-case)** — the project to run the plan against.

package/omega/Agentik_SSOT/skills/pursue/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: pursue
+description: Pursue a verifiable goal — loop Read/Edit/Bash until a shell `verify_cmd` exits 0. Agentik OS native equivalent of goal-driven workers, runs on the Claude Code Max subscription with zero API surcharge. Use when the user says "pursue X until Y", "keep iterating until <test> passes", "loop until exit 0", "implement X with verification", or asks for goal-driven autonomous coding.
+when_to_use: A concrete change with a deterministic exit-code-based verification. Not for vague tasks ("make it better") — must have a shell command that exits 0 IFF the goal is met.
+allowed-tools: Bash Read Write Edit Grep Glob
+argument-hint: "<verify_cmd> <intent>"
+arguments: [verify_cmd, intent]
+---
+
+# pursue — goal-driven execution on Max
+
+You are a goal-driven Agentik OS worker. The user has given you a GOAL and
+a VERIFICATION COMMAND. You MUST iterate Read/Edit/Bash until the
+verification command exits 0, then STOP.
+
+## This run
+
+- **Goal:** $intent
+- **Verification:** `$verify_cmd`
+- **Session:** `${CLAUDE_SESSION_ID}`
+- **Log:** `Agentik_Runtime/sessions/${CLAUDE_SESSION_ID}/pursue.log`
+
+## Protocol (strict)
+
+1. Read the relevant code. Understand current state.
+2. Make **one focused, surgical change** (Edit / Write).
+3. Run the verification: `$verify_cmd`.
+4. **If exit code == 0** → write a summary, STOP with SUCCESS.
+5. **If exit code != 0** → parse the failure, form a hypothesis, go to step 1.
+
+Append to the log on every iteration:
+```
+{"iter": N, "change": "...", "verify_exit": E, "tail": "..."}
+```
+
+## Hard rules
+
+- **Hard cap: 20 iterations.** After 20, STOP and report HONEST FAILURE with all attempts.
+- **NEVER claim success without running the verify_cmd** in the same turn.
+- Karpathy: simplicity first. Each iteration = one minimal change. No big rewrites.
+- Karpathy: surgical changes. Every changed line traces to the failure of the previous iteration.
+- First Law: only runtime tells the truth. If `verify_cmd` says fail, you have failed — regardless of how good the code "looks".
+
+## Completion
+
+When verify exits 0, write `Agentik_Runtime/sessions/${CLAUDE_SESSION_ID}/.done.json`:
+```json
+{
+  "status": "done_clean",
+  "summary": "<one-paragraph what you did>",
+  "files_changed": ["<path>", ...],
+  "artifacts": {"iterations": N, "final_verify_exit": 0}
+}
+```
+
+When budget exhausted, same file with `"status": "failed"` and the full attempts list.
+
+## Optional: drive via the engine instead
+
+For headless / unattended pursuit, run the Python primitive:
+
+```bash
+omega pursue "$verify_cmd" "$intent" --max-iters 20
+```
+
+This runs the same loop in `omega_engine.pursue.pursue()`, drives a provider
+of your choice, and writes the same log + done.json. Use this from cron, a
+worker, or another skill.

package/omega/Agentik_SSOT/skills/quality-arsenal.md

@@ -0,0 +1,180 @@
+---
+name: quality-arsenal
+description: >
+  Master entry point for the Quality Arsenal — 18 forensic audits + intelligent
+  orchestration. Use when user says "/quality-arsenal", "/qa", "audit", "/audit",
+  "audit my project", "quality check", "audit la qualité", "vérifie la qualité",
+  "audit complet". Routes to /audit-orchestrator for selection, /audit-tracker
+  for dashboard, integrates with Omega oracle/worker workflow for parallel
+  dispatch. Part of Agentik OS CAIO methodology. Public release at
+  github.com/agentik-os/claude-code-quality-audits.
+disable-model-invocation: false
+---
+
+# /quality-arsenal — Master Audit Entry Point
+
+You are the **conductor of the Quality Arsenal** — the canonical entry point that
+ties together 18 forensic audits, 2 orchestration skills, and the Omega oracle/
+worker dispatch infrastructure.
+
+## What this skill IS
+
+Single unified entry to:
+- Run any audit (`/codeaudit`, `/secaudit`, etc.)
+- Get an intelligent recommendation (`/audit-orchestrator`)
+- See past audit state (`/audit-tracker`)
+- Dispatch audits via Omega's parallel worker infrastructure (when running inside
+  an oracle session) instead of single-threaded in current Claude
+
+## What this skill IS NOT
+
+- A new audit. Audits live in their own `.md` files in `~/.claude/commands/`.
+- A replacement for the orchestrator or tracker — it routes to them.
+
+## Routing logic
+
+```
+User says "/quality-arsenal" or "/qa" with NO args
+  → Show menu:
+     1. Run audits (delegate to /audit-orchestrator)
+     2. See dashboard (delegate to /audit-tracker)
+     3. Init audits/ folder (delegate to /audit-tracker init)
+     4. Help / docs link
+
+User says "/quality-arsenal {keyword}"
+  → If keyword matches audit name (codeaudit/secaudit/etc.) → run that audit directly
+  → If keyword in [security/speed/design/full/quick/standard/forensic] → /audit-orchestrator {keyword}
+  → If keyword in [status/dashboard/scores/history] → /audit-tracker
+  → If keyword in [init/setup] → /audit-tracker init
+  → Else → ask clarification
+```
+
+## Omega Integration
+
+When running INSIDE an Omega oracle session (detected via `$TMUX_SESSION` matching
+`*-oracle*` pattern, OR `$AISB_BOT_SESSION=1` env var), the dispatch model changes:
+
+### Solo mode (default — running in user's interactive Claude)
+- Audit runs in CURRENT Claude session, single-threaded
+- Output to `audits/.{name}audit/`
+- Block UI until done
+
+### Oracle mode (running inside oracle)
+- Dispatch each audit as a separate worker session via
+  `~/.aisb/lib/dispatch-to-session.sh {ProjectName}-worker-{audit}-{ts}`
+- Oracle monitors workers, aggregates results into `audits/SYNTHESIS.md`
+- Telegram report to project topic when all done
+- Parallel waves possible (see ARSENAL-INTERCONNECTIONS.md DAG)
+
+The skill detects mode automatically:
+
+```bash
+if [[ "$TMUX" && "$(tmux display-message -p '#S')" =~ -oracle ]]; then
+    MODE=oracle
+else
+    MODE=solo
+fi
+```
+
+## Decision Matrix
+
+| User intent | Action |
+|---|---|
+| "audit my project" | Show menu → likely `/audit-orchestrator` |
+| "audit complet" / "full audit" | `/audit-orchestrator full` |
+| "security audit" / "audit sécurité" | `/audit-orchestrator security` |
+| "where am I with audits" / "status" | `/audit-tracker` |
+| "audits/.codeaudit/ not found" | `/audit-tracker init` then user re-runs |
+| "is the code secure" | `/secaudit` direct |
+| "make it bulletproof" | `/audit-orchestrator forensic` |
+
+## Three Power Levels
+
+| Level | Time | Phases | Use case |
+|---|---|---|---|
+| ⚡ **Quick** | 5-15 min | Audit only (top 5 findings) | Gut-check, demo prep |
+| 🎯 **Standard** | 30-60 min | Audit → Plan → Fix → Re-audit | Weekly cycle, pre-PR |
+| 🔬 **Forensic** | 1-4h | Full Gestalt-Popper with auto-fix until 100/100 | Pre-launch, compliance |
+
+## Power Tools
+
+### Full audit (the headline feature)
+
+```
+/quality-arsenal full
+```
+
+Dispatches all 18 audits in 3 parallel waves (file-safety partitioned):
+
+**Wave 1** (read-only, max parallelism):
+codeaudit, logicaudit, dataaudit, apiaudit, seoaudit, featureaudit, retentionaudit, copyaudit, dxaudit
+
+**Wave 2** (depends on Wave 1 outputs):
+secaudit (reads apiaudit verdict), perfaudit, debugaudit, automationaudit
+
+**Wave 3** (UI bundle):
+uiuxaudit, motionaudit, a11yaudit, flowaudit
+
+**Wave Final**:
+refontaudit if requested
+
+After all waves done:
+1. Aggregate scores into `audits/SYNTHESIS.md`
+2. Compute overall grade (avg /100, flag any < 80)
+3. Send Telegram report to project topic with verdict + per-audit links
+4. Suggest next actions
+
+### Quick presets
+
+```
+/quality-arsenal go-live      # secaudit + a11yaudit + perfaudit + dataaudit (go-live trio + GDPR)
+/quality-arsenal ship-ready   # featureaudit + debugaudit + dxaudit
+/quality-arsenal investor     # uiuxaudit + featureaudit + retentionaudit + copyaudit
+/quality-arsenal redesign     # refontaudit + uiuxaudit + motionaudit
+/quality-arsenal new-dev      # dxaudit + codeaudit (for fresh contributor onboarding)
+```
+
+## Workflow integration with Omega
+
+When dispatched from an Omega oracle, the skill writes worker tasks into:
+
+```
+~/.aisb/state/oracle-{Project}-oracle.workers.txt   # append worker names
+audits/.{name}audit/progress.json                   # per-audit progress
+audits/SYNTHESIS.md                                 # aggregate dashboard
+```
+
+The oracle monitors workers via `~/.aisb/lib/oracle-monitor-workers.sh` which is
+already aware of the canonical audits/ path (post-2026-05-13 refactor).
+
+## Output Convention
+
+ALL audit outputs live under `audits/.{name}audit/` — never at project root.
+See `AUDIT-VERIFICATION-CONTRACT.md` for the 7-file output spec every audit
+honors: verdict.json, REPORT.md, fix-plan.json, fix-plan.md, iterations.md,
+progress.json, telemetry.json, fix-log.md.
+
+## Why this matters (the deep "why")
+
+Agentik OS ships the **Chief AI Officer as a Service** methodology. One core
+hypothesis: **the bottleneck of AI-driven development isn't the AI's ability to
+write code — it's the human's ability to TRUST the code without re-reading
+every line**.
+
+Six months ago: humans trusted AI-written code ~30% of the time.
+Today (with Quality Arsenal in the loop): ~80%.
+
+The Quality Arsenal is the bridge from "vibe-coded MVP" to "production-grade
+software you'd ship to enterprise customers". It removes the human-machine
+round-trip tax by encoding senior-engineer scrutiny into deterministic protocols
+the AI runs ON ITS OWN OUTPUT before shipping.
+
+That's the wedge. That's why this skill exists.
+
+## Sources
+
+- Public mirror: https://github.com/agentik-os/claude-code-quality-audits
+- Sister skills: `/audit-orchestrator`, `/audit-tracker`
+- Helper docs: `QUALITY-ARSENAL-PREAMBLE.md`, `ARSENAL-INTERCONNECTIONS.md`,
+  `ARSENAL-ORCHESTRATION-PLAYBOOK.md`, `AUDIT-VERIFICATION-CONTRACT.md`
+- Agentik OS: https://agentik-os.com — Chief AI Officer as a Service

package/omega/Agentik_SSOT/skills/rag-route.md

@@ -1,3 +1,12 @@
+---
+name: rag-route
+description: Classify a natural-language query and dispatch to the right RAG retriever (hybrid / graph / agentic / multimodal) behind the Corrective RAG envelope. Use when the user asks "search the docs / wiki / knowledge base" or when a worker needs grounded retrieval before acting. Wraps omega_engine.rag.RAGRouter.
+when_to_use: A worker or oracle needs grounded retrieval before answering. Trigger phrases include "search the docs", "find references to X", "look up in the knowledge base", "what do we know about Y".
+allowed-tools: Bash Read
+argument-hint: "<query>"
+arguments: [query]
+---
+
 # /rag-route — Classify a query, pick a retrieval strategy
 
 > An agentic skill. Wraps `omega_engine.rag.RAGRouter`. Classifies the