tlc-claude-code 1.6.1 → 1.6.2

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

@@ -166,13 +166,17 @@ Senior engineers know when rules don't apply:
 
 This is the core TLC command. Tests before code, one task at a time.
 
-**Overdrive Mode:** When tasks are independent, TLC auto-detects and offers parallel execution with multiple agents.
+**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.
 
 ## Usage
 
 ```
 /tlc:build <phase_number>
-/tlc:build <phase_number> --sequential   # Force sequential mode
+/tlc:build <phase_number> --sequential      # Force sequential mode
+/tlc:build <phase_number> --model sonnet    # Force all agents to use sonnet
+/tlc:build <phase_number> --model haiku     # Force all agents to use haiku (fast/cheap)
+/tlc:build <phase_number> --max-turns 30    # Limit agent execution length
+/tlc:build <phase_number> --agents 5        # Limit parallel agents to 5
 ```
 
 ## Process
@@ -181,7 +185,7 @@ 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)
+### Step 1a: Overdrive Detection (Auto-Parallel, Opus 4.6)
 
 After loading plans, analyze task dependencies to determine if parallel execution is possible.
 
@@ -200,18 +204,19 @@ After loading plans, analyze task dependencies to determine if parallel executio
 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)
 
 **If 2+ independent tasks found:**
 ```
-🚀 Overdrive Mode Available
+🚀 Overdrive Mode Available (Opus 4.6)
 
 Phase 3 has 4 independent tasks that can run in parallel:
-  - Task 1: Create user schema
-  - Task 2: Add validation helpers
-  - Task 3: Write migration scripts
-  - Task 4: Create seed data
+  - 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)
 
-Recommended: 3 agents (optimal parallelism)
+Recommended: 4 agents (one per independent task)
 
 Options:
 1) Overdrive mode (parallel agents) [Recommended]
@@ -219,6 +224,15 @@ Options:
 3) Let me pick which tasks to parallelize
 ```
 
+**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 |
+
+Override with `--model sonnet` to force all agents to the same model.
+
 **If tasks have dependencies (waterfall):**
 ```
 📋 Sequential Mode
@@ -230,62 +244,87 @@ Phase 3 tasks have dependencies:
 Running in sequential order.
 ```
 
-### Step 1b: Execute Overdrive (if selected)
+### Step 1b: Execute Overdrive (if selected) — Opus 4.6 Multi-Agent
 
-When overdrive mode is selected, spawn parallel agents:
+When overdrive mode is selected, spawn parallel agents with per-task model selection:
 
 ```
-🚀 Launching Overdrive Mode
+🚀 Launching Overdrive Mode (Opus 4.6)
 
-Spawning 3 agents in parallel...
+Spawning 4 agents in parallel...
 
-Agent 1: Task 1 - Create user schema
-Agent 2: Task 2 - Add validation helpers
-Agent 3: Task 3 - Write migration scripts
+Agent 1: Task 1 - Create user schema          [opus]
+Agent 2: Task 2 - Add validation helpers      [sonnet]
+Agent 3: Task 3 - Write migration scripts     [sonnet]
+Agent 4: Task 4 - Create seed data            [haiku]
 
 [All agents spawned - working in background]
-[Task 4 queued for next available agent]
 ```
 
 **Agent execution rules:**
-- Each agent gets one task
+- One agent per independent task (no arbitrary cap)
+- Model assigned per task complexity (override with `--model`)
 - Agents work autonomously (no confirmation prompts)
 - Each agent commits after completing their task
-- When an agent finishes, it can pick up queued tasks
 - All agents follow test-first methodology
+- `max_turns` limits execution length (default: 50, override with `--max-turns`)
 
 **CRITICAL: Spawn all agents in a SINGLE message using multiple Task tool calls.**
 
 ```
-Task(description="Agent 1: Task 1", prompt="...", subagent_type="general-purpose", run_in_background=true)
-Task(description="Agent 2: Task 2", prompt="...", subagent_type="general-purpose", run_in_background=true)
-Task(description="Agent 3: Task 3", prompt="...", subagent_type="general-purpose", run_in_background=true)
+Task(description="Agent 1: Task 1", prompt="...", subagent_type="general-purpose", model="opus", max_turns=50, run_in_background=true)
+Task(description="Agent 2: Task 2", prompt="...", subagent_type="general-purpose", model="sonnet", max_turns=50, run_in_background=true)
+Task(description="Agent 3: Task 3", prompt="...", subagent_type="general-purpose", model="sonnet", max_turns=50, run_in_background=true)
+Task(description="Agent 4: Task 4", prompt="...", subagent_type="general-purpose", model="haiku", max_turns=50, run_in_background=true)
 ```
 
-**Live Progress Monitoring:**
+**Live Progress Monitoring (TaskOutput):**
 
-While agents run in background, show live status using the AgentProgressMonitor:
+Use `TaskOutput` with `block=false` for non-blocking progress checks:
+
+```
+TaskOutput(task_id="AGENT_ID_1", block=false, timeout=5000)
+TaskOutput(task_id="AGENT_ID_2", block=false, timeout=5000)
+```
+
+Or use the AgentProgressMonitor for formatted status:
 
 ```bash
 node -e "
 const { AgentProgressMonitor } = require('./server/lib/agent-progress-monitor.js');
 const monitor = new AgentProgressMonitor('/tmp/claude-1000/-mnt-c-Code-TLC/tasks');
-const agents = ['AGENT_ID_1', 'AGENT_ID_2', 'AGENT_ID_3'];
+const agents = ['AGENT_ID_1', 'AGENT_ID_2', 'AGENT_ID_3', 'AGENT_ID_4'];
 console.log(monitor.formatTable(agents));
 "
 ```
 
 Display format:
 ```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🚀 OVERDRIVE STATUS
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-| Agent | Task | Tests | Phase |
-|-------|------|-------|-------|
-| a1b2c3 | README Generator | 29 ✓ | committed |
-| d4e5f6 | Flow Diagrams | 18 ✓ | implementing |
-| g7h8i9 | ADR Generator | - | writing-tests |
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🚀 OVERDRIVE STATUS (Opus 4.6)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+| Agent | Task | Model | Tests | Phase |
+|-------|------|-------|-------|-------|
+| a1b2c3 | User Schema | opus | 29 ✓ | committed |
+| d4e5f6 | Validation | sonnet | 18 ✓ | implementing |
+| g7h8i9 | Migrations | sonnet | - | writing-tests |
+| j0k1l2 | Seed Data | haiku | 5 ✓ | committed |
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**Handling Agent Failures (Opus 4.6 Resumption):**
+
+If an agent fails or gets stuck:
+
+```
+# Check if agent is stuck (non-blocking)
+TaskOutput(task_id="AGENT_ID", block=false, timeout=5000)
+
+# Cancel a stuck agent
+TaskStop(task_id="AGENT_ID")
+
+# Resume a failed agent from where it left off (full context preserved)
+Task(resume="AGENT_ID", prompt="Continue from where you left off. Fix any errors and complete the task.")
 ```
 
 **Show status automatically:**
@@ -799,7 +838,7 @@ Writing tests for Task 2: Validation...
 Phase 1 complete. Ready for /tlc:verify 1
 ```
 
-### Overdrive Mode (Independent Tasks)
+### Overdrive Mode (Independent Tasks, Opus 4.6)
 
 ```
 User: /tlc:build 2
@@ -807,15 +846,15 @@ User: /tlc:build 2
 Claude: Loading phase 2 plans...
 Found: 2-PLAN.md (4 tasks)
 
-🚀 Overdrive Mode Available
+🚀 Overdrive Mode Available (Opus 4.6)
 
 Phase 2 has 4 independent tasks:
-  - Task 1: Create API routes
-  - Task 2: Add input validation
-  - Task 3: Write error handlers
-  - Task 4: Add rate limiting
+  - Task 1: Create API routes         [sonnet] (standard)
+  - Task 2: Add input validation      [sonnet] (standard)
+  - Task 3: Write error handlers      [sonnet] (standard)
+  - Task 4: Add rate limiting config  [haiku]  (light)
 
-Recommended: 3 agents
+Recommended: 4 agents (one per task)
 
 Options:
 1) Overdrive mode (parallel) [Recommended]
@@ -824,21 +863,20 @@ Options:
 
 User: 1
 
-Claude: 🚀 Launching Overdrive Mode
+Claude: 🚀 Launching Overdrive Mode (Opus 4.6)
 
-Spawning 3 agents...
-[Agent 1] Task 1: Create API routes - STARTED
-[Agent 2] Task 2: Add input validation - STARTED
-[Agent 3] Task 3: Write error handlers - STARTED
-[Queued] Task 4: Add rate limiting
+Spawning 4 agents...
+[Agent 1] Task 1: Create API routes        [sonnet] - STARTED
+[Agent 2] Task 2: Add input validation     [sonnet] - STARTED
+[Agent 3] Task 3: Write error handlers     [sonnet] - STARTED
+[Agent 4] Task 4: Add rate limiting config [haiku]  - STARTED
 
 ... agents working in background ...
 
-[Agent 2] ✅ Task 2 complete (3 commits)
-[Agent 2] Task 4: Add rate limiting - STARTED
-[Agent 1] ✅ Task 1 complete (4 commits)
-[Agent 3] ✅ Task 3 complete (2 commits)
-[Agent 2] ✅ Task 4 complete (2 commits)
+[Agent 4] ✅ Task 4 complete (1 commit)   [haiku - fast]
+[Agent 2] ✅ Task 2 complete (3 commits)  [sonnet]
+[Agent 1] ✅ Task 1 complete (4 commits)  [sonnet]
+[Agent 3] ✅ Task 3 complete (2 commits)  [sonnet]
 
 All agents complete. Running full test suite...
 ✅ 24 tests passing
@@ -863,18 +901,23 @@ Phase 2 complete. Ready for /tlc:verify 2
 - Suggest running `/tlc:build {phase}` again to retry
 - Or manually fix and run `/tlc:status` to verify
 
-**Overdrive mode issues:**
-- Agent stuck → Check with `TaskOutput` tool
+**Overdrive mode issues (Opus 4.6):**
+- Agent stuck → Check with `TaskOutput(task_id, block=false)`, cancel with `TaskStop(task_id)`
+- Agent failed → Resume with `Task(resume=agent_id)` to continue from where it left off
 - Merge conflicts → Agents working on same files (rare if tasks are truly independent)
-- One agent failed → Other agents continue; fix failed task manually
+- One agent failed → Other agents continue; resume failed agent or fix manually
 - Want sequential instead → Use `--sequential` flag: `/tlc:build 2 --sequential`
+- Cost too high → Use `--model haiku` to force all agents to haiku
+- Agent running too long → Use `--max-turns 30` to limit execution
 
 ## Flags
 
 | Flag | Description |
 |------|-------------|
 | `--sequential` | Force sequential execution even if tasks are independent |
-| `--agents N` | Set max parallel agents (default: 3, max: 10) |
+| `--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) |
 
 ## When Overdrive is NOT Used
 

package/.claude/commands/tlc/llm.md

@@ -61,13 +61,13 @@ Add to `.tlc.json`:
       "claude": {
         "type": "cli",
         "command": "claude",
-        "model": "claude-4-opus",
+        "model": "claude-opus-4-6",
         "capabilities": ["review", "code-gen", "refactor"]
       },
       "codex": {
         "type": "cli",
         "command": "codex",
-        "model": "gpt-5.2",
+        "model": "gpt-5.3-codex",
         "capabilities": ["review", "code-gen"]
       },
       "gemini": {
@@ -89,9 +89,9 @@ Add to `.tlc.json`:
 
 ## Supported Models
 
-**Claude:** claude-4-opus, claude-4-sonnet, claude-3.5-sonnet, claude-3-opus, claude-3-sonnet, claude-3-haiku
+**Claude:** claude-opus-4-6, claude-sonnet-4-5, claude-4-opus, claude-4-sonnet, claude-3.5-sonnet, claude-3-opus, claude-3-sonnet, claude-3-haiku
 
-**OpenAI/Codex:** gpt-5.2, gpt-5, gpt-4o, gpt-4o-mini, gpt-4-turbo, o3, o3-mini, o1, o1-mini, o1-pro
+**OpenAI/Codex:** gpt-5.3-codex, gpt-5.2, gpt-5, gpt-4o, gpt-4o-mini, gpt-4-turbo, o3, o3-mini, o1, o1-mini, o1-pro
 
 **Gemini:** gemini-3-preview, gemini-3, gemini-2.5-pro, gemini-2.0-flash, gemini-2.0-flash-thinking, gemini-1.5-pro
 

package/.claude/commands/tlc/sync.md

@@ -229,7 +229,7 @@ Create `.tlc.json` with all settings:
     "autofix": true,
     "edgeCases": true,
     "prAutoReview": true,
-    "maxAgents": 10
+    "maxAgents": "auto"
   }
 }
 ```

package/CLAUDE.md

@@ -89,6 +89,17 @@ All implementation follows **Red → Green → Refactor**:
 
 Tests are written BEFORE implementation, not after.
 
+## Context Management
+
+**Use multiple sessions/agents for large tasks.** When working in overdrive mode or across workspaces:
+- Use the `Task` tool to spawn sub-agents for independent work (research, testing, building)
+- Keep the main conversation focused on orchestration and decisions
+- Delegate file-heavy operations (reading many files, running test suites) to sub-agents
+- This prevents context window overflow, which causes crashes and lost work
+- Especially critical in workspace mode where multiple repos are involved
+
+**Signs you need to delegate:** If you've read 15+ files, run 10+ commands, or the conversation is getting long — spawn a sub-agent for the next chunk of work.
+
 ## After TLC Updates
 
 If TLC command files are updated, re-read them before executing. Check version in `package.json`.

package/README.md

@@ -72,7 +72,7 @@ Or use `/tlc` for the full dashboard.
 ### For Solo Developers
 
 - **Test-first by default** — Claude writes tests before code
-- **Auto-parallelization** — Up to 10 agents run independent tasks simultaneously
+- **Auto-parallelization** — Agents run independent tasks simultaneously with per-task model selection (Opus 4.6)
 - **`/tlc:next`** — One command to progress. No decisions needed.
 - **Smart dashboard** — See progress, run actions
 - **Coverage gaps** — Find and fix untested code
@@ -103,7 +103,7 @@ Or use `/tlc` for the full dashboard.
 | `/tlc` | Smart dashboard — full status view |
 | `/tlc:new-project` | Start new project with roadmap |
 | `/tlc:init` | Add TLC to existing codebase |
-| `/tlc:build` | Write tests → implement (auto-parallelizes up to 10 agents) |
+| `/tlc:build` | Write tests → implement (auto-parallelizes with model selection) |
 | `/tlc:coverage` | Find and fix untested code |
 | `/tlc:quality` | Test quality scoring |
 | `/tlc:autofix` | Auto-repair failing tests |

package/docker-compose.dev.yml

@@ -121,6 +121,26 @@ services:
       - app
     restart: on-failure
 
+  # TLC Dashboard Web (built from dashboard-web, serves static files via nginx)
+  dashboard-web:
+    build:
+      context: ./dashboard-web
+      dockerfile: Dockerfile
+    container_name: tlc-${COMPOSE_PROJECT_NAME:-dev}-dashboard-web
+    ports:
+      - "${DASHBOARD_WEB_PORT:-3002}:80"
+    environment:
+      - API_URL=http://dashboard:3147
+    depends_on:
+      - dashboard
+    restart: on-failure
+    healthcheck:
+      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:80/health"]
+      interval: 30s
+      timeout: 3s
+      start_period: 5s
+      retries: 3
+
   # Playwright E2E Tests (optional - starts on demand)
   playwright:
     image: mcr.microsoft.com/playwright:v1.40.0-jammy

package/package.json

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

package/server/index.js

@@ -1,5 +1,14 @@
 #!/usr/bin/env node
 
+// Suppress punycode deprecation from upstream deps (http-proxy-middleware, ws)
+const originalEmit = process.emit;
+process.emit = function (event, error) {
+  if (event === 'warning' && error?.name === 'DeprecationWarning' && error?.message?.includes('punycode')) {
+    return false;
+  }
+  return originalEmit.apply(process, arguments);
+};
+
 const express = require('express');
 const { createServer } = require('http');
 const { WebSocketServer } = require('ws');
@@ -50,6 +59,7 @@ let appProcess = null;
 let appPort = 3000;
 let wsClients = new Set();
 const logs = { app: [], test: [], git: [] };
+const commandHistory = [];
 
 // Create Express app
 const app = express();
@@ -944,6 +954,177 @@ app.post('/api/test', (req, res) => {
   res.json({ success: true });
 });
 
+// ============================================
+// Command Execution API
+// ============================================
+
+// GET /api/commands/history - Return command execution history
+app.get('/api/commands/history', (req, res) => {
+  res.json({ success: true, history: commandHistory });
+});
+
+// POST /api/commands/:command - Execute a TLC command
+app.post('/api/commands/:command', (req, res) => {
+  const command = req.params.command;
+  const { args } = req.body || {};
+
+  // Whitelist of allowed TLC commands
+  const allowedCommands = ['plan', 'build', 'verify', 'bug', 'claim', 'release', 'who', 'progress'];
+  if (!allowedCommands.includes(command)) {
+    return res.status(400).json({ success: false, error: `Unknown command: ${command}. Allowed: ${allowedCommands.join(', ')}` });
+  }
+
+  const entry = {
+    id: `cmd-${Date.now()}`,
+    command,
+    args: args || null,
+    status: 'running',
+    startedAt: new Date().toISOString(),
+    output: '',
+  };
+  commandHistory.push(entry);
+  if (commandHistory.length > 100) commandHistory.shift();
+
+  addLog('app', `Executing command: tlc:${command}${args ? ' ' + args : ''}`, 'info');
+  broadcast('command-started', { id: entry.id, command });
+
+  // Build the CLI command
+  const cliArgs = ['tlc', command];
+  if (args) cliArgs.push(args);
+  const fullCmd = `npx ${cliArgs.join(' ')}`;
+
+  const cmdProcess = spawn('npx', cliArgs.slice(1), {
+    cwd: PROJECT_DIR,
+    env: { ...process.env },
+    shell: true,
+  });
+
+  let output = '';
+
+  cmdProcess.stdout.on('data', (data) => {
+    const text = data.toString();
+    output += text;
+    broadcast('command-output', { id: entry.id, data: text, stream: 'stdout' });
+  });
+
+  cmdProcess.stderr.on('data', (data) => {
+    const text = data.toString();
+    output += text;
+    broadcast('command-output', { id: entry.id, data: text, stream: 'stderr' });
+  });
+
+  cmdProcess.on('exit', (code) => {
+    entry.status = code === 0 ? 'completed' : 'failed';
+    entry.exitCode = code;
+    entry.output = output;
+    entry.completedAt = new Date().toISOString();
+    broadcast('command-completed', { id: entry.id, exitCode: code });
+    addLog('app', `Command tlc:${command} ${code === 0 ? 'completed' : 'failed'} (exit ${code})`, code === 0 ? 'info' : 'error');
+  });
+
+  cmdProcess.on('error', (err) => {
+    entry.status = 'failed';
+    entry.output = err.message;
+    entry.completedAt = new Date().toISOString();
+    broadcast('command-completed', { id: entry.id, error: err.message });
+    addLog('app', `Command tlc:${command} error: ${err.message}`, 'error');
+  });
+
+  res.json({ success: true, id: entry.id, command, message: `Command tlc:${command} started` });
+});
+
+// ============================================
+// Dashboard Completion API (Phase 62)
+// ============================================
+
+// GET /api/config - Read .tlc.json configuration
+app.get('/api/config', (req, res) => {
+  try {
+    const tlcPath = path.join(PROJECT_DIR, '.tlc.json');
+    if (!fs.existsSync(tlcPath)) {
+      return res.json({});
+    }
+    const config = JSON.parse(fs.readFileSync(tlcPath, 'utf-8'));
+    res.json(config);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// PUT /api/config - Write .tlc.json configuration
+app.put('/api/config', (req, res) => {
+  try {
+    const tlcPath = path.join(PROJECT_DIR, '.tlc.json');
+    const config = req.body;
+    if (!config || typeof config !== 'object') {
+      return res.status(400).json({ error: 'Invalid config object' });
+    }
+    fs.writeFileSync(tlcPath, JSON.stringify(config, null, 2));
+    res.json({ success: true, config });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// GET /api/health - System health status
+app.get('/api/health', (req, res) => {
+  const memUsage = process.memoryUsage();
+  res.json({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+    memory: {
+      rss: memUsage.rss,
+      heapUsed: memUsage.heapUsed,
+      heapTotal: memUsage.heapTotal,
+    },
+    appRunning: appProcess !== null,
+    appPort,
+  });
+});
+
+// GET /api/tasks/:id - Get single task by ID
+app.get('/api/tasks/:id', (req, res) => {
+  const plan = parsePlan(PROJECT_DIR);
+  const task = (plan.tasks || []).find(t => t.id === req.params.id);
+  if (!task) {
+    return res.status(404).json({ error: 'Task not found' });
+  }
+  res.json(task);
+});
+
+// PATCH /api/tasks/:id - Update task status/owner
+app.patch('/api/tasks/:id', (req, res) => {
+  const plan = parsePlan(PROJECT_DIR);
+  const task = (plan.tasks || []).find(t => t.id === req.params.id);
+  if (!task) {
+    return res.status(404).json({ error: 'Task not found' });
+  }
+  const updates = req.body;
+  const updated = { ...task, ...updates };
+  broadcast('task-update', updated);
+  addLog('app', `Task ${req.params.id} updated`, 'info');
+  res.json(updated);
+});
+
+// DELETE /api/tasks/:id - Delete task
+app.delete('/api/tasks/:id', (req, res) => {
+  broadcast('task-update', { id: req.params.id, deleted: true });
+  addLog('app', `Task ${req.params.id} deleted`, 'info');
+  res.status(204).send();
+});
+
+// DELETE /api/logs/:type - Clear logs by type
+app.delete('/api/logs/:type', (req, res) => {
+  const type = req.params.type;
+  if (logs[type]) {
+    logs[type] = [];
+    res.json({ success: true });
+  } else {
+    res.status(404).json({ error: 'Unknown log type' });
+  }
+});
+
 // ============================================
 // Agent Registry API (Phase 32)
 // ============================================
@@ -1014,6 +1195,37 @@ app.get('/api/agents/:id', (req, res) => {
   }
 });
 
+// Stop a running agent
+app.post('/api/agents/:id/stop', (req, res) => {
+  try {
+    const registry = getAgentRegistry();
+    const agent = registry.getAgent(req.params.id);
+    if (!agent) {
+      return res.status(404).json({ success: false, error: 'Agent not found' });
+    }
+
+    // Transition state to stopped
+    if (agent.stateMachine) {
+      const currentState = agent.stateMachine.getState();
+      if (currentState === 'stopped' || currentState === 'completed') {
+        return res.status(400).json({ success: false, error: `Agent is already ${currentState}` });
+      }
+      const result = agent.stateMachine.transition('stopped', { reason: req.body.reason || 'Stopped via API' });
+      if (!result.success) {
+        // If formal transition fails, force the state
+        agent.stateMachine.forceState('stopped', { reason: req.body.reason || 'Force stopped via API' });
+      }
+    }
+
+    broadcast('agent-updated', formatAgent(agent));
+    addLog('app', `Agent ${agent.name || req.params.id} stopped`, 'info');
+
+    res.json({ success: true, agent: formatAgent(agent) });
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
 // Register new agent
 app.post('/api/agents', (req, res) => {
   try {

package/server/lib/adapters/claude-adapter.js

@@ -5,11 +5,11 @@
 
 const { BaseAdapter } = require('./base-adapter.js');
 
-// Latest model: claude-opus-4-5-20251101 (Claude Opus 4.5)
-const CLAUDE_MODEL = 'claude-opus-4-5-20251101';
+// Latest model: claude-opus-4-6-20260205 (Claude Opus 4.6)
+const CLAUDE_MODEL = 'claude-opus-4-6-20260205';
 
 const CLAUDE_PRICING = {
-  // Pricing per 1M tokens (Claude Opus 4.5)
+  // Pricing per 1M tokens (Claude Opus 4.6)
   inputPerMillion: 15.00,
   outputPerMillion: 75.00,
 };

package/server/lib/adapters/claude-adapter.test.js

@@ -166,7 +166,7 @@ describe('ClaudeAdapter', () => {
   });
 
   describe('CLAUDE_PRICING', () => {
-    it('exports default pricing for Opus 4.5', () => {
+    it('exports default pricing for Opus 4.6', () => {
       expect(CLAUDE_PRICING.inputPerMillion).toBe(15.00);
       expect(CLAUDE_PRICING.outputPerMillion).toBe(75.00);
     });
@@ -174,7 +174,7 @@ describe('ClaudeAdapter', () => {
 
   describe('CLAUDE_MODEL', () => {
     it('exports latest model identifier', () => {
-      expect(CLAUDE_MODEL).toBe('claude-opus-4-5-20251101');
+      expect(CLAUDE_MODEL).toBe('claude-opus-4-6-20260205');
     });
   });
 });

package/server/lib/adapters/openai-adapter.js

@@ -4,11 +4,11 @@
 
 const { BaseAdapter } = require('./base-adapter.js');
 
-// Latest model: o3 (January 2025)
-const OPENAI_MODEL = 'o3';
+// Latest model: gpt-5.3-codex (February 2026)
+const OPENAI_MODEL = 'gpt-5.3-codex';
 
 const OPENAI_PRICING = {
-  // Pricing per 1M tokens (o3)
+  // Pricing per 1M tokens (gpt-5.3-codex)
   inputPerMillion: 10.00,
   outputPerMillion: 40.00,
 };

package/server/lib/adapters/openai-adapter.test.js

@@ -214,13 +214,13 @@ describe('OpenAIAdapter', () => {
   });
 
   describe('exports', () => {
-    it('exports OPENAI_PRICING for o3', () => {
+    it('exports OPENAI_PRICING for gpt-5.3-codex', () => {
       expect(OPENAI_PRICING.inputPerMillion).toBe(10.00);
       expect(OPENAI_PRICING.outputPerMillion).toBe(40.00);
     });
 
     it('exports OPENAI_MODEL', () => {
-      expect(OPENAI_MODEL).toBe('o3');
+      expect(OPENAI_MODEL).toBe('gpt-5.3-codex');
     });
 
     it('exports DEFAULT_RATE_LIMITS', () => {

package/server/lib/model-pricing.js

@@ -19,6 +19,7 @@ const DEFAULT_PRICING = {
   'claude-4-opus': { inputPer1kTokens: 0.015, outputPer1kTokens: 0.075 },
   'claude-4-sonnet': { inputPer1kTokens: 0.003, outputPer1kTokens: 0.015 },
   'claude-opus-4-5-20251101': { inputPer1kTokens: 0.015, outputPer1kTokens: 0.075 },
+  'claude-opus-4-6-20260205': { inputPer1kTokens: 0.015, outputPer1kTokens: 0.075 },
 
   // OpenAI models
   'gpt-4': { inputPer1kTokens: 0.03, outputPer1kTokens: 0.06 },
@@ -33,6 +34,7 @@ const DEFAULT_PRICING = {
   'o1-pro': { inputPer1kTokens: 0.15, outputPer1kTokens: 0.6 },
   'o3': { inputPer1kTokens: 0.015, outputPer1kTokens: 0.06 },
   'o3-mini': { inputPer1kTokens: 0.0011, outputPer1kTokens: 0.0044 },
+  'gpt-5.3-codex': { inputPer1kTokens: 0.01, outputPer1kTokens: 0.04 },
 
   // DeepSeek models
   'deepseek-r1': { inputPer1kTokens: 0.00055, outputPer1kTokens: 0.00219 },

package/server/lib/overdrive-command.js

@@ -5,14 +5,99 @@
  * This is NOT a command - it's integrated into /tlc:build
  * When a plan has independent tasks, they run in parallel automatically.
  *
- * Default behavior: Auto-parallelize up to 10 agents based on task dependencies
+ * Default behavior: Auto-parallelize with one agent per independent task
  * Use --sequential to force one-at-a-time execution
  * Use --agents N to limit parallelism to specific number
+ *
+ * Opus 4.6 Multi-Agent Features:
+ * - Model selection per agent (opus/sonnet/haiku) based on task complexity
+ * - Agent resumption via `resume` parameter for retry/continuation
+ * - TaskOutput for non-blocking progress checks on background agents
+ * - TaskStop for cancelling stuck agents
+ * - Specialized agent types: general-purpose, Bash, Explore, Plan
+ * - max_turns to limit agent execution length
  */
 
 const fs = require('fs');
 const path = require('path');
 
+/**
+ * Valid subagent types for the Task tool (Opus 4.6)
+ */
+const AGENT_TYPES = {
+  BUILD: 'general-purpose',
+  SHELL: 'Bash',
+  EXPLORE: 'Explore',
+  PLAN: 'Plan',
+};
+
+/**
+ * Model tiers for cost/capability optimization (Opus 4.6)
+ * Agents are assigned models based on task complexity.
+ */
+const MODEL_TIERS = {
+  HEAVY: 'opus',    // Complex multi-file features, architectural work
+  STANDARD: 'sonnet', // Normal implementation tasks (default)
+  LIGHT: 'haiku',   // Simple tasks: config, boilerplate, single-file changes
+};
+
+/**
+ * Default max turns per agent to prevent runaway execution
+ */
+const DEFAULT_MAX_TURNS = 50;
+
+/**
+ * Estimate task complexity from its description/title
+ * @param {Object} task - Task with id and title
+ * @returns {'heavy'|'standard'|'light'} Complexity tier
+ */
+function estimateTaskComplexity(task) {
+  const title = (task.title || '').toLowerCase();
+
+  const heavyPatterns = [
+    /architect/i, /refactor/i, /migration/i, /redesign/i,
+    /integration/i, /multi.?file/i, /cross.?cutting/i,
+    /security/i, /auth/i, /database/i, /schema/i,
+  ];
+
+  const lightPatterns = [
+    /config/i, /boilerplate/i, /rename/i, /update.*readme/i,
+    /add.*comment/i, /fix.*typo/i, /seed/i, /constant/i,
+    /enum/i, /dto/i, /interface/i,
+  ];
+
+  if (heavyPatterns.some(p => p.test(title))) {
+    return 'heavy';
+  }
+  if (lightPatterns.some(p => p.test(title))) {
+    return 'light';
+  }
+  return 'standard';
+}
+
+/**
+ * Get model for a task based on its complexity
+ * @param {Object} task - Task object
+ * @param {string} [modelOverride] - Force a specific model
+ * @returns {string} Model name (opus, sonnet, haiku)
+ */
+function getModelForTask(task, modelOverride) {
+  if (modelOverride) {
+    return modelOverride;
+  }
+
+  const complexity = estimateTaskComplexity(task);
+
+  switch (complexity) {
+  case 'heavy':
+    return MODEL_TIERS.HEAVY;
+  case 'light':
+    return MODEL_TIERS.LIGHT;
+  default:
+    return MODEL_TIERS.STANDARD;
+  }
+}
+
 /**
  * Parse overdrive command arguments
  * @param {string} args - Command arguments
@@ -21,10 +106,12 @@ const path = require('path');
 function parseOverdriveArgs(args = '') {
   const options = {
     phase: null,
-    agents: 'auto', // Auto-detect based on independent tasks (up to 10)
+    agents: 'auto', // One agent per independent task
     mode: 'build', // build, test, fix
     dryRun: false,
     sequential: false,
+    model: null, // null = auto-select per task complexity
+    maxTurns: DEFAULT_MAX_TURNS,
   };
 
   const parts = args.trim().split(/\s+/).filter(Boolean);
@@ -35,9 +122,16 @@ function parseOverdriveArgs(args = '') {
     if (/^\d+$/.test(part)) {
       options.phase = parseInt(part, 10);
     } else if (part === '--agents' && parts[i + 1]) {
-      options.agents = Math.min(parseInt(parts[++i], 10), 10); // Max 10 agents
+      options.agents = parseInt(parts[++i], 10);
     } else if (part === '--mode' && parts[i + 1]) {
       options.mode = parts[++i];
+    } else if (part === '--model' && parts[i + 1]) {
+      const model = parts[++i].toLowerCase();
+      if (['opus', 'sonnet', 'haiku'].includes(model)) {
+        options.model = model;
+      }
+    } else if (part === '--max-turns' && parts[i + 1]) {
+      options.maxTurns = parseInt(parts[++i], 10);
     } else if (part === '--dry-run') {
       options.dryRun = true;
     } else if (part === '--sequential' || part === '-s') {
@@ -104,6 +198,18 @@ function loadPhaseTasks(projectDir, phase) {
   };
 }
 
+/**
+ * Determine the best agent type for a task
+ * @param {Object} task - Task object
+ * @param {string} mode - Execution mode (build, test, fix)
+ * @returns {string} Agent type for Task tool subagent_type
+ */
+function selectAgentType(task, mode) {
+  // Build/test/fix all require full general-purpose agent
+  // (reads files, writes code, runs tests, commits)
+  return AGENT_TYPES.BUILD;
+}
+
 /**
  * Generate agent prompts for parallel execution
  * @param {Array} tasks - Tasks to distribute
@@ -111,7 +217,7 @@ function loadPhaseTasks(projectDir, phase) {
  * @returns {Array} Agent prompts
  */
 function generateAgentPrompts(tasks, options = {}) {
-  const { mode = 'build', projectDir, phase } = options;
+  const { mode = 'build', projectDir, phase, model, maxTurns } = options;
 
   return tasks.map((task, index) => {
     const basePrompt = `You are Agent ${index + 1} working on Phase ${phase}.
@@ -142,7 +248,10 @@ GO. Execute now. No questions.`;
       taskId: task.id,
       taskTitle: task.title,
       prompt: basePrompt,
-      agentType: 'tlc-executor',
+      agentType: selectAgentType(task, mode),
+      model: getModelForTask(task, model),
+      maxTurns: maxTurns || DEFAULT_MAX_TURNS,
+      complexity: estimateTaskComplexity(task),
     };
   });
 }
@@ -171,7 +280,7 @@ function distributeTasks(tasks, agentCount) {
 function formatOverdrivePlan(plan) {
   const lines = [];
 
-  lines.push('# Overdrive Mode');
+  lines.push('# Overdrive Mode (Opus 4.6)');
   lines.push('');
   lines.push(`**Phase:** ${plan.phase}`);
   lines.push(`**Mode:** ${plan.mode}`);
@@ -184,16 +293,24 @@ function formatOverdrivePlan(plan) {
   plan.agentAssignments.forEach((assignment, idx) => {
     lines.push(`### Agent ${idx + 1}`);
     assignment.tasks.forEach(task => {
-      lines.push(`- Task ${task.id}: ${task.title}`);
+      const complexity = estimateTaskComplexity(task);
+      const model = getModelForTask(task, plan.modelOverride);
+      lines.push(`- Task ${task.id}: ${task.title} [${model}] (${complexity})`);
     });
     lines.push('');
   });
 
   lines.push('## Execution');
   lines.push('');
-  lines.push('All agents will be spawned simultaneously using Task tool.');
+  lines.push('All agents spawned simultaneously via Task tool (Opus 4.6 multi-agent).');
   lines.push('Each agent works independently until completion.');
   lines.push('');
+  lines.push('**Capabilities:**');
+  lines.push('- Model selection per task complexity (opus/sonnet/haiku)');
+  lines.push('- Agent resumption for failed tasks (resume parameter)');
+  lines.push('- Non-blocking progress checks (TaskOutput block=false)');
+  lines.push('- Agent cancellation (TaskStop) for stuck agents');
+  lines.push('');
   lines.push('**Rules enforced:**');
   lines.push('- No confirmation prompts');
   lines.push('- No "shall I continue" questions');
@@ -204,7 +321,8 @@ function formatOverdrivePlan(plan) {
 }
 
 /**
- * Generate Task tool calls for parallel execution
+ * Generate Task tool calls for parallel execution (Opus 4.6)
+ * Includes model selection, max_turns, and correct subagent_type.
  * @param {Array} prompts - Agent prompts
  * @returns {Array} Task tool call specifications
  */
@@ -216,6 +334,8 @@ function generateTaskCalls(prompts) {
       prompt: p.prompt,
       subagent_type: p.agentType,
       run_in_background: true,
+      model: p.model,
+      max_turns: p.maxTurns,
     },
   }));
 }
@@ -270,12 +390,12 @@ async function executeOverdriveCommand(args = '', context = {}) {
     };
   }
 
-  // Determine agent count: auto = max parallelism based on independent tasks
+  // Determine agent count: auto = one agent per independent task (no cap)
   let agentCount;
   if (options.sequential) {
     agentCount = 1;
   } else if (options.agents === 'auto') {
-    // Auto-detect: use as many agents as there are independent tasks (up to 10)
+    // Auto-detect: one agent per independent task, no arbitrary cap
     let planContent = '';
     try {
       planContent = fs.readFileSync(phaseInfo.planPath, 'utf-8');
@@ -285,7 +405,7 @@ async function executeOverdriveCommand(args = '', context = {}) {
     const depAnalysis = analyzeDependencies(planContent);
     const parallelAnalysis = canParallelize(availableTasks, depAnalysis);
     agentCount = parallelAnalysis.canParallelize
-      ? Math.min(parallelAnalysis.independentTasks.length, 10)
+      ? parallelAnalysis.independentTasks.length
       : 1;
   } else {
     agentCount = Math.min(options.agents, availableTasks.length);
@@ -293,7 +413,7 @@ async function executeOverdriveCommand(args = '', context = {}) {
 
   const taskGroups = distributeTasks(availableTasks, agentCount);
 
-  // Generate prompts
+  // Generate prompts with model selection and max turns
   const agentAssignments = taskGroups.map((tasks, idx) => ({
     agentId: idx + 1,
     tasks,
@@ -301,6 +421,8 @@ async function executeOverdriveCommand(args = '', context = {}) {
       mode: options.mode,
       projectDir,
       phase: options.phase,
+      model: options.model,
+      maxTurns: options.maxTurns,
     }),
   }));
 
@@ -310,6 +432,7 @@ async function executeOverdriveCommand(args = '', context = {}) {
     agentCount,
     totalTasks: availableTasks.length,
     agentAssignments,
+    modelOverride: options.model,
   };
 
   if (options.dryRun) {
@@ -331,7 +454,7 @@ async function executeOverdriveCommand(args = '', context = {}) {
     taskCalls,
     output: formatOverdrivePlan(plan),
     instructions: `
-EXECUTE NOW: Spawn ${agentCount} agents in parallel using the Task tool.
+EXECUTE NOW: Spawn ${agentCount} agents in parallel using the Task tool (Opus 4.6).
 
 ${taskCalls.map((tc, i) => `
 Agent ${i + 1}:
@@ -339,12 +462,18 @@ Task(
   description="${tc.params.description}",
   prompt="${tc.params.prompt.slice(0, 100)}...",
   subagent_type="${tc.params.subagent_type}",
+  model="${tc.params.model}",
+  max_turns=${tc.params.max_turns},
   run_in_background=true
 )
 `).join('\n')}
 
 CRITICAL: Call ALL Task tools in a SINGLE message to run them in parallel.
 Do NOT wait between spawns. Fire them all at once.
+
+MONITORING: Use TaskOutput(task_id, block=false) to check progress.
+STUCK AGENT: Use TaskStop(task_id) to cancel, then resume with Task(resume=agent_id).
+FAILED AGENT: Use Task(resume=agent_id) to continue from where it left off.
 `,
   };
 }
@@ -458,7 +587,7 @@ function canParallelize(tasks, depAnalysis) {
     canParallelize: true,
     independentTasks,
     dependentTasks: tasks.filter(t => dependentTasks.has(t.id)),
-    recommendedAgents: Math.min(independentTasks.length, 10), // Max 10 parallel agents
+    recommendedAgents: independentTasks.length, // One agent per independent task
   };
 }
 
@@ -543,4 +672,11 @@ module.exports = {
   canParallelize,
   shouldUseOverdrive,
   autoParallelize,
+  // Opus 4.6 multi-agent functions
+  estimateTaskComplexity,
+  getModelForTask,
+  selectAgentType,
+  AGENT_TYPES,
+  MODEL_TIERS,
+  DEFAULT_MAX_TURNS,
 };

package/server/lib/overdrive-command.test.js

@@ -9,6 +9,12 @@ import {
   canParallelize,
   shouldUseOverdrive,
   createOverdriveCommand,
+  estimateTaskComplexity,
+  getModelForTask,
+  selectAgentType,
+  AGENT_TYPES,
+  MODEL_TIERS,
+  DEFAULT_MAX_TURNS,
 } from './overdrive-command.js';
 
 describe('overdrive-command', () => {
@@ -21,6 +27,8 @@ describe('overdrive-command', () => {
       expect(options.mode).toBe('build');
       expect(options.dryRun).toBe(false);
       expect(options.sequential).toBe(false);
+      expect(options.model).toBeNull();
+      expect(options.maxTurns).toBe(DEFAULT_MAX_TURNS);
     });
 
     it('parses phase number', () => {
@@ -28,14 +36,14 @@ describe('overdrive-command', () => {
       expect(options.phase).toBe(5);
     });
 
-    it('parses --agents flag', () => {
+    it('parses --agents flag without cap', () => {
       const options = parseOverdriveArgs('--agents 4');
       expect(options.agents).toBe(4);
     });
 
-    it('caps agents at 10', () => {
+    it('allows agent count beyond 10', () => {
       const options = parseOverdriveArgs('--agents 15');
-      expect(options.agents).toBe(10);
+      expect(options.agents).toBe(15);
     });
 
     it('parses --mode flag', () => {
@@ -65,18 +73,35 @@ describe('overdrive-command', () => {
       expect(options.agents).toBe(1);
     });
 
-    it('parses multiple flags', () => {
-      const options = parseOverdriveArgs('5 --agents 2 --mode test --dry-run');
+    it('parses --model flag', () => {
+      expect(parseOverdriveArgs('--model opus').model).toBe('opus');
+      expect(parseOverdriveArgs('--model sonnet').model).toBe('sonnet');
+      expect(parseOverdriveArgs('--model haiku').model).toBe('haiku');
+    });
+
+    it('ignores invalid model values', () => {
+      expect(parseOverdriveArgs('--model gpt4').model).toBeNull();
+    });
+
+    it('parses --max-turns flag', () => {
+      const options = parseOverdriveArgs('--max-turns 30');
+      expect(options.maxTurns).toBe(30);
+    });
+
+    it('parses multiple flags including new ones', () => {
+      const options = parseOverdriveArgs('5 --agents 2 --mode test --model sonnet --max-turns 25 --dry-run');
 
       expect(options.phase).toBe(5);
       expect(options.agents).toBe(2);
       expect(options.mode).toBe('test');
+      expect(options.model).toBe('sonnet');
+      expect(options.maxTurns).toBe(25);
       expect(options.dryRun).toBe(true);
     });
   });
 
   describe('generateAgentPrompts', () => {
-    it('generates prompts for tasks', () => {
+    it('generates prompts for tasks with model and maxTurns', () => {
       const tasks = [
         { id: 1, title: 'Create schema' },
         { id: 2, title: 'Add validation' },
@@ -93,6 +118,9 @@ describe('overdrive-command', () => {
       expect(prompts[0].taskTitle).toBe('Create schema');
       expect(prompts[0].prompt).toContain('Task 1');
       expect(prompts[0].prompt).toContain('Write tests first');
+      expect(prompts[0].agentType).toBe('general-purpose');
+      expect(prompts[0].model).toBeDefined();
+      expect(prompts[0].maxTurns).toBe(DEFAULT_MAX_TURNS);
     });
 
     it('includes no-question rules', () => {
@@ -123,6 +151,55 @@ describe('overdrive-command', () => {
 
       expect(prompts[0].prompt).toContain('Fix any failing tests');
     });
+
+    it('assigns model based on task complexity', () => {
+      const tasks = [
+        { id: 1, title: 'Refactor authentication system' },
+        { id: 2, title: 'Add helper function' },
+        { id: 3, title: 'Create enum constants' },
+      ];
+
+      const prompts = generateAgentPrompts(tasks, {
+        mode: 'build', projectDir: '/p', phase: 1,
+      });
+
+      expect(prompts[0].model).toBe('opus');    // refactor = heavy
+      expect(prompts[1].model).toBe('sonnet');   // default = standard
+      expect(prompts[2].model).toBe('haiku');    // enum = light
+    });
+
+    it('respects model override', () => {
+      const tasks = [
+        { id: 1, title: 'Refactor auth' },
+        { id: 2, title: 'Create enum' },
+      ];
+
+      const prompts = generateAgentPrompts(tasks, {
+        mode: 'build', projectDir: '/p', phase: 1,
+        model: 'haiku',
+      });
+
+      expect(prompts[0].model).toBe('haiku');
+      expect(prompts[1].model).toBe('haiku');
+    });
+
+    it('respects maxTurns override', () => {
+      const prompts = generateAgentPrompts(
+        [{ id: 1, title: 'Test' }],
+        { mode: 'build', projectDir: '/p', phase: 1, maxTurns: 25 }
+      );
+
+      expect(prompts[0].maxTurns).toBe(25);
+    });
+
+    it('includes complexity estimate', () => {
+      const prompts = generateAgentPrompts(
+        [{ id: 1, title: 'Database migration' }],
+        { mode: 'build', projectDir: '/p', phase: 1 }
+      );
+
+      expect(prompts[0].complexity).toBe('heavy');
+    });
   });
 
   describe('distributeTasks', () => {
@@ -207,10 +284,10 @@ describe('overdrive-command', () => {
   });
 
   describe('generateTaskCalls', () => {
-    it('generates task tool calls', () => {
+    it('generates task tool calls with model and max_turns', () => {
       const prompts = [
-        { taskId: 1, taskTitle: 'Test', prompt: 'Do task 1', agentType: 'tlc-executor' },
-        { taskId: 2, taskTitle: 'Test 2', prompt: 'Do task 2', agentType: 'tlc-executor' },
+        { taskId: 1, taskTitle: 'Test', prompt: 'Do task 1', agentType: 'general-purpose', model: 'sonnet', maxTurns: 50 },
+        { taskId: 2, taskTitle: 'Test 2', prompt: 'Do task 2', agentType: 'general-purpose', model: 'haiku', maxTurns: 30 },
       ];
 
       const calls = generateTaskCalls(prompts);
@@ -219,6 +296,11 @@ describe('overdrive-command', () => {
       expect(calls[0].tool).toBe('Task');
       expect(calls[0].params.description).toContain('Agent 1');
       expect(calls[0].params.run_in_background).toBe(true);
+      expect(calls[0].params.subagent_type).toBe('general-purpose');
+      expect(calls[0].params.model).toBe('sonnet');
+      expect(calls[0].params.max_turns).toBe(50);
+      expect(calls[1].params.model).toBe('haiku');
+      expect(calls[1].params.max_turns).toBe(30);
     });
   });
 
@@ -326,7 +408,7 @@ Blocked by Task 1
       expect(result.reason).toContain('Waterfall');
     });
 
-    it('returns true for independent tasks', () => {
+    it('returns true for independent tasks with one agent per task', () => {
       const result = canParallelize(
         [{ id: 1 }, { id: 2 }, { id: 3 }],
         { hasDependencies: false, dependencies: [] }
@@ -337,6 +419,14 @@ Blocked by Task 1
       expect(result.recommendedAgents).toBe(3);
     });
 
+    it('recommends agents beyond 10 when tasks warrant it', () => {
+      const tasks = Array.from({ length: 15 }, (_, i) => ({ id: i + 1 }));
+      const result = canParallelize(tasks, { hasDependencies: false, dependencies: [] });
+
+      expect(result.canParallelize).toBe(true);
+      expect(result.recommendedAgents).toBe(15);
+    });
+
     it('identifies mixed independent/dependent tasks', () => {
       const result = canParallelize(
         [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }],
@@ -372,4 +462,111 @@ Blocked by Task 1
       expect(handler.distributeTasks).toBeDefined();
     });
   });
+
+  describe('estimateTaskComplexity', () => {
+    it('classifies heavy tasks', () => {
+      expect(estimateTaskComplexity({ title: 'Refactor auth module' })).toBe('heavy');
+      expect(estimateTaskComplexity({ title: 'Database migration scripts' })).toBe('heavy');
+      expect(estimateTaskComplexity({ title: 'Redesign user schema' })).toBe('heavy');
+      expect(estimateTaskComplexity({ title: 'Security audit implementation' })).toBe('heavy');
+      expect(estimateTaskComplexity({ title: 'Integration with payment API' })).toBe('heavy');
+    });
+
+    it('classifies light tasks', () => {
+      expect(estimateTaskComplexity({ title: 'Add config constants' })).toBe('light');
+      expect(estimateTaskComplexity({ title: 'Create user enum' })).toBe('light');
+      expect(estimateTaskComplexity({ title: 'Create DTO for response' })).toBe('light');
+      expect(estimateTaskComplexity({ title: 'Add seed data' })).toBe('light');
+      expect(estimateTaskComplexity({ title: 'Create interface for service' })).toBe('light');
+    });
+
+    it('classifies standard tasks by default', () => {
+      expect(estimateTaskComplexity({ title: 'Add user listing endpoint' })).toBe('standard');
+      expect(estimateTaskComplexity({ title: 'Create helper function' })).toBe('standard');
+      expect(estimateTaskComplexity({ title: 'Add pagination support' })).toBe('standard');
+    });
+
+    it('handles empty or missing title', () => {
+      expect(estimateTaskComplexity({ title: '' })).toBe('standard');
+      expect(estimateTaskComplexity({})).toBe('standard');
+    });
+  });
+
+  describe('getModelForTask', () => {
+    it('returns opus for heavy tasks', () => {
+      expect(getModelForTask({ title: 'Refactor auth' })).toBe('opus');
+    });
+
+    it('returns sonnet for standard tasks', () => {
+      expect(getModelForTask({ title: 'Add endpoint' })).toBe('sonnet');
+    });
+
+    it('returns haiku for light tasks', () => {
+      expect(getModelForTask({ title: 'Create enum' })).toBe('haiku');
+    });
+
+    it('respects model override', () => {
+      expect(getModelForTask({ title: 'Refactor auth' }, 'haiku')).toBe('haiku');
+      expect(getModelForTask({ title: 'Create enum' }, 'opus')).toBe('opus');
+    });
+  });
+
+  describe('selectAgentType', () => {
+    it('returns general-purpose for build mode', () => {
+      expect(selectAgentType({ title: 'Test' }, 'build')).toBe('general-purpose');
+    });
+
+    it('returns general-purpose for test mode', () => {
+      expect(selectAgentType({ title: 'Test' }, 'test')).toBe('general-purpose');
+    });
+
+    it('returns general-purpose for fix mode', () => {
+      expect(selectAgentType({ title: 'Test' }, 'fix')).toBe('general-purpose');
+    });
+  });
+
+  describe('constants', () => {
+    it('exports valid agent types', () => {
+      expect(AGENT_TYPES.BUILD).toBe('general-purpose');
+      expect(AGENT_TYPES.SHELL).toBe('Bash');
+      expect(AGENT_TYPES.EXPLORE).toBe('Explore');
+      expect(AGENT_TYPES.PLAN).toBe('Plan');
+    });
+
+    it('exports valid model tiers', () => {
+      expect(MODEL_TIERS.HEAVY).toBe('opus');
+      expect(MODEL_TIERS.STANDARD).toBe('sonnet');
+      expect(MODEL_TIERS.LIGHT).toBe('haiku');
+    });
+
+    it('exports default max turns', () => {
+      expect(DEFAULT_MAX_TURNS).toBe(50);
+    });
+  });
+
+  describe('formatOverdrivePlan', () => {
+    it('includes Opus 4.6 branding and model info', () => {
+      const plan = {
+        phase: 3,
+        mode: 'build',
+        agentCount: 2,
+        totalTasks: 2,
+        modelOverride: null,
+        agentAssignments: [
+          { tasks: [{ id: 1, title: 'Refactor auth' }] },
+          { tasks: [{ id: 2, title: 'Create enum' }] },
+        ],
+      };
+
+      const output = formatOverdrivePlan(plan);
+
+      expect(output).toContain('Opus 4.6');
+      expect(output).toContain('[opus]');
+      expect(output).toContain('[haiku]');
+      expect(output).toContain('Model selection per task complexity');
+      expect(output).toContain('Agent resumption');
+      expect(output).toContain('TaskOutput');
+      expect(output).toContain('TaskStop');
+    });
+  });
 });

package/sync.md

@@ -229,7 +229,7 @@ Create `.tlc.json` with all settings:
     "autofix": true,
     "edgeCases": true,
     "prAutoReview": true,
-    "maxAgents": 10
+    "maxAgents": "auto"
   }
 }
 ```