Review Chamber

# Capture Workflow Module

Detailed workflow for capturing PR review knowledge into the review chamber.

## Trigger Points

Knowledge capture can be triggered:

1. **Automatically**: After `sanctum:pr-review` completes Phase 6
2. **Manually**: Via `/review-room capture` command
3. **Retroactively**: From existing PR review threads

## Automatic Capture Flow

```mermaid
graph TD
    A[PR Review Completed] --> B{Has BLOCKING findings?}
    B -->|Yes| C[Evaluate each finding]
    B -->|No| D{Has IN-SCOPE findings?}
    D -->|Yes| C
    D -->|No| E[Skip capture]

    C --> F{Score ≥ 60?}
    F -->|Yes| G[Classify room type]
    F -->|No| E

    G --> H[Create ReviewEntry]
    H --> I[Add to project palace]
    I --> J[Update connections]
    J --> K[Report captured entries]
```

## Finding Evaluation

For each PR finding, compute a capture score:

### Novelty Check (25 points max)

```python
def evaluate_novelty(finding, existing_entries):
    """Check if finding represents new knowledge."""

    # Search existing entries for similar content
    similar = search_similar(finding.content, existing_entries)

    if not similar:
        return 25  # Completely novel

    best_match = similar[0]
    if best_match.similarity < 0.5:
        return 20  # Mostly novel
    elif best_match.similarity < 0.8:
        return 10  # Partial overlap - may add context
    else:
        return 0   # Duplicate - skip
```

### Applicability Check (30 points max)

```python
def evaluate_applicability(finding, project_context):
    """Estimate future relevance."""

    score = 0

    # Affects common code paths
    if finding.file in project_context.hot_paths:
        score += 15

    # Relates to core domain
    if finding.category in project_context.core_domains:
        score += 10

    # Has broad applicability
    if len(finding.affected_files) > 3:
        score += 5

    return min(30, score)
```

### Durability Check (20 points max)

```python
def evaluate_durability(finding):
    """Distinguish architectural from tactical."""

    # Architectural indicators
    architectural_keywords = [
        'architecture', 'design', 'pattern', 'convention',
        'security', 'performance', 'scalability', 'api'
    ]

    # Tactical indicators
    tactical_keywords = [
        'typo', 'formatting', 'temporary', 'workaround',
        'quick fix', 'hotfix', 'revert'
    ]

    content_lower = finding.content.lower()

    arch_matches = sum(1 for k in architectural_keywords if k in content_lower)
    tact_matches = sum(1 for k in tactical_keywords if k in content_lower)

    if arch_matches > tact_matches:
        return 20  # Architectural
    elif arch_matches == tact_matches:
        return 10  # Mixed
    else:
        return 0   # Tactical - skip
```

### Connectivity Check (15 points max)

```python
def evaluate_connectivity(finding, palace):
    """Check links to existing knowledge."""

    score = 0

    # Links to existing ADRs
    if finding.references_adr:
        score += 5

    # Links to workshop patterns
    if finding.references_pattern:
        score += 5

    # Would create new connections
    potential_links = find_potential_links(finding, palace)
    if len(potential_links) > 2:
        score += 5

    return score
```

### Authority Check (10 points max)

```python
def evaluate_authority(finding, participants):
    """Weight by reviewer expertise."""

    score = 0

    # Senior reviewer involved
    if any(is_senior(p) for p in participants):
        score += 5

    # Domain expert reviewed
    domain = extract_domain(finding)
    if any(is_domain_expert(p, domain) for p in participants):
        score += 5

    return score
```

## Room Classification Logic

After evaluation, classify into appropriate room:

```python
def classify_finding(finding, score):
    """Determine target room for finding."""

    if score < 60:
        return None  # Don't capture

    severity = finding.severity
    category = finding.category.lower()

    # D