tlc-claude-code 2.6.0 → 2.6.1

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

@@ -113,24 +113,99 @@ After `resolveRouting` returns, immediately write `.tlc/.build-routing-active` w
 
 Use this mode only when `models[0]` is **NOT** `claude`.
 
-Claude does not execute the build instructions inline in this path. Claude acts as the orchestrator for the routed provider run:
-
-1. Read the full build plan and break the work into the smallest practical execution slices for Codex-style `exec` dispatches.
-2. For each slice, prepare the exact task context, success criteria, test target, and file scope before dispatch.
-3. Resolve orchestration modules with fallback: try `tlc-claude-code/server/lib/...` first, then `$PROJECT_DIR/server/lib/...`.
-4. Build the full prompt with `buildFullPrompt` from `orchestration/prompt-builder`.
-5. Dispatch through unified CLI routing with `dispatch` from `orchestration/cli-dispatch`.
-6. After each provider response, capture output for memory with `captureFromProvider` from `capture`.
-7. Verify every returned result:
-   - Confirm the requested change was actually made.
-   - Confirm tests relevant to that slice were run or explain why not.
-   - Reject incomplete, unverifiable, or off-plan output.
-8. Handle failures explicitly:
-   - If dispatch fails because of model mismatch, auth, or missing CLI, check `.tlc/.router-state.json` for the provider's actual available model and retry once with the corrected model.
-   - If retry still fails, stop and report the exact failure to the user. Do not silently fall back to Claude inline execution.
-   - If a dispatched task returns partial or broken work, issue a focused follow-up dispatch for the fix instead of continuing blindly.
-9. Continue dispatch/verify/fix until the routed provider work is complete and validated.
-10. When finished, display the provider output summary, persist captured memory, remove `.tlc/.build-routing-active`, and stop. Do **not** execute Inline Mode instructions afterward.
+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.
+
+### Step O1: Read the Plan
+
+Read `.planning/phases/{N}-PLAN.md`. Extract each task's goal, files, acceptance criteria, and test cases.
+
+### Step O2: Check Orchestrator Health
+
+```bash
+curl -sf http://localhost:3100/health
+```
+
+If healthy, dispatch via orchestrator (Step O3). If unreachable, fall back to direct Codex dispatch via Bash (Step O3-fallback).
+
+### Step O3: Dispatch Tasks to Orchestrator
+
+For each independent task, dispatch via the orchestrator API:
+
+```bash
+curl -s -X POST http://localhost:3100/sessions \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "project": "<project-name>",
+    "pool": "local-tmux",
+    "command": "<provider>",
+    "prompt": "<task prompt — one clear action, explicit file paths, under 500 words>"
+  }'
+```
+
+- `project`: the repo directory name under `/workspace/` (e.g., `Tools/TLC`)
+- `command`: the provider from routing result (e.g., `codex`)
+- `prompt`: small focused prompt for one task — include file paths, acceptance criteria, test command
+
+**Save each returned session ID** to `.tlc/.active-sessions.json`:
+
+```bash
+node -e "
+const fs = require('fs');
+const path = '.tlc/.active-sessions.json';
+const existing = fs.existsSync(path) ? JSON.parse(fs.readFileSync(path, 'utf8')) : [];
+existing.push({ sessionId: '<id>', taskName: '<task>', startedAt: new Date().toISOString() });
+fs.writeFileSync(path, JSON.stringify(existing, null, 2));
+"
+```
+
+### Step O3-fallback: Direct Dispatch (No Orchestrator)
+
+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
+```
+
+### Step O4: Report and Free
+
+After dispatching all tasks, report:
+
+```
+Dispatched N tasks to orchestrator:
+  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?
+```
+
+**STOP HERE.** Do not write code. Do not execute inline mode. Claude is the PM, not the coder.
+
+### Step O5: Monitor (When User Asks)
+
+When the user asks for status or agents complete, check:
+
+```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));
+"
+
+# Check specific session output (inside container)
+docker exec tlc-agent-runner tmux capture-pane -t <session_id> -p -S -20
+```
+
+Auto-approve any prompts found in tmux sessions:
+
+```bash
+docker exec tlc-agent-runner tmux send-keys -t <session_id> Enter
+```
+
+### Step O6: Cleanup
+
+When all tasks complete, remove `.tlc/.build-routing-active` and report results.
 
 ## INLINE MODE
 

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

@@ -44,12 +44,32 @@ else
 fi
 
 # --- tlc-core Orchestrator ---
+# Kill switch: export TLC_CORE_AUTOSTART=false to disable auto-start
 TLC_CORE_PORT="${TLC_CORE_PORT:-3100}"
-if curl -sf --max-time 1 "http://localhost:${TLC_CORE_PORT}/health" > /dev/null 2>&1; then
+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)"
 else
-  echo "tlc-core orchestrator: not running. Agent dispatch will fall back to local mode."
+  # 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
 fi
 
 # ─── Memory System Init ─────────────────────────────

package/package.json

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