Nav Workflow

---
name: nav-workflow
description: Unified workflow orchestration for substantial tasks. Auto-detects complexity, defers to matching skills, or provides phase-based execution. Solves workflow conflicts between skills, loop mode, and CLAUDE.md.
allowed-tools: Read, Write, Edit, Bash, Grep, Glob, AskUserQuestion
version: 1.0.0
---

# Navigator Task Mode Skill

Unified workflow orchestration that coordinates between skills, loop mode, and direct execution based on task complexity and type.

## Why This Exists

Navigator had three disconnected workflow systems:
1. **Skills** (frontend-component, etc.) - have mini-workflows (Step 1 → Step 7)
2. **Loop Mode** - separate phase system (INIT → COMPLETE)
3. **CLAUDE.md** - documents workflow nobody enforces

**Result**: Conflicts when multiple systems try to run.

**Solution**: Task Mode acts as a coordinator - detecting when skills should handle workflow vs when to provide standalone phase guidance.

## How It Works

```
User Request
    ↓
TASK MODE (this skill)
    ├─ Simple task? → Direct execution (no overhead)
    ├─ Skill matches? → Let skill run (it has workflow)
    └─ Substantial, no skill? → Task Mode phases
```

## When to Invoke

**Auto-invoke when**:
- User starts substantial work (3+ steps expected)
- No obvious skill match (not "create component", "add endpoint", etc.)
- Request involves planning, refactoring, or multi-file changes
- Loop mode is disabled but structured execution needed

**DO NOT invoke if**:
- Trivial task (typo fix, single line change)
- Skill will clearly handle it (component creation, endpoint, migration, etc.)
- User says "quick", "just do", "simple fix"
- Already in Task Mode or Loop Mode

## Configuration

Task Mode settings in `.agent/.nav-config.json`:

```json
{
  "task_mode": {
    "enabled": true,
    "auto_detect": true,
    "defer_to_skills": true,
    "complexity_threshold": 0.5,
    "show_phase_indicator": true
  }
}
```

**Options**:
- `enabled`: Master switch for Task Mode
- `auto_detect`: Auto-detect complexity (vs explicit invocation only)
- `defer_to_skills`: Let matching skills handle their own workflow
- `complexity_threshold`: Score (0-1) required to activate
- `show_phase_indicator`: Show phase banners during execution

## Execution Steps

### Step 1: Analyze Request

**Run complexity detection**:
```bash
python3 functions/complexity_detector.py \
  --request "{USER_REQUEST}" \
  --context "{RECENT_CONTEXT}"
```

**Complexity signals**:
- Multi-file changes expected (+0.3)
- Planning language ("implement", "refactor", "add feature") (+0.2)
- Vague requirements needing research (+0.2)
- Cross-system changes (frontend+backend) (+0.3)
- Testing requirements mentioned (+0.1)

**Simple task signals**:
- Single file mentioned (-0.3)
- Fix/typo/update language (-0.2)
- Specific location given (-0.2)
- "Quick" or "simple" mentioned (-0.3)

**Decision**:
```
IF complexity_score < threshold:
  → Direct execution (exit Task Mode)
```

### Step 2: Check Skill Match

**Run skill detection**:
```bash
python3 functions/skill_detector.py \
  --request "{USER_REQUEST}" \
  --available-skills "{SKILLS_LIST}"
```

**Skill matching rules**:
- "create component" → frontend-component
- "add endpoint" → backend-endpoint
- "database migration" → database-migration
- "write test" → backend-test/frontend-test
- etc.

**Decision**:
```
IF matching_skill AND defer_to_skills:
  → Show: "Detected: {SKILL_NAME} skill will handle this"
  → Exit Task Mode (skill has workflow)
```

### Step 3: Initialize Task Mode

**If substantial task, no skill match**:

**Display activation**:
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TASK MODE ACTIVATED
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Task: {TASK_SUMMARY}
Complexity: {SCORE} (threshold: {THRESHOLD})
Skills matched: None (Task Mode will orchestrate)

Phases:
  ○ RESEARCH - Understand requirements
  ○ PLAN - Create implementation strategy
  ○ IMPL - Execute changes
  ○ VERIFY - Test and validate
  ○ COMPLETE - Commit and document

Starting RESEARCH phase...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

### Step 4: Execute Phases

**RESEARCH Phase**:
- Use Task agent for codebase exploration
- State the Ideal Final Result (the no-new-code version) and the reuse inventory
  (what already does ≥80% of this)
- If the brief declared a Contradiction, query prior resolutions
  (`graph_manager.py --action contradictions --filter "<terms>"`) and run the
  nav-triz divergence step: three candidates from different separation modes,
  one recommended, before PLAN
- Identify affected files
- Find existing patterns
- Document unknowns

**Show phase transition**:
```bash
python3 functions/phase_indicator.py \
  --phase "RESEARCH" \
  --status "complete" \
  --next "PLAN"
```

```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PHASE: RESEARCH → PLAN
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Research completed:
  ✓ Found {N} related files
  ✓ Identified patterns in {LOCATION}
  ✓ Dependencies mapped

Moving to PLAN phase...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

**PLAN Phase**:
- Create TodoWrite items
- Identify order of changes
- Document approach

**IMPL Phase**:
- Execute planned changes
- Follow project patterns
- Write tests as appropriate

**VERIFY Phase**:
- Run tests
- Type check
- Build validation
- **Run nav-simplify** (if enabled)

**COMPLETE Phase**:
- Commit changes
- Update documentation
- Close tickets (if PM configured)
- Suggest compact

### Step 5: Complete Task Mode

**Display completion**:
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TASK MODE COMPLETE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Task: {TASK_SUMMARY}
Phases:
  ✓ RESEARCH - {DURATION}
  ✓ PLAN - {DURATION}
  ✓ IMPL - {DURATION}
  ✓ VERIFY - {DURATION}
  ✓ COMPLETE

Summary:
- {FILES_CHANGED} files changed
- {TESTS_ADDED} tests added
- Committed: {COMMIT_SHA}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

---

## Predefined Functions

### functions/complexity_detector.py

Analyzes request to determine complexity score.

**Usage**:
```bash
python3 functions/complexity_detector.py \
  --request "Refactor the auth system to use JWT" \
  --context "Working on user management"
```

**Returns**:
```json
{
  "complexity_score": 0.7,
  "signals": {
    "multi_file": true,
    "planning_language": true,
    "cross_system": false
  },
  "recommendation": "task_mode",
  "reason": "Refactoring task with multi-file scope"
}
```

### functions/skill_detector.py

Checks if a skill should handle this request.

**Usage**:
```bash
python3 functions/skill_detector.py \
  --request "Add a login component" \
  --available-skills '["frontend-component", "backend-endpoint", "database-migration"]'
```

**Returns**:
```json
{
  "matching_skill": "frontend-component",
  "confidence": 0.95,
  "triggers": ["create component", "add component"],
  "defer": true,
  "reason": "Request matches frontend-component skill triggers"
}
```

### functions/phase_indicator.py

Generates phase transition displays.

**Usage**:
```bash
python3 functions/phase_indicator.py \
  --phase "IMPL" \
  --status "in_progress" \
  --progress 60 \
  --details '{"files_changed": 3, "tests_written": 2}'
```

**Returns**: Formatted phase indicator block.

---

## Integration with Navigator

### With Loop Mode

Task Mode is **lighter weight** than Loop Mode:
- Loop Mode: Strict iteration control, stagnation detection, EXIT_SIGNAL
- Task Mode: Phase guidance, skill coordination, no strict gates

**When to use which**:
- Loop Mode: "Run until done", autonomous iteration
- Task Mode: Substantial task, need structure but not strict iteration

**Can coexist**: Loop Mode wraps Task Mode phases if both active.

### With Skills

Task Mode **defers to skills** by default:
- Skill has its own workflow (Steps 1-7)
- Task Mode doesn't add overhead
- Just shows "Skill X will handle this"

**Override**: Set `defer_to_skills: false` to always use Task Mode phases.

### With nav-simplify

Simplification runs during VERIFY phase:
- After tests pass
- Before committing
- Respects simplification.enabled config

### With Autonomous Completion

COMPLETE phase triggers autonomous protocol:
- Commit changes
- Archive documentation
- Close tickets
- Create markers

---

## Comparison Table

| Aspect | Direct Execution | Task Mode | Loop Mode |
|--------|------------------|-----------|-----------|
| Complexity | Low | Medium-High | High |
| Phase tracking | None | Visual phases | Strict phases |
| Iteration control | None | None | EXIT_SIGNAL |
| Skill coordination | None | Defers | Independent |
| Best for | Quick fixes | Features | Autonomous work |

---

## Examples

### Example 1: Simple Fix (Direct Execution)

```
User: "Fix the typo in README"

→ Complexity: 0.1 (below threshold)
→ Direct execution (no Task Mode overhead)
```

### Example 2: Component Creation (Skill Defers)

```
User: "Create a UserProfile component"

→ Complexity: 0.6
→ Skill match: frontend-component (0.95 confidence)
→ Task Mode defers: "frontend-component skill will handle this"
→ Skill executes its own Step 1-7 workflow
```

### Example 3: Refactoring (Task Mode Active)

```
User: "Refactor auth to use JWT instead of sessions"

→ Complexity: 0.8
→ Skill match: None
→ Task Mode activates
→ RESEARCH: Explore current auth implementation
→ PLAN: Document JWT migration steps
→ IMPL: Execute changes across files
→ VERIFY: Run tests, simplify code
→ COMPLETE: Commit, document
```

### Example 4: With Loop Mode

```
User: "Run until done: implement user roles"

→ Loop Mode activated (explicit trigger)
→ Task Mode phases guide each iteration:
    Iteration 1: RESEARCH phase
    Iteration 2: PLAN + IMPL phases
    Iteration 3: IMPL + VERIFY phases
    Iteration 4: COMPLETE + EXIT_SIGNAL
```

---

## Error Handling

**Config not found**:
```
Task Mode config not found in .nav-config.json.
Using defaults: auto_detect=true, threshold=0.5
```

**Skill detection fails**:
- Fall back to Task Mode (conservative)
- Log warning but continue

**Phase detection ambiguous**:
- Default to current or next logical phase
- Show reasoning for user

---

## Success Criteria

Task Mode succeeds when:
- [ ] Simple tasks execute without overhead
- [ ] Skills handle their matched requests
- [ ] Substantial tasks get phase structure
- [ ] No conflicts between systems
- [ ] User sees clear progress indicators

---

## Verification Checklist

After implementation:
- [ ] "Add login component" → frontend-component runs (not Task Mode)
- [ ] "Refactor auth system" → Task Mode runs (no matching skill)
- [ ] "Fix typo" → Direct execution (not substantial)
- [ ] Phase indicators show during Task Mode
- [ ] Skills continue working unchanged
- [ ] Loop Mode can wrap Task Mode phases

---

**This skill provides unified workflow orchestration, resolving conflicts between Navigator's multiple workflow systems.**