Feature orchestration: Multi-session workflow with integrated verification

## Overview

Implement `daf feature` command to orchestrate multiple sessions into a cohesive feature implementation. Execute related tickets sequentially on a single branch, verify acceptance criteria between sessions, and create one final PR for the complete feature.

## Problem Statement

**Current workflow (manual):**
```bash
git checkout -b feature/my-epic
daf open PROJ-101  # work, commit
daf open PROJ-102  # work, commit  
daf open PROJ-103  # work, commit
gh pr create       # manually create PR
```

**Pain points:**
- ❌ Manual orchestration of related sessions
- ❌ No verification between sessions (issues accumulate)
- ❌ Acceptance criteria checked only at PR review (too late)
- ❌ Easy to forget which sessions are part of feature
- ❌ No state tracking for multi-session features
- ❌ Manual PR creation with multi-ticket context
- ❌ Risk of working on wrong branch between sessions

**What users want:**
- ✅ Declare all sessions upfront: "These 5 tickets = 1 feature"
- ✅ Automated execution: system handles open → complete → verify loop
- ✅ Single branch for all work
- ✅ Acceptance criteria verification gates between sessions
- ✅ One PR at the end linking all tickets
- ✅ Pause/resume capability

## Proposed Solution

### Command Interface

```bash
# Create feature orchestration
daf feature create auth-system \
  --sessions "PROJ-101,PROJ-102,PROJ-103" \
  --branch "feature/oauth-integration" \
  --verify auto

# Execute sessions automatically
daf feature run auth-system

# Check progress
daf feature status auth-system

# Resume after pause
daf feature resume auth-system

# Complete and create PR
daf feature complete auth-system
```

## Architecture

### Feature Orchestration Model

**Add to `devflow/config/models.py`:**
```python
class FeatureOrchestration(BaseModel):
    """Multi-session feature orchestration."""
    
    name: str                          # Feature name
    branch: str                        # Shared git branch
    base_branch: str = "main"          # Base branch
    sessions: List[str]                # Session names in order
    current_session_index: int = 0     # Active session
    status: str = "created"            # created, running, paused, complete, failed
    verification_mode: str = "auto"    # auto, manual, skip
    workspace_name: Optional[str]      # Workspace for all sessions
    created: datetime
    last_active: datetime
    completed: Optional[datetime]
    session_statuses: Dict[str, str]   # session_name → status
    verification_results: Dict[str, str] # session_name → passed/failed/skipped
```

**Storage:**
```
$DEVAIFLOW_HOME/
├── features.json              # Index of all features
└── features/
    └── auth-system/
        ├── metadata.json      # FeatureOrchestration data
        ├── state.md           # Current state (human-readable)
        ├── progress.md        # Session completion log
        └── verification/
            ├── PROJ-101.md    # Verification reports per session
            ├── PROJ-102.md
            └── PROJ-103.md
```

### Orchestration Flow

```
┌─────────────────────────────────────────────────────┐
│  daf feature create                                 │
│  ├─ Validate all sessions exist                    │
│  ├─ Create shared feature branch                   │
│  ├─ Initialize feature metadata                    │
│  └─ Status: created                                │
└─────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────┐
│  daf feature run (automated loop)                   │
│                                                      │
│  For each session:                                  │
│    1. daf open {session} --branch {feature-branch}  │
│    2. AI agent works on ticket                      │
│    3. daf complete {session} (commits to branch)    │
│    4. VERIFY (built-in):                            │
│       ├─ auto: Check acceptance criteria + tests   │
│       ├─ manual: Prompt user for approval          │
│       └─ skip: Continue immediately                │
│    5. If verify PASS → next session                │
│    6. If verify FAIL → PAUSE for debugging         │
└─────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────┐
│  daf feature complete                               │
│  ├─ Verify all sessions completed                  │
│  ├─ Run final integration tests                    │
│  ├─ Create PR with all commits                     │
│  ├─ Link PR to all tickets                         │
│  ├─ Transition all tickets                         │
│  └─ Status: complete                               │
└─────────────────────────────────────────────────────┘
```

## Key Features

### 1. Feature Creation

```bash
# Basic creation
daf feature create my-feature \
  --sessions "PROJ-101,PROJ-102,PROJ-103"

# With verification mode
daf feature create my-feature \
  --sessions "PROJ-101,PROJ-102,PROJ-103" \
  --verify auto

# Specify branch and base
daf feature create my-feature \
  --sessions "PROJ-101,PROJ-102,PROJ-103" \
  --branch "feature/oauth" \
  --base-branch "develop"

# Auto-discover from epic
daf feature create my-feature \
  --epic "PROJ-100" \
  --auto-order
```

**Creates:**
- Feature branch from base
- Feature metadata file
- Links to all session tickets
- Initial STATE.md

### 2. Automated Execution

```bash
daf feature run my-feature
```

**Behavior:**
- Loops through sessions in order
- For each session:
  - Opens session with feature branch
  - Waits for completion
  - Runs verification (based on mode)
  - Continues or pauses based on result
- Updates progress in real-time
- Generates STATE.md after each session

**Output:**
```
╭──────────────────────────────────────────────╮
│ Feature: my-feature                          │
│ Branch: feature/oauth                        │
│ Progress: 2/3 sessions                       │
╰──────────────────────────────────────────────╯

✓ [1/3] PROJ-101: OAuth provider setup
  ├─ Commits: 5
  ├─ Verification: PASSED (5/5 criteria)
  └─ Duration: 45m

✓ [2/3] PROJ-102: Token validation
  ├─ Commits: 3
  ├─ Verification: PASSED (4/4 criteria)
  └─ Duration: 30m

⧗ [3/3] PROJ-103: User profile integration
  └─ Status: in_progress
```

### 3. Built-in Verification (Between Sessions)

**Core verification for feature orchestration:**

After each session completes, automatically verify:

#### Acceptance Criteria Check
- Fetch ticket from JIRA/GitHub/GitLab
- Parse acceptance criteria checkboxes
- For each criterion:
  - Check if marked as complete in ticket
  - Validate against code changes (where possible)
  - Report verified vs unverified items

#### Test Suite Check
- Run configured test command (pytest, npm test, etc.)
- Capture pass/fail status
- Include test output in verification report

#### Artifact Check
- Verify required files exist (from ticket description)
- Check files are substantial (not empty stubs)
- Validate expected code patterns present

#### Code Quality Check (optional)
- Run linter if configured
- Check for build success
- Verify no uncommitted changes

**Verification Modes:**

**Auto Mode** (default):
```bash
daf feature create my-feature \
  --sessions "..." \
  --verify auto
```
- Automatically runs all checks
- Pauses feature if checks fail
- Generates detailed VERIFICATION.md report

**Manual Mode**:
```bash
daf feature create my-feature \
  --sessions "..." \
  --verify manual
```
- Prompts user after each session: "Review complete?"
- User manually checks acceptance criteria
- User confirms to proceed or pause for fixes

**Skip Mode**:
```bash
daf feature create my-feature \
  --sessions "..." \
  --verify skip
```
- No verification between sessions
- Proceeds immediately to next session
- Use for rapid prototyping

### 4. VERIFICATION.md Report

**Generated after each session:**

```markdown
# Verification Report: PROJ-101

**Session**: PROJ-101 (OAuth provider setup)
**Feature**: auth-system
**Status**: PASSED
**Timestamp**: 2026-03-27T15:30:00Z
**Duration**: 8.5s

## Acceptance Criteria

**Progress**: 5/5 criteria verified

### ✓ Verified Criteria

- [x] OAuth provider loads configuration from environment
  - Verified: Config loading code present in oauth_provider.py:45
  - Test: test_oauth_config_loading PASSED
  
- [x] Authorization redirect works with correct scopes
  - Verified: Redirect logic in oauth_provider.py:120
  - Test: test_authorization_redirect PASSED
  
- [x] Token exchange endpoint handles authorization code
  - Verified: Token exchange in token_handler.py:60
  - Test: test_token_exchange PASSED
  
- [x] Error handling for invalid OAuth responses
  - Verified: Error handling in oauth_provider.py:200
  - Test: test_oauth_error_handling PASSED
  
- [x] Documentation updated with OAuth setup steps
  - Verified: docs/api/oauth.md exists (145 lines)

### ⚠ Notes

All acceptance criteria verified successfully!

## Test Suite

**Status**: PASSED
**Command**: pytest tests/test_oauth.py
**Output**: 12 passed in 2.3s

## Required Artifacts

**Status**: PASSED

Files verified:
- ✓ src/auth/oauth_provider.py (347 lines)
- ✓ src/auth/token_handler.py (128 lines)
- ✓ tests/test_oauth.py (89 lines)
- ✓ docs/api/oauth.md (145 lines)

## Overall Result

**✓ VERIFICATION PASSED**

All checks completed successfully. Feature orchestration will proceed to next session.

---
Next session: PROJ-102 (Token validation endpoint)
```

**When verification FAILS:**

```markdown
# Verification Report: PROJ-102

**Session**: PROJ-102 (Token validation endpoint)
**Feature**: auth-system
**Status**: GAPS FOUND
**Timestamp**: 2026-03-27T16:15:00Z

## Acceptance Criteria

**Progress**: 3/4 criteria verified

### ✓ Verified Criteria

- [x] Token validation endpoint accepts Bearer tokens
  - Verified: Endpoint at api/validate.py:30
  - Test: test_bearer_token_validation PASSED

- [x] Returns 401 for invalid tokens
  - Verified: Error handling in validate.py:50
  - Test: test_invalid_token_401 PASSED

- [x] Returns user info for valid tokens
  - Verified: User info extraction in validate.py:70
  - Test: test_valid_token_user_info PASSED

### ✗ Unverified Criteria

- [ ] Token refresh endpoint handles expired tokens
  - **ISSUE**: No code found for token refresh
  - **ISSUE**: No test coverage for refresh flow
  - **Suggestion**: Add refresh_token() method to token_handler.py
  - **Suggestion**: Add test_token_refresh() to tests/

## Test Suite

**Status**: PASSED
**Command**: pytest tests/test_validation.py
**Output**: 8 passed in 1.8s

**Note**: Tests pass but refresh functionality not tested

## Overall Result

**✗ GAPS FOUND - FEATURE PAUSED**

1 of 4 acceptance criteria not verified.

### To Fix:
1. Implement token refresh endpoint
2. Add test coverage for refresh flow
3. Mark criterion as complete in JIRA ticket
4. Resume feature: `daf feature resume auth-system`

---
Feature orchestration PAUSED until gaps resolved.
```

### 5. Pause/Resume

```bash
# Auto-pauses on verification failure

# Fix issues, then resume:
daf feature resume auth-system

# Output:
# Resuming feature: auth-system
# Re-running verification for PROJ-102...
# ✓ Verification PASSED (4/4 criteria)
# Continuing to next session...
```

**Resume behavior:**
- Continues from last paused session
- Re-runs verification if it failed
- Preserves all state and progress

### 6. State Visualization

```bash
daf feature status auth-system
```

**Output:**
```
╭──────────────────────────────────────────────╮
│ Feature: auth-system                         │
│ Branch: feature/oauth-integration            │
│ Status: paused (verification failed)         │
│ Progress: 1/3 sessions                       │
╰──────────────────────────────────────────────╯

Completed Sessions:
  ✓ PROJ-101: OAuth provider setup
    ├─ Commits: 5
    ├─ Criteria: 5/5 verified
    └─ Duration: 45m

Current Session (PAUSED):
  ⧗ PROJ-102: Token validation endpoint
    ├─ Status: PAUSED (verification failed)
    ├─ Commits: 3
    ├─ Criteria: 3/4 verified
    └─ Missing: Token refresh endpoint

Pending Sessions:
  ○ PROJ-103: User profile integration
  ○ PROJ-104: Session management

Next Steps:
  1. Fix missing token refresh in PROJ-102
  2. Run: daf feature resume auth-system
  
Verification report: ~/.daf-sessions/features/auth-system/verification/PROJ-102.md
```

**STATE.md** (generated):
```markdown
# Feature: auth-system

**Status**: paused
**Branch**: feature/oauth-integration
**Progress**: 1/3 sessions completed
**Last Updated**: 2026-03-27 16:15:00

## Completed Sessions

### ✓ PROJ-101: OAuth provider setup
- **Status**: complete
- **Commits**: 5
- **Acceptance Criteria**: 5/5 verified
- **Verification**: PASSED
- **Completed**: 2026-03-27 15:30:00

## Current Session

### ⧗ PROJ-102: Token validation endpoint
- **Status**: paused
- **Reason**: Verification failed
- **Acceptance Criteria**: 3/4 verified
- **Missing Criteria**:
  - Token refresh endpoint handles expired tokens (no implementation found)

## Pending Sessions

### ○ PROJ-103: User profile integration
- **Status**: pending

### ○ PROJ-104: Session management
- **Status**: pending

## Next Steps

1. Implement token refresh endpoint in PROJ-102
2. Add test coverage for refresh flow
3. Resume feature: `daf feature resume auth-system`
```

### 7. Feature Completion

```bash
daf feature complete auth-system
```

**Actions:**
1. Verify all sessions completed
2. Verify all acceptance criteria met across all sessions
3. Run final integration tests (optional)
4. Create PR with aggregated context
5. Link PR to all tickets
6. Update all tickets with PR link
7. Update acceptance criteria checkboxes in all tickets
8. Optionally transition all tickets
9. Mark feature as complete

**PR Description Template:**
```markdown
## Feature: OAuth Integration

This PR implements the complete OAuth integration feature across 4 related tickets.

### Tickets Included

- PROJ-101: OAuth provider setup ✓
- PROJ-102: Token validation endpoint ✓
- PROJ-103: User profile integration ✓
- PROJ-104: Session management ✓

### Changes by Session

#### PROJ-101: OAuth provider setup (5 commits)
**Acceptance Criteria**: 5/5 verified
- Added OAuth2 provider configuration
- Implemented authorization flow
- Added tests for OAuth endpoints

#### PROJ-102: Token validation endpoint (3 commits)
**Acceptance Criteria**: 4/4 verified
- Created token validation middleware
- Added JWT verification
- Implemented token refresh endpoint
- Added token refresh logic

#### PROJ-103: User profile integration (4 commits)
**Acceptance Criteria**: 3/3 verified
- Integrated OAuth with user profiles
- Added profile update endpoint
- Added profile persistence tests

#### PROJ-104: Session management (6 commits)
**Acceptance Criteria**: 4/4 verified
- Implemented session storage
- Added session expiry logic
- Added concurrent session handling
- Added session cleanup cron job

### Verification Summary

All sessions verified:
- ✓ PROJ-101: 5/5 criteria verified, 12 tests passing
- ✓ PROJ-102: 4/4 criteria verified, 8 tests passing
- ✓ PROJ-103: 3/3 criteria verified, 15 tests passing
- ✓ PROJ-104: 4/4 criteria verified, 10 tests passing

**Total**: 16/16 acceptance criteria verified

### Testing

- Total commits: 18
- Total tests added: 45
- All integration tests: PASSING
- Code coverage: 94%

### Verification Reports

Detailed verification reports available:
- [PROJ-101 Verification](link-to-verification-report)
- [PROJ-102 Verification](link-to-verification-report)
- [PROJ-103 Verification](link-to-verification-report)
- [PROJ-104 Verification](link-to-verification-report)

---
🤖 Generated by DevAIFlow Feature Orchestration
All acceptance criteria automatically verified during development
```

### 8. Auto-Discovery from Epic

```bash
# Discover sessions from JIRA epic
daf feature create oauth-feature \
  --epic "PROJ-100" \
  --auto-order

# DevAIFlow:
# 1. Fetches epic PROJ-100
# 2. Finds all linked tickets (child stories/tasks)
# 3. Orders by dependencies (if detectable)
# 4. Prompts user to confirm order
# 5. Creates feature orchestration
```

## Verification Architecture

### New Verification Module

**devflow/verification/__init__.py**
- Core verification logic (separate from PR review #172)
- Used by feature orchestration

**devflow/verification/criteria_checker.py**
```python
class AcceptanceCriteriaChecker:
    """Check acceptance criteria for a session."""
    
    def check_criteria(self, session, ticket) -> VerificationResult:
        """
        Parse acceptance criteria checkboxes from ticket.
        Check each criterion against code changes.
        Return verified vs unverified items.
        """
        
    def verify_criterion(self, criterion: str, session) -> bool:
        """
        Attempt to verify a single criterion.
        Returns True if verifiable, False if needs human review.
        """
```

**devflow/verification/test_runner.py**
```python
class TestRunner:
    """Run test suite and capture results."""
    
    def run_tests(self, test_command: str, timeout: int) -> TestResult:
        """Execute test command and parse output."""
```

**devflow/verification/artifact_validator.py**
```python
class ArtifactValidator:
    """Validate required files exist."""
    
    def validate_artifacts(self, required_files: List[str]) -> ArtifactResult:
        """Check files exist and are substantial."""
```

**devflow/verification/report_generator.py**
```python
class VerificationReportGenerator:
    """Generate VERIFICATION.md reports."""
    
    def generate_report(self, results: VerificationResult) -> str:
        """Create markdown report from verification results."""
```

### Integration with Feature Orchestration

**devflow/orchestration/feature.py**
```python
class FeatureManager:
    def _verify_session(self, session_name: str, mode: str) -> bool:
        """
        Verify a completed session.
        
        Args:
            session_name: Session to verify
            mode: auto, manual, or skip
            
        Returns:
            True if verification passed, False if gaps found
        """
        if mode == "skip":
            return True
            
        # Fetch ticket
        ticket = self._fetch_ticket(session_name)
        
        # Run verification
        verifier = AcceptanceCriteriaChecker()
        result = verifier.check_criteria(session_name, ticket)
        
        # Generate report
        report_gen = VerificationReportGenerator()
        report = report_gen.generate_report(result)
        
        # Save report
        self._save_verification_report(session_name, report)
        
        # Display results
        self._display_verification_results(result)
        
        if result.status == "passed":
            return True
        elif result.status == "gaps_found":
            # Pause feature
            self._pause_feature(session_name, result)
            return False
```

## User Stories

### As a developer working on a feature epic
- I want to declare all related sessions upfront
- So that the system orchestrates their execution
- And automatically verifies acceptance criteria between sessions

### As a developer concerned about quality
- I want acceptance criteria checked immediately after each session
- So that issues are caught before moving to the next ticket
- And I don't accumulate technical debt across the feature

### As a team lead managing complex features
- I want visibility into which acceptance criteria are met
- So that I can see real progress on the feature
- And know exactly where the team is blocked

### As a reviewer
- I want one PR with verified acceptance criteria
- So that I know all requirements were met
- And can focus on architecture review instead of checking basics

## Implementation Phases

### Phase 1: Core Orchestration (MVP)
**Duration**: 4-6 weeks

**Features:**
- `daf feature create` - Initialize feature from session list
- `daf feature run` - Execute sessions sequentially
- `daf feature status` - Show progress
- Feature branch creation and management
- Session state tracking
- Basic STATE.md generation
- Basic acceptance criteria checking
- Simple verification reports

**Stories:**
1. Create FeatureOrchestration model
2. Implement feature index (features.json)
3. Build session execution loop
4. Track session completion status
5. Parse acceptance criteria from tickets
6. Check criteria against code changes
7. Generate VERIFICATION.md reports
8. Pause on verification failures
9. Resume from paused sessions

**Acceptance Criteria:**
- [ ] Create feature from list of existing sessions
- [ ] All sessions execute on same feature branch
- [ ] Sessions run in declared order
- [ ] After each session, acceptance criteria checked
- [ ] VERIFICATION.md report generated
- [ ] Feature pauses if criteria not met
- [ ] Resume continues from failed session
- [ ] State persists between runs
- [ ] Status shows completed vs pending sessions
- [ ] Feature completion creates single PR

### Phase 2: Enhanced Verification
**Duration**: 2-4 weeks

**Features:**
- Test suite integration
- Artifact validation
- Code quality checks
- Multiple verification modes (auto/manual/skip)
- Richer verification reports
- Verification history

**Stories:**
1. Integrate test runner (pytest, npm test, etc.)
2. Add artifact validation
3. Add optional lint/build checks
4. Implement manual verification mode
5. Add skip verification mode
6. Store verification history per session
7. Improve verification report formatting

**Acceptance Criteria:**
- [ ] Auto mode runs tests + checks criteria
- [ ] Manual mode prompts for user approval
- [ ] Skip mode bypasses verification
- [ ] Test results included in reports
- [ ] Artifact validation checks required files
- [ ] Multiple verification runs saved (history)
- [ ] Config controls verification behavior

### Phase 3: Advanced Features
**Duration**: 4-6 weeks

**Features:**
- `--epic` flag for auto-discovery
- `--auto-order` for dependency-based ordering
- Rollback capability
- Progress visualization
- Smart verification (optimize checks)
- Cross-session acceptance criteria

**Stories:**
1. Epic → sessions discovery
2. Dependency analysis for ordering
3. Rollback to previous session
4. Rich progress dashboard
5. Smart verification (skip unchanged code)
6. Check acceptance criteria across entire feature

**Acceptance Criteria:**
- [ ] Auto-discover sessions from epic key
- [ ] Order sessions by dependencies
- [ ] Rollback reverts to previous session state
- [ ] Dashboard shows timeline and metrics
- [ ] Verification optimized for unchanged code
- [ ] Cross-session criteria validated

### Phase 4: AI-Assisted Features
**Duration**: 4-6 weeks

**Features:**
- AI suggests session ordering
- AI generates feature plan from tickets
- AI verifies acceptance criteria semantically
- AI auto-fixes verification gaps
- Predictive failure detection

**Stories:**
1. AI analyzes tickets for dependencies
2. AI suggests optimal execution order
3. AI validates acceptance criteria coverage
4. AI attempts to fix verification gaps
5. AI predicts likely failure points

**Acceptance Criteria:**
- [ ] AI suggests session order with rationale
- [ ] AI validates acceptance criteria completeness
- [ ] AI attempts to fix gaps automatically
- [ ] AI warns about missing prerequisites

## Acceptance Criteria (Epic Level)

### Must Have (MVP - Phase 1)
- [ ] `daf feature create` accepts list of session names
- [ ] Feature creates shared branch for all sessions
- [ ] Sessions execute sequentially via automated loop
- [ ] All session commits go to feature branch
- [ ] After each session, acceptance criteria checked
- [ ] VERIFICATION.md report generated per session
- [ ] Feature pauses if acceptance criteria not met
- [ ] Verification reports show verified vs unverified criteria
- [ ] Feature state persists (can pause/resume)
- [ ] `daf feature status` shows progress and verification status
- [ ] `daf feature complete` creates single PR
- [ ] PR links to all tickets with verification summary
- [ ] STATE.md generated and updated

### Should Have (Phase 2)
- [ ] Test suite runs between sessions
- [ ] Artifact validation checks required files
- [ ] Auto mode runs all automated checks
- [ ] Manual mode prompts for approval
- [ ] Skip mode bypasses verification
- [ ] Verification history saved per session
- [ ] Config controls verification behavior
- [ ] Failed sessions can be debugged and retried

### Nice to Have (Phase 3-4)
- [ ] Auto-discovery from epic key
- [ ] AI-powered session ordering
- [ ] Rollback to previous session
- [ ] Progress timeline visualization
- [ ] Smart verification optimization
- [ ] AI auto-fixes verification gaps
- [ ] Cross-session acceptance criteria validation
- [ ] Predictive failure detection

## Technical Design

### New Modules

**devflow/orchestration/feature.py**
- `FeatureManager` class
- Methods: create, run, pause, resume, complete, rollback
- Session execution loop
- State management

**devflow/verification/criteria_checker.py**
- `AcceptanceCriteriaChecker` class
- Parse criteria from tickets
- Validate against code changes

**devflow/verification/test_runner.py**
- `TestRunner` class
- Execute test commands
- Parse test output

**devflow/verification/artifact_validator.py**
- `ArtifactValidator` class
- Check required files
- Validate file substance

**devflow/verification/report_generator.py**
- `VerificationReportGenerator` class
- Generate VERIFICATION.md
- Format results

**devflow/cli/commands/feature_command.py**
- CLI command group
- Subcommands: create, run, pause, resume, status, complete

**tests/test_feature_orchestration.py**
- Unit tests for FeatureManager
- Integration tests for full workflow

**tests/test_verification.py**
- Unit tests for verification components

### Modified Files

**devflow/config/models.py**
- Add `FeatureOrchestration` model
- Add `FeatureIndex` model
- Add `VerificationConfig` model

**devflow/session/manager.py**
- Feature orchestration awareness
- Track which sessions belong to features

**devflow/cli/main.py**
- Register `daf feature` command group

**devflow/cli/commands/open_command.py**
- Support `--feature-branch` parameter
- Detect if session is part of feature

**devflow/cli/commands/complete_command.py**
- Detect feature orchestration context
- Skip individual PR creation if part of feature
- Notify feature manager of completion

## Testing Strategy

**Unit Tests:**
- FeatureOrchestration model CRUD
- Session execution loop logic
- Acceptance criteria parsing
- Test runner integration
- Artifact validation
- Report generation
- State persistence and recovery

**Integration Tests:**
```bash
./test_feature_orchestration.sh

# Tests:
# - Create → run 3 sessions → verify criteria → complete → check PR
# - Pause after session 1 → fix issues → resume → complete
# - Verification failure → pause → fix criteria → resume
# - Auto-discovery from epic
# - Skip verification mode
# - Manual verification mode
```

**Manual Testing:**
- Real JIRA epic with 5+ linked tickets
- GitHub Issues with related tasks
- Mixed ticket types (story, task, bug)
- Verification failures
- Branch conflicts between sessions
- Test command failures
- Missing acceptance criteria

## Example Workflows

### Workflow 1: OAuth Feature (Auto Mode)

```bash
# 1. Create feature from sessions
daf feature create oauth-integration \
  --sessions "AAP-101,AAP-102,AAP-103,AAP-104" \
  --branch "feature/oauth" \
  --verify auto

# 2. Run orchestration
daf feature run oauth-integration

# Automated execution with verification:
# [1/4] AAP-101: OAuth provider setup
#   ↳ Opening session...
#   ↳ AI working... (commits: 5)
#   ↳ Completing session...
#   ↳ Verifying acceptance criteria...
#      ✓ OAuth provider loads config from environment
#      ✓ Authorization redirect works with scopes
#      ✓ Token exchange handles auth code
#      ✓ Error handling for invalid OAuth responses
#      ✓ Documentation updated
#   ↳ Running tests... 12 passed in 2.3s
#   ✓ VERIFICATION PASSED (5/5 criteria)
#
# [2/4] AAP-102: Token validation
#   ↳ Opening session...
#   ↳ AI working... (commits: 3)
#   ↳ Completing session...
#   ↳ Verifying acceptance criteria...
#      ✓ Token validation accepts Bearer tokens
#      ✓ Returns 401 for invalid tokens
#      ✓ Returns user info for valid tokens
#      ✗ Token refresh handles expired tokens
#   ↳ Running tests... 8 passed in 1.8s
#   ✗ VERIFICATION FAILED (3/4 criteria)
#
# ⚠ Verification failed for AAP-102
# Missing acceptance criterion:
#   - Token refresh endpoint handles expired tokens
# Report: ~/.daf-sessions/features/oauth-integration/verification/AAP-102.md
#
# Feature PAUSED
# Resume: daf feature resume oauth-integration

# 3. Fix issues (implement token refresh)
# ... developer adds missing functionality ...

# 4. Resume
daf feature resume oauth-integration

# [2/4] AAP-102: Token validation (RESUMED)
#   ↳ Re-verifying acceptance criteria...
#      ✓ Token refresh handles expired tokens
#   ✓ VERIFICATION PASSED (4/4 criteria)
#
# [3/4] AAP-103: User profile integration
#   ... continues automatically ...

# 5. Complete feature
daf feature complete oauth-integration

# ✓ All sessions completed
# ✓ All acceptance criteria verified (16/16 across 4 sessions)
# ✓ Creating PR... #456
# ✓ PR includes verification summary
#
# PR: https://github.com/org/repo/pull/456
# Feature complete!
```

### Workflow 2: Manual Verification Mode

```bash
daf feature create payment-flow \
  --sessions "AAP-201,AAP-202,AAP-203" \
  --verify manual

daf feature run payment-flow

# [1/3] AAP-201: Payment provider integration
#   ↳ Opening session...
#   ↳ AI working... (commits: 4)
#   ↳ Completing session...
#
# Manual verification required for AAP-201
#
# Acceptance criteria:
#   - [ ] Payment provider API integrated
#   - [ ] Test mode enabled by default
#   - [ ] Error handling for API failures
#
# Please verify:
# 1. Review code changes
# 2. Test payment flow manually
# 3. Check all acceptance criteria met
#
# Verification passed? (y/n/pause):
```

## Dependencies

**Required:**
- Issue tracker integration (JIRA/GitHub/GitLab)
- Session management (existing)
- Git operations (existing)
- Test framework detection (pytest, jest, npm, etc.)

**Optional:**
- AI agent for ordering suggestions
- Epic → sessions discovery API
- Dependency analysis tools

## Risks & Mitigation

| Risk | Impact | Mitigation |
|------|--------|------------|
| Acceptance criteria not in checkbox format | High | Support multiple formats, prompt user to standardize |
| Branch conflicts between sessions | High | Check for conflicts after each session, pause if detected |
| Long-running features (10+ sessions) | Medium | Allow pause/resume, save checkpoints |
| Test failures block progress | Medium | Configurable retry counts, skip option |
| Ambiguous acceptance criteria | High | AI-assisted interpretation, manual mode fallback |
| Session dependencies not explicit | High | AI-assisted ordering, user confirmation |
| State corruption on interruption | High | Atomic state updates, validation on resume |

## Metrics for Success

- **Adoption**: % of multi-ticket features using orchestration
- **Quality**: % of acceptance criteria verified before PR
- **Efficiency**: Time saved vs manual orchestration
- **Reliability**: % of features completing without manual intervention
- **Verification**: % of issues caught between sessions vs in PR review
- **Coverage**: Average acceptance criteria coverage per feature

## Documentation

- **docs/07-commands.md**: Add `daf feature` command group
- **docs/14-workflows.md**: Multi-session feature development
- **docs/feature-orchestration.md**: Architecture and design
- **docs/verification.md**: Verification between sessions
- **AGENTS.md**: Feature orchestration patterns
- **README.md**: Add to key features

## Open Questions

1. **Criteria format**: Require checkbox format or support free text?
2. **Verification strictness**: All criteria must pass or allow partial?
3. **Session ordering**: User-specified vs AI-suggested vs manual override?
4. **PR size limits**: Warning if feature has too many sessions?
5. **Rollback scope**: Session-level or commit-level?
6. **Epic discovery**: Auto-create sessions for tickets without sessions?
7. **Cross-session criteria**: How to verify acceptance criteria that span multiple sessions?


- [ ] Create feature from session list with shared branch
- [ ] Execute sessions sequentially with state tracking
- [ ] Verify acceptance criteria between sessions
- [ ] Pause on verification failures
- [ ] Generate VERIFICATION.md reports
- [ ] Resume from failed sessions
- [ ] Complete feature creates single PR with verification summary

Risk	Impact	Mitigation
Acceptance criteria not in checkbox format	High	Support multiple formats, prompt user to standardize
Branch conflicts between sessions	High	Check for conflicts after each session, pause if detected
Long-running features (10+ sessions)	Medium	Allow pause/resume, save checkpoints
Test failures block progress	Medium	Configurable retry counts, skip option
Ambiguous acceptance criteria	High	AI-assisted interpretation, manual mode fallback
Session dependencies not explicit	High	AI-assisted ordering, user confirmation
State corruption on interruption	High	Atomic state updates, validation on resume

Feature orchestration: Multi-session workflow with integrated verification #330

Description

Overview

Problem Statement

Proposed Solution

Command Interface

Architecture

Feature Orchestration Model

Orchestration Flow

Key Features

1. Feature Creation

2. Automated Execution

3. Built-in Verification (Between Sessions)

Acceptance Criteria Check

Test Suite Check

Artifact Check

Code Quality Check (optional)

4. VERIFICATION.md Report

5. Pause/Resume

6. State Visualization

7. Feature Completion

8. Auto-Discovery from Epic

Verification Architecture

New Verification Module

Integration with Feature Orchestration

User Stories

As a developer working on a feature epic

As a developer concerned about quality

As a team lead managing complex features

As a reviewer

Implementation Phases

Phase 1: Core Orchestration (MVP)

Phase 2: Enhanced Verification

Phase 3: Advanced Features

Phase 4: AI-Assisted Features

Acceptance Criteria (Epic Level)

Must Have (MVP - Phase 1)

Should Have (Phase 2)

Nice to Have (Phase 3-4)

Technical Design

New Modules

Modified Files

Testing Strategy

Example Workflows

Workflow 1: OAuth Feature (Auto Mode)

Workflow 2: Manual Verification Mode

Dependencies

Risks & Mitigation

Metrics for Success

Documentation

Open Questions

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions