tlc-claude-code 2.9.2 → 2.10.0

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

@@ -106,14 +106,14 @@ process.stdout.write(JSON.stringify(result));" 2>/dev/null
 After `resolveRouting` returns, immediately write `.tlc/.build-routing-active` with the active provider name from `models[0]` before doing any other build work. Remove `.tlc/.build-routing-active` on completion, cancellation, or failure cleanup.
 
 **Routing decision:**
-- If routing says external provider (`models[0] !== 'claude'`), follow **ONLY Orchestrator Mode** below.
-- If routing says Claude (`models[0] === 'claude'`), follow **Inline Mode** below.
+- **ALWAYS use Orchestrator Mode.** Claude never writes code inline. The routing config determines which provider the orchestrator dispatches TO (codex, claude session, gemini), but Claude in this conversation is always the PM.
+- If the orchestrator is unreachable, auto-recover it (restart container, deploy latest code). If recovery fails, STOP — do not fall back to inline code.
 
-## ORCHESTRATOR MODE
+## ORCHESTRATOR MODE (ALWAYS)
 
-Use this mode only when `models[0]` is **NOT** `claude`.
+Claude is the **project manager**. Claude reads the plan, breaks tasks into small prompts, and dispatches each to the tlc-core orchestrator. Claude does NOT write code. This is not conditional on routing — it is always the mode.
 
-Claude is the **project manager**. Claude reads the plan, breaks tasks into small prompts, and dispatches each to the tlc-core orchestrator. Claude does NOT write code.
+The `models[0]` value from routing determines which provider the orchestrator uses (`codex`, `claude`, `gemini`), not whether Claude writes code inline.
 
 ### Step O1: Read the Plan
 
@@ -254,11 +254,9 @@ After PR is created (or phase completes):
 - Mark completed tasks `[x]` in PLAN.md
 - Report final summary
 
-## INLINE MODE
+## AGENT INSTRUCTIONS (Reference for Dispatched Sessions)
 
-Use this mode only when `models[0]` **IS** `claude`.
-
-The existing build instructions below are the Inline Mode instructions and should be followed unchanged.
+**These instructions are NOT for Claude in the main conversation.** They are the reference for what the dispatched orchestrator agent (Codex, Claude session, or Gemini) should do inside its tmux session. Claude packages these into the dispatch prompt — Claude does not execute them inline.
 
 ## Engineering Standards
 

package/.claude/commands/tlc/init.md

@@ -19,9 +19,62 @@ For brand new projects with no code, use `/tlc:new-project` instead.
 
 ## Process
 
-### 0. Upgrade Check (runs first, always)
+### 0. Orchestrator Enforcement (runs first, always)
 
-**Before anything else**, check if this is already a TLC project:
+**Before anything else**, verify the orchestrator is available. All code execution goes through it — no exceptions.
+
+```bash
+# Check orchestrator health
+if curl -sf --max-time 2 http://localhost:3100/health > /dev/null 2>&1; then
+  echo "Orchestrator: ✅ healthy"
+else
+  echo "Orchestrator: ❌ not running — attempting recovery..."
+  # Try to find and restart the orchestrator container
+  ORCH_CONTAINER=$(docker ps -a --format '{{.Names}}' 2>/dev/null | grep "orchestrator" | head -1)
+  if [ -n "$ORCH_CONTAINER" ]; then
+    docker start "$ORCH_CONTAINER" 2>/dev/null
+    sleep 3
+  fi
+  # If still down and tlc-core source exists, deploy and start
+  if ! curl -sf --max-time 2 http://localhost:3100/health > /dev/null 2>&1; then
+    if command -v tlc-core >/dev/null 2>&1; then
+      tlc-core start &
+      sleep 5
+    fi
+  fi
+  # Final check
+  if curl -sf --max-time 2 http://localhost:3100/health > /dev/null 2>&1; then
+    echo "Orchestrator: ✅ recovered"
+  else
+    echo "Orchestrator: ❌ FAILED — code execution will not work"
+    echo "Install tlc-core: git clone git@github.com:TwentyTwoLabs22/tlc-core.git && cd cli && npm i && npm link"
+    echo "Then run: tlc-core start"
+  fi
+fi
+```
+
+Also verify CodeDB and agent runner:
+
+```bash
+# CodeDB
+if ! curl -sf --max-time 1 http://localhost:7719/health > /dev/null 2>&1; then
+  if command -v codedb >/dev/null 2>&1; then
+    codedb serve . &
+    echo "CodeDB: ✅ started"
+  else
+    echo "CodeDB: ❌ not installed — run: npx tlc-claude-code"
+  fi
+fi
+
+# Agent runner container
+if ! docker ps --format '{{.Names}}' 2>/dev/null | grep -q "tlc-agent-runner"; then
+  docker start tlc-agent-runner 2>/dev/null && echo "Agent Runner: ✅ started" || echo "Agent Runner: ❌ not available"
+fi
+```
+
+### 0b. Upgrade Check
+
+**After orchestrator is verified**, check if this is already a TLC project:
 
 ```bash
 # Check for existing TLC markers

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

@@ -100,14 +100,12 @@ process.stdout.write(JSON.stringify(result));" 2>/dev/null
 After `resolveRouting` returns, immediately write `.tlc/.quick-routing-active` with the active provider name from `models[0]` before doing any other quick work. Remove `.tlc/.quick-routing-active` on completion, cancellation, or failure cleanup.
 
 **Routing decision:**
-- If routing says external provider (`models[0] !== 'claude'`), follow **ONLY ORCHESTRATOR MODE** below.
-- If routing says Claude (`models[0] === 'claude'`), follow **INLINE MODE** below.
+- **ALWAYS use Orchestrator Mode.** Claude never writes code inline. Routing determines which provider the orchestrator dispatches to.
+- If orchestrator is down, auto-recover. If recovery fails, STOP — do not fall back to inline.
 
-## ORCHESTRATOR MODE
+## ORCHESTRATOR MODE (ALWAYS)
 
-Use this mode only when `models[0]` is **NOT** `claude`.
-
-Claude does not execute the quick-task instructions inline in this path. Claude acts as the orchestrator for the routed provider run:
+Claude acts as the orchestrator — dispatches the quick task to the orchestrator, monitors completion, verifies result. Claude does NOT write code.
 
 1. Treat Claude as the orchestrator for a small, test-first routed task rather than executing the work inline.
 2. Gather the minimal project context needed for the quick task, then package a focused prompt with the task request, expected failing test, implementation scope, and verification target.
@@ -123,12 +121,9 @@ Claude does not execute the quick-task instructions inline in this path. Claude
    - If the provider returns incomplete code or missing tests, issue a targeted retry for the missing part.
 7. When finished, display the routed provider result, persist any captured memory, remove `.tlc/.quick-routing-active`, and stop. Do **not** execute Inline Mode afterward.
 
-## INLINE MODE
-
-Use this mode only when `models[0]` **IS** `claude`.
-
-The existing quick-task instructions below are the Inline Mode instructions and should be followed unchanged.
+## AGENT INSTRUCTIONS (Reference for Dispatched Sessions)
 
+**These instructions are NOT for Claude in the main conversation.** They are packaged into the dispatch prompt for the orchestrator agent.
 
 ## Engineering Standards
 

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

@@ -181,6 +181,31 @@ Only mention upgrade details in `--verbose` mode.
 
 ## One-Pass Detection
 
+### Step 0: Quick Health Check
+
+Before phase detection, run a fast health check (no auto-recovery — that's the SessionStart hook's job). Just report status in one line:
+
+```bash
+# Check key systems in parallel (each with 1s timeout)
+CODEDB=$(curl -sf --max-time 1 http://localhost:7719/health > /dev/null 2>&1 && echo "✅" || echo "❌")
+ORCH=$(curl -sf --max-time 1 http://localhost:3100/health > /dev/null 2>&1 && echo "✅" || echo "❌")
+RUNNER=$(docker ps --format '{{.Names}}' 2>/dev/null | grep -q "tlc-agent-runner" && echo "✅" || echo "❌")
+```
+
+Print one compact line:
+
+```
+Systems: CodeDB ${CODEDB} | Orchestrator ${ORCH} | Agent Runner ${RUNNER}
+```
+
+If any system is ❌, **auto-recover immediately** before continuing:
+
+1. CodeDB ❌ → run `codedb serve . &` (or `npx tlc-claude-code` if binary missing), wait 2s, re-check
+2. Orchestrator ❌ → find orchestrator container (`docker ps | grep orchestrator`), deploy latest code from `../tlc-core/orchestrator/`, restart container, wait 3s, re-check
+3. Agent Runner ❌ → `docker start tlc-agent-runner` if stopped, report if container doesn't exist
+
+After recovery attempts, print updated status. Only continue to phase detection after all recoverable systems are up. If recovery fails, print the failure and continue anyway — don't block indefinitely.
+
 ### Step 1: Load Core Context
 
 Read, in this order:
@@ -256,11 +281,22 @@ Backward compatibility:
 
 ## Output Format
 
-Normal output must stay within 3-5 lines.
+Normal output must stay compact — health line + phase status + action.
 
 Use this pattern:
 
 ```text
+Systems: CodeDB ✅ | Orchestrator ✅ | Agent Runner ✅
+TLC v{version} | Phase {PHASE_ID}: {Name} | {done}/{total} tasks done
+Next: {action summary}
+Running /tlc:{command} {PHASE_ID}...
+```
+
+If any system is down:
+
+```text
+Systems: CodeDB ✅ | Orchestrator ❌ | Agent Runner ✅
+⚠️  Orchestrator down — run /tlc:init to recover
 TLC v{version} | Phase {PHASE_ID}: {Name} | {done}/{total} tasks done
 Next: {action summary}
 Running /tlc:{command} {PHASE_ID}...
@@ -269,6 +305,7 @@ Running /tlc:{command} {PHASE_ID}...
 If there is nothing safe to auto-run:
 
 ```text
+Systems: CodeDB ✅ | Orchestrator ✅ | Agent Runner ✅
 TLC v{version} | All phases complete
 Next: release or start the next milestone
 Run /tlc:complete or /tlc:new-milestone
@@ -338,7 +375,8 @@ Run /tlc:complete or /tlc:new-milestone
 ## Example
 
 ```text
-TLC v2.4.2 | Phase TLC-8: Auth System | 3/5 tasks done
+Systems: CodeDB ✅ | Orchestrator ✅ | Agent Runner ✅
+TLC v2.9.2 | Phase TLC-8: Auth System | 3/5 tasks done
 Next: build task 4 (JWT middleware)
 Running /tlc:build TLC-8...
 ```

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

@@ -26,8 +26,15 @@ if [ "$INSTALLED_VER" = "not-installed" ]; then
   echo "  TLC Package:     ❌ not installed (run: npm i -g tlc-claude-code)"
   ERRORS=$((ERRORS + 1))
 elif [ "$INSTALLED_VER" != "$LATEST_VER" ] && [ "$LATEST_VER" != "unknown" ]; then
-  echo "  TLC Package:     ⚠️  ${INSTALLED_VER} (latest: ${LATEST_VER}) — run: npm i -g tlc-claude-code"
-  WARNINGS=$((WARNINGS + 1))
+  echo "  TLC Package:     ⏳ ${INSTALLED_VER} → ${LATEST_VER} — auto-updating..."
+  npm i -g tlc-claude-code@latest > /dev/null 2>&1
+  NEW_VER=$(node -e "try{console.log(require('tlc-claude-code/package.json').version)}catch{console.log('?')}" 2>/dev/null)
+  if [ "$NEW_VER" = "$LATEST_VER" ]; then
+    echo "  TLC Package:     ✅ updated to v${NEW_VER}"
+  else
+    echo "  TLC Package:     ⚠️  update failed — still on v${INSTALLED_VER}"
+    WARNINGS=$((WARNINGS + 1))
+  fi
 else
   echo "  TLC Package:     ✅ v${INSTALLED_VER} (latest)"
 fi
@@ -100,8 +107,20 @@ MCPEOF
     echo "  CodeDB MCP:      ✅ created .mcp.json"
   fi
 else
-  echo "  CodeDB:          ❌ not installed (run: npx tlc-claude-code)"
-  ERRORS=$((ERRORS + 1))
+  # Auto-install CodeDB binary
+  echo "  CodeDB:          ⏳ not installed — auto-installing..."
+  if npx -y tlc-claude-code 2>/dev/null | tail -1; then
+    if command -v codedb >/dev/null 2>&1; then
+      codedb serve "$PROJECT_DIR" > /dev/null 2>&1 &
+      echo "  CodeDB:          ✅ installed and started"
+    else
+      echo "  CodeDB:          ❌ install failed"
+      ERRORS=$((ERRORS + 1))
+    fi
+  else
+    echo "  CodeDB:          ❌ install failed"
+    ERRORS=$((ERRORS + 1))
+  fi
 fi
 
 # ─── 4. tlc-core Orchestrator + Containers ────────────────
@@ -125,17 +144,49 @@ elif curl -sf --max-time 2 "http://localhost:${TLC_CORE_PORT}/health" > /dev/nul
 
   # Check session monitor + watchdog
   ORCH_LOGS=$(docker logs tlc-core-orchestrator-1 --tail 50 2>&1)
+  MONITOR_OK=false
+  WATCHDOG_OK=false
   if echo "$ORCH_LOGS" | grep -q "Session monitor started"; then
+    MONITOR_OK=true
     echo "  Session Monitor: ✅ active (10s interval)"
-  else
-    echo "  Session Monitor: ❌ not running — orchestrator needs restart"
-    ERRORS=$((ERRORS + 1))
   fi
   if echo "$ORCH_LOGS" | grep -q "Watchdog started\|watchdog.*Started"; then
+    WATCHDOG_OK=true
     echo "  Watchdog:        ✅ active (60s interval)"
-  else
-    echo "  Watchdog:        ⚠️  not detected in logs"
-    WARNINGS=$((WARNINGS + 1))
+  fi
+
+  # Auto-recover: if monitor or watchdog missing, deploy latest code and restart
+  if [ "$MONITOR_OK" = false ] || [ "$WATCHDOG_OK" = false ]; then
+    echo "  Monitor/Watchdog: ⏳ missing — deploying latest code and restarting..."
+    # Find orchestrator source
+    ORCH_SRC=""
+    if [ -d "$PROJECT_DIR/../tlc-core/orchestrator" ]; then
+      ORCH_SRC="$PROJECT_DIR/../tlc-core/orchestrator"
+    elif [ -d "$(dirname "$PROJECT_DIR")/tlc-core/orchestrator" ]; then
+      ORCH_SRC="$(dirname "$PROJECT_DIR")/tlc-core/orchestrator"
+    fi
+    if [ -n "$ORCH_SRC" ]; then
+      ORCH_CONTAINER=$(docker ps --format '{{.Names}}' 2>/dev/null | grep "orchestrator" | head -1)
+      if [ -n "$ORCH_CONTAINER" ]; then
+        docker cp "$ORCH_SRC/lib/." "$ORCH_CONTAINER:/app/lib/" 2>/dev/null
+        docker cp "$ORCH_SRC/index.js" "$ORCH_CONTAINER:/app/index.js" 2>/dev/null
+        docker cp "$ORCH_SRC/migrations/." "$ORCH_CONTAINER:/app/migrations/" 2>/dev/null
+        docker restart "$ORCH_CONTAINER" > /dev/null 2>&1
+        sleep 3
+        if curl -sf --max-time 2 "http://localhost:${TLC_CORE_PORT}/health" > /dev/null 2>&1; then
+          echo "  Monitor/Watchdog: ✅ restarted with latest code"
+        else
+          echo "  Monitor/Watchdog: ❌ restart failed"
+          ERRORS=$((ERRORS + 1))
+        fi
+      else
+        echo "  Monitor/Watchdog: ❌ orchestrator container not found"
+        ERRORS=$((ERRORS + 1))
+      fi
+    else
+      [ "$MONITOR_OK" = false ] && echo "  Session Monitor: ❌ not running (tlc-core source not found)" && ERRORS=$((ERRORS + 1))
+      [ "$WATCHDOG_OK" = false ] && echo "  Watchdog:        ⚠️  not detected" && WARNINGS=$((WARNINGS + 1))
+    fi
   fi
 else
   if command -v tlc-core >/dev/null 2>&1; then
@@ -180,6 +231,14 @@ PROVIDER_LIST=$(echo "$PROVIDER_LIST" | sed 's/, $//')
 
 if [ "$PROVIDER_COUNT" -gt 0 ]; then
   echo "  LLM Providers:   ✅ ${PROVIDER_COUNT} available — ${PROVIDER_LIST}"
+  # Check for updates (non-blocking, just warn)
+  if [ "$CODEX_VER" != "not installed" ]; then
+    CODEX_LATEST=$(npm view @openai/codex version 2>/dev/null || echo "")
+    if [ -n "$CODEX_LATEST" ] && [ "$CODEX_VER" != *"$CODEX_LATEST"* ] 2>/dev/null; then
+      echo "  Codex Update:    ⚠️  latest: ${CODEX_LATEST} — run: npm i -g @openai/codex"
+      WARNINGS=$((WARNINGS + 1))
+    fi
+  fi
 else
   echo "  LLM Providers:   ❌ none found"
   ERRORS=$((ERRORS + 1))
@@ -209,6 +268,8 @@ cat > "$STATE_FILE" <<STATEEOF
 STATEEOF
 
 # ─── 6. Git + Remote Sync ────────────────────────────────
+# Fetch remote to get accurate ahead/behind counts
+git fetch --quiet 2>/dev/null
 CURRENT_BRANCH=$(git branch --show-current 2>/dev/null)
 BEHIND=$(git rev-list --count HEAD..@{u} 2>/dev/null || echo "?")
 AHEAD=$(git rev-list --count @{u}..HEAD 2>/dev/null || echo "?")
@@ -254,11 +315,16 @@ if [ -n "$WORKSPACE_FILE" ]; then
       const rp = path.resolve(wsRoot, repo.path);
       try {
         fs.accessSync(rp);
+        // Fetch remote for accurate state
+        try { execSync('git -C ' + JSON.stringify(rp) + ' fetch --quiet', { stdio: ['pipe','pipe','pipe'], timeout: 10000 }); } catch {}
         const branch = execSync('git -C ' + JSON.stringify(rp) + ' branch --show-current', { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim();
         let status = 'unknown';
         try {
           const behind = execSync('git -C ' + JSON.stringify(rp) + ' rev-list --count HEAD..@{u}', { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim();
-          status = behind === '0' ? 'in sync' : behind + ' behind';
+          const ahead = execSync('git -C ' + JSON.stringify(rp) + ' rev-list --count @{u}..HEAD', { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim();
+          if (behind === '0' && ahead === '0') status = 'in sync';
+          else if (behind !== '0') status = behind + ' behind — needs pull';
+          else status = ahead + ' ahead — push pending';
         } catch { status = 'no remote tracking'; }
         console.log('    [' + repo.prefix + '] ' + branch + ': ' + status);
       } catch {

package/CLAUDE.md

@@ -10,6 +10,7 @@
 4. **No direct implementation.** User says "build X" → run `/tlc:progress` then `/tlc:build`.
 5. **No Co-Authored-By in commits.** The user is the author. Claude is a tool.
 6. **Ask before `git push`.** Never push without explicit approval.
+7. **Claude NEVER writes code.** All code execution goes through the orchestrator (tlc-core :3100). Claude is PM — read, plan, dispatch, review. Sub-agents writing code is a bug. If the orchestrator is down, recover it first — never fall back to inline code.
 
 ## CodeDB
 

package/package.json

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