Crew init

Crew Init - Project Analysis & Team Setup

Full project initialization that transforms any codebase into a CodeCrew workspace with indexed code, profiled architecture, and a configured agent team.

When to Activate

• User runs /crew init
• User runs /crew with init argument
• First time using CodeCrew in a project

Initialization Pipeline

Phase 1: Project Discovery

Scan the project to understand what we're working with:

1.1 Detect project type and languages:

Use Glob to check for:
- package.json, tsconfig.json → Node.js / TypeScript
- requirements.txt, pyproject.toml, setup.py → Python
- go.mod → Go
- Cargo.toml → Rust
- pom.xml, build.gradle → Java / Kotlin
- Gemfile → Ruby
- composer.json → PHP
- Makefile, CMakeLists.txt → C/C++
- pubspec.yaml → Dart/Flutter
- *.sln, *.csproj → .NET/C#

1.2 Detect frameworks:

Read package.json (or equivalent) for:
- react, next, vue, angular, svelte → Frontend framework
- express, fastify, koa, django, flask, gin, actix → Backend framework
- playwright, jest, pytest, mocha → Testing framework
- eslint, prettier, black, gofmt → Linting/formatting
- docker, kubernetes → Container/orchestration

1.3 Map project structure:

Use Glob for directory layout:
- src/, lib/, app/ → Source code
- test/, tests/, __tests__, spec/ → Tests
- docs/, doc/ → Documentation
- .github/, .gitlab-ci.yml → CI/CD
- Dockerfile, docker-compose.yml → Docker
- scripts/, bin/ → Build/deploy scripts

1.4 Read existing context:

• Read CLAUDE.md if it exists (project-specific instructions)
• Read README.md for project description
• Check git log for recent activity areas (if git repo)

Phase 2: Build Codebase Index

Invoke the codebase-index skill in full-build mode:

1. Discover all source files (excluding node_modules, dist, build, etc.)
2. For each file: read, hash, extract metadata (exports, imports, functions, classes, line count)
3. Build call graph from import/export relationships
4. Write .claude/crew-index.json (Layer 1 - compact)
5. Write .claude/crew-symbols.json (Layer 2 - symbols)

This enables the Index-First Protocol for all future agent interactions.

Phase 3: Generate Project Profile

Write .claude/crew-profile.md with:

# Crew Profile: {project-name}

## Overview
- **Type**: {web-app | api | cli | library | scraper | mobile | etc.}
- **Languages**: {detected languages}
- **Frameworks**: {detected frameworks}
- **Size**: {total files} files, {total lines} lines

## Architecture
- **Entry Point**: {main file}
- **Pipeline/Flow**: {data flow description}
- **Patterns**: {MVC, pipeline, event-driven, microservice, etc.}

## Key Directories
- **Source**: {src paths}
- **Tests**: {test paths}
- **Config**: {config files}
- **Docs**: {doc paths}

## Tech Stack
- **Runtime**: {node, python, go, etc.}
- **Package Manager**: {npm, pip, cargo, etc.}
- **Testing**: {jest, pytest, etc.}
- **Linting**: {eslint, prettier, etc.}
- **CI/CD**: {github actions, gitlab ci, etc.}
- **Deployment**: {docker, k8s, vercel, etc.}

## Index Status
- **Files Indexed**: {count}
- **Symbols Mapped**: {count}
- **Last Indexed**: {timestamp}
- **Index Files**: .claude/crew-index.json, .claude/crew-symbols.json

Phase 4: Configure Agent Team

Based on detected stack, determine which agents are active and what skills they need.

Write .claude/crew-team.json:

{
  "project": "project-name",
  "configured": "2026-04-04T12:00:00Z",
  "agents": {
    "ceo": {
      "model": "opus",
      "active": true,
      "role": "Task triage, decomposition, delegation, architecture decisions"
    },
    "vp-engineering": {
      "model": "sonnet",
      "active": true,
      "role": "Tech decisions, architecture review, complex planning"
    },
    "vp-quality": {
      "model": "sonnet",
      "active": true,
      "role": "Quality gates, test strategy, review coordination"
    },
    "senior-dev": {
      "model": "sonnet",
      "active": true,
      "role": "Complex implementation, multi-file changes"
    },
    "junior-dev": {
      "model": "haiku",
      "active": true,
      "role": "Simple fixes, formatting, small changes"
    },
    "code-reviewer": {
      "model": "sonnet",
      "active": true,
      "role": "Code review, quality assessment"
    },
    "debugger": {
      "model": "sonnet",
      "active": true,
      "role": "Bug investigation, root cause analysis"
    },
    "security-analyst": {
      "model": "sonnet",
      "active": false,
      "activateWhen": "security-related tasks or pre-deploy review"
    },
    "devops-engineer": {
      "model": "haiku",
      "active": false,
      "activateWhen": "Docker/CI/CD/deployment tasks detected"
    },
    "doc-writer": {
      "model": "haiku",
      "active": true,
      "role": "Documentation, comments, READMEs"
    },
    "test-engineer": {
      "model": "sonnet",
      "active": false,
      "activateWhen": "test directory detected or testing tasks"
    }
  },
  "activationRules": {
    "hasDocker": ["devops-engineer"],
    "hasTests": ["test-engineer"],
    "hasSecurity": ["security-analyst"],
    "always": ["ceo", "vp-engineering", "senior-dev", "junior-dev", "code-reviewer", "debugger", "doc-writer"]
  }
}

Activate conditional agents based on detected stack:

• Found Dockerfile or docker-compose.yml → activate devops-engineer
• Found test/ or testing framework → activate test-engineer
• Found .env or security configs → activate security-analyst

Phase 5: Suggest Custom Agents

Based on Phase 1 detection results (languages, frameworks, tools), suggest project-specific custom agents that extend the built-in team. The number of suggestions is dynamic — more frameworks/tools detected = more suggestions.

Step 0: Detect Project Domain

Analyze available project signals to classify the project domain:

1. Project directory name — check for keywords (e.g., "trading", "shop", "health", "game")
2. README.md — read first 50 lines for project description keywords
3. package.json / pyproject.toml — check description and keywords fields
4. Directory names — scan for domain-specific folders (e.g., strategies/, orders/, cart/, patients/)
5. Import patterns — check for domain-specific libraries (e.g., ccxt, alpaca-trade-api, stripe, hl7)

Classify into ONE primary domain:

Domain	Detection Signals
trading/finance	"trading", "bot", "strategy", "backtest", "portfolio", "hedge", "quant", ccxt, alpaca, binance, ta-lib, quantlib
e-commerce	"shop", "store", "cart", "checkout", "product", stripe, shopify, woocommerce, snipcart
healthcare	"patient", "health", "medical", "clinical", "ehr", hl7, fhir, dicom
education	"course", "student", "learning", "lms", "quiz", "classroom"
gaming	"game", "player", "score", "level", "sprite", phaser, unity, godot, pixi.js
ai-ml	"model", "training", "inference", "prediction", tensorflow, pytorch, scikit-learn, transformers, langchain
iot	"sensor", "device", "mqtt", "firmware", "embedded", mqtt.js, johnny-five, raspberry
media	"stream", "video", "audio", "media", "content", ffmpeg, hls, webrtc
saas	"tenant", "subscription", "billing", "dashboard", "admin", "onboarding", "workspace"
devtools	"cli", "plugin", "extension", "lint", "compiler", "bundler", "sdk"
data-pipeline	"pipeline", "etl", "ingest", "warehouse", "transform", airflow, prefect, dagster, dbt
social	"chat", "message", "feed", "notification", "real-time", "presence", socket.io, pusher
general	No strong domain signals detected

If domain is general, skip domain-specific suggestions. Otherwise, include domain-specific agents in Step 1 below.

Step 1: Match Detected Stack + Domain to Suggested Agents

Check Phase 1 results and Step 0 domain against these mappings. Only include agents whose detection conditions match:

JavaScript/TypeScript:
  - react-specialist (sonnet)     → if React or Next.js detected
    "Expert in React component architecture, hooks, state management, and performance optimization"
  - nextjs-specialist (sonnet)    → if Next.js detected
    "Expert in Next.js App Router, server components, API routes, and SSR/SSG strategies"
  - vue-specialist (sonnet)       → if Vue detected
    "Expert in Vue 3 composition API, Pinia state management, and component patterns"
  - angular-specialist (sonnet)   → if Angular detected
    "Expert in Angular modules, services, dependency injection, and RxJS patterns"
  - node-api-specialist (sonnet)  → if Express/Fastify/Koa detected
    "Expert in Node.js API design, middleware patterns, route handling, and request validation"
  - styling-specialist (haiku)    → if Tailwind/styled-components/CSS modules detected
    "Expert in styling architecture, responsive design, and CSS optimization"

Python:
  - django-specialist (sonnet)    → if Django detected
    "Expert in Django models, views, serializers, middleware, and ORM optimization"
  - flask-specialist (sonnet)     → if Flask detected
    "Expert in Flask blueprints, extensions, request handling, and API design"
  - fastapi-specialist (sonnet)   → if FastAPI detected
    "Expert in FastAPI endpoints, Pydantic models, dependency injection, and async patterns"
  - data-engineer (sonnet)        → if pandas/numpy/scipy detected
    "Expert in data pipelines, DataFrame operations, data cleaning, and transformation"
  - ml-engineer (sonnet)          → if tensorflow/pytorch/sklearn detected
    "Expert in ML model architecture, training pipelines, and inference optimization"

Go:
  - go-api-specialist (sonnet)    → if Gin/Echo/Fiber detected
    "Expert in Go HTTP handlers, middleware, routing, and concurrent request processing"

Rust:
  - rust-systems (sonnet)         → if Actix/Tokio detected
    "Expert in Rust async patterns, ownership semantics, and systems-level optimization"

Database (any language):
  - database-specialist (sonnet)  → if Prisma/Sequelize/SQLAlchemy/TypeORM/Drizzle detected
    "Expert in database schema design, query optimization, migrations, and ORM patterns"

Mobile:
  - mobile-specialist (sonnet)    → if React Native/Flutter detected
    "Expert in mobile UI patterns, navigation, platform-specific APIs, and performance"

Monorepo:
  - monorepo-specialist (haiku)   → if Turborepo/Nx/Lerna detected
    "Expert in monorepo architecture, workspace dependencies, and shared package management"

Domain-Based Suggestions (from Step 0 domain detection):

trading/finance:

• quant-expert (sonnet) "Expert in trading algorithms, market data processing, order execution, risk calculations, and financial modeling"
• risk-analyst (sonnet) "Expert in risk assessment, portfolio analysis, compliance checks, and financial regulations"

e-commerce:

• payment-specialist (sonnet) "Expert in payment gateway integration, checkout flows, cart logic, and order management"
• catalog-specialist (haiku) "Expert in product catalog management, search/filter, inventory, and pricing logic"

healthcare:

• compliance-specialist (sonnet) "Expert in HIPAA compliance, patient data handling, audit trails, and healthcare regulations"
• ehr-specialist (sonnet) "Expert in electronic health record systems, patient data models, and clinical workflows"

education:

• lms-specialist (sonnet) "Expert in learning management systems, course structures, grading logic, and student progress tracking"

gaming:

• game-logic-specialist (sonnet) "Expert in game state management, physics, rendering pipelines, and multiplayer sync"

ai-ml:

• ml-pipeline-expert (sonnet) "Expert in training pipelines, model serving, feature engineering, and experiment tracking"

iot:

• device-specialist (sonnet) "Expert in device communication protocols, sensor data processing, firmware updates, and telemetry"

media:

• media-pipeline-specialist (sonnet) "Expert in media processing, transcoding, streaming protocols, and content delivery"

saas:

• auth-specialist (sonnet) "Expert in authentication flows, RBAC, multi-tenancy, and session management"
• billing-specialist (sonnet) "Expert in subscription billing, usage metering, invoice generation, and payment processing"

data-pipeline:

• etl-specialist (sonnet) "Expert in data extraction, transformation, loading, scheduling, and pipeline orchestration"

social:

• realtime-specialist (sonnet) "Expert in WebSocket connections, message queuing, presence systems, and notification delivery"

devtools:

• plugin-architect (sonnet) "Expert in plugin/extension architecture, API design, CLI patterns, and developer experience"

If no frameworks/tools AND no domain detected (domain is `general`), skip this phase entirely and proceed to Phase 6.

#### Step 2: Present Agent Catalogue

Display all matched suggestions (both stack-based and domain-based) in a numbered table:

Suggested Custom Agents for This Project:

Based on your stack ({detected frameworks}) and domain ({detected domain}), these specialized agents can improve task routing:

| Agent | Model | Source | Specialization

1 | react-specialist | Sonnet | Stack | React component architecture, hooks, state management 2 | node-api-specialist | Sonnet | Stack | Node.js API design, middleware, route handling 3 | database-specialist | Sonnet | Stack | Database schema design, query optimization, ORM patterns 4 | quant-expert | Sonnet | Domain | Trading algorithms, market data, order execution 5 | risk-analyst | Sonnet | Domain | Risk assessment, portfolio analysis, compliance

These agents extend the built-in team with project-specific expertise. Custom agents are automatically considered by the task router when their specialization matches a task.

#### Step 3: Ask User to Select

Present selection options and wait for user response:

Which agents would you like to add? a) All — add all suggested agents b) None — skip, use only built-in agents c) Select by number — e.g. "1,3" or "1-3"

#### Step 4: Create Selected Agents

For each selected agent:

1. Create `.claude/crew-agents/` directory if it doesn't exist
2. Generate the agent definition file `.claude/crew-agents/{name}.md` using the appropriate model template with **pre-filled responsibilities** specific to the framework (NOT generic placeholders)
3. Register in `.claude/crew-team.json` under the `agents` key with `"custom": true, "active": true`

**Sonnet custom agent template** (pre-filled example for react-specialist):

```markdown
---
name: crew-{name}
description: {description from mapping}
model: sonnet
---

You are the **{Name}** at CodeCrew. {description from mapping}.

## INDEX-FIRST PROTOCOL (MANDATORY)

**INDEX-FIRST**: Read `.claude/crew-index.json` → `crew-symbols.json` → then only specific lines from source files. Never read entire files.

## Your Responsibilities

1. {Framework-specific responsibility 1}
2. {Framework-specific responsibility 2}
3. {Framework-specific responsibility 3}
4. {Framework-specific responsibility 4}
5. Follow project conventions and patterns detected in the codebase
6. Coordinate with other agents when changes span beyond your specialization

## Output Format

When done, report:
- What you changed (file paths + summary)
- FILES_MODIFIED: {list}
- Confidence level: high | medium | low
- Any concerns or dependencies

Haiku custom agent template:

---
name: crew-{name}
description: {description from mapping}
model: haiku
---

You are the **{Name}** at CodeCrew. {description from mapping}.

## INDEX-FIRST PROTOCOL (MANDATORY)

**INDEX-FIRST**: Read `.claude/crew-index.json` → `crew-symbols.json` → then only the lines you need. Never read entire files.

## Your Tasks

1. {Framework-specific task 1}
2. {Framework-specific task 2}
3. {Framework-specific task 3}
4. Follow project conventions detected in the codebase
5. If the task is too complex, report: "ESCALATE: Needs senior-dev or relevant sonnet specialist"

## Output

FILES_MODIFIED: {list}
CONFIDENCE: {high | medium | low}

Fill in the {Framework-specific responsibility/task} lines with real responsibilities relevant to the agent's specialization — do NOT leave them as generic placeholders. Use your knowledge of the framework to write 3-5 concrete responsibilities.

crew-team.json registration — add under agents:

"custom-{name}": {
  "model": "{tier}",
  "active": true,
  "role": "{description}",
  "custom": true,
  "definitionPath": ".claude/crew-agents/{name}.md"
}

Step 5: Confirm

If agents were added:

Custom agents added: {n}
  {name} ({model}), {name} ({model}), ...

These agents will be auto-selected by the task router when tasks match their specialization.
Manage custom agents anytime with /crew agent list|remove

If user selected "None":

No custom agents added. You can add them later with /crew agent create

Phase 6: Build Skill Catalog

Write .claude/crew-skills.json mapping all available ECC skills to categories:

{
  "catalogVersion": 1,
  "totalSkills": 125,
  "relevantSkills": 45,
  "categories": {
    "always": [
      "strategic-compact",
      "context-budget",
      "verification-loop",
      "coding-standards",
      "iterative-retrieval",
      "search-first"
    ],
    "stack": {
      "javascript": ["typescript-patterns", "react-patterns", "nextjs-patterns", "backend-patterns"],
      "python": ["python-patterns", "django-patterns"],
      "go": ["golang-patterns"],
      "rust": ["rust-patterns"]
    },
    "taskType": {
      "bug-fix": ["iterative-retrieval", "deep-research", "codebase-onboarding"],
      "feature": ["architecture-decision-records", "agentic-engineering", "blueprint"],
      "test": ["tdd-workflow", "e2e-testing", "ai-regression-testing"],
      "security": ["security-scanning"],
      "docs": ["article-writing", "documentation-lookup"],
      "devops": ["deployment-patterns", "docker-patterns", "database-migrations", "git-workflow"],
      "review": ["verification-loop"],
      "refactor": ["architecture-decision-records", "backend-patterns"],
      "performance": ["cost-aware-llm-pipeline"]
    }
  },
  "detectedStack": ["javascript"],
  "activeSkills": ["typescript-patterns", "backend-patterns"]
}

Phase 7: Report

Display initialization summary to the user:

CodeCrew ready — {project-name}
  {type} | {languages} | {count} files, {lines} lines
  Agents: {count}/{total} (Opus: 1, Sonnet: X, Haiku: Y) | Skills: {relevant}/{total}

Use /crew task "desc" to delegate work.