crewkit 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewkit",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Context engineering framework for AI-assisted development. One command to set up agents, skills, hooks, rules, and memory for your project.",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -51,16 +51,36 @@ If `.claude/` or `CLAUDE.md` or `.ai/memory/` exists:
 3. Report: "Existing setup backed up to `.crewkit-backup/`"
 
 ### Create directory structure
+Create directories based on the **selected IDE targets** from Phase 1:
+
+**Always:**
+```
+.ai/
+  memory/
+  plans/
+.crewkit/
+```
+
+**If Claude Code is a selected target:**
 ```
 .claude/
   agents/
   hooks/
   rules/
   skills/
-.ai/
-  memory/
-  plans/
-.crewkit/
+```
+
+**If GitHub Copilot is a selected target:**
+```
+.github/
+  agents/
+  instructions/
+```
+
+**If Cursor is a selected target:**
+```
+.cursor/
+  rules/
 ```
 
 ### Version tracking
@@ -144,22 +164,38 @@ Read `package.json` scripts, CI configs, or Makefiles to find the actual command
 
 ### IDE Target Detection
 
-Detect which IDEs are in use or configured in this project:
+Detect which IDEs are available. Check **two sources**: project-level signals AND global install markers.
 
-| IDE | Detection signals |
-|-----|------------------|
-| Claude Code | **Always** — this skill runs inside Claude Code |
-| GitHub Copilot | `.github/` directory exists OR `.github/copilot-instructions.md` found |
-| Cursor | `.cursor/` directory exists OR `.cursorrules` file found |
+| IDE | Project signals | Global install marker |
+|-----|----------------|----------------------|
+| Claude Code | `.claude/` directory exists | `~/.claude/skills/crewkit-setup/` exists |
+| GitHub Copilot | `.github/` directory exists OR `.github/copilot-instructions.md` found | `~/.copilot/agents/crewkit-setup.md` exists |
+| Cursor | `.cursor/` directory exists OR `.cursorrules` file found | `~/.cursor/crewkit-setup.md` exists |
 
-Save all detected IDE targets to the scan data. Example:
+An IDE is **available** if ANY of its signals match (project OR global).
+
+**IDE target selection (exception to zero-questions rule):**
+
+If more than one IDE is available, present the user with a choice:
+
+> "Multiple IDEs detected. Generate context for which?"
+> - **[1] Claude Code**
+> - **[2] GitHub Copilot**
+> - **[3] Cursor**
+> - **[4] All detected**
+>
+> (Only show IDEs that were detected. Default: all detected.)
+
+If only one IDE is available, use it without asking.
+
+Save the **selected** IDE targets to scan data. Example:
 ```
-IDE targets: Claude Code (always), GitHub Copilot (detected: .github/ exists), Cursor (not detected)
+IDE targets selected: GitHub Copilot
 ```
 
 **Store results as: `ReconProfile`** — write to `.crewkit/scan-phase1-recon.md` for persistence.
 
-Report: "Phase 1 complete. Detected: [stacks], [CI], [DBs], [build/test commands]."
+Report: "Phase 1 complete. Detected: [stacks], [CI], [DBs], [build/test commands]. IDE target: [selected IDEs]."
 
 ---
 
@@ -409,8 +445,8 @@ Compile all profiles into a single summary and present it to the user.
 - Test: `[command]`
 - Dev server: `[command]` (if detected)
 
-## IDE Targets
-- [list each detected IDE — e.g., "Claude Code (always), GitHub Copilot (detected: .github/ exists)"]
+## IDE Targets (selected)
+- [list selected IDE targets — e.g., "GitHub Copilot" or "Claude Code, Cursor"]
 ```
 
 ### Save profile
@@ -437,9 +473,16 @@ This step is critical for large projects where context compaction may have evict
 
 ---
 
-Generate all files in order. This order is designed for **graceful failure** — if the process is interrupted, the user has the most valuable files first.
+Generate files based on the **selected IDE targets** from Phase 1. The generation order is designed for **graceful failure** — if the process is interrupted, the user has the most valuable files first.
 
-**If the user chose [M] (memory only):** generate steps 1-2 (memory + CLAUDE.md), then update the `<!-- crewkit:context-start -->` headers in existing agents (Step 3, header-only — do not overwrite agent body). Stop after that.
+**IDE-conditional generation:**
+- **Step 1** (`.ai/memory/`): ALWAYS — shared across all IDEs.
+- **Steps 2-9** (CLAUDE.md, `.claude/agents/`, `.claude/rules/`, `.claude/settings.json`, `.claude/hooks/`, `.claude/skills/`, `.claude/QUICKSTART.md`, `.mcp.json`): ONLY if **Claude Code** is a selected target.
+- **Step 10** (IDE Adapters): Runs for each non-Claude IDE in the selected targets. Adapters generate directly from scan data + `.ai/memory/` — they do NOT depend on Claude files existing.
+
+If the only selected target is GitHub Copilot or Cursor, Steps 2-9 are **skipped entirely**. The adapter generates the IDE-native files directly.
+
+**If the user chose [M] (memory only):** generate Step 1 (memory) + the project rules file for the selected IDE (CLAUDE.md / copilot-instructions.md / .cursor/rules/project.md), then update context headers in existing agents. Stop after that.
 
 ### Templates directory
 Templates are located at `~/.claude/skills/crewkit-setup/templates/`. Read them from disk.
@@ -591,6 +634,8 @@ Create empty `lessons-{stack}.md` files for each detected stack.
 
 ### Step 2 — `CLAUDE.md` (AI-generated from scan)
 
+> **Conditional:** Skip this step if Claude Code is NOT a selected IDE target. Jump to Step 10.
+
 Generate the project's root `CLAUDE.md`. This is the most important generated file — it defines the AI's behavior for this project.
 
 **Structure:**
@@ -1001,15 +1046,20 @@ For any placeholder tokens, add a comment in the profile or tell the user to fil
 
 ### Step 10 — IDE Adapters
 
-If IDE targets beyond Claude Code were detected in Phase 1 (e.g., GitHub Copilot, Cursor):
+For each **non-Claude IDE** in the selected targets (GitHub Copilot, Cursor):
 
-1. For each additional IDE target detected:
+1. For each selected non-Claude IDE target:
    a. Determine the adapter file path: `~/.claude/skills/crewkit-setup/adapters/{ide}.md`
       - GitHub Copilot → `adapters/copilot.md`
       - Cursor → `adapters/cursor.md`
    b. If the adapter file does not exist: WARN the user ("Adapter file not found for [IDE] — skipping") and continue to the next IDE. Do not fail.
-   c. If the adapter file exists: read it completely, then MANDATORY: follow ALL instructions in it. The adapter reads scan data from `.crewkit/last-scan.md` and uses the already-generated Claude Code files (Steps 1-9) as its source.
-2. If no additional IDE targets were detected, skip this step entirely.
+   c. If the adapter file exists: read it completely, then MANDATORY: follow ALL instructions in it.
+
+**Source of truth for adapters (in priority order):**
+1. If Claude Code files exist (Steps 2-9 were generated): use them as the primary source, converting content to the target IDE format.
+2. If Claude Code files do NOT exist (Claude was not a selected target): generate IDE-native files directly from `.crewkit/last-scan.md` + `.ai/memory/` (Step 1). The adapter instructions describe the expected output format — use scan data to fill in the content instead of reformatting Claude files.
+
+If no non-Claude IDE targets were selected, skip this step entirely.
 
 **Note:** The adapters do NOT duplicate `.ai/memory/` — that directory is shared across all IDEs without transformation.
 
@@ -1022,8 +1072,12 @@ After all generation steps, run the **Completion Checklist** (at the bottom of t
 ```markdown
 # crewkit setup complete
 
-## Generated files
+## IDE target: [selected IDE(s)]
+
+## Generated files (shared)
 - `.ai/memory/` — [N] files (architecture, conventions, commands, testing, lessons, state)
+
+## Generated files (Claude Code) — only if selected
 - `CLAUDE.md` — project rules ([N] hard rules)
 - `.claude/agents/` — 5 agents (explorer, architect, coder, tester, reviewer)
 - `.claude/rules/` — [N] rule files ([list stacks])
@@ -1033,20 +1087,29 @@ After all generation steps, run the **Completion Checklist** (at the bottom of t
 - `.claude/napkin.md` — priorities board
 - `.claude/QUICKSTART.md` — onboarding guide
 - `.mcp.json` — [N] MCP servers
-- Validation: [N]/17 checks passed
+
+## Generated files (GitHub Copilot) — only if selected
+- `.github/copilot-instructions.md` — project rules
+- `.github/instructions/` — [N] per-stack instruction files
+- `.github/agents/` — 5 agent files
+
+## Generated files (Cursor) — only if selected
+- `.cursor/rules/project.md` — project rules
+- `.cursor/rules/` — [N] per-stack rule files
+- `AGENTS.md` — all agents
+
+## Validation: [X]/[Y] checks passed
 
 ## Commands detected
 - Build: `[command]`
 - Test: `[command]`
 
-## Recommended MCPs to configure
-[List MCPs with placeholder tokens that need user input]
-
 ## Next steps
-1. Review `CLAUDE.md` and adjust rules as needed
-2. Fill in MCP tokens in `.mcp.json` (if applicable)
-3. Commit the setup: `git add .claude/ .ai/ CLAUDE.md .mcp.json && git commit -m "chore: add crewkit context engineering setup"`
-4. Run `/full-workflow <your-first-task>` to test the setup
+[Adapt next steps to the selected IDE:]
+- Claude Code: "Review CLAUDE.md → run /full-workflow"
+- Copilot: "Review .github/copilot-instructions.md → open Copilot Chat"
+- Cursor: "Review .cursor/rules/project.md → start coding"
+- All: "Commit the setup"
 ```
 
 ---
@@ -1065,27 +1128,37 @@ After all generation steps, run the **Completion Checklist** (at the bottom of t
 
 Before presenting the Final Report, go through EVERY item. Fix failures before reporting.
 
-### Content checks
+### Content checks (shared — always verify)
 - [ ] `.ai/memory/architecture.md` — has constructor/DI signatures table (if project uses DI)
 - [ ] `.ai/memory/conventions.md` — has Design System section (if frontend detected)
 - [ ] `.ai/memory/testing.md` — has Fakes/Stubs inventory table (if test doubles detected)
 - [ ] `.ai/memory/commands.md` — has build + test + dev commands for ALL detected stacks
+
+### Content checks (Claude Code — only if Claude is a selected target)
 - [ ] `CLAUDE.md` — hard rules present, all in English
 - [ ] `.claude/agents/` — all 5 have `crewkit:context-start` header with real project data
 - [ ] `.claude/QUICKSTART.md` — exists with workflow guide
 
-### Validation checks (run these, don't just assume)
+### Validation checks (Claude Code — only if Claude is a selected target)
 - [ ] `.claude/settings.json` — read back, verify valid JSON, has Write(.ai/memory/*), has stack permissions, has MCP permissions (Layer 4)
 - [ ] `.mcp.json` — read back, verify valid JSON, has context7
 - [ ] `.claude/hooks/*.sh` — run `bash -n` on each, all 4 pass syntax check
 - [ ] `.claude/rules/` — at least 1 per detected stack, glob patterns match real files in project
 - [ ] `.claude/skills/` — all 4 core skills have SKILL.md
 
-### Integrity checks
+### Content checks (Copilot — only if Copilot is a selected target)
+- [ ] `.github/copilot-instructions.md` — exists, contains project hard rules, no Claude-specific sections
+- [ ] `.github/instructions/` — at least 1 per detected stack with `applyTo:` frontmatter
+- [ ] `.github/agents/` — 5 agent files with `.agent.md` extension, no `model:` lines
+
+### Content checks (Cursor — only if Cursor is a selected target)
+- [ ] `.cursor/rules/project.md` — exists, has `alwaysApply: true` frontmatter, no Claude-specific sections
+- [ ] `.cursor/rules/` — at least 1 per detected stack with `globs:` frontmatter
+- [ ] `AGENTS.md` — exists at project root with all 5 agents as `##` sections
+
+### Integrity checks (always)
 - [ ] `.crewkit/last-scan.md` — exists with full profile including Domain section
 - [ ] `.crewkit/scan-phase*.md` — all 4 phase files exist with content
 - [ ] No Portuguese in any generated file (only in user-facing output)
-- [ ] If Copilot target detected: `.github/copilot-instructions.md` exists and contains the project hard rules
-- [ ] If Cursor target detected: `.cursor/rules/project.md` exists and has `alwaysApply: true` frontmatter
 
-Report checklist results as: "Validation: X/17 checks passed." If any failed, list which ones and why.
+Count only the checks applicable to the selected IDE targets. Report as: "Validation: X/Y checks passed." If any failed, list which ones and why.

package/skill/adapters/copilot.md

@@ -3,8 +3,11 @@
 This adapter is executed during Phase 7, Step 10 of `/crewkit-setup`.
 You are the AI. Follow every instruction in this file to generate GitHub Copilot-compatible context files.
 
-**Input:** Read `.crewkit/last-scan.md` for the project profile. The Claude Code files generated in Steps 1-9 are your source of truth.
-**Output:** Files under `.github/` that mirror the Claude Code setup for GitHub Copilot.
+**Input (two modes):**
+- **With Claude files:** If `CLAUDE.md` and `.claude/` exist (Claude Code was also a target), use them as primary source and reformat for Copilot.
+- **Standalone:** If Claude files do NOT exist, generate directly from `.crewkit/last-scan.md` (project profile) + `.ai/memory/` (architecture, conventions, commands). This is the primary source of truth.
+
+**Output:** Files under `.github/` — GitHub Copilot-native context files.
 
 ---
 
@@ -20,15 +23,15 @@ You are the AI. Follow every instruction in this file to generate GitHub Copilot
 
 ## Step C1 — `.github/copilot-instructions.md`
 
-**Source:** `CLAUDE.md`
-**Transformation:** Reformat for Copilot. Remove the Agent Discipline, Skills (slash commands), Architect Decision Gate, and Test Safety Loop sections — these are Claude Code-specific orchestration mechanics that do not apply to Copilot. Keep the hard rules, overview, memory loading instructions, and output format.
+**Source:** `CLAUDE.md` if it exists, otherwise `.crewkit/last-scan.md` + `.ai/memory/conventions.md`
+**Transformation:** If using CLAUDE.md, reformat for Copilot — remove Agent Discipline, Skills (slash commands), Architect Decision Gate, and Test Safety Loop sections (Claude Code-specific). Keep hard rules, overview, memory loading instructions, and output format. If generating from scan data, create the content directly using the project profile and conventions.
 
 **Expected output format:**
 ```markdown
 # [PROJECT NAME] — Copilot Instructions
 
 ## Overview
-[1-2 sentences from CLAUDE.md overview — what the project is, main stack]
+[1-2 sentences — what the project is, main stack]
 [Business domain: what it does, core entities, risk profile]
 
 **Stack:** [stacks]
@@ -38,7 +41,7 @@ You are the AI. Follow every instruction in this file to generate GitHub Copilot
 
 ## Hard rules (apply to every response)
 
-[Numbered list — copy from CLAUDE.md hard rules verbatim. These are non-negotiable.]
+[Numbered list of non-negotiable rules — from CLAUDE.md or from HIGH confidence patterns in scan data.]
 
 1. [Rule 1]
 2. [Rule 2]
@@ -85,8 +88,8 @@ Always return:
 
 ## Step C2 — `.github/instructions/*.instructions.md`
 
-**Source:** `.claude/rules/*.md`
-**Transformation:** Convert frontmatter to Copilot format. Keep glob patterns and all rule content unchanged.
+**Source:** `.claude/rules/*.md` if they exist, otherwise generate directly from scan data (detected stacks + HIGH/MEDIUM confidence patterns).
+**Transformation:** If using Claude rules, convert frontmatter to Copilot format — keep glob patterns and rule content unchanged. If generating from scan data, create one instructions file per detected stack with appropriate glob patterns and rules.
 
 Claude Code frontmatter format:
 ```markdown
@@ -142,8 +145,8 @@ applyTo: "src/**/*.{js,ts}"
 
 ## Step C3 — `.github/agents/*.agent.md`
 
-**Source:** `.claude/agents/*.md`
-**Transformation:** Strip `model:` frontmatter line. Keep `name:` and `description:`. Remove the `<!-- crewkit:context-start -->...<!-- crewkit:context-end -->` block — Copilot agents do not use this inline context injection. Keep the full agent role description and instructions.
+**Source:** `.claude/agents/*.md` if they exist, otherwise generate directly from the agent templates at `~/.claude/skills/crewkit-setup/templates/agents/` (or from scan data if templates are unavailable).
+**Transformation:** Strip `model:` frontmatter line. Keep `name:` and `description:`. Remove the `<!-- crewkit:context-start -->...<!-- crewkit:context-end -->` block — Copilot agents do not use this inline context injection. Keep the full agent role description and instructions. When generating from templates, inject project context from `.crewkit/last-scan.md` into each agent.
 
 **Copilot agent frontmatter format:**
 ```markdown

package/skill/adapters/cursor.md

@@ -3,7 +3,10 @@
 This adapter is executed during Phase 7, Step 10 of `/crewkit-setup`.
 You are the AI. Follow every instruction in this file to generate Cursor-compatible context files.
 
-**Input:** Read `.crewkit/last-scan.md` for the project profile. The Claude Code files generated in Steps 1-9 are your source of truth.
+**Input (two modes):**
+- **With Claude files:** If `CLAUDE.md` and `.claude/` exist (Claude Code was also a target), use them as primary source and reformat for Cursor.
+- **Standalone:** If Claude files do NOT exist, generate directly from `.crewkit/last-scan.md` (project profile) + `.ai/memory/` (architecture, conventions, commands). This is the primary source of truth.
+
 **Output:** Files under `.cursor/rules/` and `AGENTS.md` at the project root.
 
 ---
@@ -20,8 +23,8 @@ You are the AI. Follow every instruction in this file to generate Cursor-compati
 
 ## Step U1 — `.cursor/rules/project.md`
 
-**Source:** `CLAUDE.md`
-**Transformation:** Reformat for Cursor. Add required frontmatter. Remove agent/skill/hook sections that are Claude Code-specific.
+**Source:** `CLAUDE.md` if it exists, otherwise `.crewkit/last-scan.md` + `.ai/memory/conventions.md`
+**Transformation:** If using CLAUDE.md, reformat for Cursor — add required frontmatter, remove agent/skill/hook sections. If generating from scan data, create the content directly using the project profile and conventions.
 
 **Required Cursor frontmatter:**
 ```markdown
@@ -93,8 +96,8 @@ Always return:
 
 ## Step U2 — `.cursor/rules/*.md`
 
-**Source:** `.claude/rules/*.md`
-**Transformation:** Convert frontmatter to Cursor format. Keep glob patterns and all rule content unchanged.
+**Source:** `.claude/rules/*.md` if they exist, otherwise generate directly from scan data (detected stacks + HIGH/MEDIUM confidence patterns).
+**Transformation:** If using Claude rules, convert frontmatter to Cursor format — keep glob patterns and rule content unchanged. If generating from scan data, create one rules file per detected stack with appropriate glob patterns and rules.
 
 Claude Code frontmatter format:
 ```markdown
@@ -150,8 +153,8 @@ globs: "**/*.py"
 
 ## Step U3 — `AGENTS.md` (project root)
 
-**Source:** All `.claude/agents/*.md` files
-**Transformation:** Concatenate all agents into a single markdown file with `##` sections. Strip `model:` frontmatter from each. Remove the `<!-- crewkit:context-start -->...<!-- crewkit:context-end -->` block from each agent. Keep the `name:` and `description:` from frontmatter and all agent instructions.
+**Source:** `.claude/agents/*.md` if they exist, otherwise generate directly from the agent templates at `~/.claude/skills/crewkit-setup/templates/agents/` (or from scan data if templates are unavailable).
+**Transformation:** Concatenate all agents into a single markdown file with `##` sections. Strip `model:` frontmatter from each. Remove the `<!-- crewkit:context-start -->...<!-- crewkit:context-end -->` block from each agent. Keep the `name:` and `description:` from frontmatter and all agent instructions. When generating from templates, inject project context from `.crewkit/last-scan.md` into each agent.
 
 **Output format:**
 ```markdown

package/skill/copilot-agent.md

@@ -0,0 +1,142 @@
+---
+name: crewkit-setup
+description: "Scan your codebase and generate a complete context engineering setup: agents, instructions, memory files, and copilot-instructions.md."
+---
+
+# crewkit-setup
+
+Scan the current project and generate a complete context engineering setup tailored to this codebase.
+
+**You are the AI executing this.** Follow each phase in order. Do not ask the user questions. Scan, generate, report.
+
+---
+
+## Phase 1 — Reconnaissance
+
+Scan the project to identify:
+- **Stack & frameworks**: languages, build tools, test frameworks, package managers
+- **Architecture**: monolith/microservices, key directories, entry points
+- **Existing AI context**: any `.github/`, `.ai/`, `CLAUDE.md`, `AGENTS.md` files
+
+Write findings to `.crewkit/scan-phase1-recon.md`.
+
+---
+
+## Phase 2 — Codebase Mapping
+
+Read representative source files (3-5 per layer: models, services, controllers, tests). Identify:
+- Naming conventions, code style
+- Core domain concepts and entities
+- Test patterns and coverage approach
+- CI/CD and build commands
+
+Write findings to `.crewkit/scan-phase2-map.md`.
+
+---
+
+## Phase 3 — Profile Compilation
+
+Synthesize phases 1-2 into a project profile:
+- Stack summary
+- Architecture summary
+- Key commands (build, test, lint)
+- Domain concepts
+- Hard rules to enforce
+
+Write profile to `.crewkit/last-scan.md`.
+
+---
+
+## Phase 4 — File Generation
+
+Generate all files using the profile from `.crewkit/last-scan.md`.
+
+### Step 1 — `.ai/memory/`
+
+Create these files (all in English):
+- `architecture.md` — system design, key components, data flow
+- `conventions.md` — naming rules, patterns, anti-patterns
+- `commands.md` — build, test, lint, run commands with flags
+- `testing.md` — test strategy, frameworks, coverage approach
+- `lessons.md` — known gotchas, non-obvious behaviors
+- `state.md` — current sprint goal, recent changes, open issues
+
+### Step 2 — `.github/copilot-instructions.md`
+
+```markdown
+# [PROJECT NAME] — Copilot Instructions
+
+## Overview
+[1-2 sentences: what the project is, main stack]
+
+**Stack:** [stacks]
+**Architecture:** [key patterns]
+
+---
+
+## Hard rules (apply to every response)
+
+[Numbered list of non-negotiable rules]
+
+Details → `.ai/memory/conventions.md`
+
+---
+
+## Memory
+
+- `.ai/memory/architecture.md` — system design
+- `.ai/memory/conventions.md` — coding conventions
+- `.ai/memory/commands.md` — build/test commands
+- `.ai/memory/lessons.md` — known gotchas
+```
+
+### Step 3 — `.github/instructions/` (per-stack rules)
+
+For each detected stack, create `[stack].instructions.md`:
+```markdown
+---
+applyTo: "**/*.ts"
+---
+[Stack-specific rules: error handling, imports, typing, testing patterns]
+```
+
+### Step 4 — `.github/agents/` (agent definitions)
+
+Create one file per agent: `explorer.agent.md`, `architect.agent.md`, `coder.agent.md`, `tester.agent.md`, `reviewer.agent.md`.
+
+Each file:
+```markdown
+---
+name: [Agent Name]
+description: "[One-line role description]"
+---
+# [Agent Name]
+
+**Role:** [role]
+**Responsibilities:** [responsibilities]
+**Approach:** [how it works]
+**Output:** [what it produces]
+```
+
+---
+
+## Phase 5 — Completion Report
+
+After all files are generated, report to the user:
+
+```
+crewkit-setup complete
+
+Generated:
+  .ai/memory/                    (6 files)
+  .github/copilot-instructions.md
+  .github/instructions/          (per-stack rules)
+  .github/agents/                (5 agents)
+
+Stack detected: [stack]
+Architecture:   [pattern]
+
+Next steps:
+  1. Review .github/copilot-instructions.md — adjust hard rules if needed
+  2. Open Copilot Chat — context is now active
+```

package/skill/cursor-global.md

@@ -0,0 +1,157 @@
+---
+description: "Context engineering setup — scan codebase and generate AI context files (.cursor/rules, AGENTS.md, .ai/memory)"
+alwaysApply: false
+---
+
+# crewkit-setup
+
+Scan the current project and generate a complete context engineering setup tailored to this codebase.
+
+**You are the AI executing this.** Follow each phase in order. Do not ask the user questions. Scan, generate, report.
+
+---
+
+## Phase 1 — Reconnaissance
+
+Scan the project to identify:
+- **Stack & frameworks**: languages, build tools, test frameworks, package managers
+- **Architecture**: monolith/microservices, key directories, entry points
+- **Existing AI context**: any `.cursor/`, `.github/`, `.ai/`, `CLAUDE.md`, `AGENTS.md` files
+
+Write findings to `.crewkit/scan-phase1-recon.md`.
+
+---
+
+## Phase 2 — Codebase Mapping
+
+Read representative source files (3-5 per layer: models, services, controllers, tests). Identify:
+- Naming conventions, code style
+- Core domain concepts and entities
+- Test patterns and coverage approach
+- CI/CD and build commands
+
+Write findings to `.crewkit/scan-phase2-map.md`.
+
+---
+
+## Phase 3 — Profile Compilation
+
+Synthesize phases 1-2 into a project profile:
+- Stack summary
+- Architecture summary
+- Key commands (build, test, lint)
+- Domain concepts
+- Hard rules to enforce
+
+Write profile to `.crewkit/last-scan.md`.
+
+---
+
+## Phase 4 — File Generation
+
+Generate all files using the profile from `.crewkit/last-scan.md`.
+
+### Step 1 — `.ai/memory/`
+
+Create these files (all in English):
+- `architecture.md` — system design, key components, data flow
+- `conventions.md` — naming rules, patterns, anti-patterns
+- `commands.md` — build, test, lint, run commands with flags
+- `testing.md` — test strategy, frameworks, coverage approach
+- `lessons.md` — known gotchas, non-obvious behaviors
+- `state.md` — current sprint goal, recent changes, open issues
+
+### Step 2 — `.cursor/rules/project.md`
+
+```
+---
+description: "Project rules"
+alwaysApply: true
+---
+# [PROJECT NAME] — Project Rules
+
+## Overview
+[1-2 sentences: what the project is, main stack]
+
+**Stack:** [stacks]
+**Architecture:** [key patterns]
+
+---
+
+## Hard rules
+
+[Numbered list of non-negotiable rules from the profile]
+
+---
+
+## Memory
+
+Reference files in `.ai/memory/` for detailed context:
+- `.ai/memory/architecture.md` — system design
+- `.ai/memory/conventions.md` — coding conventions
+- `.ai/memory/commands.md` — build/test commands
+```
+
+### Step 3 — `.cursor/rules/` (per-stack rules)
+
+For each detected stack (e.g., `typescript.md`, `python.md`), generate a rules file with:
+```
+---
+description: "[Stack] coding rules"
+globs: ["**/*.ts"] (or appropriate glob)
+alwaysApply: false
+---
+[Stack-specific rules: error handling, imports, typing, testing patterns]
+```
+
+### Step 4 — `AGENTS.md`
+
+Create a single `AGENTS.md` at the project root with all agents as `##` sections:
+
+```markdown
+# Agents
+
+## Explorer
+Role: Codebase reconnaissance and research.
+[...]
+
+## Architect
+Role: System design and planning.
+[...]
+
+## Coder
+Role: Implementation.
+[...]
+
+## Tester
+Role: Test writing and validation.
+[...]
+
+## Reviewer
+Role: Code review and quality.
+[...]
+```
+
+Each agent section should include: Role, Responsibilities, Approach, Output format.
+
+---
+
+## Phase 5 — Completion Report
+
+After all files are generated, report to the user:
+
+```
+crewkit-setup complete
+
+Generated:
+  .ai/memory/          (6 files)
+  .cursor/rules/       (project.md + per-stack rules)
+  AGENTS.md            (5 agents)
+
+Stack detected: [stack]
+Architecture:   [pattern]
+
+Next steps:
+  1. Review .cursor/rules/project.md — adjust hard rules if needed
+  2. Open Cursor and start coding — context is active
+```

package/skill/packs/analytics/pack.json

@@ -0,0 +1,7 @@
+{
+  "name": "analytics",
+  "description": "Development metrics and post-mortem analysis",
+  "components": {
+    "skills": ["dev-metrics", "retro"]
+  }
+}

package/skill/packs/quality/pack.json

@@ -0,0 +1,7 @@
+{
+  "name": "quality",
+  "description": "Code review, blast radius analysis, and post-mortems",
+  "components": {
+    "skills": ["review-pr", "impact", "retro"]
+  }
+}

package/skill/packs/security/pack.json

@@ -0,0 +1,7 @@
+{
+  "name": "security",
+  "description": "OWASP vulnerability scanning and security hardening",
+  "components": {
+    "skills": ["security-scan"]
+  }
+}

package/src/add.js

@@ -1,45 +1,109 @@
-import { cpSync, mkdirSync, existsSync } from 'node:fs';
+import { cpSync, mkdirSync, existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { CORE_SKILLS } from './constants.js';
 
-const OPTIONAL_SKILLS = ['retro', 'dev-metrics', 'security-scan', 'impact'];
+function getOptionalSkills() {
+  const skillsDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills');
+  if (!existsSync(skillsDir)) return [];
+  return readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && !CORE_SKILLS.includes(d.name))
+    .map(d => d.name);
+}
 
-export function add(skillName) {
-  if (!skillName) {
-    console.error('Error: skill name is required.');
-    console.log(`\n  Available optional skills:\n${OPTIONAL_SKILLS.map(s => `    - ${s}`).join('\n')}\n`);
+function getAvailablePacks() {
+  const packsDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'packs');
+  if (!existsSync(packsDir)) return [];
+  return readdirSync(packsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && existsSync(join(packsDir, d.name, 'pack.json')))
+    .map(d => d.name);
+}
+
+function installSkill(skillName) {
+  const sourceDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills', skillName);
+
+  if (!existsSync(sourceDir)) {
+    console.error(`Error: source not found at ${sourceDir}`);
+    console.log('  Make sure crewkit is installed first: npx crewkit install');
     process.exit(1);
   }
 
-  if (!OPTIONAL_SKILLS.includes(skillName)) {
-    console.error(`Error: "${skillName}" is not a known optional skill.`);
-    console.log(`\n  Available optional skills:\n${OPTIONAL_SKILLS.map(s => `    - ${s}`).join('\n')}\n`);
-    process.exit(1);
+  const targetDir = join(process.cwd(), '.claude', 'skills', skillName);
+
+  if (existsSync(targetDir)) {
+    console.log(`  Warning: ${targetDir} already exists. Overwriting.`);
   }
 
-  const source = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills', skillName, 'SKILL.md');
+  mkdirSync(targetDir, { recursive: true });
+  cpSync(sourceDir, targetDir, { recursive: true, force: true });
+
+  return targetDir;
+}
+
+function installPack(packName) {
+  const packJson = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'packs', packName, 'pack.json');
+  let pack;
+  try {
+    pack = JSON.parse(readFileSync(packJson, 'utf8'));
+  } catch {
+    console.error(`Error: invalid pack.json for "${packName}".`);
+    process.exit(1);
+  }
+  const skills = pack.components?.skills ?? [];
 
-  if (!existsSync(source)) {
-    console.error(`Error: source not found at ${source}`);
+  const templatesDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills');
+  const missing = skills.filter(s => !existsSync(join(templatesDir, s)));
+  if (missing.length) {
+    console.error(`Error: pack "${packName}" references missing skills: ${missing.join(', ')}`);
     console.log('  Make sure crewkit is installed first: npx crewkit install');
     process.exit(1);
   }
 
-  const targetDir = join(process.cwd(), '.claude', 'skills', skillName);
-  const target = join(targetDir, 'SKILL.md');
+  const installed = [];
+  for (const skillName of skills) {
+    const targetDir = installSkill(skillName);
+    installed.push({ name: skillName, path: targetDir });
+  }
 
-  if (existsSync(target)) {
-    console.log(`  Warning: ${target} already exists. Overwriting.`);
+  console.log(`
+  ✓ Pack "${packName}" installed (${installed.length} skill${installed.length !== 1 ? 's' : ''})
+`);
+  for (const { name, path } of installed) {
+    console.log(`    /${name}  →  ${path}`);
   }
+  console.log('');
+}
 
-  mkdirSync(targetDir, { recursive: true });
-  cpSync(source, target);
+export function add(skillName) {
+  const availablePacks = getAvailablePacks();
+  const optionalSkills = getOptionalSkills();
 
-  console.log(`
+  if (!skillName) {
+    console.error('Error: skill name is required.');
+    console.log(`\n  Available packs:\n${availablePacks.map(p => `    - ${p}`).join('\n')}`);
+    console.log(`\n  Available optional skills:\n${optionalSkills.map(s => `    - ${s}`).join('\n')}\n`);
+    process.exit(1);
+  }
+
+  if (availablePacks.includes(skillName)) {
+    installPack(skillName);
+    return;
+  }
+
+  if (optionalSkills.includes(skillName)) {
+    const targetDir = installSkill(skillName);
+    console.log(`
   ✓ Skill "${skillName}" installed
 
-  Copied to: ${target}
+  Copied to: ${targetDir}
 
   Use /${skillName} in Claude Code to run it.
   `);
+    return;
+  }
+
+  console.error(`Error: "${skillName}" is not a known pack or optional skill.`);
+  console.log(`\n  Available packs:\n${availablePacks.map(p => `    - ${p}`).join('\n')}`);
+  console.log(`\n  Available optional skills:\n${optionalSkills.map(s => `    - ${s}`).join('\n')}\n`);
+  process.exit(1);
 }

package/src/cli.js

@@ -1,19 +1,23 @@
 import { install } from './install.js';
 import { update } from './update.js';
 import { add } from './add.js';
+import { list } from './list.js';
 
 const HELP = `
 crewkit — Context engineering for AI-assisted development
 
 Commands:
-  install       Install crewkit skill globally (~/.claude/skills/)
+  install       Install crewkit globally (Claude Code, Copilot, Cursor)
   update        Update to latest version (re-run install)
-  add <skill>   Add an optional skill to the current project
+  add <name>    Add an optional skill or pack to the current project
+  list          List all available skills and packs (core + add-ons)
   help          Show this message
 
 Usage:
   npx crewkit install          # one-time setup
+  npx crewkit list             # see all available skills and packs
   npx crewkit add retro        # add optional skill to project
+  npx crewkit add quality      # add a pack (multiple skills)
   /crewkit-setup               # run in your IDE to scan & calibrate a project
 `;
 
@@ -22,14 +26,18 @@ export function run(args) {
 
   switch (command) {
     case 'install':
-      install();
-      break;
+      install().catch(err => { console.error(err.message); process.exit(1); });
+      return;
+
     case 'update':
-      update();
-      break;
+      update().catch(err => { console.error(err.message); process.exit(1); });
+      return;
     case 'add':
       add(args[1]);
       break;
+    case 'list':
+      list();
+      break;
     case 'help':
     case '--help':
     case '-h':

package/src/constants.js

@@ -0,0 +1 @@
+export const CORE_SKILLS = ['full-workflow', 'hotfix', 'explore-and-plan', 'review-pr'];

package/src/detect.js

@@ -0,0 +1,25 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function detectTools() {
+  const tools = [];
+  const home = homedir();
+
+  if (existsSync(join(home, '.claude'))) {
+    const dest = join(home, '.claude', 'skills', 'crewkit-setup');
+    tools.push({ id: 'claude', name: 'Claude Code', dest, versionFile: join(dest, '.version') });
+  }
+
+  if (existsSync(join(home, '.copilot'))) {
+    const dest = join(home, '.copilot', 'agents');
+    tools.push({ id: 'copilot', name: 'GitHub Copilot', dest, versionFile: join(dest, 'crewkit-setup.version') });
+  }
+
+  if (existsSync(join(home, '.cursor'))) {
+    const dest = join(home, '.cursor');
+    tools.push({ id: 'cursor', name: 'Cursor', dest, versionFile: join(dest, 'crewkit-setup.version') });
+  }
+
+  return tools;
+}

package/src/install.js

@@ -1,43 +1,65 @@
-import { cpSync, mkdirSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { cpSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { detectTools } from './detect.js';
+import { selectTargets } from './prompt.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-export function install() {
-  const skillSource = join(__dirname, '..', 'skill');
-  const skillDest = join(homedir(), '.claude', 'skills', 'crewkit-setup');
-
-  // Verify source exists
-  if (!existsSync(skillSource)) {
-    console.error('Error: skill/ directory not found. Package may be corrupted.');
-    process.exit(1);
-  }
-
-  // Create destination
-  mkdirSync(skillDest, { recursive: true });
+function readVersion() {
+  return JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
+}
 
-  // Copy skill + templates
-  cpSync(skillSource, skillDest, { recursive: true, force: true });
+function installClaude(target, version) {
+  const skillSource = join(__dirname, '..', 'skill');
+  mkdirSync(target.dest, { recursive: true });
+  cpSync(skillSource, target.dest, { recursive: true, force: true });
+  writeFileSync(target.versionFile, version, 'utf8');
+  console.log(`  ✓ Claude Code       →  ${target.dest}`);
+  console.log(`    Run /crewkit-setup in any project\n`);
+}
 
-  // Read version
-  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+function installSingleFile(target, templateFile, outputFile, label, hint, version) {
+  const template = join(__dirname, '..', 'skill', templateFile);
+  mkdirSync(target.dest, { recursive: true });
+  copyFileSync(template, join(target.dest, outputFile));
+  writeFileSync(target.versionFile, version, 'utf8');
+  console.log(`  ✓ ${label}  →  ${join(target.dest, outputFile)}`);
+  console.log(`    ${hint}\n`);
+}
 
-  // Write version marker
-  writeFileSync(join(skillDest, '.version'), pkg.version, 'utf8');
+export async function install() {
+  const version = readVersion();
+  const tools = detectTools();
 
-  console.log(`
-  ✓ crewkit v${pkg.version} installed
+  if (tools.length === 0) {
+    console.log(`
+  No supported AI tools detected.
 
-  Skill copied to: ${skillDest}
+  crewkit looks for: ~/.claude, ~/.copilot, ~/.cursor
+  Install one of these tools and re-run.
+    `);
+    process.exit(1);
+  }
 
-  Next: open any project in Claude Code and run:
+  const targets = await selectTargets(tools);
 
-    /crewkit-setup
+  console.log(`\n  Installing crewkit v${version}...\n`);
 
-  This will scan your codebase and generate a complete
-  context engineering setup (agents, skills, hooks, rules, memory).
-  `);
+  for (const target of targets) {
+    switch (target.id) {
+      case 'claude':
+        installClaude(target, version);
+        break;
+      case 'copilot':
+        installSingleFile(target, 'copilot-agent.md', 'crewkit-setup.md',
+          'GitHub Copilot  ', 'Use @crewkit-setup in Copilot CLI or Chat', version);
+        break;
+      case 'cursor':
+        installSingleFile(target, 'cursor-global.md', 'crewkit-setup.md',
+          'Cursor          ', 'Copy to .cursor/rules/ in your projects', version);
+        break;
+    }
+  }
 }

package/src/list.js

@@ -0,0 +1,75 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { CORE_SKILLS } from './constants.js';
+
+function readDescription(skillDir) {
+  const skillMd = join(skillDir, 'SKILL.md');
+  if (!existsSync(skillMd)) return '';
+  const content = readFileSync(skillMd, 'utf8');
+  const match = content.match(/^---[\s\S]*?^description:\s*"?(.+?)"?\s*$/m);
+  if (!match) return '';
+  const desc = match[1].trim();
+  return desc.length > 45 ? desc.slice(0, 44) + '…' : desc;
+}
+
+function getAvailablePacks() {
+  const packsDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'packs');
+  if (!existsSync(packsDir)) return [];
+  return readdirSync(packsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && existsSync(join(packsDir, d.name, 'pack.json')))
+    .map(d => {
+      try {
+        const pack = JSON.parse(readFileSync(join(packsDir, d.name, 'pack.json'), 'utf8'));
+        return { name: d.name, description: pack.description ?? '', skills: pack.components?.skills ?? [] };
+      } catch {
+        return { name: d.name, description: '(invalid pack.json)', skills: [] };
+      }
+    });
+}
+
+export function list() {
+  const skillsDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills');
+
+  if (!existsSync(skillsDir)) {
+    console.error('Error: crewkit templates not found.');
+    console.log('  Make sure crewkit is installed first: npx crewkit install');
+    process.exit(1);
+  }
+
+  const allDirs = readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  const coreSkills = CORE_SKILLS.filter(s => allDirs.includes(s));
+  const addonSkills = allDirs.filter(s => !CORE_SKILLS.includes(s)).sort();
+  const packs = getAvailablePacks();
+
+  const pad = (name, width) => name + ' '.repeat(Math.max(1, width - name.length));
+  const nameWidth = Math.max(...[...coreSkills, ...addonSkills, ...packs.map(p => p.name)].map(s => s.length)) + 2;
+
+  console.log('\ncrewkit — available components\n');
+
+  console.log('  Core skills (installed by /crewkit-setup):');
+  for (const name of coreSkills) {
+    const desc = readDescription(join(skillsDir, name));
+    console.log(`    ${pad(name, nameWidth)}${desc}`);
+  }
+
+  console.log('\n  Add-on skills (install with: npx crewkit add <name>):');
+  for (const name of addonSkills) {
+    const desc = readDescription(join(skillsDir, name));
+    console.log(`    ${pad(name, nameWidth)}${desc}`);
+  }
+
+  if (packs.length > 0) {
+    console.log('\n  Packs (install with: npx crewkit add <name>):');
+    for (const { name, description, skills } of packs) {
+      const desc = description.length > 45 ? description.slice(0, 44) + '…' : description;
+      const contents = skills.length > 0 ? `  [${skills.join(', ')}]` : '';
+      console.log(`    ${pad(name, nameWidth)}${desc}${contents}`);
+    }
+  }
+
+  console.log('');
+}

package/src/prompt.js

@@ -0,0 +1,32 @@
+import { createInterface } from 'node:readline';
+
+function ask(question) {
+  return new Promise(resolve => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export async function selectTargets(tools) {
+  if (tools.length === 0) return [];
+  if (tools.length === 1) return [tools[0]];
+
+  console.log('\n  Multiple AI tools detected. Where do you want to install crewkit?\n');
+  tools.forEach((tool, i) => {
+    console.log(`    [${i + 1}] ${tool.name}`);
+  });
+  console.log(`    [${tools.length + 1}] All of the above`);
+  console.log();
+
+  const answer = await ask('  Your choice: ');
+  const num = parseInt(answer, 10);
+
+  if (num === tools.length + 1) return tools;
+  if (num >= 1 && num <= tools.length) return [tools[num - 1]];
+
+  console.log('  Invalid choice. Installing to all detected tools.');
+  return tools;
+}

package/src/update.js

@@ -1,27 +1,32 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { detectTools } from './detect.js';
 import { install } from './install.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-export function update() {
-  const versionFile = join(homedir(), '.claude', 'skills', 'crewkit-setup', '.version');
-  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+function getInstalledVersion() {
+  for (const tool of detectTools()) {
+    if (existsSync(tool.versionFile)) {
+      return readFileSync(tool.versionFile, 'utf8').trim();
+    }
+  }
+  return 'unknown';
+}
 
+export async function update() {
+  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
   const newVersion = pkg.version;
-  const currentVersion = existsSync(versionFile)
-    ? readFileSync(versionFile, 'utf8').trim()
-    : 'unknown';
+  const currentVersion = getInstalledVersion();
 
   if (currentVersion === newVersion) {
     console.log(`  Already up to date (v${newVersion})`);
     return;
   }
 
-  install();
+  await install();
 
   const fromLabel = currentVersion === 'unknown' ? 'v0.1 (untracked)' : `v${currentVersion}`;
   console.log(`  Updated: ${fromLabel} → v${newVersion}`);