tlc-claude-code 2.2.0 → 2.2.1

package/.claude/commands/tlc/build.md

@@ -166,7 +166,7 @@ Senior engineers know when rules don't apply:
 
 This is the core TLC command. Tests before code, one task at a time.
 
-**Overdrive Mode (Opus 4.6):** When tasks are independent, TLC auto-detects and offers parallel execution with multiple agents. Agents are assigned models based on task complexity (opus for heavy, sonnet for standard, haiku for light). Failed agents can be resumed. No arbitrary cap on agent count.
+**Parallel by default:** When tasks are independent, TLC auto-detects and runs them in parallel. Multiple providers (Claude + Codex) get their own git worktrees and tmux panes. Single provider uses in-process agents. No flags needed — it just works.
 
 ## Usage
 
@@ -185,74 +185,80 @@ This is the core TLC command. Tests before code, one task at a time.
 
 Read all `.planning/phases/{phase}-*-PLAN.md` files for this phase.
 
-### Step 1a: Overdrive Detection (Auto-Parallel, Opus 4.6)
+### Step 1a: Auto-Parallel Detection
 
-After loading plans, analyze task dependencies to determine if parallel execution is possible.
+After loading plans, analyze task dependencies and available providers to pick the best execution strategy automatically.
 
-**Check for dependencies:**
-```javascript
-// Patterns that indicate dependencies:
-// - "depends on task N"
-// - "after task N"
-// - "requires task N"
-// - "blocked by task N"
-// - "## Dependencies" section with task relationships
-```
-
-**Decision logic:**
+**Detection:**
 1. Parse all tasks from plan
-2. Look for dependency markers in task descriptions
-3. Check "## Dependencies" section if present
-4. Identify independent tasks (no dependencies)
-5. Estimate task complexity for model assignment (heavy/standard/light)
+2. Check "## Dependencies" section for task relationships
+3. Identify independent tasks (no unmet dependencies)
+4. Read `.tlc/.router-state.json` for available providers
+5. Check if tmux is available
 
-**If 2+ independent tasks found:**
-```
-🚀 Overdrive Mode Available (Opus 4.6)
+**Strategy selection (automatic, no flags needed):**
 
-Phase 3 has 4 independent tasks that can run in parallel:
-  - Task 1: Create user schema          [opus]   (heavy)
-  - Task 2: Add validation helpers      [sonnet] (standard)
-  - Task 3: Write migration scripts     [sonnet] (standard)
-  - Task 4: Create seed data            [haiku]  (light)
+| Condition | Strategy | What happens |
+|-----------|----------|--------------|
+| 2+ independent tasks, Claude + Codex available, tmux available | **Worktree + Tmux** | Each task gets own git worktree + tmux pane. Claude and Codex work simultaneously. |
+| 2+ independent tasks, Claude + Codex available, no tmux | **Worktree + Background** | Same but without tmux visibility. |
+| 2+ independent tasks, single provider only | **In-process agents** | Agent tool spawns parallel sub-agents (sonnet/haiku by complexity). |
+| All tasks have dependencies | **Sequential** | One task at a time, in dependency order. |
+| 1 task only | **Sequential** | Just build it. |
 
-Recommended: 4 agents (one per independent task)
+**No prompt, no options menu.** TLC picks the best strategy and runs it. User sees:
 
-Options:
-1) Overdrive mode (parallel agents) [Recommended]
-2) Sequential mode (one task at a time)
-3) Let me pick which tasks to parallelize
 ```
+Phase 3 has 4 independent tasks.
+Providers: claude, codex (2 available)
+Strategy: worktree + tmux (parallel)
 
-**Model auto-selection per task complexity:**
-| Complexity | Model | When |
-|-----------|-------|------|
-| Heavy | opus | Architecture, multi-file features, security, auth, database |
-| Standard | sonnet | Normal implementation tasks (default) |
-| Light | haiku | Config, boilerplate, DTOs, enums, constants, seed data |
+  Task 1: Create user schema         → claude  [worktree-phase-3-task-1]
+  Task 2: Add validation helpers     → codex   [worktree-phase-3-task-2]
+  Task 3: Write migration scripts    → claude  [worktree-phase-3-task-3]
+  Task 4: Create seed data           → codex   [worktree-phase-3-task-4]
 
-Override with `--model sonnet` to force all agents to the same model.
+Launching...
+```
 
-**Router-aware model selection:**
-Before assigning models, check `.tlc.json` for `router.providers` and `router.capabilities`. If the project has a router config, respect it:
-- Use configured providers for their assigned capabilities (e.g., Gemini for design tasks)
-- Fall back to the complexity table above only when no router config exists
-- Run `/tlc:llm status` to see current routing
+Or for single provider:
+```
+Phase 3 has 4 independent tasks.
+Providers: claude (1 available)
+Strategy: in-process agents (parallel)
 
-**If tasks have dependencies (waterfall):**
+  Task 1: Create user schema         → opus   (heavy)
+  Task 2: Add validation helpers     → sonnet (standard)
+  Task 3: Write migration scripts    → sonnet (standard)
+  Task 4: Create seed data           → haiku  (light)
+
+Launching...
 ```
-📋 Sequential Mode
 
+Or for waterfall:
+```
 Phase 3 tasks have dependencies:
   Task 2 depends on Task 1
   Task 3 depends on Task 2
 
-Running in sequential order.
+Strategy: sequential
+
+Starting Task 1...
 ```
 
-### Step 1b: Execute Overdrive (if selected) — Opus 4.6 Multi-Agent
+**Model auto-selection (in-process agent mode):**
+| Complexity | Model | When |
+|-----------|-------|------|
+| Heavy | opus | Architecture, multi-file features, security, auth, database |
+| Standard | sonnet | Normal implementation tasks (default) |
+| Light | haiku | Config, boilerplate, DTOs, enums, constants, seed data |
+
+**Provider round-robin (worktree mode):**
+Tasks alternate between available providers. If Claude + Codex are both available, odd tasks go to Claude, even to Codex. Respects router state — never dispatches to unavailable providers.
+
+### Step 1b: Execute Parallel Build
 
-When overdrive mode is selected, spawn parallel agents with per-task model selection:
+**Worktree + Tmux mode** (multi-provider):
 
 ```
 🚀 Launching Overdrive Mode (Opus 4.6)
@@ -962,14 +968,13 @@ Phase 2 complete. Ready for /tlc:verify 2
 | `--agents N` | Limit parallel agents to N (default: one per independent task) |
 | `--model MODEL` | Force all agents to use a specific model (opus, sonnet, haiku) |
 | `--max-turns N` | Limit each agent's execution to N turns (default: 50) |
-| `--parallel` | Multi-agent with git worktrees + tmux. Each task gets its own worktree and tmux pane. Claude and Codex work simultaneously. |
-| `--parallel --providers claude,codex` | Force specific providers for parallel mode |
-| `--parallel --no-tmux` | Parallel worktrees but without tmux visibility (background processes) |
-| `--parallel --dry-run` | Preview execution plan: show DAG, task assignments, provider routing |
+| `--providers claude,codex` | Force specific providers (default: auto-detect from router state) |
+| `--no-tmux` | Skip tmux panes, run worktree agents in background |
+| `--dry-run` | Preview execution plan without running (show DAG, task assignments) |
 
-## When Overdrive is NOT Used
+## When Parallel is NOT Used
 
-Overdrive auto-detects but won't activate when:
+Parallel is the default but won't activate when:
 - Only 1 task in phase
 - All tasks have dependencies (waterfall)
 - Tasks modify the same files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc-claude-code": "./bin/install.js",