tlc-claude-code 2.3.0 → 2.4.1

package/.claude/commands/tlc/autofix.md

@@ -2,6 +2,37 @@
 
 Run tests, analyze failures, and automatically apply fixes for common error patterns.
 
+## Routing
+
+This command supports multi-model routing via `~/.tlc/config.json`.
+
+**Before executing this command:**
+
+1. Read routing config:
+   ```bash
+   node -e "
+     const { resolveRouting } = require('./server/lib/task-router-config');
+     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
+     const r = resolveRouting({ command: 'autofix', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
+     console.log(JSON.stringify(r));
+   " 2>/dev/null
+   ```
+
+2. If `models[0]` is NOT `claude` (i.e., routed to external model):
+   - Read PROJECT.md, current phase PLAN.md, CODING-STANDARDS.md
+   - Package the agent prompt below with project context using `prompt-packager`
+   - Dispatch to the target CLI using `cli-dispatcher`
+   - Display the CLI output and stop — do NOT execute the agent prompt below
+
+3. If `models[0]` IS `claude` (or no routing config exists):
+   - Execute the agent prompt below as normal (current behavior)
+
+4. If `strategy` is `parallel`:
+   - Execute inline (Claude) AND dispatch to CLI models simultaneously
+   - Collect and merge results
+
+**Override:** Pass `--model <name>` to route this specific run to a different model.
+
 ## What This Does
 
 1. Runs test suite and captures failures

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

@@ -2,6 +2,37 @@
 
 Write failing tests, then implement to make them pass.
 
+## Routing
+
+This command supports multi-model routing via `~/.tlc/config.json`.
+
+**Before executing this command:**
+
+1. Read routing config:
+   ```bash
+   node -e "
+     const { resolveRouting } = require('./server/lib/task-router-config');
+     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
+     const r = resolveRouting({ command: 'build', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
+     console.log(JSON.stringify(r));
+   " 2>/dev/null
+   ```
+
+2. If `models[0]` is NOT `claude` (i.e., routed to external model):
+   - Read PROJECT.md, current phase PLAN.md, CODING-STANDARDS.md
+   - Package the agent prompt below with project context using `prompt-packager`
+   - Dispatch to the target CLI using `cli-dispatcher`
+   - Display the CLI output and stop — do NOT execute the agent prompt below
+
+3. If `models[0]` IS `claude` (or no routing config exists):
+   - Execute the agent prompt below as normal (current behavior)
+
+4. If `strategy` is `parallel`:
+   - Execute inline (Claude) AND dispatch to CLI models simultaneously
+   - Collect and merge results
+
+**Override:** Pass `--model <name>` to route this specific run to a different model.
+
 ## Engineering Standards
 
 **Code like a senior engineer with 15+ years experience.** Every line should reflect:

package/.claude/commands/tlc/coverage.md

@@ -2,6 +2,37 @@
 
 Scan existing code, identify what's untested, and offer to write retrospective tests.
 
+## Routing
+
+This command supports multi-model routing via `~/.tlc/config.json`.
+
+**Before executing this command:**
+
+1. Read routing config:
+   ```bash
+   node -e "
+     const { resolveRouting } = require('./server/lib/task-router-config');
+     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
+     const r = resolveRouting({ command: 'coverage', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
+     console.log(JSON.stringify(r));
+   " 2>/dev/null
+   ```
+
+2. If `models[0]` is NOT `claude` (i.e., routed to external model):
+   - Read PROJECT.md, current phase PLAN.md, CODING-STANDARDS.md
+   - Package the agent prompt below with project context using `prompt-packager`
+   - Dispatch to the target CLI using `cli-dispatcher`
+   - Display the CLI output and stop — do NOT execute the agent prompt below
+
+3. If `models[0]` IS `claude` (or no routing config exists):
+   - Execute the agent prompt below as normal (current behavior)
+
+4. If `strategy` is `parallel`:
+   - Execute inline (Claude) AND dispatch to CLI models simultaneously
+   - Collect and merge results
+
+**Override:** Pass `--model <name>` to route this specific run to a different model.
+
 ## When to Use
 
 - After `/tlc:init` to add tests to existing code

package/.claude/commands/tlc/discuss.md

@@ -2,6 +2,37 @@
 
 Capture implementation preferences before planning.
 
+## Routing
+
+This command supports multi-model routing via `~/.tlc/config.json`.
+
+**Before executing this command:**
+
+1. Read routing config:
+   ```bash
+   node -e "
+     const { resolveRouting } = require('./server/lib/task-router-config');
+     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
+     const r = resolveRouting({ command: 'discuss', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
+     console.log(JSON.stringify(r));
+   " 2>/dev/null
+   ```
+
+2. If `models[0]` is NOT `claude` (i.e., routed to external model):
+   - Read PROJECT.md, current phase PLAN.md, CODING-STANDARDS.md
+   - Package the agent prompt below with project context using `prompt-packager`
+   - Dispatch to the target CLI using `cli-dispatcher`
+   - Display the CLI output and stop — do NOT execute the agent prompt below
+
+3. If `models[0]` IS `claude` (or no routing config exists):
+   - Execute the agent prompt below as normal (current behavior)
+
+4. If `strategy` is `parallel`:
+   - Execute inline (Claude) AND dispatch to CLI models simultaneously
+   - Collect and merge results
+
+**Override:** Pass `--model <name>` to route this specific run to a different model.
+
 ## What This Does
 
 Gathers your preferences for HOW a phase should be built through adaptive questioning. Saves decisions to guide planning and test writing.

package/.claude/commands/tlc/docs.md

@@ -2,6 +2,37 @@
 
 Automatically maintain your project's documentation, screenshots, and wiki.
 
+## Routing
+
+This command supports multi-model routing via `~/.tlc/config.json`.
+
+**Before executing this command:**
+
+1. Read routing config:
+   ```bash
+   node -e "
+     const { resolveRouting } = require('./server/lib/task-router-config');
+     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
+     const r = resolveRouting({ command: 'docs', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
+     console.log(JSON.stringify(r));
+   " 2>/dev/null
+   ```
+
+2. If `models[0]` is NOT `claude` (i.e., routed to external model):
+   - Read PROJECT.md, current phase PLAN.md, CODING-STANDARDS.md
+   - Package the agent prompt below with project context using `prompt-packager`
+   - Dispatch to the target CLI using `cli-dispatcher`
+   - Display the CLI output and stop — do NOT execute the agent prompt below
+
+3. If `models[0]` IS `claude` (or no routing config exists):
+   - Execute the agent prompt below as normal (current behavior)
+
+4. If `strategy` is `parallel`:
+   - Execute inline (Claude) AND dispatch to CLI models simultaneously
+   - Collect and merge results
+
+**Override:** Pass `--model <name>` to route this specific run to a different model.
+
 ## Usage
 
 ```bash

package/.claude/commands/tlc/edge-cases.md

@@ -2,6 +2,37 @@
 
 Analyze code and generate comprehensive edge case tests to improve test coverage.
 
+## Routing
+
+This command supports multi-model routing via `~/.tlc/config.json`.
+
+**Before executing this command:**
+
+1. Read routing config:
+   ```bash
+   node -e "
+     const { resolveRouting } = require('./server/lib/task-router-config');
+     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
+     const r = resolveRouting({ command: 'edge-cases', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
+     console.log(JSON.stringify(r));
+   " 2>/dev/null
+   ```
+
+2. If `models[0]` is NOT `claude` (i.e., routed to external model):
+   - Read PROJECT.md, current phase PLAN.md, CODING-STANDARDS.md
+   - Package the agent prompt below with project context using `prompt-packager`
+   - Dispatch to the target CLI using `cli-dispatcher`
+   - Display the CLI output and stop — do NOT execute the agent prompt below
+
+3. If `models[0]` IS `claude` (or no routing config exists):
+   - Execute the agent prompt below as normal (current behavior)
+
+4. If `strategy` is `parallel`:
+   - Execute inline (Claude) AND dispatch to CLI models simultaneously
+   - Collect and merge results
+
+**Override:** Pass `--model <name>` to route this specific run to a different model.
+
 ## What This Does
 
 1. Analyzes target file/function

package/.claude/commands/tlc/plan.md

@@ -2,6 +2,37 @@
 
 Research and create implementation plans with clear tasks.
 
+## Routing
+
+This command supports multi-model routing via `~/.tlc/config.json`.
+
+**Before executing this command:**
+
+1. Read routing config:
+   ```bash
+   node -e "
+     const { resolveRouting } = require('./server/lib/task-router-config');
+     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
+     const r = resolveRouting({ command: 'plan', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
+     console.log(JSON.stringify(r));
+   " 2>/dev/null
+   ```
+
+2. If `models[0]` is NOT `claude` (i.e., routed to external model):
+   - Read PROJECT.md, current phase PLAN.md, CODING-STANDARDS.md
+   - Package the agent prompt below with project context using `prompt-packager`
+   - Dispatch to the target CLI using `cli-dispatcher`
+   - Display the CLI output and stop — do NOT execute the agent prompt below
+
+3. If `models[0]` IS `claude` (or no routing config exists):
+   - Execute the agent prompt below as normal (current behavior)
+
+4. If `strategy` is `parallel`:
+   - Execute inline (Claude) AND dispatch to CLI models simultaneously
+   - Collect and merge results
+
+**Override:** Pass `--model <name>` to route this specific run to a different model.
+
 ## Architectural Standards
 
 **Plan like a principal engineer designing for scale:**

package/.claude/commands/tlc/quick.md

@@ -2,6 +2,37 @@
 
 For ad-hoc tasks that don't need full phase planning, but still deserve tests.
 
+## Routing
+
+This command supports multi-model routing via `~/.tlc/config.json`.
+
+**Before executing this command:**
+
+1. Read routing config:
+   ```bash
+   node -e "
+     const { resolveRouting } = require('./server/lib/task-router-config');
+     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
+     const r = resolveRouting({ command: 'quick', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
+     console.log(JSON.stringify(r));
+   " 2>/dev/null
+   ```
+
+2. If `models[0]` is NOT `claude` (i.e., routed to external model):
+   - Read PROJECT.md, current phase PLAN.md, CODING-STANDARDS.md
+   - Package the agent prompt below with project context using `prompt-packager`
+   - Dispatch to the target CLI using `cli-dispatcher`
+   - Display the CLI output and stop — do NOT execute the agent prompt below
+
+3. If `models[0]` IS `claude` (or no routing config exists):
+   - Execute the agent prompt below as normal (current behavior)
+
+4. If `strategy` is `parallel`:
+   - Execute inline (Claude) AND dispatch to CLI models simultaneously
+   - Collect and merge results
+
+**Override:** Pass `--model <name>` to route this specific run to a different model.
+
 ## Engineering Standards
 
 Even quick tasks follow senior engineer standards:

package/.claude/commands/tlc/review.md

@@ -2,6 +2,37 @@
 
 Review changes on current branch before pushing. **Runs in a loop until clean.**
 
+## Routing
+
+This command supports multi-model routing via `~/.tlc/config.json`.
+
+**Before executing this command:**
+
+1. Read routing config:
+   ```bash
+   node -e "
+     const { resolveRouting } = require('./server/lib/task-router-config');
+     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
+     const r = resolveRouting({ command: 'review', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
+     console.log(JSON.stringify(r));
+   " 2>/dev/null
+   ```
+
+2. If `models[0]` is NOT `claude` (i.e., routed to external model):
+   - Read PROJECT.md, current phase PLAN.md, CODING-STANDARDS.md
+   - Package the agent prompt below with project context using `prompt-packager`
+   - Dispatch to the target CLI using `cli-dispatcher`
+   - Display the CLI output and stop — do NOT execute the agent prompt below
+
+3. If `models[0]` IS `claude` (or no routing config exists):
+   - Execute the agent prompt below as normal (current behavior)
+
+4. If `strategy` is `parallel`:
+   - Execute inline (Claude) AND dispatch to CLI models simultaneously
+   - Collect and merge results
+
+**Override:** Pass `--model <name>` to route this specific run to a different model.
+
 ## What This Does
 
 1. Compares current branch to main/master

package/.claude/hooks/tlc-session-init.sh

@@ -10,6 +10,17 @@ fi
 
 echo "TLC project detected. All work goes through /tlc commands. Run /tlc for current status and next action."
 
+# ─── TLC Update Notification ─────────────────────────────
+UPDATE_FILE="$HOME/.tlc/.update-available"
+if [ -f "$UPDATE_FILE" ]; then
+  CURRENT=$(grep '^current=' "$UPDATE_FILE" | cut -d= -f2)
+  LATEST=$(grep '^latest=' "$UPDATE_FILE" | cut -d= -f2)
+  CMD=$(grep '^command=' "$UPDATE_FILE" | cut -d= -f2-)
+  if [ -n "$CURRENT" ] && [ -n "$LATEST" ]; then
+    echo "TLC update available: ${CURRENT} → ${LATEST}. Run: ${CMD}"
+  fi
+fi
+
 PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
 
 # ─── TLC Server ───────────────────────────────────────────
@@ -53,9 +64,9 @@ fi
 
 if [ "$STALE" = true ]; then
   # Probe each provider
-  CLAUDE_PATH=$(which claude 2>/dev/null || echo "")
-  CODEX_PATH=$(which codex 2>/dev/null || echo "")
-  GEMINI_PATH=$(which gemini 2>/dev/null || echo "")
+  CLAUDE_PATH=$(command -v claude 2>/dev/null || echo "")
+  CODEX_PATH=$(command -v codex 2>/dev/null || echo "")
+  GEMINI_PATH=$(command -v gemini 2>/dev/null || echo "")
 
   CLAUDE_OK="false"
   CODEX_OK="false"