@kevinrabun/judges 3.124.5 → 3.126.0

package/agents/accessibility.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code has accessibility defects and actively hunt for them. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is accessible. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/agent-instructions.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Assume instruction files are brittle until proven robust.
 - Never praise or compliment; report risks, ambiguities, and missing controls.
 - If uncertain, flag likely ambiguity only when you can cite specific evidence from the instruction file. Speculative findings without concrete evidence erode trust.
-- Absence of findings does not guarantee execution safety; state analysis limits when relevant.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code.

package/agents/ai-code-safety.judge.md

@@ -48,8 +48,17 @@ FALSE POSITIVE AVOIDANCE:
 - Missing AI-specific guardrails (content filtering, toxicity detection) are only relevant for AI-facing code.
 - Framework-level AI safety features (OpenAI content policy, Anthropic safety layers) are external controls — code calling these APIs is correctly delegating safety.
 
+CLEAN CODE RECOGNITION (if ALL of the following are true, report ZERO findings):
+- Input validation present on user-facing entry points
+- No eval(), exec(), or dynamic code generation from untrusted input
+- API keys/secrets not hardcoded (using environment variables or secret managers)
+- Dependencies from standard registries with no placeholder/example credentials
+- Error handling does not expose internal details to callers
+- No disabled security features (TLS verification, CORS restrictions)
+- Standard application code without AI/LLM interactions does not need AI safety review
+
 ADVERSARIAL MANDATE:
 - Assume the code was generated by an AI and has not been security-reviewed. Hunt for the patterns LLMs typically get wrong.
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If uncertain, flag the issue only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is safe. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/api-design.judge.md

@@ -52,4 +52,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the API has design flaws and actively hunt for them. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the API is well-designed. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/authentication.judge.md

@@ -58,4 +58,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume authentication is broken and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean auth is secure. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/backwards-compatibility.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume backwards compatibility is not considered and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean compatibility is maintained. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/caching.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the caching strategy is flawed or absent and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean caching is optimal. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/ci-cd.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the CI/CD posture is weak and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean CI/CD is solid. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/cloud-readiness.judge.md

@@ -48,4 +48,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code is not cloud-ready and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is cloud-native. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/code-structure.judge.md

@@ -40,7 +40,7 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code has structural problems and actively hunt for complexity, dead code, and over-sized functions. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is well-structured. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.
 
 FALSE POSITIVE AVOIDANCE:
 - **Dict[str, Any] at serialization boundaries**: When code deserializes JSON (json.loads, JSON.parse, API responses), Dict[str, Any] / Record<string, any> is the correct type until schema validation narrows it. Do not flag dynamic types at JSON I/O boundaries when the schema is defined elsewhere (Pydantic model, TypedDict, Zod schema).

package/agents/compliance.judge.md

@@ -44,4 +44,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code has compliance gaps and actively hunt for them. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is compliant. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/concurrency.judge.md

@@ -43,4 +43,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code has concurrency bugs and actively hunt for them. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is thread-safe. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/configuration-management.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume configuration management is inadequate and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean configuration is properly managed. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/cost-effectiveness.judge.md

@@ -33,8 +33,16 @@ FALSE POSITIVE AVOIDANCE:
 - **Tree/hierarchy traversal**: Nested loops that iterate parent → children (e.g., chapters → sections → articles) visit each element once. Total work is O(total_items), NOT O(n²). Only flag quadratic cost when two independent collections are cross-joined.
 - **Bounded reference datasets**: Loaders for fixed-size data (regulations, schemas, configs with <1000 items) have bounded cost regardless of algorithm choice. Do not flag these as scaling cost concerns.
 
+CLEAN CODE RECOGNITION (if ALL of the following are true, report ZERO findings):
+- Database queries are targeted (no SELECT * on large tables without limits)
+- No unbounded loops or recursive calls on external data
+- Resources (connections, file handles, streams) cleaned up after use
+- No redundant network calls or duplicate computations in hot paths
+- Appropriate use of caching or memoization where data is re-read
+- Small utility functions, type definitions, and configuration code are inherently cost-neutral
+
 ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code wastes resources and actively hunt for inefficiencies. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is cost-effective. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/cybersecurity.judge.md

@@ -58,4 +58,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code is vulnerable and actively hunt for exploits. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is secure. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/data-security.judge.md

@@ -45,4 +45,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code leaks or mishandles data and actively hunt for exposures. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean data is secure. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/data-sovereignty.judge.md

@@ -55,4 +55,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume sovereignty controls are missing unless explicitly shown.
 - Never praise or compliment the code. Report only gaps, risks, and deficiencies.
 - If uncertain, flag potential sovereignty exposure only when you can cite specific code evidence. Speculative findings without concrete evidence erode trust.
-- Absence of findings does not prove sovereignty compliance. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code.

package/agents/database.judge.md

@@ -46,4 +46,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume database usage is unsafe and inefficient and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean database usage is optimal. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/dependency-health.judge.md

@@ -43,4 +43,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the dependency tree has risks and actively hunt for them. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean dependencies are healthy. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/documentation.judge.md

@@ -50,4 +50,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the documentation is inadequate and actively hunt for gaps. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the documentation is good. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/error-handling.judge.md

@@ -50,4 +50,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume error handling is insufficient and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean error handling is complete. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/ethics-bias.judge.md

@@ -43,4 +43,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code has ethical risks or bias and actively hunt for them. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is ethical. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/framework-safety.judge.md

@@ -40,8 +40,16 @@ FALSE POSITIVE AVOIDANCE:
 - Missing framework features (no CSRF middleware, no rate limiting) should be deferred to specialized judges (SEC, RATE) unless the framework provides them as defaults that were explicitly disabled.
 - Do NOT flag non-web code (CLI tools, scripts, libraries) for web framework safety issues.
 
+CLEAN CODE RECOGNITION (if ALL of the following are true, report ZERO findings):
+- Framework middleware/plugins used per official documentation
+- Security middleware enabled (helmet, CSRF protection, etc.) where applicable
+- No explicitly disabled built-in protections
+- Route handlers follow framework conventions
+- Template rendering uses auto-escaping (not disabled)
+- Non-web code (CLI tools, libraries, scripts) does not need web framework review
+
 ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code misuses framework APIs and actively hunt for violations. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code follows framework best practices. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/hallucination-detection.judge.md

@@ -43,4 +43,4 @@ ADVERSARIAL MANDATE:
 - Assume every API call could be hallucinated. Hunt for subtle mismatches between documented APIs and actual usage.
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is hallucination-free. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/iac-security.judge.md

@@ -41,5 +41,5 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the infrastructure code is insecure and actively hunt for misconfigurations. Back every finding with concrete code evidence (line numbers, resource definitions, configuration blocks).
 - Never praise or compliment the code. Report only problems, risks, and security gaps.
 - If you are uncertain whether something is a misconfiguration, flag it only when you can cite specific code evidence (line numbers, patterns, resource definitions). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is secure. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.
 - Pay special attention to defaults that are insecure when not explicitly configured (e.g., public access defaults, missing encryption defaults).

package/agents/intent-alignment.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Assume every comment could be lying. Verify that implementations match their stated intent.
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is well-aligned. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/internationalization.judge.md

@@ -39,4 +39,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code will break in non-English locales and actively hunt for i18n defects. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is internationalization-ready. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/logging-privacy.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume logs contain sensitive data and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean logging is privacy-safe. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/logic-review.judge.md

@@ -32,3 +32,11 @@ FALSE POSITIVE AVOIDANCE:
 - Feature flags intentionally create "dead" branches — skip if flag-guarded
 - Test files may intentionally test edge cases with unusual conditions
 - Framework-required patterns (e.g., exhaustive switch in Redux) are intentional
+
+CLEAN CODE RECOGNITION (if ALL of the following are true, report ZERO findings):
+- Control flow is straightforward with no inverted conditions or unreachable code
+- Functions return consistent types and handle edge cases
+- Boolean expressions read naturally without double negatives
+- Switch/match statements cover expected cases
+- No partial refactor artifacts, dead code, or contradictory logic
+- Guard clauses and early returns used appropriately

package/agents/maintainability.judge.md

@@ -37,8 +37,17 @@ FALSE POSITIVE AVOIDANCE:
 - Do NOT flag configuration files, data files, or build scripts for code maintainability issues.
 - Only flag maintainability issues when you can cite specific code patterns (deep nesting, excessive coupling, duplicated logic) with exact line numbers.
 
+CLEAN CODE RECOGNITION (if ALL of the following are true, report ZERO findings):
+- Functions/methods have clear single responsibilities and reasonable length
+- Naming is consistent and self-documenting
+- No deep nesting (>3 levels) or excessive cyclomatic complexity
+- No copy-pasted logic blocks
+- No magic numbers in business logic (configuration constants are fine)
+- Standard library and framework patterns used idiomatically
+- Code reads top-to-bottom without requiring cross-referencing
+
 ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code is unmaintainable and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is maintainable. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/observability.judge.md

@@ -49,4 +49,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code is unobservable and will be impossible to debug in production. Actively hunt for monitoring gaps. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is observable. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/performance.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code has performance problems and actively hunt for bottlenecks. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is performant. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/portability.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code is not portable and actively hunt for platform dependencies. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is portable. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/rate-limiting.judge.md

@@ -50,4 +50,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume rate limiting is absent or insufficient and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean rate limiting is adequate. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/reliability.judge.md

@@ -52,4 +52,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code will fail in production and actively hunt for reliability gaps. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is reliable. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/scalability.judge.md

@@ -47,4 +47,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code will not scale and actively hunt for bottlenecks. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code will scale. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/security.judge.md

@@ -59,4 +59,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code has security vulnerabilities and actively hunt for them. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is secure. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/software-practices.judge.md

@@ -51,4 +51,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the code has engineering quality problems and actively hunt for them. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code follows best practices. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/testing.judge.md

@@ -49,4 +49,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the test coverage is insufficient and actively hunt for gaps. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the code is well-tested. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/agents/ux.judge.md

@@ -41,4 +41,4 @@ ADVERSARIAL MANDATE:
 - Your role is adversarial: assume the user experience is poor and actively hunt for problems. Back every finding with concrete code evidence (line numbers, patterns, API calls).
 - Never praise or compliment the code. Report only problems, risks, and deficiencies.
 - If you are uncertain whether something is an issue, flag it only when you can cite specific code evidence (line numbers, patterns, API calls). Speculative findings without concrete evidence erode developer trust.
-- Absence of findings does not mean the UX is good. It means your analysis reached its limits. State this explicitly.
+- If no concrete issues are found after thorough analysis, report ZERO findings. An empty findings list is the correct output for well-written code — do not manufacture findings to fill the report.

package/dist/api.d.ts

@@ -8,7 +8,7 @@
  * const result = evaluateCode("const x = eval(input);", "typescript");
  * ```
  */
-export type { Severity, Verdict, Finding, Patch, LangFamily, JudgesConfig, RuleOverride, ProjectFile, ProjectVerdict, DiffVerdict, DependencyEntry, DependencyVerdict, JudgeEvaluation, TribunalVerdict, JudgeDefinition, EvaluationContextV2, EvidenceBundleV2, SpecializedFindingV2, TribunalVerdictV2, MustFixGateOptions, MustFixGateResult, AppBuilderWorkflowResult, PlainLanguageFinding, WorkflowTask, PolicyProfile, SuppressionRecord, SuppressionResult, ExecutionTrace, RuleTrace, StreamingBatch, JudgeSelectionContext, JudgeSelectionResult, SessionContext, } from "./types.js";
+export type { Severity, Verdict, Finding, Patch, LangFamily, JudgesConfig, RuleOverride, ProjectFile, ProjectVerdict, DiffVerdict, DependencyEntry, DependencyVerdict, JudgeEvaluation, TribunalVerdict, JudgeDefinition, EvaluationContextV2, EvidenceBundleV2, SpecializedFindingV2, TribunalVerdictV2, MustFixGateOptions, MustFixGateResult, AppBuilderWorkflowResult, PlainLanguageFinding, WorkflowTask, PolicyProfile, SuppressionRecord, SuppressionResult, ExecutionTrace, RuleTrace, StreamingBatch, JudgeSelectionContext, JudgeSelectionResult, SessionContext, HumanFocusGuide, FocusItem, BlindSpot, } from "./types.js";
 export { JudgesError, ConfigError, EvaluationError, ParseError } from "./errors.js";
 export { parseConfig, defaultConfig, mergeConfigs, discoverCascadingConfigs, loadCascadingConfig, loadConfigFile, expandEnvPlaceholders, loadPluginJudges, validatePluginSpecifiers, isValidJudgeDefinition, validateJudgeDefinition, applyOverridesForFile, applyLanguageProfile, resolveExtendsConfig, } from "./config.js";
 export { EXT_TO_LANG, SUPPORTED_EXTENSIONS, detectLanguageFromPath } from "./ext-to-lang.js";
@@ -47,6 +47,7 @@ export { runFeedbackLoop, formatFeedbackLoopReport } from "./feedback-loop.js";
 export type { FeedbackLoopResult, ConfidenceAdjustment, FeedbackLoopStats } from "./feedback-loop.js";
 export { registerPlugin, unregisterPlugin, getRegisteredPlugins, getCustomRules, getPluginJudges, evaluateCustomRules, runBeforeHooks, runAfterHooks, clearPlugins, } from "./plugins.js";
 export type { CustomRule, JudgesPlugin, PluginRegistration } from "./plugins.js";
+export { filterByRegulatoryScope, getSupportedFrameworks } from "./regulatory-scope.js";
 export { JudgeRegistry, defaultRegistry } from "./judge-registry.js";
 export { parseFrontmatter, validateFrontmatter, parseAgentFile, resolveEvaluator, agentToJudgeDefinition, loadAgentDirectory, loadAndRegisterAgents, } from "./agent-loader.js";
 export type { AgentFrontmatter, ParsedAgent } from "./agent-loader.js";

package/dist/api.js

@@ -56,6 +56,8 @@ export { getAgentCard, createTask, getTask, completeTask, failTask, listTasks, p
 export { runFeedbackLoop, formatFeedbackLoopReport } from "./feedback-loop.js";
 // ─── Plugin API ──────────────────────────────────────────────────────────────
 export { registerPlugin, unregisterPlugin, getRegisteredPlugins, getCustomRules, getPluginJudges, evaluateCustomRules, runBeforeHooks, runAfterHooks, clearPlugins, } from "./plugins.js";
+// ─── Regulatory Scope ────────────────────────────────────────────────────────
+export { filterByRegulatoryScope, getSupportedFrameworks } from "./regulatory-scope.js";
 // ─── Judge Registry ──────────────────────────────────────────────────────────
 export { JudgeRegistry, defaultRegistry } from "./judge-registry.js";
 // ─── Agent Markdown Loader ───────────────────────────────────────────────────

package/dist/cli-formatters.js

@@ -136,6 +136,44 @@ export function formatTextOutput(verdict) {
         }
         lines.push("");
     }
+    // Human Focus Guide
+    if (verdict.humanFocusGuide) {
+        const guide = verdict.humanFocusGuide;
+        lines.push("  👤 Human Reviewer Focus Guide");
+        lines.push("  " + "─".repeat(60));
+        lines.push(`  ${guide.summary}`);
+        lines.push("");
+        if (guide.trust.length > 0) {
+            lines.push("  ✅ TRUST (act on these directly):");
+            for (const item of guide.trust.slice(0, 10)) {
+                const lineRef = item.lineNumbers?.[0] ? ` L${item.lineNumbers[0]}` : "";
+                lines.push(`     [${item.severity.toUpperCase()}] ${item.ruleId}${lineRef}: ${item.title}`);
+                lines.push(`            ${item.reason}`);
+            }
+            if (guide.trust.length > 10)
+                lines.push(`     ... and ${guide.trust.length - 10} more`);
+            lines.push("");
+        }
+        if (guide.verify.length > 0) {
+            lines.push("  🔍 VERIFY (use your judgment):");
+            for (const item of guide.verify.slice(0, 10)) {
+                const lineRef = item.lineNumbers?.[0] ? ` L${item.lineNumbers[0]}` : "";
+                lines.push(`     [${item.severity.toUpperCase()}] ${item.ruleId}${lineRef}: ${item.title}`);
+                lines.push(`            ${item.reason}`);
+            }
+            if (guide.verify.length > 10)
+                lines.push(`     ... and ${guide.verify.length - 10} more`);
+            lines.push("");
+        }
+        if (guide.blindSpots.length > 0) {
+            lines.push("  🔦 BLIND SPOTS (automated analysis cannot evaluate):");
+            for (const spot of guide.blindSpots) {
+                lines.push(`     • ${spot.area}`);
+                lines.push(`       ${spot.guidance.slice(0, 120)}${spot.guidance.length > 120 ? "…" : ""}`);
+            }
+            lines.push("");
+        }
+    }
     // Exit guidance
     if (verdict.overallVerdict === "fail") {
         lines.push("  ⛔ FAIL — This code has issues that should be addressed before shipping.");

package/dist/cli.js

@@ -43,6 +43,7 @@ import { formatComparisonReport, formatFullComparisonMatrix, TOOL_PROFILES } fro
 import { loadOverrideStore, applyOverrides } from "./commands/override.js";
 import { runGit } from "./tools/command-safety.js";
 import { detectLanguageFromPath, SUPPORTED_EXTENSIONS } from "./ext-to-lang.js";
+import { getSupportedFrameworks } from "./regulatory-scope.js";
 import { formatTribunalOutput, writeOutputIfSpecified, formatSingleJudgeTextOutput, } from "./cli-formatters.js";
 import { COMMAND_TABLE } from "./cli-dispatch.js";
 // ─── Language Detection ─────────────────────────────────────────────────────
@@ -226,6 +227,8 @@ function printHelp() {
      * over-promising features that aren't wired yet.
      */
     const coreCommands = [
+        ["judges list", "List all available judges"],
+        ["judges list --frameworks", "List supported regulatory frameworks"],
         ["judges eval [options] [file]", "Evaluate code with the full tribunal"],
         ["judges eval --judge <id> [file]", "Evaluate with a single judge"],
         ["judges init", "Interactive project setup wizard"],
@@ -485,6 +488,24 @@ function listJudges() {
     console.log(`  Total: ${judges.length} judges`);
     console.log("");
 }
+// ─── List Regulatory Frameworks ─────────────────────────────────────────────
+function listFrameworks() {
+    const frameworks = getSupportedFrameworks();
+    console.log("");
+    console.log("  Supported Regulatory Frameworks:");
+    console.log("  " + "─".repeat(60));
+    console.log("  Use these IDs in .judgesrc → regulatoryScope: [...]");
+    console.log("");
+    for (const fw of frameworks) {
+        console.log(`  ${fw.id.padEnd(15)} ${fw.description}`);
+    }
+    console.log("");
+    console.log(`  Total: ${frameworks.length} frameworks`);
+    console.log("");
+    console.log("  Example .judgesrc:");
+    console.log('  { "regulatoryScope": ["GDPR", "PCI-DSS", "SOC2"] }');
+    console.log("");
+}
 // ─── Version ────────────────────────────────────────────────────────────────
 function getPackageVersion() {
     try {
@@ -681,7 +702,12 @@ export async function runCli(argv) {
     }
     // ─── List Command ────────────────────────────────────────────────────
     if (args.command === "list") {
-        listJudges();
+        if (argv.includes("--frameworks")) {
+            listFrameworks();
+        }
+        else {
+            listJudges();
+        }
         process.exit(0);
     }
     // ─── Eval Command ────────────────────────────────────────────────────

package/dist/commands/llm-benchmark.js

@@ -148,14 +148,27 @@ export function parseLlmRuleIds(response) {
     const validPrefixes = getValidRulePrefixes();
     const pattern = /\b([A-Z][A-Z0-9]+)-(\d{1,3})\b/g;
     const found = new Set();
-    let match;
-    while ((match = pattern.exec(response)) !== null) {
-        if (validPrefixes.has(match[1])) {
-            found.add(match[0]);
+    // Split response into paragraphs/sections and skip sections that explicitly
+    // declare zero findings — rule IDs mentioned in "zero findings" rationale
+    // are explanatory references, not actual detections.
+    const sections = response.split(/\n{2,}/);
+    const zeroFindingsPattern = /\*?\*?(?:ZERO|zero|0|no)\s+findings?\*?\*?|(?:findings?|issues?)[\s:]*\*?\*?(?:none|0|zero)\*?\*?|no\s+(?:issues?|findings?|problems?|concerns?)\s+(?:found|detected|identified|reported)/i;
+    for (const section of sections) {
+        // If this section explicitly declares zero/no findings, skip rule ID extraction
+        if (zeroFindingsPattern.test(section))
+            continue;
+        let match;
+        pattern.lastIndex = 0;
+        while ((match = pattern.exec(section)) !== null) {
+            if (validPrefixes.has(match[1])) {
+                found.add(match[0]);
+            }
         }
     }
-    // Secondary pass: extract known prefixes from compound IDs like DEPS-TYPO-001
+    // Secondary pass on full text: extract known prefixes from compound IDs like DEPS-TYPO-001
+    // These are almost always in findings tables, not rationale
     const compoundPattern = /\b([A-Z][A-Z0-9]+)-[A-Z][A-Z0-9]+-(\d{1,3})\b/g;
+    let match;
     while ((match = compoundPattern.exec(response)) !== null) {
         if (validPrefixes.has(match[1])) {
             found.add(`${match[1]}-${match[2]}`);