# v1.10 Update
Release Date: 2026-02 (Planned)
## Summary
v1.10 introduces three major changes:
1. **Per-Phase Necessity Checks**: Evaluate necessity at each phase transition
2. **VERIFICATION and IMPACT_ANALYSIS Separation**: Split the phases merged in v1.9, execute IMPACT_ANALYSIS after seeing VERIFICATION results
3. **gate_level Simplification**: Reduce from 5 levels to 2 (`full` and `auto` only)
**Expected Improvements**:
- Time savings of 15-50 seconds by skipping unnecessary phases
- Improved accuracy through flexible judgment before each phase
- Accurate IMPACT_ANALYSIS based on VERIFICATION results
- Flexible handling through LLM autonomous judgment (removal of automatic file type detection)
## Background
### Current Issues (up to v1.9)
#### 1. Judgment Timing Too Early
**Step 3: Judgment at QueryFrame creation** (before seeing code):
```python
# tools/query_frame.py:436-472
def assess_risk_level(frame: QueryFrame, intent: str) -> str:
# Empty observed_issue → HIGH
if frame.desired_action and not frame.observed_issue:
return "HIGH"
```
**Problem**: Judgment based only on QueryFrame content cannot reflect actual code complexity.
#### 2. Server-Driven Fixed Decisions
**Automatic judgment after Step 4**:
```python
# tools/session.py:1336-1342
confidence, missing = evaluate_exploration_v36(...)
# confidence="low" → Automatically move to SEMANTIC phase
if confidence == "low":
self.phase = Phase.SEMANTIC
```
**Problems**:
- LLM doesn't know the judgment reasoning (black box)
- No flexibility due to fixed rules
- Unnecessary phases are still executed
#### 3. All Phases Decided in One Judgment
**Current Issue**:
```
EXPLORATION complete
↓
Single check:
Q1: Information complete? → NO
Q2: Hypothesis verification? → false
Q3: Impact confirmation? → false
↓
Decision: "Execute all of SEMANTIC → VERIFICATION → IMPACT_ANALYSIS"
```
**Problem**:
- Even if situation changes after SEMANTIC, VERIFICATION is automatically executed
- Cannot reflect each phase's results in next judgment
- No flexibility
#### 4. VERIFICATION_AND_IMPACT Merge Issue (v1.9)
v1.9 merged VERIFICATION and IMPACT_ANALYSIS to save 10 seconds, but:
**Problem**: Impact analysis scope should be determined after seeing verification results
- New dependencies may be discovered during hypothesis verification
- Impact scope changes based on verification results
- This judgment opportunity is lost due to merging
**Conclusion**: Accuracy should be prioritized over 10 seconds of LLM wait time
#### 5. gate_level Complexity and Inaccuracy
Current `gate_level` has 5 levels including automatic file type detection:
```python
# v1.9: 5 gate_levels
gate_level = "high" # Strict requirements
gate_level = "middle" # Moderate requirements
gate_level = "low" # Relaxed requirements
gate_level = "auto" # QueryFrame-based auto judgment
gate_level = "none" # Skip all phases
# Special handling for HTML files etc.
if is_markup_context(files_analyzed):
# Automatically relax requirements
reqs["symbols_identified"] = 1
```
**Problems**:
- 5-level differences unclear
- Judgment based only on file extension (complex cases exist even for HTML)
- Cannot reflect LLM's judgment after seeing actual code
**v1.10 Solution**: Simplify to 2 levels and delegate judgment to LLM
- `full`: Execute all phases (for debugging)
- `auto`: LLM judges before each phase (default)
---
## Proposed Design
### New Phase Flow
```
Step 4: Execute EXPLORATION
↓
Necessity Check (Q1) ← NEW
Q1: Need additional information gathering?
→ YES: Execute SEMANTIC
→ NO: Skip SEMANTIC
↓
[Execute SEMANTIC (only if needed)]
↓
Necessity Check (Q2) ← NEW
Q2: Are there hypotheses to verify?
→ YES: Execute VERIFICATION
→ NO: Skip VERIFICATION
↓
[Execute VERIFICATION (only if needed)]
↓
Necessity Check (Q3) ← NEW
Q3: Need to confirm impact scope?
→ YES: Execute IMPACT_ANALYSIS
→ NO: Skip IMPACT_ANALYSIS
↓
[Execute IMPACT_ANALYSIS (only if needed)]
↓
READY
```
**Key Changes**:
- **Individual check before each phase**: Immediately reflect situation changes
- **VERIFICATION and IMPACT_ANALYSIS separation** (abolish v1.9 merge)
- **Control behavior with gate_level**: `full` (ignore checks) or `auto` (check each time)
- **Unify all questions to necessity confirmation**: `true` = execute, `false` = skip
### Behavior Differences by gate_level
#### gate_level="auto" (default)
Check before each phase:
```
EXPLORATION complete
↓
Q1 Check: Need additional information gathering?
→ YES
↓
Execute SEMANTIC
↓
Q2 Check: Are there hypotheses to verify?
→ NO (verified during SEMANTIC)
↓
Skip VERIFICATION
↓
Q3 Check: Need to confirm impact scope?
→ YES
↓
Execute IMPACT_ANALYSIS
↓
READY
```
#### gate_level="full"
Ignore all checks and execute all phases:
```
EXPLORATION complete
↓
Skip all Q1-Q3 checks
↓
SEMANTIC → VERIFICATION → IMPACT_ANALYSIS (execute all)
↓
READY
```
### Checkpoint Details
#### Q1: Check Before SEMANTIC
**Timing**: Right after EXPLORATION complete
**Question**: Do you need additional information gathering?
**Response Format**:
```json
{
"needs_more_information": false,
"needs_more_information_reason": "Service + Repository pattern is clear. Existing implementation understood."
}
```
**Judgment**:
- `true`: Execute SEMANTIC
- `false`: Skip SEMANTIC → Q2 check
#### Q2: Check Before VERIFICATION
**Timing**: After EXPLORATION complete, or after SEMANTIC complete
**Question**: Are there hypotheses that need verification?
**Response Format**:
```json
{
"has_unverified_hypotheses": false,
"has_unverified_hypotheses_reason": "No hypotheses formed"
}
```
or
```json
{
"has_unverified_hypotheses": true,
"has_unverified_hypotheses_reason": "Formed hypothesis X about dependency resolution but not verified with actual code"
}
```
**Judgment**:
- `true`: Execute VERIFICATION
- `false`: Skip VERIFICATION → Q3 check
#### Q3: Check Before IMPACT_ANALYSIS
**Timing**: After EXPLORATION, SEMANTIC, or VERIFICATION complete
**Question**: Do you need to confirm change impact scope?
**Response Format**:
```json
{
"needs_impact_analysis": true,
"needs_impact_analysis_reason": "Impact scope confirmation not yet performed"
}
```
**Judgment**:
- `true`: Execute IMPACT_ANALYSIS
- `false`: Skip IMPACT_ANALYSIS → READY
### Execution Examples
#### Case 1: Everything Completed During SEMANTIC
```
EXPLORATION complete
↓
Q1 Check:
needs_more_information = true (insufficient info)
↓
Execute SEMANTIC
├─ Information gathering
├─ Form and verify hypotheses (during SEMANTIC)
└─ Confirm impact scope (during SEMANTIC)
↓
Q2 Check:
has_unverified_hypotheses = false (no hypotheses, or verified during SEMANTIC)
↓
Skip VERIFICATION
↓
Q3 Check:
needs_impact_analysis = false (confirmed during SEMANTIC)
↓
Skip IMPACT_ANALYSIS
↓
READY
```
#### Case 2: Sequential Execution of Each Phase
```
EXPLORATION complete
↓
Q1 Check:
needs_more_information = true (insufficient info)
↓
Execute SEMANTIC
└─ Information gathering only
↓
Q2 Check:
has_unverified_hypotheses = true (hypotheses unverified)
↓
Execute VERIFICATION
└─ Hypothesis verification
↓
Q3 Check:
needs_impact_analysis = true (not confirmed)
↓
Execute IMPACT_ANALYSIS
└─ Impact scope confirmation
↓
READY
```
#### Case 3: Skip All Phases
```
EXPLORATION complete
↓
Q1 Check:
needs_more_information = false (sufficient info)
↓
Skip SEMANTIC
↓
Q2 Check:
has_unverified_hypotheses = false (no hypotheses)
↓
Skip VERIFICATION
↓
Q3 Check:
needs_impact_analysis = false (confirmed during EXPLORATION)
↓
Skip IMPACT_ANALYSIS
↓
READY
```
---
## Implementation Approach
### 1. Phase Enum Update
`tools/session.py`:
```python
class Phase(Enum):
EXPLORATION = "EXPLORATION"
SEMANTIC = "SEMANTIC"
VERIFICATION = "VERIFICATION" # NEW (separated)
IMPACT_ANALYSIS = "IMPACT_ANALYSIS" # NEW (separated)
READY = "READY"
# VERIFICATION_AND_IMPACT = "VERIFICATION_AND_IMPACT" # Removed (v1.9 abolished)
```
### 2. New Tool: check_phase_necessity
Tool for checking necessity before each phase.
Documented in `.claude/commands/code.md`:
```markdown
## v1.10: Phase Necessity Check
Check if each phase is necessary before entering:
### Before SEMANTIC (Q1 Check)
**Question**: Do you need additional information gathering?
- YES: Insufficient information, additional investigation needed
- NO: Existing patterns clear, implementation approach understood
**Response Format**:
```json
{
"needs_more_information": true,
"needs_more_information_reason": "Auth flow details unclear"
}
```
**Tool**: `check_phase_necessity(phase="SEMANTIC", assessment={...})`
### Before VERIFICATION (Q2 Check)
**Question**: Are there hypotheses to verify?
- YES: Hypotheses formed but not verified with code
- NO: No hypotheses, or already verified
**Response Format**:
```json
{
"has_unverified_hypotheses": false,
"has_unverified_hypotheses_reason": "No hypotheses formed"
}
```
or
```json
{
"has_unverified_hypotheses": true,
"has_unverified_hypotheses_reason": "Hypothesis about dependency resolution not verified"
}
```
**Tool**: `check_phase_necessity(phase="VERIFICATION", assessment={...})`
### Before IMPACT_ANALYSIS (Q3 Check)
**Question**: Do you need to confirm change impact scope?
- YES: Not yet confirmed
- NO: Impact scope confirmed (references, dependencies, etc.)
**Response Format**:
```json
{
"needs_impact_analysis": true,
"needs_impact_analysis_reason": "Impact scope confirmation not yet performed"
}
```
**Tool**: `check_phase_necessity(phase="IMPACT_ANALYSIS", assessment={...})`
```
### 3. Server-Side Handler
`code_intel_server.py`:
```python
if name == "check_phase_necessity":
phase = arguments["phase"] # "SEMANTIC" | "VERIFICATION" | "IMPACT_ANALYSIS"
assessment = arguments["assessment"]
# For gate_level="full", ignore checks and always execute
if session.gate_level == "full":
session.phase = Phase[phase]
return {
"success": True,
"phase_required": True,
"next_phase": phase,
"reason": "gate_level=full: All phases are executed"
}
# For gate_level="auto", judge based on assessment
phase_required = False
next_phase = None
if phase == "SEMANTIC":
needs_more_info = assessment.get("needs_more_information", False)
if needs_more_info:
# Insufficient info → Execute SEMANTIC
phase_required = True
next_phase = "SEMANTIC"
else:
# Sufficient info → Skip SEMANTIC → Q2 check
next_phase = None # To next check
elif phase == "VERIFICATION":
has_unverified_hypotheses = assessment.get("has_unverified_hypotheses", False)
if has_unverified_hypotheses:
# Unverified hypotheses exist → Execute VERIFICATION
phase_required = True
next_phase = "VERIFICATION"
else:
# No hypotheses or verified → Skip VERIFICATION → Q3 check
next_phase = None # To next check
elif phase == "IMPACT_ANALYSIS":
needs_impact = assessment.get("needs_impact_analysis", False)
if needs_impact:
# Impact scope not confirmed → Execute IMPACT_ANALYSIS
phase_required = True
next_phase = "IMPACT_ANALYSIS"
else:
# Impact scope confirmed → Skip IMPACT_ANALYSIS → READY
next_phase = "READY"
# Update phase
if next_phase == "READY":
session.phase = Phase.READY
elif phase_required:
session.phase = Phase[next_phase]
# Save assessment to log
if not hasattr(session, "phase_assessments"):
session.phase_assessments = {}
session.phase_assessments[phase] = assessment
return {
"success": True,
"phase_required": phase_required,
"next_phase": next_phase or "NEXT_CHECK",
"assessment": assessment
}
```
### 4. Post-Phase Flow
After each phase completes, proceed to next checkpoint:
```python
def get_next_checkpoint(current_phase: Phase) -> str | None:
"""Determine next checkpoint from current phase"""
if current_phase == Phase.EXPLORATION:
return "Q1_CHECK" # SEMANTIC necessity check
elif current_phase == Phase.SEMANTIC:
return "Q2_CHECK" # VERIFICATION necessity check
elif current_phase == Phase.VERIFICATION:
return "Q3_CHECK" # IMPACT_ANALYSIS necessity check
elif current_phase == Phase.IMPACT_ANALYSIS:
return "READY"
return None
# On each phase complete
if name == "submit_semantic":
# SEMANTIC complete
session.phase = Phase.SEMANTIC
return {
"success": True,
"phase_complete": "SEMANTIC",
"next_checkpoint": "Q2_CHECK",
"instruction": "Now check if VERIFICATION is necessary using check_phase_necessity(phase='VERIFICATION', assessment={...})"
}
```
### 5. Validation
Validate response validity at each checkpoint:
```python
def validate_phase_assessment(phase: str, assessment: dict) -> tuple[bool, str | None]:
"""Check validity of phase necessity response"""
if phase == "SEMANTIC":
# Q1 check
if "needs_more_information" not in assessment:
return False, "needs_more_information field required"
if "needs_more_information_reason" not in assessment:
return False, "needs_more_information_reason field required"
reason = assessment["needs_more_information_reason"]
if len(reason) < 10:
return False, "Reason must be at least 10 characters"
elif phase == "VERIFICATION":
# Q2 check
if "has_unverified_hypotheses" not in assessment:
return False, "has_unverified_hypotheses field required"
if "has_unverified_hypotheses_reason" not in assessment:
return False, "has_unverified_hypotheses_reason field required"
has_hypotheses = assessment["has_unverified_hypotheses"]
if has_hypotheses not in [True, False]:
return False, "has_unverified_hypotheses must be true/false"
elif phase == "IMPACT_ANALYSIS":
# Q3 check
if "needs_impact_analysis" not in assessment:
return False, "needs_impact_analysis field required"
if "needs_impact_analysis_reason" not in assessment:
return False, "needs_impact_analysis_reason field required"
return True, None
```
---
## Expected Benefits
### 1. Performance Improvement
| Case | Current (v1.9) | v1.10 | Reduction |
|------|---------------|-------|-----------|
| Simple fix (sufficient info, clear impact) | EXPLORATION → VERIFICATION_AND_IMPACT | EXPLORATION → Q1(NO) → Q2(NO) → Q3(NO) → READY | 15-20s |
| Everything completed during SEMANTIC | EXPLORATION → SEMANTIC → VERIFICATION_AND_IMPACT | EXPLORATION → Q1(YES) → SEMANTIC → Q2(NO) → Q3(NO) → READY | 25-30s |
| Sufficient info, no hypotheses, clear impact | EXPLORATION → SEMANTIC → VERIFICATION_AND_IMPACT | EXPLORATION → Q1(NO) → Q2(NO) → Q3(NO) → READY | 50-70s |
**Reduction Breakdown**:
- Skip SEMANTIC: 30-40s (when info is sufficient)
- Skip VERIFICATION: 10-15s (when no hypotheses)
- Skip IMPACT_ANALYSIS: 10-15s (when impact scope is clear)
- **Verification complete during SEMANTIC: 25-30s** (new benefit)
**Average Expected Reduction**: 20-60 seconds
### 2. Accuracy Improvement
**v1.9 Problem**:
```
EXPLORATION complete
↓
Single judgment: Decided to execute SEMANTIC + VERIFICATION_AND_IMPACT
↓
Execute SEMANTIC (info gathered)
↓
Forced VERIFICATION_AND_IMPACT execution (actually unnecessary)
```
**v1.10 Improvement**:
```
EXPLORATION complete
↓
Q1 Check: Insufficient info → Execute SEMANTIC
↓
Execute SEMANTIC (info gathered + hypotheses verified)
↓
Q2 Check: No unverified hypotheses → Skip VERIFICATION
↓
Q3 Check: Already confirmed → Skip IMPACT_ANALYSIS
↓
READY (unnecessary phases avoided)
```
**Benefit**: Immediately reflect each phase's execution results in next judgment
### 3. Flexibility Improvement
**Handling situations where conditions change during each phase**:
```
EXPLORATION complete
↓
Q1 Check: Insufficient info
↓
Execute SEMANTIC
├─ More complex than expected
├─ New hypotheses emerged
└─ Impact scope not confirmed
↓
Q2 Check: Unverified hypotheses exist → Execute VERIFICATION
↓
Execute VERIFICATION
└─ Impact scope also clarified during hypothesis verification
↓
Q3 Check: Already confirmed → Skip IMPACT_ANALYSIS
↓
READY
```
### 4. Unified Judgment Criteria
**v1.10 Improvement**: All questions unified to necessity confirmation type
| Question | Field | `true` means | `false` means |
|----------|-------|--------------|---------------|
| Q1: Need additional info gathering? | `needs_more_information` | Execute | Skip |
| Q2: Are there hypotheses to verify? | `has_unverified_hypotheses` | Execute | Skip |
| Q3: Need impact scope confirmation? | `needs_impact_analysis` | Execute | Skip |
**Benefits**:
- LLM can respond accurately without confusion
- Simple code (all `if field: execute`)
- Improved maintainability
---
## Breaking Changes
### 1. VERIFICATION_AND_IMPACT Abolished
**v1.9**:
```python
Phase.VERIFICATION_AND_IMPACT # Merged phase
submit_verification_and_impact(...)
```
**v1.10**:
```python
Phase.VERIFICATION # Separated
Phase.IMPACT_ANALYSIS # Separated
submit_verification(...) # New tool
submit_impact_analysis(...) # New tool
```
### 2. submit_understanding Abolished → check_phase_necessity
**v1.9**:
```python
submit_understanding(result)
# Server auto-judges
```
**v1.10**:
```python
# After EXPLORATION complete
check_phase_necessity(phase="SEMANTIC", assessment={...})
# After SEMANTIC complete
check_phase_necessity(phase="VERIFICATION", assessment={...})
# After VERIFICATION complete
check_phase_necessity(phase="IMPACT_ANALYSIS", assessment={...})
```
### 3. gate_level Restructuring
**Up to v1.9**: 5 levels (`high`, `middle`, `low`, `auto`, `none`)
**v1.10 onwards**: 2 levels only (`full`, `auto`)
- `full`: Execute all phases ignoring all checks
- `auto`: Check before each phase (default)
**Deprecated Features**:
- Markup context detection for HTML files etc. (`is_markup_context`)
- Requirement relaxation by file extension (`extract_extensions_from_text`)
- QueryFrame-based risk assessment (`assess_risk_level`)
- Batch phase decision (`evaluate_exploration_v36`)
---
## Implementation Status
| Feature | Status | Notes |
|---------|--------|-------|
| Phase enum update | 📋 Design complete | VERIFICATION/IMPACT_ANALYSIS separation |
| check_phase_necessity | 📋 Design complete | Necessity check before each phase |
| submit_verification | 📋 Design complete | VERIFICATION dedicated tool |
| submit_impact_analysis | 📋 Design complete | IMPACT_ANALYSIS dedicated tool |
| validate_phase_assessment | 📋 Design complete | Response validity check |
| get_next_checkpoint | 📋 Design complete | Determine next checkpoint |
| gate_level restructuring (full/auto) | 📋 Design complete | 5 levels → 2 levels |
| Markup detection abolished | 📋 Design complete | Remove is_markup_context etc. |
| code.md update | 📋 Design complete | Check instructions before each phase |
| **Total** | 📋 Design complete | **Expected reduction: 20-60s** |
**Design Complete**: 2026-01-26
**Implementation Start**: 2026-02
---
## Migration Guide
Migration from v1.9 to v1.10 **requires code changes**.
### Changes Required
#### 1. code.md
**Remove**:
- `submit_understanding` description
**Add**:
- Check instructions before each phase (Q1/Q2/Q3)
- `check_phase_necessity` description
**Change**:
- `submit_verification_and_impact` → `submit_verification` + `submit_impact_analysis` (separated)
#### 2. code_intel_server.py
**Remove**:
- `VERIFICATION_AND_IMPACT` phase handler
- `submit_understanding` handler
- `submit_verification_and_impact` handler
**Add**:
- `check_phase_necessity` handler
- `submit_verification` handler (separated)
- `submit_impact_analysis` handler (separated)
- `validate_phase_assessment` function
- `get_next_checkpoint` function
#### 3. tools/session.py
**Change**:
```python
class Phase(Enum):
EXPLORATION = "EXPLORATION"
SEMANTIC = "SEMANTIC"
VERIFICATION = "VERIFICATION" # NEW
IMPACT_ANALYSIS = "IMPACT_ANALYSIS" # NEW
READY = "READY"
```
**Add**:
- `phase_assessments` field (record of each checkpoint)
**Remove**:
- `GATE_LEVEL_REQUIREMENTS` constant
- `is_markup_context()` function
- `extract_extensions_from_text()` function
- `get_dynamic_requirements()` function
- `evaluate_exploration_v36()` function
#### 4. tools/query_frame.py
**Remove**:
- `assess_risk_level()` function
- `get_exploration_requirements()` function
#### 5. .claude/commands/code.md
**Change**:
```markdown
# Up to v1.9
| `--gate=LEVEL` | `-g=LEVEL` | Gate level: h(igh), m(iddle), l(ow), a(uto), n(one) |
# v1.10 onwards
| `--gate=LEVEL` | `-g=LEVEL` | Gate level: f(ull), a(uto) [default: auto] |
```
**Option Description**:
- `--gate=full` or `-g=f`: Force execute all phases
- `--gate=auto` or `-g=a`: Check before each phase (default)
---
## gate_level Migration Guide
### Mapping from v1.9 to v1.10
| v1.9 | v1.10 | Behavior |
|------|-------|----------|
| `--gate=high` | `--gate=full` | Execute all phases (ignore checks) |
| `--gate=middle` | `--gate=full` | Execute all phases (ignore checks) |
| `--gate=low` | `--gate=auto` | Check before each phase |
| `--gate=auto` | `--gate=auto` | Check before each phase (new method) |
| `--gate=none` | (abolished) | Use different method to skip exploration |
### HTML File Special Handling Abolished
**Up to v1.9**:
```python
# For HTML files, automatically relax requirements
if is_markup_context(files_analyzed):
reqs["symbols_identified"] = 1
```
**v1.10 onwards**:
```
LLM checks before each phase after seeing actual code:
Q1: It's an HTML file, but need additional info gathering? → NO
→ Skip SEMANTIC
```
**Reason**: More accurate to have LLM judge based on actual content rather than file extension
---
## Future Optimization Directions
### v1.11 onwards (Further Improvements)
1. **Dynamic Checkpoint Addition**
- Insert new checkpoints during phase execution
- Flexible flow control based on situation
2. **Check Result Learning**
- Learn from past check results
- Present recommended responses based on project characteristics
3. **Parallel Check Consideration**
- Parallelize independent checks
- Further time reduction
---
## Related Changes
- `.claude/commands/code.md`:
- Add check instructions before each phase (Q1/Q2/Q3)
- Update gate_level options (h/m/l/a/n → f/a)
- `code_intel_server.py`:
- `check_phase_necessity` new handler
- `submit_verification` new handler (separated)
- `submit_impact_analysis` new handler (separated)
- `validate_phase_assessment` function
- `get_next_checkpoint` function
- `tools/session.py`:
- `Phase` enum update (VERIFICATION/IMPACT_ANALYSIS separation)
- `phase_assessments` field added
- `GATE_LEVEL_REQUIREMENTS` removed
- `is_markup_context()` removed
- `extract_extensions_from_text()` removed
- `get_dynamic_requirements()` removed
- `evaluate_exploration_v36()` removed
- `tools/query_frame.py`:
- `assess_risk_level()` removed
- `get_exploration_requirements()` removed
- `docs/DESIGN_ja.md`: Workflow update (per-phase check method, phase separation, gate_level restructuring)
---
## Detailed Time Reduction Analysis
### Estimated Reduction by Case
| Case | Frequency | v1.9 Time | v1.10 Time | Reduction |
|------|-----------|-----------|------------|-----------|
| Simple fix (sufficient info, no hypotheses, clear impact) | 20% | 70s | 10s | 60s |
| Everything completed during SEMANTIC | 25% | 80s | 35s | 45s |
| No hypotheses, impact not confirmed | 25% | 80s | 35s | 45s |
| Insufficient info, hypotheses exist, impact not confirmed | 25% | 110s | 100s | 10s |
| Complex case (all phases needed) | 5% | 110s | 120s | -10s |
**Weighted Average Reduction**: ~35 seconds
**Notes**:
- Complex cases have +10 seconds due to VERIFICATION and IMPACT_ANALYSIS separation, but accuracy improves
- Large reduction effect when verification/confirmation completes during SEMANTIC (45 seconds saved for 25% of cases)
