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:

Skills (frontend-component, etc.) - have mini-workflows (Step 1 → Step 7)
Loop Mode - separate phase system (INIT → COMPLETE)
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
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.

nav-task-mode

NPX Install

Tags

SKILL.md Content

Navigator Task Mode Skill

Why This Exists

How It Works

When to Invoke

Configuration

Execution Steps

Step 1: Analyze Request

Step 2: Check Skill Match

Step 3: Initialize Task Mode

Step 4: Execute Phases

Step 5: Complete Task Mode

Predefined Functions

functions/complexity_detector.py

functions/skill_detector.py

functions/phase_indicator.py

Integration with Navigator

With Loop Mode

With Skills

With nav-simplify

With Autonomous Completion

Comparison Table

Examples

Example 1: Simple Fix (Direct Execution)

Example 2: Component Creation (Skill Defers)

Example 3: Refactoring (Task Mode Active)

Example 4: With Loop Mode

Error Handling

Success Criteria

Verification Checklist