VC Router - ULTIMATE EDITION

Core Philosophy

code

┌─────────────────────────────────────────────────────────────┐
│                   INTELLIGENT ROUTING                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. UNDERSTAND INTENT - Not just keywords                   │
│  2. SELECT BEST FIT - With confidence scoring               │
│  3. COMPOSE IF NEEDED - Chain skills intelligently          │
│  4. FALLBACK GRACEFULLY - Always have a path forward        │
│  5. LEARN FROM RESULTS - Improve routing over time          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Quick Invoke

Any of these activate the router:

•use vc-router: <goal>
•just do this: <goal>
•vc go <goal> (router mode)
•vc finish <goal> (force end-to-end)
•vcf: <goal> → routes to vc-phase-loop
•use vcf: <goal> → same as above (explicit invocation; Codex may output this form)

The Routing Engine

Step 1: Intent Classification

code

┌─────────────────────────────────────────────────────────────┐
│              INTENT CLASSIFICATION                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Extract from user request:                                 │
│  ├─ ACTION: What to do (build, create, fix, analyze...)    │
│  ├─ DOMAIN: What area (frontend, backend, docs, git...)    │
│  ├─ OUTPUT: Expected result (file, component, document...) │
│  └─ SCOPE: Size of task (single file, multi-file, system)  │
│                                                             │
│  Example: "Build a login page with OAuth"                   │
│  ├─ ACTION: build                                           │
│  ├─ DOMAIN: frontend                                        │
│  ├─ OUTPUT: page/component                                  │
│  └─ SCOPE: multi-file                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Step 1.5: Sub-Agent Assisted Routing (Optional)

If the request is large, ambiguous, or multi-domain, spawn 1–2 sub-agents to parallelize:

•Repo scan (recommended preset: explorer): locate relevant code/config and constraints
•Risk/validation scan (recommended preset: worker): identify security/ops risks, tests, and verification strategy

Rules:

•Keep it lightweight (max 2) and timeboxed.
•Sub-agents report findings only; main agent makes routing decision.
•If sub-agents aren’t available, continue without them.
•Prefer send_input with interrupt if an agent goes off-track; always close_agent when done.

Step 2: Skill Matching

code

┌─────────────────────────────────────────────────────────────┐
│              SKILL MATCHING MATRIX                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  VC-ONLY DISTRIBUTION:                                      │
│  ├─ "finish", "hands off" → vc-phase-loop                   │
│  ├─ Multi-step, open-ended → vc-phase-loop                  │
│  └─ Everything else → vc-phase-loop                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Step 3: Confidence Scoring

code

For each potential skill match, calculate confidence:

HIGH (80-100%): Clear keyword match + domain match
  → Route immediately

MEDIUM (50-79%): Partial match, some ambiguity
  → Select best fit, proceed with note

LOW (<50%): Weak match, unclear intent
  → Use vc-phase-loop as safe default

Skill Composition

This repo intentionally ships only vc* skills, so there are no additional bundled skills to chain.

If the request is multi-domain or open-ended, route to vc-phase-loop and run the full end-to-end workflow.

Fallback Strategy

When No Skill Matches

code

┌─────────────────────────────────────────────────────────────┐
│              FALLBACK HIERARCHY                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Level 1: Route to vc-phase-loop (universal fallback)       │
│                                                             │
│  NEVER: "I don't know which skill to use"                   │
│  ALWAYS: Route to vc-phase-loop as universal fallback     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Error Recovery

When Selected Skill Fails

code

Skill Failed
    ↓
Analyze failure reason
    ↓
Option 1: Retry same skill with adjusted approach
    ↓
Option 2: Try alternative skill from same category
    ↓
Option 3: Decompose task and route parts separately
    ↓
Option 4: Escalate to vc-phase-loop for full autonomy
    ↓
NEVER: Stop and report failure without attempting recovery

VC Defaults

For ALL routing decisions:

•Prefer fast iteration over perfection
•Make safe default choices without pausing
•Ask questions only after delivering initial result
•Keep outputs concise and actionable
•Assume user is non-technical

VC Finish Mode

When user triggers "vc finish" explicitly:

•ALWAYS route to vc-phase-loop
•Enable full autonomous execution
•No mid-stream questions
•Complete end-to-end
•Provide completion proof

Triggers:

•"vc finish", "finish it", "take it to the end"
•"plan and execute", "hands off"

Execution Rules

•Single Pass Classification - Decide quickly, don't overthink
•Best Fit Selection - If uncertain, choose narrower scope skill
•Immediate Execution - Route and run, collect questions for end
•Safe Defaults - vc-phase-loop handles anything
•No Dead Ends - Always have a path forward

Routing Decision Log

For transparency, log routing decisions:

markdown

## Routing Decision

Request: "Build a login page"
Classification:
  - Action: build
  - Domain: frontend
  - Output: page
  - Scope: multi-file

Candidates:
  1. vc-phase-loop (100% match)

Selected: vc-phase-loop
Reason: vc-only distribution; use the end-to-end engine as the default.

Proceeding with execution...

The Router Promise

code

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│   YOU SAY WHAT YOU WANT.                                    │
│                                                             │
│   WE UNDERSTAND YOUR INTENT.                                │
│   WE SELECT THE BEST SKILL.                                 │
│   WE COMPOSE IF NEEDED.                                     │
│   WE RECOVER FROM FAILURES.                                 │
│   WE ALWAYS HAVE A PATH FORWARD.                            │
│                                                             │
│   NO "I DON'T KNOW" - ALWAYS ROUTE.                         │
│   NO DEAD ENDS - ALWAYS FALLBACK.                           │
│   NO FAILURES - ALWAYS RECOVER.                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘