tlc-claude-code 1.6.0 → 1.6.2

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

@@ -6,6 +6,55 @@ Write failing tests, then implement to make them pass.
 
 **Code like a senior engineer with 15+ years experience.** Every line should reflect:
 
+### Project Structure (NestJS-Style Modules)
+
+**Group by domain entity, not by file type.** Each entity gets its own module folder:
+
+```
+src/modules/{entity}/
+  ├── interfaces/                 # Types and interfaces (NEVER at module root)
+  │   ├── {entity}.interface.ts
+  │   └── index.ts
+  ├── dto/                        # Request/Response DTOs
+  │   ├── create.dto.ts
+  │   └── index.ts
+  ├── enums/                      # Enums (no magic strings)
+  ├── constants/                  # Configuration constants
+  ├── guards/                     # Auth/permission middleware
+  ├── {entity}.service.ts         # Business logic
+  ├── {entity}.controller.ts      # HTTP handlers
+  ├── {entity}.repository.ts      # Data access
+  ├── {entity}.seed.ts            # Seed data (per-entity, not monolithic)
+  ├── {entity}.test.ts            # Tests
+  └── index.ts                    # Barrel exports
+```
+
+**Server/src root should ONLY contain:**
+- `index.ts` - Entry point
+- `lib/` - Core shared libraries
+- `modules/` - Feature modules
+- `shared/` - Cross-cutting utilities
+- Config files
+
+**❌ NEVER do this:**
+```
+src/
+  services/          # ❌ All services dumped together
+  interfaces/        # ❌ All types dumped together
+  controllers/       # ❌ Flat controller folder
+
+server/
+  auth.ts            # ❌ Loose file at root (should be modules/auth/)
+  helpers.ts         # ❌ Should be in lib/ or shared/
+```
+
+**Key rules:**
+- Interfaces ALWAYS in `interfaces/` subdirectory, never at module root
+- No inline interfaces in service files - import from `interfaces/`
+- No magic strings - use `enums/` or `constants/`
+- Seeds per-entity, not one giant seeds.ts
+- Every module has `index.ts` barrel export
+
 ### Code Quality
 - **Clean Architecture**: Separate concerns. Domain logic never depends on infrastructure.
 - **SOLID Principles**: Single responsibility, open/closed, Liskov substitution, interface segregation, dependency inversion.
@@ -117,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
@@ -132,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.
 
@@ -151,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]
@@ -170,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
@@ -181,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):**
+
+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)
+```
 
-While agents run in background, show live status using the AgentProgressMonitor:
+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:**
@@ -750,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
@@ -758,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]
@@ -775,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
@@ -814,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.0",
+  "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 {