claude-code-team 0.1.6 → 0.1.8

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://badge.fury.io/js/claude-code-team.svg)](https://www.npmjs.com/package/claude-code-team)
 
-Orchestrate multiple Claude sessions to work on complex tasks in parallel.
+Orchestrate multiple Claude sessions with hierarchical team structure.
 
 ## Installation
 
@@ -31,22 +31,42 @@ claude --dangerously-skip-permissions
 ### Give orchestrator a task
 
 ```
-> Create a web service for generating startup ideas...
+> Analyze Smart Traffic market in Central Asia
 ```
 
-The orchestrator will:
-1. Ask clarifying questions
-2. Create worker sessions (specialists)
-3. Delegate tasks to workers
-4. Coordinate and aggregate results
+## Hierarchy
+
+```
+Orchestrator (you talk to this)
+    ↓ creates & manages
+Leads (Team Leads - coordinate domains)
+    ↓ create & manage
+Workers (Specialists - do actual work)
+```
+
+| Level | Creates | Manages | Does Work |
+|-------|---------|---------|-----------|
+| Orchestrator | Leads | Leads | NO |
+| Leads | Workers | Workers | NO |
+| Workers | — | — | YES |
 
 ## Project Structure
 
 After `cct init`:
 ```
 my-project/
-├── CLAUDE.md           # Orchestrator (reads this automatically)
-└── features/           # Agent & skill templates
+├── CLAUDE.md              # Orchestrator instructions
+├── features/              # Capabilities catalog
+│   ├── agents.md          # Available agent roles
+│   ├── skills.md          # Available skills
+│   ├── mcps.md            # Available MCP tools
+│   └── commands.md        # Available commands
+├── templates/
+│   └── lead.md            # Lead template (for orchestrator)
+├── leads/                 # Empty (leads created on demand)
+├── .context/              # Shared project context
+├── .outputs/              # Lead outputs
+└── .sessions/             # Session IDs
 ```
 
 After orchestrator runs:
@@ -54,23 +74,48 @@ After orchestrator runs:
 my-project/
 ├── CLAUDE.md
 ├── features/
-├── .sessions/          # Session IDs for Q&A
-├── .outputs/           # Worker results
+├── templates/
 ├── .context/
-│   └── project.md      # Shared project context
-├── workers/
-│   └── backend_worker/
-│       └── CLAUDE.md   # Worker identity
-├── backend/            # Actual code (written by workers)
-└── frontend/
+│   └── project.md         # Project context (written by orchestrator)
+├── .sessions/
+│   ├── orchestrator.id
+│   └── ba_lead.id
+├── .outputs/
+│   ├── ba_analysis.md     # Lead output
+│   └── ba_lead.status     # Completion signal
+└── leads/
+    └── ba_lead/
+        ├── CLAUDE.md      # Lead instructions
+        ├── .outputs/      # Worker outputs
+        │   ├── market.md
+        │   └── competitors.md
+        └── workers/
+            ├── market_analyst/
+            │   └── CLAUDE.md
+            └── competitive_analyst/
+                └── CLAUDE.md
 ```
 
 ## How It Works
 
-1. **Orchestrator** reads CLAUDE.md and understands its role
-2. **Orchestrator** creates workers (separate Claude sessions)
-3. **Workers** execute tasks and write results to `.outputs/`
-4. **Orchestrator** aggregates results and responds to user
+1. **User** gives task to Orchestrator
+2. **Orchestrator** writes `.context/project.md` and creates Leads
+3. **Leads** create Workers from `features/` catalog
+4. **Workers** execute tasks, write to Lead's `.outputs/`
+5. **Leads** aggregate worker results, write to root `.outputs/`
+6. **Orchestrator** reads Lead outputs, responds to User
+
+## Session Types
+
+| Type | How Created | By Whom |
+|------|-------------|---------|
+| User session | `claude` (interactive) | Human |
+| CCT session | `claude --session-id $ID -p "TASK"` | Orchestrator/Lead |
+
+- **Orchestrator** runs in user session (you talk to it)
+- **Leads** and **Workers** run as CCT sessions (created programmatically)
+- CCT sessions can be resumed with `-r $ID` for Q&A
+- Only **Workers** do actual work
 
 ## License
 

package/package.json

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

package/templates/lead.md

@@ -9,31 +9,6 @@ You are a **Team Lead** — a coordinator for your domain.
 - You **aggregate results** and report back to Orchestrator
 - You do NOT do the work yourself — you delegate to workers
 
-## CRITICAL: Workers vs Subagents
-
-| Type | How to Run | Use When |
-|------|-----------|----------|
-| **Worker** | `claude -p "TASK: ..." &` | One-shot task, no Q&A needed |
-| **Subagent** | `claude --session-id $ID -p "..."` | Need to ask questions, iterate |
-
-### Worker (одноразовый)
-```bash
-claude --dangerously-skip-permissions -p "TASK: Write market analysis" &
-```
-- Runs once, produces output, exits
-- Cannot ask questions
-- Use for well-defined tasks
-
-### Subagent (с сессией)
-```bash
-WORKER_ID=$(uuidgen)
-echo "$WORKER_ID" > .outputs/analyst.id
-claude --dangerously-skip-permissions --session-id "$WORKER_ID" -p "TASK: Research competitors"
-```
-- Can be resumed with `-r $WORKER_ID`
-- Can receive follow-up instructions
-- Use when you might need to clarify or iterate
-
 ## Your Structure
 
 ```
@@ -115,19 +90,11 @@ EOF
 
 ### 5. Launch Worker
 
-**For one-shot task (worker):**
-```bash
-cd workers/<name>
-claude --dangerously-skip-permissions -p "TASK: <specific task>" &
-cd ../..
-```
-
-**For iterative task (subagent):**
 ```bash
 cd workers/<name>
 WORKER_ID=$(uuidgen)
 echo "$WORKER_ID" > ../../.outputs/<name>.id
-claude --dangerously-skip-permissions --session-id "$WORKER_ID" -p "TASK: <task>"
+claude --dangerously-skip-permissions --session-id "$WORKER_ID" -p "TASK: <specific task>" &
 cd ../..
 ```
 
@@ -137,12 +104,21 @@ cd ../..
 # Check status
 ls .outputs/*.status 2>/dev/null
 
+# Check for questions
+ls .outputs/*.question 2>/dev/null
+
 # Read outputs
 cat .outputs/*.md
+```
+
+## Answering Worker Questions
 
-# Resume subagent if needed
+When worker writes a question to `.outputs/<name>.question`:
+
+```bash
 WORKER_ID=$(cat .outputs/<name>.id)
-claude -r "$WORKER_ID" -p "Additional instruction..."
+claude -r "$WORKER_ID" -p "ANSWER: <your answer>"
+rm .outputs/<name>.question
 ```
 
 ## When All Workers Done
@@ -185,6 +161,5 @@ fi
 1. **Check catalog first** — `../../features/` has available roles and tools
 2. **Read project context** — `../../.context/project.md`
 3. **Delegate everything** — don't do work yourself
-4. **Choose worker vs subagent** — one-shot vs iterative
-5. **Aggregate results** — combine worker outputs into cohesive report
-6. **Signal when done** — so Orchestrator knows
+4. **Aggregate results** — combine worker outputs into cohesive report
+5. **Signal when done** — so Orchestrator knows