tlc-claude-code 2.9.0 → 2.9.2

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

@@ -174,50 +174,85 @@ If orchestrator is down, dispatch directly via tmux on the host:
 
 ```bash
 tmux new-session -d -s <task-id> -c $(pwd)
-tmux send-keys -t <task-id> "/opt/homebrew/bin/codex --full-auto '<prompt>'" Enter
+tmux send-keys -t <task-id> "/opt/homebrew/bin/codex --dangerously-bypass-approvals-and-sandbox '<prompt>'" Enter
 ```
 
-### Step O4: Report and Free
+### Step O4: Report and Monitor
 
-After dispatching all tasks, report:
+After dispatching all tasks, report the initial state:
 
 ```
 Dispatched N tasks to orchestrator:
-  ses_abc123  Task 1: Create schema         codex  running  monitor=running
-  ses_def456  Task 2: Add validation        codex  running  monitor=running
+  ses_abc123  Task 1: Create schema         codex  running
+  ses_def456  Task 2: Add validation        codex  running
 
-Run /tlc:status to check progress.
-I'm free — what would you like to work on?
+Monitoring for completion...
 ```
 
-Include each session's current monitor state in the status display. When available, prefer the same session-status formatting used by orchestration status views so monitor values stay consistent across commands.
+**Do NOT stop here. Do NOT say "I'm free". Enter the monitoring loop immediately.**
 
-**STOP HERE.** Do not write code. Do not execute inline mode. Claude is the PM, not the coder.
+### Step O5: Auto-Monitor Loop (Mandatory)
 
-### Step O5: Monitor (When User Asks)
+After dispatching, poll all sessions every 30 seconds until all reach terminal states. This loop runs automatically — do not wait for the user to ask.
 
-When the user asks for status or agents complete, check:
+```
+Poll cycle:
+1. For each dispatched session, check: GET /sessions/:id/status (or tmux capture-pane)
+2. Classify each session:
+   - completed → ready for merge-back
+   - stuck → send Enter once, re-check next cycle. After 3 attempts, ask user: "Session stuck. Retry or cancel?"
+   - budget_exhausted → ask user: "Budget exhausted. Re-dispatch or skip?"
+   - crashed / errored → log error, mark task as failed, continue with others
+   - timed_out → log timeout, mark task as failed
+   - running → continue monitoring
+3. When ANY session completes, report immediately: "✅ ses_abc123 Task 1 complete"
+4. When ALL dispatched sessions reach terminal states, exit the loop
+```
 
-```bash
-# Check all sessions
-curl -s http://localhost:3100/sessions | node -e "
-const d=require('fs').readFileSync('/dev/stdin','utf8');
-JSON.parse(d).forEach(s=>console.log(s.id, s.status, s.project));
-"
+**Use Bash `sleep 30` between poll cycles. Do not use background tasks for this — poll sequentially in the main conversation so results are visible.**
 
-# Check specific session output (inside container)
-docker exec tlc-agent-runner tmux capture-pane -t <session_id> -p -S -20
-```
+Surface progress at natural milestones:
+- When a session completes: one-line status update
+- When all sessions in a parallel batch complete: summary + trigger next batch
+- When a session fails: immediate report with error details
 
-Auto-approve any prompts found in tmux sessions:
+### Step O5a: Dispatch Dependent Tasks
+
+When a batch of tasks completes, check the dependency graph for newly unblocked tasks. Dispatch them immediately without asking.
 
-```bash
-docker exec tlc-agent-runner tmux send-keys -t <session_id> Enter
 ```
+Example:
+  Tasks 1+2 dispatched (parallel, no deps)
+  Task 1 completes → check if any task depends only on Task 1 → dispatch it
+  Task 2 completes → check if remaining tasks are unblocked → dispatch them
+  Tasks 3+4 now unblocked → dispatch immediately
+  ...continue until all tasks dispatched and completed
+```
+
+### Step O5b: Auto Merge-Back
+
+When all tasks in the phase complete (or all non-failed tasks complete):
+
+1. Pull all commits from container worktrees to the host phase branch
+2. Run the full test suite: `cd server && npx vitest run` (or project's test command)
+3. If tests pass → continue to Step O5c
+4. If tests fail → report failures, attempt auto-fix (one round), re-run tests
+
+### Step O5c: Auto Review + PR
+
+After tests pass:
+
+1. Run auto-review (same checks as Step 10 in Inline Mode)
+2. If review passes → push branch and create PR (ask user before pushing per project rules)
+3. If review fails → fix issues, re-run tests, re-review (max 3 iterations)
 
 ### Step O6: Cleanup
 
-When all tasks complete, remove `.tlc/.build-routing-active` and report results.
+After PR is created (or phase completes):
+- Remove `.tlc/.build-routing-active`
+- Remove `.tlc/.active-sessions.json`
+- Mark completed tasks `[x]` in PLAN.md
+- Report final summary
 
 ## INLINE MODE
 

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

@@ -1,86 +1,91 @@
 #!/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 ──────────────────────────────"
 
-# ─── 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
+# ─── 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)
 
-PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+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))
+else
+  echo "  TLC Package:     ✅ v${INSTALLED_VER} (latest)"
+fi
 
-# ─── 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 +97,210 @@ if command -v codedb >/dev/null 2>&1; then
   }
 }
 MCPEOF
-    echo "codedb: created .mcp.json"
+    echo "  CodeDB MCP:      ✅ created .mcp.json"
   fi
+else
+  echo "  CodeDB:          ❌ not installed (run: npx tlc-claude-code)"
+  ERRORS=$((ERRORS + 1))
 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)
+  if echo "$ORCH_LOGS" | grep -q "Session monitor started"; then
+    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
+    echo "  Watchdog:        ✅ active (60s interval)"
+  else
+    echo "  Watchdog:        ⚠️  not detected in logs"
+    WARNINGS=$((WARNINGS + 1))
+  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 [ "$CODEX_VER" != "not installed" ]; then
+  PROVIDER_COUNT=$((PROVIDER_COUNT + 1))
+  PROVIDER_LIST="${PROVIDER_LIST}codex(${CODEX_VER}), "
 fi
-if [ -n "$SPOOL_DRAIN" ]; then
-  node -e "$SPOOL_DRAIN" 2>/dev/null
+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}"
+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 ────────────────────────────────
+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);
+        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';
+        } 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/package.json

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