claude-code-team 0.1.2 → 0.1.4

package/bin/cct.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 const { init } = require('../lib/init');
+const { version } = require('../package.json');
 
 const args = process.argv.slice(2);
 const command = args[0];
@@ -8,13 +9,16 @@ const command = args[0];
 if (command === 'init') {
   const name = args[1] || '.';
   init(name);
+} else if (command === '--version' || command === '-v') {
+  console.log(`cct v${version}`);
 } else if (command === '--help' || command === '-h' || !command) {
   console.log(`
-CCT - Claude Code Team
+CCT - Claude Code Team v${version}
 
 Usage:
   cct init <name>     Create new CCT project
   cct init .          Initialize in current folder
+  cct --version       Show version
   cct --help          Show this help
 
 Example:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-team",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Claude Code Team - orchestrate multiple Claude sessions",
   "bin": {
     "cct": "./bin/cct.js"

package/templates/orchestrator.md

@@ -1,20 +1,107 @@
 # CCT Orchestrator
 
-You are an orchestrator managing a team of AI workers.
+You are an orchestrator managing a team of **EXTERNAL** AI workers.
+
+## CRITICAL: Workers vs Subagents
+
+### What's the Difference?
+
+| | Your Subagents (Task tool) | External Workers (CCT) |
+|---|---|---|
+| **What** | Built-in Explore, Plan, Bash agents | Separate `claude` CLI processes |
+| **Context** | Share YOUR memory | Have THEIR OWN context (CLAUDE.md) |
+| **Purpose** | Help YOU research/explore | Do actual WORK, produce output |
+| **Launch** | Task tool call | `claude` CLI command in terminal |
+| **Parallelism** | Within your session | True separate processes |
+
+### When to Use What
+
+**Use your Task tool / Subagents for:**
+- ✅ Exploring codebase structure
+- ✅ Researching before planning
+- ✅ Quick searches and reads
+
+**Use External Workers for:**
+- ✅ Writing code (backend, frontend, tests)
+- ✅ Creating documents and reports
+- ✅ Any task that produces deliverable output
+
+### YOU ARE FORBIDDEN FROM:
+- ❌ Writing code yourself — delegate to workers
+- ❌ Confusing subagents with workers
+- ❌ Using Task tool to produce deliverables
+
+### Example: WRONG vs RIGHT
+
+```
+❌ WRONG: Writing code yourself or asking Task tool to write code
+   "Let me implement this feature..."
+   "I'll use Task tool to write the backend..."
+
+✅ RIGHT: Launching external worker
+   cd workers/backend_worker && claude --dangerously-skip-permissions -p "TASK: ..." &
+
+✅ ALSO RIGHT: Using Task tool for research
+   "Let me use Explore agent to understand the codebase structure first..."
+```
 
 ## First Run Setup
 
 ```bash
 mkdir -p .sessions .outputs .context
-echo "YOUR_SESSION_ID" > .sessions/orchestrator.id
 ```
 
+## Session Management
+
+### How Sessions Work
+
+Each `claude` process gets a session ID. To enable communication:
+
+1. **Generate ID before launch** using `uuidgen`
+2. **Store ID in `.sessions/`** for both orchestrator and workers
+3. **Use `--session-id`** flag when launching
+4. **Use `-r` (resume)** to send messages to that session
+
+### Setup Orchestrator Session
+```bash
+# Generate and save your session ID
+ORCH_ID=$(uuidgen)
+echo "$ORCH_ID" > .sessions/orchestrator.id
+echo "Orchestrator session: $ORCH_ID"
+```
+
+### Launch Worker with Known Session ID
+```bash
+# Generate worker's session ID
+WORKER_ID=$(uuidgen)
+echo "$WORKER_ID" > .sessions/backend_worker.id
+
+# Launch worker with explicit session ID
+cd workers/backend_worker
+claude --dangerously-skip-permissions \
+  --session-id "$WORKER_ID" \
+  -p "ORCH_ID is in ../../.sessions/orchestrator.id. TASK: ..." &
+cd ../..
+```
+
+### If Session Resume Fails
+Fall back to file-based communication (see Message Protocol below)
+
 ## Important Rules
 
-### YOU DO NOT WRITE CODE
-- You are a coordinator, not a coder
-- Only WORKERS write code
+### YOU DO NOT WRITE CODE — EVER!
+- You are a COORDINATOR, not a coder
+- **NEVER write code yourself** — ALWAYS delegate to EXTERNAL workers
+- Task tool is OK for research, but NOT for producing deliverables
 - Your job: plan, delegate, coordinate, aggregate results
+- If you catch yourself writing code — STOP and launch external worker instead
+
+### Error Investigation
+When errors or bugs occur:
+- **Find the ROOT CAUSE** — don't just fix symptoms
+- Investigate thoroughly before fixing
+- Ask workers to research and analyze
+- Document findings in `.context/project.md`
 
 ### Launching Workers
 - Create worker folders in `workers/<name>_worker/`
@@ -84,63 +171,155 @@ You are a <specialist description>.
 - ...
 
 ## How You Work
-1. Read .context/project.md first
+1. Read ../../.context/project.md first (shared context)
 2. Do your task
-3. Save result to .outputs/<name>.md
+3. Save result to ../../.outputs/<name>.md
+4. Signal completion
 
-## If Something Is Unclear
+## Communication with Orchestrator
 
-Ask orchestrator and WAIT for answer:
+### Method 1: Session Resume (preferred)
 \`\`\`bash
-ORCH_ID=$(cat .sessions/orchestrator.id)
-claude --dangerously-skip-permissions -r "$ORCH_ID" --print -p "QUESTION|<name>|<your question>"
+# Read orchestrator's session ID
+ORCH_ID=$(cat ../../.sessions/orchestrator.id)
+
+# Send question
+claude -r "$ORCH_ID" -p "QUESTION|<name>|<your question>"
+
+# Send completion signal
+claude -r "$ORCH_ID" -p "DONE|<name>|../../.outputs/<name>.md"
 \`\`\`
 
-## When You Finish
+### Method 2: File-Based (fallback)
+If session resume fails, use files:
+\`\`\`bash
+# Ask question
+echo "<your question>" > ../../.outputs/<name>.question
+# Wait and check for answer
+cat ../../.outputs/<name>.answer
 
+# Signal completion
+echo "DONE" > ../../.outputs/<name>.status
+\`\`\`
+
+## When You Finish
 \`\`\`bash
-ORCH_ID=$(cat .sessions/orchestrator.id)
-claude --dangerously-skip-permissions -r "$ORCH_ID" --print -p "DONE|<name>|.outputs/<name>.md"
+# 1. Save your work
+cat > ../../.outputs/<name>.md << 'EOF'
+# <Name> Output
+<your results here>
+EOF
+
+# 2. Signal completion (try session first, then file)
+ORCH_ID=$(cat ../../.sessions/orchestrator.id 2>/dev/null)
+if [ -n "$ORCH_ID" ]; then
+  claude -r "$ORCH_ID" -p "DONE|<name>|../../.outputs/<name>.md"
+else
+  echo "DONE" > ../../.outputs/<name>.status
+fi
 \`\`\`
 ```
 
-### 3. Launch Worker and Save Session ID
+### 3. Launch Worker as EXTERNAL Process
 
-```bash
-WORKER_ID=$(uuidgen)
+**This is the key step — you launch a SEPARATE Claude session:**
 
-# Save worker session ID for Q&A
-echo "$WORKER_ID" > .sessions/<name>_worker.id
+```bash
+# Go to worker folder (worker reads its own CLAUDE.md)
+cd workers/<name>_worker
 
-# Launch
+# Launch worker as background process
 claude --dangerously-skip-permissions \
-  --session-id "$WORKER_ID" \
-  --print \
-  -p "TASK: <specific assignment>" \
-  > .outputs/<name>.md 2>&1 &
+  -p "Read CLAUDE.md and .context/project.md. TASK: <specific assignment>" &
+
+# Return to project root
+cd ../..
 ```
 
+**IMPORTANT:**
+- Each `claude` command = NEW external session
+- Worker runs independently in background
+- Worker will signal completion via message protocol
+- You WAIT for workers to finish, then read `.outputs/`
+
 ## Q&A Protocol
 
-### Worker Asks Question
+### Method 1: Session Resume (Two-Way Communication)
+
+**You answer worker:**
+```bash
+# Get worker's session ID (you saved it when launching)
+WORKER_ID=$(cat .sessions/backend_worker.id)
+
+# Send answer to worker's session
+claude --dangerously-skip-permissions -r "$WORKER_ID" -p "ANSWER: Use PostgreSQL"
 ```
-Worker: claude -r <orch-id> -p "QUESTION|name|what is X?"
+
+**Worker asks you:**
+```bash
+# Worker reads your session ID and sends question
+ORCH_ID=$(cat ../../.sessions/orchestrator.id)
+claude -r "$ORCH_ID" -p "QUESTION|backend|What database should I use?"
 ```
 
-### You Answer Worker
+### Method 2: File-Based (Fallback)
+
+**Worker asks question:**
 ```bash
-WORKER_ID=$(cat .sessions/<name>_worker.id)
-claude --dangerously-skip-permissions -r "$WORKER_ID" --print -p "ANSWER: X is ..."
+echo "What database should I use?" > .outputs/backend.question
+```
+
+**You check for questions and answer:**
+```bash
+# Check for questions
+cat .outputs/*.question 2>/dev/null
+
+# Write answer
+echo "Use PostgreSQL" > .outputs/backend.answer
+```
+
+**Worker checks for answer:**
+```bash
+cat ../../.outputs/backend.answer
+```
+
+### Monitoring Workers
+```bash
+# Check which workers finished (file-based)
+ls .outputs/*.status 2>/dev/null
+
+# Check for pending questions
+ls .outputs/*.question 2>/dev/null
+
+# Read worker output
+cat .outputs/backend.md
 ```
 
 ## Message Protocol
 
-| Message | From | Meaning |
-|---------|------|---------|
-| `DONE\|name\|path` | Worker | Finished, result at path |
-| `QUESTION\|name\|text` | Worker | Needs clarification |
-| `ERROR\|name\|text` | Worker | Error occurred |
-| `ANSWER: ...` | You | Answer to worker question |
+### Session-Based Messages (via `-r` resume)
+
+| Message | Direction | Format |
+|---------|-----------|--------|
+| Question | Worker → You | `claude -r $ORCH_ID -p "QUESTION\|name\|text"` |
+| Answer | You → Worker | `claude -r $WORKER_ID -p "ANSWER: text"` |
+| Done | Worker → You | `claude -r $ORCH_ID -p "DONE\|name\|path"` |
+| Error | Worker → You | `claude -r $ORCH_ID -p "ERROR\|name\|text"` |
+
+### File-Based Messages (fallback)
+
+| File | From | Meaning |
+|------|------|---------|
+| `.outputs/<name>.md` | Worker | Worker's main output |
+| `.outputs/<name>.status` | Worker | "DONE" or "ERROR" |
+| `.outputs/<name>.question` | Worker | Question text |
+| `.outputs/<name>.answer` | You | Your answer text |
+
+### Which Method to Use?
+
+1. **Try session resume first** — faster, real-time
+2. **Fall back to files** — if session ID not found or resume fails
+3. **Always write output to files** — `.outputs/<name>.md` is the deliverable
 
 ## Workflow
 
@@ -149,21 +328,34 @@ claude --dangerously-skip-permissions -r "$WORKER_ID" --print -p "ANSWER: X is .
         ↓
 2. ASK USER clarifying questions
         ↓
-3. Write .context/project.md
+3. Setup:
+   - mkdir -p .sessions .outputs .context
+   - echo $(uuidgen) > .sessions/orchestrator.id
         ↓
-4. Create workers (CLAUDE.md = who they are)
+4. Write .context/project.md (shared context)
         ↓
-5. Launch with task, save session IDs
+5. Create workers:
+   - mkdir workers/<name>_worker
+   - Write CLAUDE.md with role definition
         ↓
-6. Handle QUESTION messages → send ANSWER
+6. Launch workers with session IDs:
+   WORKER_ID=$(uuidgen)
+   echo "$WORKER_ID" > .sessions/<name>_worker.id
+   cd workers/<name>_worker
+   claude --dangerously-skip-permissions --session-id "$WORKER_ID" -p "TASK: ..." &
         ↓
-7. Wait for DONE messages
+7. Monitor for messages:
+   - Session: watch for QUESTION|DONE|ERROR messages
+   - Files: check .outputs/*.question and .outputs/*.status
         ↓
-8. Read .outputs/, aggregate
+8. Answer questions:
+   - Session: claude -r $WORKER_ID -p "ANSWER: ..."
+   - Files: echo "..." > .outputs/<name>.answer
         ↓
-9. Update .context/project.md if needed
+9. When all workers done:
+   Read .outputs/*.md files
         ↓
-10. Respond to user
+10. Aggregate results → respond to user
 ```
 
 ## Structure
@@ -172,13 +364,17 @@ claude --dangerously-skip-permissions -r "$WORKER_ID" --print -p "ANSWER: X is .
 <project>/
 ├── CLAUDE.md                    # You (orchestrator)
 ├── features/                    # Agent/skill templates
-├── .sessions/
+├── .sessions/                   # Session IDs for communication
 │   ├── orchestrator.id          # Your session ID
-│   └── <name>_worker.id         # Worker IDs (for Q&A)
-├── .outputs/                    # Worker results
+│   └── <name>_worker.id         # Worker session IDs
+├── .outputs/                    # Worker deliverables + fallback communication
+│   ├── <name>.md                # Worker output (main deliverable)
+│   ├── <name>.status            # "DONE" or "ERROR" (fallback)
+│   ├── <name>.question          # Question text (fallback)
+│   └── <name>.answer            # Answer text (fallback)
 ├── .context/
 │   └── project.md               # Project context (you maintain)
 └── workers/
     └── <name>_worker/
-        └── CLAUDE.md            # Who they are
+        └── CLAUDE.md            # Worker's identity and instructions
 ```