tlc-claude-code 2.9.1 → 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

@@ -1,86 +1,98 @@
 #!/bin/bash
-# TLC Enforcement Layer 2b: Session initialization
-# 1. Inject TLC awareness
-# 2. Ensure TLC server is running
-# 3. Probe LLM providers and write persistent router state
+# TLC Session Init — Comprehensive Health Check
+# Verifies ALL systems and reports status clearly.
+# No silent failures. No partial checks.
 
 if [ ! -f ".tlc.json" ]; then
   exit 0
 fi
 
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+TLC_PORT="${TLC_PORT:-3147}"
+TLC_CORE_PORT="${TLC_CORE_PORT:-3100}"
+ERRORS=0
+WARNINGS=0
+
 echo "TLC project detected. All work goes through /tlc commands. Run /tlc for current status and next action."
+echo ""
+echo "── System Health Check ──────────────────────────────"
+
+# ─── 1. TLC Package Version ──────────────────────────────
+INSTALLED_VER=$(node -e "try{console.log(require('tlc-claude-code/package.json').version)}catch{try{console.log(require('$PROJECT_DIR/package.json').version)}catch{console.log('not-installed')}}" 2>/dev/null)
+LATEST_VER=$(npm view tlc-claude-code version 2>/dev/null || echo "unknown")
+PROJECT_VER=$(node -e "try{console.log(require('./.tlc.json').tlcVersion||'unknown')}catch{console.log('unknown')}" 2>/dev/null)
 
-# ─── 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}"
+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_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
 
-PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
-
-# ─── TLC Server ───────────────────────────────────────────
+# ─── 2. TLC Memory System ────────────────────────────────
+mkdir -p "$PROJECT_DIR/.tlc/memory/team/decisions" \
+         "$PROJECT_DIR/.tlc/memory/team/gotchas" \
+         "$PROJECT_DIR/.tlc/memory/.local/sessions" 2>/dev/null
 
-TLC_PORT="${TLC_PORT:-3147}"
 if curl -sf --max-time 1 "http://localhost:${TLC_PORT}/api/health" > /dev/null 2>&1; then
-  : # Server is running
+  echo "  TLC Server:      ✅ running (:${TLC_PORT})"
+  # Drain spool
+  SPOOL_DRAIN=""
+  if node -e "require('tlc-claude-code/server/lib/capture/spool-processor')" 2>/dev/null; then
+    SPOOL_DRAIN="require('tlc-claude-code/server/lib/capture/spool-processor').processSpool('$PROJECT_DIR')"
+  elif [ -f "$PROJECT_DIR/server/lib/capture/spool-processor.js" ]; then
+    SPOOL_DRAIN="require('$PROJECT_DIR/server/lib/capture/spool-processor').processSpool('$PROJECT_DIR')"
+  fi
+  [ -n "$SPOOL_DRAIN" ] && node -e "$SPOOL_DRAIN" 2>/dev/null
 else
   PLIST="$HOME/Library/LaunchAgents/com.tlc.server.plist"
-
   if [ -f "$PLIST" ]; then
     launchctl kickstart -k "gui/$(id -u)/com.tlc.server" 2>/dev/null
   elif [ -f "$PROJECT_DIR/server/index.js" ]; then
     nohup node "$PROJECT_DIR/server/index.js" > "$HOME/.tlc/logs/server.log" 2>&1 &
   fi
-
-  for i in 1 2 3; do
-    sleep 1
-    curl -sf --max-time 1 "http://localhost:${TLC_PORT}/api/health" > /dev/null 2>&1 && break
-  done
+  sleep 2
+  if curl -sf --max-time 1 "http://localhost:${TLC_PORT}/api/health" > /dev/null 2>&1; then
+    echo "  TLC Server:      ✅ started (:${TLC_PORT})"
+  else
+    echo "  TLC Server:      ❌ failed to start"
+    ERRORS=$((ERRORS + 1))
+  fi
 fi
 
-# --- tlc-core Orchestrator ---
-# Kill switch: export TLC_CORE_AUTOSTART=false to disable auto-start
-TLC_CORE_PORT="${TLC_CORE_PORT:-3100}"
-if [ "${TLC_CORE_AUTOSTART}" = "false" ]; then
-  echo "tlc-core orchestrator: auto-start disabled (TLC_CORE_AUTOSTART=false)"
-elif curl -sf --max-time 1 "http://localhost:${TLC_CORE_PORT}/health" > /dev/null 2>&1; then
-  SESSIONS=$(curl -sf --max-time 1 "http://localhost:${TLC_CORE_PORT}/sessions" 2>/dev/null | jq "length" 2>/dev/null || echo "0")
-  echo "tlc-core orchestrator: healthy (${SESSIONS} sessions)"
+SPOOL_FILE="$PROJECT_DIR/.tlc/memory/.spool.jsonl"
+SPOOL_COUNT=0
+if [ -f "$SPOOL_FILE" ]; then
+  SPOOL_COUNT=$(wc -l < "$SPOOL_FILE" 2>/dev/null || echo "0")
+fi
+SPOOL_COUNT=$(echo "$SPOOL_COUNT" | tr -d ' ')
+if [ "$SPOOL_COUNT" -gt 0 ] 2>/dev/null; then
+  echo "  Memory Spool:    ⚠️  ${SPOOL_COUNT} entries pending drain"
+  WARNINGS=$((WARNINGS + 1))
 else
-  # Try to auto-start if tlc-core CLI is available
-  if command -v tlc-core >/dev/null 2>&1; then
-    echo "tlc-core orchestrator: not running — starting..."
-    tlc-core start > /dev/null 2>&1 &
-    # Wait up to 15s for health
-    for i in 1 2 3 4 5; do
-      sleep 3
-      if curl -sf --max-time 1 "http://localhost:${TLC_CORE_PORT}/health" > /dev/null 2>&1; then
-        echo "tlc-core orchestrator: started successfully"
-        break
-      fi
-    done
-    if ! curl -sf --max-time 1 "http://localhost:${TLC_CORE_PORT}/health" > /dev/null 2>&1; then
-      echo "tlc-core orchestrator: failed to start. Run 'tlc-core start' manually."
-    fi
-  else
-    echo "tlc-core orchestrator: not installed. Run: git clone git@github.com:TwentyTwoLabs22/tlc-core.git && cd cli && npm install && npm link"
-  fi
+  echo "  Memory:          ✅ ready (spool empty)"
 fi
 
-# ─── CodeDB (codebase awareness) ─────────────────────
+# ─── 3. CodeDB ───────────────────────────────────────────
 if command -v codedb >/dev/null 2>&1; then
   if curl -sf --max-time 1 "http://localhost:7719/health" > /dev/null 2>&1; then
-    echo "codedb: running"
+    CODEDB_FILES=$(curl -sf --max-time 1 "http://localhost:7719/status" 2>/dev/null | node -e "try{const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.files||'?')}catch{console.log('?')}" 2>/dev/null || echo "?")
+    echo "  CodeDB:          ✅ running (${CODEDB_FILES} files indexed)"
   else
     codedb serve "$PROJECT_DIR" > /dev/null 2>&1 &
-    echo "codedb: started indexing $PROJECT_DIR"
+    echo "  CodeDB:          ✅ started indexing"
   fi
-  # Ensure .mcp.json exists for Claude Code MCP discovery
+  # Ensure .mcp.json
   if [ ! -f "$PROJECT_DIR/.mcp.json" ]; then
     cat > "$PROJECT_DIR/.mcp.json" <<'MCPEOF'
 {
@@ -92,126 +104,269 @@ if command -v codedb >/dev/null 2>&1; then
   }
 }
 MCPEOF
-    echo "codedb: created .mcp.json"
+    echo "  CodeDB MCP:      ✅ created .mcp.json"
+  fi
+else
+  # 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
 
-# ─── Memory System Init ─────────────────────────────
-mkdir -p "$PROJECT_DIR/.tlc/memory/team/decisions" \
-         "$PROJECT_DIR/.tlc/memory/team/gotchas" \
-         "$PROJECT_DIR/.tlc/memory/.local/sessions"
-
-# ─── Spool Drain ─────────────────────────────────────
-# Try to drain any pending spool entries from previous sessions
-SPOOL_DRAIN=""
-if node -e "require('tlc-claude-code/server/lib/capture/spool-processor')" 2>/dev/null; then
-  SPOOL_DRAIN="require('tlc-claude-code/server/lib/capture/spool-processor').processSpool('$PROJECT_DIR')"
-elif [ -f "$PROJECT_DIR/server/lib/capture/spool-processor.js" ]; then
-  SPOOL_DRAIN="require('$PROJECT_DIR/server/lib/capture/spool-processor').processSpool('$PROJECT_DIR')"
+# ─── 4. tlc-core Orchestrator + Containers ────────────────
+if [ "${TLC_CORE_AUTOSTART}" = "false" ]; then
+  echo "  Orchestrator:    ⏸  disabled (TLC_CORE_AUTOSTART=false)"
+elif curl -sf --max-time 2 "http://localhost:${TLC_CORE_PORT}/health" > /dev/null 2>&1; then
+  ORCH_HEALTH=$(curl -sf --max-time 2 "http://localhost:${TLC_CORE_PORT}/health" 2>/dev/null)
+  PG_STATUS=$(echo "$ORCH_HEALTH" | node -e "try{console.log(JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')).postgres)}catch{console.log('?')}" 2>/dev/null)
+  DOCKER_STATUS=$(echo "$ORCH_HEALTH" | node -e "try{console.log(JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')).docker)}catch{console.log('?')}" 2>/dev/null)
+  RUNNING_SESSIONS=$(curl -sf --max-time 2 "http://localhost:${TLC_CORE_PORT}/sessions" 2>/dev/null | node -e "try{const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));const r=d.filter(s=>s.status==='running');console.log(r.length+'/'+d.length)}catch{console.log('?')}" 2>/dev/null)
+  echo "  Orchestrator:    ✅ healthy (pg:${PG_STATUS}, docker:${DOCKER_STATUS}, sessions:${RUNNING_SESSIONS})"
+
+  # Check agent-runner container
+  if docker ps --format '{{.Names}}' 2>/dev/null | grep -q "tlc-agent-runner"; then
+    TMUX_COUNT=$(docker exec tlc-agent-runner tmux list-sessions 2>/dev/null | wc -l | tr -d ' ')
+    echo "  Agent Runner:    ✅ running (${TMUX_COUNT} tmux sessions)"
+  else
+    echo "  Agent Runner:    ❌ container not running"
+    ERRORS=$((ERRORS + 1))
+  fi
+
+  # 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)"
+  fi
+  if echo "$ORCH_LOGS" | grep -q "Watchdog started\|watchdog.*Started"; then
+    WATCHDOG_OK=true
+    echo "  Watchdog:        ✅ active (60s interval)"
+  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
+    echo "  Orchestrator:    ❌ not running — starting..."
+    tlc-core start > /dev/null 2>&1 &
+    for i in 1 2 3 4 5; do
+      sleep 3
+      curl -sf --max-time 1 "http://localhost:${TLC_CORE_PORT}/health" > /dev/null 2>&1 && break
+    done
+    if curl -sf --max-time 1 "http://localhost:${TLC_CORE_PORT}/health" > /dev/null 2>&1; then
+      echo "  Orchestrator:    ✅ started"
+    else
+      echo "  Orchestrator:    ❌ failed to start. Run 'tlc-core start' manually."
+      ERRORS=$((ERRORS + 1))
+    fi
+  else
+    echo "  Orchestrator:    ❌ not installed"
+    ERRORS=$((ERRORS + 1))
+  fi
+fi
+
+# ─── 5. LLM CLI Versions ─────────────────────────────────
+CLAUDE_VER=$(claude --version 2>/dev/null | head -1 || echo "not installed")
+CODEX_VER=$(codex --version 2>/dev/null | head -1 || echo "not installed")
+GEMINI_VER=$(gemini --version 2>/dev/null | head -1 || echo "not installed")
+
+PROVIDER_COUNT=0
+PROVIDER_LIST=""
+if [ "$CLAUDE_VER" != "not installed" ]; then
+  PROVIDER_COUNT=$((PROVIDER_COUNT + 1))
+  PROVIDER_LIST="${PROVIDER_LIST}claude(${CLAUDE_VER}), "
 fi
-if [ -n "$SPOOL_DRAIN" ]; then
-  node -e "$SPOOL_DRAIN" 2>/dev/null
+if [ "$CODEX_VER" != "not installed" ]; then
+  PROVIDER_COUNT=$((PROVIDER_COUNT + 1))
+  PROVIDER_LIST="${PROVIDER_LIST}codex(${CODEX_VER}), "
 fi
+if [ "$GEMINI_VER" != "not installed" ]; then
+  PROVIDER_COUNT=$((PROVIDER_COUNT + 1))
+  PROVIDER_LIST="${PROVIDER_LIST}gemini(${GEMINI_VER}), "
+fi
+PROVIDER_LIST=$(echo "$PROVIDER_LIST" | sed 's/, $//')
 
-# ─── LLM Router: Probe Providers ─────────────────────────
-#
-# Writes .tlc/.router-state.json with provider availability.
-# Skills read this file instead of probing from scratch.
-# State has a TTL — re-probed if older than 1 hour.
+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))
+fi
 
+# Write router state
 STATE_DIR="$PROJECT_DIR/.tlc"
 STATE_FILE="$STATE_DIR/.router-state.json"
 mkdir -p "$STATE_DIR"
 
-# Check if state is fresh (less than 1 hour old)
-STALE=true
-if [ -f "$STATE_FILE" ]; then
-  STATE_AGE=$(( $(date +%s) - $(stat -f %m "$STATE_FILE" 2>/dev/null || stat -c %Y "$STATE_FILE" 2>/dev/null || echo 0) ))
-  if [ "$STATE_AGE" -lt 3600 ]; then
-    STALE=false
-  fi
-fi
-
-if [ "$STALE" = true ]; then
-  # Probe each provider
-  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"
-  GEMINI_OK="false"
-
-  [ -n "$CLAUDE_PATH" ] && CLAUDE_OK="true"
-  [ -n "$CODEX_PATH" ] && CODEX_OK="true"
-  [ -n "$GEMINI_PATH" ] && GEMINI_OK="true"
-
-  # Count available
-  AVAILABLE=0
-  [ "$CLAUDE_OK" = "true" ] && AVAILABLE=$((AVAILABLE + 1))
-  [ "$CODEX_OK" = "true" ] && AVAILABLE=$((AVAILABLE + 1))
-  [ "$GEMINI_OK" = "true" ] && AVAILABLE=$((AVAILABLE + 1))
-
-  # Read configured providers from .tlc.json
-  CONFIGURED_PROVIDERS=""
-  if command -v jq >/dev/null 2>&1; then
-    CONFIGURED_PROVIDERS=$(jq -r '.router.providers // {} | keys[]' .tlc.json 2>/dev/null | tr '\n' ',' | sed 's/,$//')
-  fi
+CLAUDE_OK="false"; CODEX_OK="false"; GEMINI_OK="false"
+[ "$CLAUDE_VER" != "not installed" ] && CLAUDE_OK="true"
+[ "$CODEX_VER" != "not installed" ] && CODEX_OK="true"
+[ "$GEMINI_VER" != "not installed" ] && GEMINI_OK="true"
 
-  # Write state file
-  cat > "$STATE_FILE" <<STATEEOF
+cat > "$STATE_FILE" <<STATEEOF
 {
   "probed_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
   "ttl_seconds": 3600,
   "providers": {
-    "claude": {
-      "available": $CLAUDE_OK,
-      "path": "$CLAUDE_PATH"
-    },
-    "codex": {
-      "available": $CODEX_OK,
-      "path": "$CODEX_PATH"
-    },
-    "gemini": {
-      "available": $GEMINI_OK,
-      "path": "$GEMINI_PATH"
-    }
+    "claude": { "available": $CLAUDE_OK, "version": "$CLAUDE_VER" },
+    "codex": { "available": $CODEX_OK, "version": "$CODEX_VER" },
+    "gemini": { "available": $GEMINI_OK, "version": "$GEMINI_VER" }
   },
-  "summary": {
-    "available_count": $AVAILABLE,
-    "configured": "$CONFIGURED_PROVIDERS"
-  }
+  "summary": { "available_count": $PROVIDER_COUNT }
 }
 STATEEOF
 
-  # Report to Claude
-  if [ "$AVAILABLE" -gt 0 ]; then
-    PROVIDERS_LIST=""
-    [ "$CLAUDE_OK" = "true" ] && PROVIDERS_LIST="${PROVIDERS_LIST}claude, "
-    [ "$CODEX_OK" = "true" ] && PROVIDERS_LIST="${PROVIDERS_LIST}codex, "
-    [ "$GEMINI_OK" = "true" ] && PROVIDERS_LIST="${PROVIDERS_LIST}gemini, "
-    PROVIDERS_LIST=$(echo "$PROVIDERS_LIST" | sed 's/, $//')
-    echo "LLM Router: ${AVAILABLE} providers available (${PROVIDERS_LIST}). State written to .tlc/.router-state.json. All routing skills MUST read this file for provider availability — do not probe manually."
-  else
-    echo "LLM Router: No external providers detected. Running Claude-only mode. Install codex or gemini for multi-LLM reviews."
-  fi
+# ─── 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 "?")
+
+if [ "$BEHIND" = "0" ] && [ "$AHEAD" = "0" ]; then
+  echo "  Git (${CURRENT_BRANCH}): ✅ in sync with remote"
+elif [ "$BEHIND" != "?" ] && [ "$BEHIND" -gt 0 ] 2>/dev/null; then
+  echo "  Git (${CURRENT_BRANCH}): ⚠️  ${BEHIND} commits behind remote — run: git pull"
+  WARNINGS=$((WARNINGS + 1))
+elif [ "$AHEAD" != "?" ] && [ "$AHEAD" -gt 0 ] 2>/dev/null; then
+  echo "  Git (${CURRENT_BRANCH}): ⚠️  ${AHEAD} commits ahead — push pending"
+  WARNINGS=$((WARNINGS + 1))
 else
-  # State is fresh — just report it
-  if command -v jq >/dev/null 2>&1 && [ -f "$STATE_FILE" ]; then
-    COUNT=$(jq -r '.summary.available_count' "$STATE_FILE" 2>/dev/null)
-    echo "LLM Router: ${COUNT} providers available (cached). State at .tlc/.router-state.json."
+  echo "  Git (${CURRENT_BRANCH}): ⚠️  remote tracking unknown"
+  WARNINGS=$((WARNINGS + 1))
+fi
+
+# ─── 7. Workspace Awareness ──────────────────────────────
+WORKSPACE_FILE=""
+CHECK_DIR="$PROJECT_DIR"
+while [ "$CHECK_DIR" != "/" ]; do
+  if [ -f "$CHECK_DIR/.tlc-workspace.json" ]; then
+    WORKSPACE_FILE="$CHECK_DIR/.tlc-workspace.json"
+    break
   fi
+  CHECK_DIR=$(dirname "$CHECK_DIR")
+done
+
+if [ -n "$WORKSPACE_FILE" ]; then
+  WORKSPACE_NAME=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$WORKSPACE_FILE','utf8')).workspace)}catch{console.log('?')}" 2>/dev/null)
+  REPO_COUNT=$(node -e "try{console.log(Object.keys(JSON.parse(require('fs').readFileSync('$WORKSPACE_FILE','utf8')).repos).length)}catch{console.log('?')}" 2>/dev/null)
+  echo "  Workspace:       ✅ ${WORKSPACE_NAME} (${REPO_COUNT} repos)"
+
+  # Check each repo's sync status
+  WORKSPACE_ROOT=$(dirname "$WORKSPACE_FILE")
+  node -e "
+    const fs = require('fs');
+    const path = require('path');
+    const { execSync } = require('child_process');
+    const wsRoot = process.argv[1];
+    const ws = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+    for (const [name, repo] of Object.entries(ws.repos)) {
+      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();
+          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 {
+        console.log('    [' + repo.prefix + '] not cloned');
+      }
+    }
+  " "$WORKSPACE_ROOT" "$WORKSPACE_FILE" 2>/dev/null
+else
+  echo "  Workspace:       ⚠️  no .tlc-workspace.json found (single-repo mode)"
+  WARNINGS=$((WARNINGS + 1))
 fi
 
-# ─── Health Check (runs AFTER router probe so provider state is fresh) ───
-HEALTH_MOD=""
-if node -e "require('tlc-claude-code/server/lib/health-check')" 2>/dev/null; then
-  HEALTH_MOD="tlc-claude-code/server/lib/health-check"
-elif [ -f "$PROJECT_DIR/server/lib/health-check.js" ]; then
-  HEALTH_MOD="$PROJECT_DIR/server/lib/health-check"
+# ─── 8. CI/CD Status ─────────────────────────────────────
+if command -v gh >/dev/null 2>&1; then
+  LAST_RUN=$(gh run list --limit 1 --json conclusion,status,name -q '.[0]' 2>/dev/null)
+  if [ -n "$LAST_RUN" ]; then
+    RUN_STATUS=$(echo "$LAST_RUN" | node -e "try{const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.conclusion||d.status)}catch{console.log('?')}" 2>/dev/null)
+    RUN_NAME=$(echo "$LAST_RUN" | node -e "try{const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.name)}catch{console.log('?')}" 2>/dev/null)
+    if [ "$RUN_STATUS" = "success" ]; then
+      echo "  CI/CD:           ✅ last run passed (${RUN_NAME})"
+    elif [ "$RUN_STATUS" = "failure" ]; then
+      echo "  CI/CD:           ❌ last run FAILED (${RUN_NAME})"
+      ERRORS=$((ERRORS + 1))
+    else
+      echo "  CI/CD:           ⏳ ${RUN_STATUS} (${RUN_NAME})"
+    fi
+  else
+    echo "  CI/CD:           ⚠️  no recent runs"
+  fi
+else
+  echo "  CI/CD:           ⚠️  gh CLI not installed"
+  WARNINGS=$((WARNINGS + 1))
 fi
-if [ -n "$HEALTH_MOD" ]; then
-  node -e "require('$HEALTH_MOD').runHealthChecks('$PROJECT_DIR').then(r => r.warnings.forEach(w => console.error(w)))" 2>/dev/null
+
+# ─── Summary ─────────────────────────────────────────────
+echo "────────────────────────────────────────────────────"
+if [ "$ERRORS" -eq 0 ] && [ "$WARNINGS" -eq 0 ]; then
+  echo "All systems healthy. ✅"
+elif [ "$ERRORS" -eq 0 ]; then
+  echo "${WARNINGS} warning(s), 0 errors. Systems operational."
+else
+  echo "⚠️  ${ERRORS} error(s), ${WARNINGS} warning(s). Check above."
 fi
 
 exit 0

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.1",
+  "version": "2.10.0",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc-claude-code": "./bin/install.js",