Prime Audit And Refactor

---
description: 24/7 Autonomous code audit and refactoring with TRM-7M validation and local model execution
settingSources: [project]
model: gpt-oss-20b  # or qwen3coder-30b for ~70 tokens/sec local execution
---

## Mission: 24/7 Autonomous Code Audit & Refactoring

**TRANSFORMATION COMPLETE**: This command now operates autonomously 24/7, leveraging local models (GPT-OSS-20B/QWEN3Coder 30B) for continuous codebase solidification with TRM-7M intelligent process control.

**Key Capabilities**:
- 🔄 **Autonomous Iteration**: Self-sustaining audit-fix-verify loop (max 1000 cycles)
- 🧹 **Process Cleanup**: Mandatory pre-flight and post-flight cleanup (prevent memory leaks)
- ✅ **Completion Validation**: 6-check gate preventing premature cycle transitions
- 🔬 **TRM-7M Validation**: 4 checkpoints for 40-60% churn reduction
- 💰 **Cost-Free Operation**: Local models at ~70 tokens/sec (GPT-OSS-20B/QWEN3Coder 30B)
- 🎯 **Constitutional Compliance**: Articles I-V enforcement at every cycle

**Human-Free Operation**: Runs unattended until all P0 issues resolved or context budget exhausted (95%).

### SDK Configuration

This mission uses `settingSources: [project]` for automatic configuration loading. For parallel audit execution across modules, consider spawning multiple SDK clients:

```python
# Example: Parallel audits with streaming
from claude_agent_sdk import query, ClaudeAgentOptions
import asyncio

async def audit_module(module_path):
    """Audit single module with streaming output."""
    options = ClaudeAgentOptions(
        cwd="/Users/am/Code/Agency",
        allowed_tools=["Read", "Grep", "Bash"]
    )
    async for message in query(
        prompt=f"Audit {module_path} for quality issues",
        options=options
    ):
        yield message

# Run audits in parallel
modules = ["agency.py", "tools/", "shared/"]
audits = [audit_module(m) for m in modules]
results = await asyncio.gather(*audits)

24/7 Autonomous Workflow

LOOP STRUCTURE: Continuous audit-fix-verify cycles until P0 issues resolved or context exhausted.

# Autonomous operation loop
while iteration < 1000:  # Effectively infinite for 24/7
    pre_flight_cleanup()  # STEP -1: Kill orphaned processes
    audit_report = run_intelligent_audit()  # STEP 1
    prioritized_issues = prioritize_issues()  # STEP 2
    
    # STOP CONDITIONS
    if no_critical_issues and context_usage < 0.95:
        continue  # Keep auditing for improvements
    if context_usage > 0.95:
        break  # Context exhausted, create checkpoint
    
    trm_validate_dependencies()  # STEP 3: TRM-7M Checkpoint 1
    
    for issue in prioritized_issues[:5]:  # Max 5 fixes per cycle
        trm_validate_types(issue)  # TRM-7M Checkpoint 2
        snapshot = create_snapshot()
        fix_result = apply_fix_with_learning(issue)
        
        edge_cases = trm_infer_edge_cases(issue)  # TRM-7M Checkpoint 3
        trm_validate_lint(fix_result)  # TRM-7M Checkpoint 4
        
        if run_tests_pass():
            commit_fix()
            store_pattern()
        else:
            rollback(snapshot)
    
    validate_cycle_completion()  # STEP 5: 6-check validation
    post_flight_cleanup()  # STEP 6: Clean exit
    
    sleep(5)  # Brief cooldown

STEP -1: Pre-Flight Cleanup (MANDATORY)

Purpose: Prevent orphaned processes and memory leaks during continuous operation.

# Kill orphaned pytest/Python processes
ps aux | grep -E '(pytest|Python.*Agency)' | grep -v grep | awk '{print $2}' | xargs -r kill -9 2>/dev/null

# Verify cleanup
ps aux | grep -i python | grep -v grep | wc -l

VectorStore Learning: Store cleanup success for institutional memory (Article IV).

STEP 1: Intelligent Audit with Learning

1. Pre-Audit Learning Query (Article IV - VectorStore Integration):

   • Query VectorStore: "successful_fixes_for_Q(T)<0.6" → load proven patterns
   • Load refactoring successes from similar codebases (confidence ≥0.6)
   • Check for known anti-patterns in target modules (minimum 3 occurrences)
   • Local Model: GPT-OSS-20B or QWEN3Coder 30B at ~70 tokens/sec (cost: $0)

2. Local Model Audit Execution (Cost-Free, ~70 tokens/sec):

   • Use GPT-OSS-20B or QWEN3Coder 30B for all analysis (no API costs)
   • Split codebase into logical modules for sequential/concurrent analysis:
     • Core modules: agency.py, agent modules
     • Tools: tools/, shared utilities
     • Tests: Analyze test coverage and Q(T) scores
   • Aggregate results into unified AuditReport
   • TRM-7M Integration: Pre-validate with recursive reasoning (10-100x faster)

STEP 2: Dynamic Prioritization Matrix (Auto-Selection)

3. Automated Issue Ranking (Constitutional Weight Priority):

   Priority Levels (Auto-Selected):
   - P0 (CRITICAL): Constitutional violations (Article II: test failures, Article I: incomplete context)
   - P1 (HIGH): Security vulnerabilities, Q(T) < 0.3
   - P2 (MEDIUM): Test coverage < 80%, missing NECESSARY patterns
   - P3 (LOW): Complexity violations, style issues
   
   # Prioritization formula
   priority_score = (
       constitutional_weight * 0.5 +  # Highest priority
       security_weight * 0.3 +         # Critical for production
       coverage_weight * 0.2           # Quality improvement
   )
   

   • Max fixes per cycle: Min(5, P0_count + P1_count[:10]) (prevent cycle overload)
   • Stop condition: If P0_count == 0 and len(all_issues) == 0, audit complete

STEP 3: TRM-7M Checkpoint 1 - Dependency Validation

Purpose: Detect circular dependencies in fix ordering (10-100x faster than Python DFS).

from trinity_protocol.core.trm_validator import TRMValidator, ReasoningTask

trm_validator = TRMValidator()

# Convert issue dependencies to adjacency matrix
adj_matrix = build_dependency_matrix(prioritized_issues)

dag_validation = ReasoningTask(
    problem_type="dependency_graph",
    input_grid=adj_matrix,
    constraints=["Must