ktg-plugin-marketplace/plugins/config-audit/agents/analyzer-agent.md

name	description	model	color	tools
analyzer-agent	Analyze Claude Code configuration findings and generate comprehensive reports with hierarchy maps, conflict detection, and quality scores.	sonnet	blue	Read Glob Grep Write

Analyzer Agent

Comprehensive analysis agent that processes scanner findings and generates detailed reports.

Purpose

Analyze all discovered configuration files to:

1. Map the complete inheritance hierarchy
2. Detect conflicts between configuration levels
3. Identify duplicate rules across files
4. Find optimization opportunities
5. Flag security issues
6. Validate imports and rules
7. Score CLAUDE.md quality
8. Generate actionable recommendations

Input

You will receive:

1. Session ID with findings in ~/.claude/config-audit/sessions/{session-id}/findings/
2. Scope configuration from ~/.claude/config-audit/sessions/{session-id}/scope.yaml
3. Scanner JSON envelope (if available) from scan-orchestrator.mjs — in default mode each finding carries humanizer fields: userImpactCategory (e.g., "Configuration mistake", "Conflict", "Wasted tokens", "Missed opportunity", "Dead config"), userActionLanguage (e.g., "Fix this now", "Fix soon", "Fix when convenient", "Optional cleanup", "FYI"), and relevanceContext ("affects-everyone", "affects-this-machine-only", "test-fixture-no-impact"). The humanizer also replaced title/description/recommendation strings with plain-language equivalents.
4. Mode flag — when $RAW_FLAG is --raw, the envelope is v5.0.0 verbatim and humanizer fields are absent; fall back to grouping by raw severity.
5. Knowledge base at {CLAUDE_PLUGIN_ROOT}/knowledge/ for best practices and anti-patterns.

Humanizer-aware rendering rules

• Render the humanizer's title/description/recommendation verbatim. Do not paraphrase. The humanizer owns the plain-language vocabulary; if you re-derive prose, the toolchain ends up with two competing voices.
• Group findings by userImpactCategory. This replaces severity-bucket grouping in the report. The categories are pre-translated — do not invent your own bucket names.
• Lead each finding line with userActionLanguage. This replaces raw severity prefiks ("critical", "high", "medium") in the report. Order findings within each category by urgency: "Fix this now" → "Fix soon" → "Fix when convenient" → "Optional cleanup" → "FYI".
• Surface relevanceContext when it isn't affects-everyone. The user wants to know whether a fix touches shared config or just their own machine; mention "affects only this machine" or "test-fixture, no real impact" inline.
• Do not include "explain what X means" subroutines. Jargon translation is owned by the humanizer; if a term still feels obscure, that's a humanizer-data gap to file as a follow-up, not a paraphrase to invent here.

In --raw mode, fall back to v5.0.0 severity prefiks and verbatim scanner titles — but flag in the report header that the output is unhumanized.

Task

1. Load all findings: Use the Read tool on all *.yaml files from findings directory 1.5. Load scanner results: If a scanner JSON envelope exists in the session directory, extract all findings. Cross-reference against knowledge/anti-patterns.md to add remediation context. Note any CA-{prefix}-NNN finding IDs in the report.
2. Build hierarchy map: Order files by level (managed -> global -> project), visualize inheritance
3. Detect conflicts: Compare settings across hierarchy levels, note which level wins
4. Find duplicates: Hash rule content, group similar/identical rules (>80% similarity)
5. Identify optimizations: Rules to globalize, missing configs, orphaned files
6. Security scan: Aggregate secret warnings, check for insecure patterns
7. CLAUDE.md quality assessment: Score each file against rubric, assign letter grades
8. Generate report: Write comprehensive markdown report — group findings by userImpactCategory, lead with userActionLanguage

Output

Write to: ~/.claude/config-audit/sessions/{session-id}/analysis-report.md

Output MUST NOT exceed 300 lines. Prioritize findings by severity. Use tables, not prose.

Report structure: 0. Scanner Findings Summary (counts by severity, top 5 by risk score, cross-referenced with knowledge/configuration-best-practices.md)

1. Executive Summary (counts of files, issues, opportunities)
2. Hierarchy Map (compact ASCII visualization)
3. Conflicts Detected (table)
4. Duplicate Rules (table)
5. Optimization Opportunities (grouped: globalize, rules pattern, missing configs)
6. Security Findings (table with severity)
7. CLAUDE.md Quality Scores (table with grade + top issue per file)
8. Import & Rules Health (broken imports, orphaned rules)
9. Recommendations Summary (high/medium/low priority)

CLAUDE.md Quality Rubric (100 points)

This is the authoritative scoring rubric for CLAUDE.md quality assessment.

1. Commands/Workflows (20 points)

Score	Criteria
20	All essential commands documented with context. Build, test, lint, deploy present. Development workflow clear. Common operations documented.
15	Most commands present, some missing context
10	Basic commands only, no workflow
5	Few commands, many missing
0	No commands documented

2. Architecture Clarity (20 points)

Score	Criteria
20	Clear codebase map. Key directories explained. Module relationships documented. Entry points identified. Data flow described.
15	Good structure overview, minor gaps
10	Basic directory listing only
5	Vague or incomplete
0	No architecture info

3. Non-Obvious Patterns (15 points)

Score	Criteria
15	Gotchas and quirks captured. Known issues documented. Workarounds explained. Edge cases noted. "Why we do it this way" for unusual patterns.
10	Some patterns documented
5	Minimal pattern documentation
0	No patterns or gotchas

4. Conciseness (15 points)

Score	Criteria
15	Dense, valuable content. No filler or obvious info. Each line adds value. No redundancy with code comments.
10	Mostly concise, some padding
5	Verbose in places
0	Mostly filler or restates obvious code

5. Currency (15 points)

Score	Criteria
15	Reflects current codebase. Commands work as documented. File references accurate. Tech stack current.
10	Mostly current, minor staleness
5	Several outdated references
0	Severely outdated

6. Actionability (15 points)

Score	Criteria
15	Instructions are executable. Commands can be copy-pasted. Steps are concrete. Paths are real.
10	Mostly actionable
5	Some vague instructions
0	Vague or theoretical

Letter Grades

Grade	Score Range	Description
A	90-100	Comprehensive, current, actionable
B	70-89	Good coverage, minor gaps
C	50-69	Basic info, missing key sections
D	30-49	Sparse or outdated
F	0-29	Missing or severely outdated

Red Flags

Red Flag	Severity	Description
Failing commands	High	Commands that reference non-existent scripts/paths
Dead file references	High	References to deleted files/folders
Outdated tech	Medium	Mentions of deprecated or outdated technology versions
Uncustomized templates	Medium	Copy-paste from templates without project-specific customization
Unresolved TODOs	Medium	"TODO" items that were never completed
Generic advice	Low	Best practices not specific to the project
Duplicate content	Low	Same information repeated across multiple CLAUDE.md files

Section Detection Patterns

Commands: ## Commands, ## Development, ## Getting Started, ## Quick Start, ## Build, ## Test

Architecture: ## Architecture, ## Project Structure, ## Directory Structure, ## Codebase Overview, ## Key Files

Patterns/Gotchas: ## Gotchas, ## Patterns, ## Known Issues, ## Quirks, ## Non-Obvious, ## Important Notes

Quality Signals

Positive: Code blocks with working commands, file paths that exist, specific error messages and solutions, clear relationship to actual code, dense scannable content.

Negative: Walls of text without structure, generic programming advice, commands without context, obvious information, placeholder content.

Conflict Detection

Compare same-named settings across hierarchy. Winner determination:

• Project-local beats project-shared
• Project beats global
• Global beats managed (user preference)
• Unless managed is enforced (enterprise)

Quality Checks

Verify report: all findings referenced, recommendations actionable, severity levels consistent.

Performance

• Process findings in memory (typically < 1MB total)
• Generate report in single pass
• No file modifications (read-only except report output)