specweave 0.1.4 → 0.1.6

package/src/skills/specweave-detector/SKILL.md

@@ -1,99 +1,69 @@
 ---
 name: specweave-detector
-description: Entry point for SpecWeave framework. Automatically activates when .specweave directory is detected in the project. Acts as a factory of agents, parsing user requests and routing to appropriate skills. Supports nested skill calls and context management. This skill should ALWAYS be loaded first in SpecWeave projects. Activates for ANY user request in a SpecWeave project (auto-detects .specweave/).
+description: MANDATORY entry point for SpecWeave framework. Activates when .specweave/ exists OR when user mentions "SpecWeave", "increment", "feature", "/create-increment". All 10 agents and 35+ skills are PRE-INSTALLED during init - no auto-installation needed. Routes requests to increment-planner, skill-router, or appropriate agents. Keywords SpecWeave, spec-driven, increment, feature, spec, plan, task, create feature, build feature, new increment.
 proactive: true
 ---
 
 # SpecWeave Detector & Entry Point
 
-This skill is the **automatic entry point** for all SpecWeave operations. When Claude Code detects a `.specweave/config.yaml` file, this skill activates and orchestrates the SpecWeave framework.
+This skill is the **MANDATORY entry point** for all SpecWeave operations. When Claude Code detects a `.specweave/config.yaml` file OR user mentions SpecWeave-related keywords, this skill MUST activate and orchestrate the framework.
 
 ## Purpose
 
 Act as the "factory of agents" that:
-1. Detects SpecWeave projects automatically
-2. Parses user requests
-3. Routes to appropriate skills
-4. Orchestrates nested skill calls
-5. Manages context loading
+1. **Detects SpecWeave projects automatically** (when .specweave/ exists)
+2. **Parses user requests** and determines intent
+3. **Routes to appropriate skills/agents** (all pre-installed!)
+4. **Orchestrates nested skill calls** for complex operations
+5. **Manages context loading** via context-loader skill
 
-## Detection Logic
+## Detection Logic (0.1.5 - Pre-Installation)
 
 ```javascript
 // Pseudo-code for detection
 if (fileExists('.specweave/config.yaml')) {
+  // ACTIVATE SPECWEAVE MODE
   activateSpecWeaveMode();
   loadConfiguration();
 
-  // AUTO-INSTALL MISSING COMPONENTS (NEW!)
-  await autoInstallComponents(userPrompt);
+  // ALL COMPONENTS ALREADY INSTALLED!
+  // ✅ 10 agents in .claude/agents/
+  // ✅ 35+ skills in .claude/skills/
+  // ✅ 10 commands in .claude/commands/
+
+  // NO AUTO-INSTALLATION NEEDED (pre-installed in 0.1.5)
 
   parseUserIntent();
   routeToSkills();
 }
 ```
 
-## Just-In-Time Component Installation (CRITICAL!)
+## Pre-Installed Components (0.1.5+)
 
-**SpecWeave uses intelligent auto-installation** - components are installed on-demand based on user intent.
+**IMPORTANT**: SpecWeave 0.1.5+ uses **pre-installation** instead of auto-installation.
 
-### How It Works
+After `specweave init`, ALL components are ready:
+- ✅ **10 agents**: PM, Architect, Security, QA Lead, DevOps, Tech Lead, SRE, Docs Writer, Performance, Diagrams Architect
+- ✅ **35+ skills**: Technology stacks, integrations, utilities
+- ✅ **10 slash commands**: /create-increment, /validate-increment, etc.
 
-1. **User makes a request** (e.g., "Create Next.js authentication")
-2. **Analyze user intent** - Extract keywords (Next.js, authentication)
-3. **Map to required components**:
-   - "Next.js" → nextjs skill, nodejs-backend skill
-   - "authentication" → security agent
-   - "Create" → pm agent, architect agent
-4. **Check if components installed** in `.claude/skills/` and `.claude/agents/`
-5. **Auto-install missing components** from npm package (`node_modules/specweave/src/`)
-6. **Proceed with routing** - now all needed components are available
-
-### Keyword → Component Mapping
-
-```typescript
-// From src/utils/auto-install.ts
-const COMPONENT_MAPPING = {
-  // Framework detection
-  'next.js': { skills: ['nextjs', 'nodejs-backend'], agents: [] },
-  'react': { skills: ['frontend'], agents: [] },
-  'fastapi': { skills: ['python-backend'], agents: [] },
-  'django': { skills: ['python-backend'], agents: [] },
-  '.net': { skills: ['dotnet-backend'], agents: [] },
-
-  // Feature detection
-  'authentication': { skills: ['nodejs-backend'], agents: ['security'] },
-  'auth': { skills: [], agents: ['security'] },
-  'oauth': { skills: [], agents: ['security'] },
-  'payment': { skills: ['stripe-integrator'], agents: ['security'] },
-  'stripe': { skills: ['stripe-integrator'], agents: ['security'] },
-
-  // Infrastructure detection
-  'deploy': { skills: [], agents: ['devops'] },
-  'hetzner': { skills: ['hetzner-provisioner'], agents: ['devops'] },
-  'aws': { skills: [], agents: ['devops'] },
-
-  // Testing detection
-  'test': { skills: [], agents: ['qa-lead'] },
-  'e2e': { skills: ['e2e-playwright'], agents: ['qa-lead'] },
-  'playwright': { skills: ['e2e-playwright'], agents: ['qa-lead'] },
-
-  // Design detection
-  'figma': { skills: ['figma-implementer', 'figma-designer'], agents: [] },
-  'design system': { skills: ['design-system-architect'], agents: [] },
-
-  // Integration detection
-  'jira': { skills: ['jira-sync'], agents: [] },
-  'github': { skills: ['github-sync'], agents: [] },
-};
-
-// Always include strategic agents for new features
-if (prompt.includes('create') || prompt.includes('build')) {
-  agents.push('pm', 'architect');
-}
-```
+**No installation wait time** - components activate immediately!
+
+### How It Works (0.1.5+)
 
-### Example User Experience
+1. **User makes a request** (e.g., "Create Next.js authentication")
+2. **SpecWeave detector activates** (all components already installed!)
+3. **Analyze user intent**:
+   - "Create" → Route to increment-planner skill
+   - "Next.js" → Will use nextjs skill (already installed)
+   - "authentication" → Will involve security agent (already installed)
+4. **Route to increment-planner**:
+   - Creates increment folder
+   - Generates spec.md, plan.md, tasks.md, tests.md
+   - Coordinates with PM agent → Architect agent
+5. **Implementation ready** - All skills/agents available immediately
+
+### Example User Experience (0.1.5+)
 
 **Example 1: Next.js Authentication**
 ```
@@ -101,24 +71,28 @@ User: "Create Next.js authentication with OAuth"
 
 🔷 SpecWeave Active
 
-📦 Installing required components...
-   ✅ Installed nextjs skill
-   ✅ Installed nodejs-backend skill
-   ✅ Installed security agent
-   ✅ Installed pm agent
-   ✅ Installed architect agent
-
 🚀 Creating increment 0001-nextjs-authentication...
+   📝 Using nextjs skill (already installed!)
+   🤖 PM agent creating requirements...
+   🏗️  Architect agent designing system...
+
+✅ Increment created: .specweave/increments/0001-nextjs-authentication/
+✅ Files: spec.md, plan.md, tasks.md, tests.md
 ```
 
-**Example 2: Already Installed**
+**Example 2: Real Estate Platform**
 ```
-User: "Add another Next.js feature"
+User: "Build a real estate listing platform with Node.js/Express"
 
 🔷 SpecWeave Active
-   (Components already installed, proceeding...)
 
-🚀 Creating increment 0002-next-feature...
+🚀 Creating increment 0001-real-estate-platform...
+   📝 Using nodejs-backend skill (already installed!)
+   🤖 PM agent creating requirements...
+   🏗️  Architect agent designing system...
+   🛡️  Security agent reviewing authentication...
+
+✅ Increment created with complete specifications
 ```
 
 **Example 3: Python FastAPI**
@@ -127,53 +101,21 @@ User: "Create FastAPI backend with PostgreSQL"
 
 🔷 SpecWeave Active
 
-📦 Installing required components...
-   ✅ Installed python-backend skill
-   ✅ Installed pm agent
-   ✅ Installed architect agent
-
 🚀 Creating increment 0001-fastapi-backend...
-```
+   📝 Using python-backend skill (already installed!)
+   🤖 PM agent creating requirements...
+   🏗️  Architect agent designing system...
 
-### Configuration
-
-Auto-install can be disabled in `.specweave/config.yaml`:
-
-```yaml
-# .specweave/config.yaml
-auto_install: true  # Default: enabled
-
-# Tracked installed components (auto-updated)
-installed_components:
-  skills:
-    - nextjs
-    - nodejs-backend
-    - security
-  agents:
-    - pm
-    - architect
-    - security
+✅ Increment created: .specweave/increments/0001-fastapi-backend/
 ```
 
-Set `auto_install: false` to require manual installation (advanced users only).
+### Benefits of Pre-Installation (0.1.5+)
 
-### Installation Process
-
-When auto-installing:
-
-1. **Find npm package**: Locate `node_modules/specweave/`
-2. **Copy component**: `src/skills/nextjs/` → `.claude/skills/nextjs/`
-3. **Verify**: Check component has SKILL.md or AGENT.md
-4. **Update config**: Add to `installed_components` list
-5. **Continue routing**: Component now available for use
-
-### Benefits
-
-- ✅ **Zero manual installation** - users never run `specweave install`
-- ✅ **Just-in-time** - only install what's actually needed
-- ✅ **Automatic** - completely transparent to users
-- ✅ **Intelligent** - understands intent from natural language
-- ✅ **Efficient** - unused components never installed
+- ✅ **Zero wait time** - all components ready immediately
+- ✅ **No installation confusion** - everything works out of the box
+- ✅ **Predictable** - same components every time
+- ✅ **Simple mental model** - init once, use forever
+- ✅ **Offline-friendly** - all components local after init
 
 ## Auto-Activation
 
@@ -194,11 +136,11 @@ User: "I want to add payment processing"
 # 1. specweave-detector intercepts request
 # 2. Parses request: "add feature" + "payment processing"
 # 3. Routes to: increment-planner skill
-# 4. increment-planner creates Feature 002
+# 4. increment-planner creates Increment 0002
 # 5. Returns result to user
 
 # User sees:
-✅ Feature created: 002-payment-processing
+✅ Increment created: .specweave/increments/0002-payment-processing/
 ```
 
 ## Request Parsing & Routing
@@ -220,11 +162,11 @@ User: "I want to add payment processing"
 **Example**: "Create and implement a new payment feature"
 
 **Request Breakdown**:
-1. Create feature → `increment-planner`
-2. Implement code → Load context via `context-loader`
-3. Implement code → `developer`
-4. Generate tests → `qa-engineer`
-5. Update docs → `docs-updater`
+1. Create increment → `increment-planner`
+2. Load context → `context-loader`
+3. Implement code → Coordinate with appropriate agents/skills
+4. Generate tests → Use QA Lead agent
+5. Update docs → Use Docs Writer agent
 
 **Execution Flow**:
 ```
@@ -234,17 +176,17 @@ specweave-detector parses: CREATE + IMPLEMENT + FEATURE + PAYMENT
     ↓
 Orchestrate nested skills:
     ↓
-increment-planner: Create 003-payment-processing/
+increment-planner: Create .specweave/increments/0003-payment-processing/
     ↓
-context-loader: Load specs/modules/payments/**
+context-loader: Load .specweave/docs/internal/strategy/payments/**
     ↓
-developer: Implement based on tasks.md
+Implementation: Use nodejs-backend skill + security agent
     ↓
-qa-engineer: Generate test cases
+Testing: Use QA Lead agent (generate E2E tests)
     ↓
-docs-updater: Update README, docs/
+Documentation: Update .specweave/docs/internal/architecture/
     ↓
-Result: "✅ Feature 003 implemented and documented"
+Result: "✅ Increment 0003 implemented and documented"
 ```
 
 ### Ambiguous Request
@@ -269,14 +211,14 @@ skill-router asks:
 
 ### Automatic Context Loading
 
-When a user is working on a feature:
+When a user is working on an increment:
 
 ```javascript
-// Detect active work
-const activeIssue = detectActiveIssue(); // work/issues/###-xxx/
+// Detect active increment
+const activeIncrement = detectActiveIncrement(); // .specweave/increments/####-xxx/
 
-if (activeIssue) {
-  const manifest = loadManifest(`${activeIssue}/context-manifest.yaml`);
+if (activeIncrement) {
+  const manifest = loadManifest(`${activeIncrement}/context-manifest.yaml`);
   const context = await contextLoader.load(manifest);
   // Context now available for all skills
 }
@@ -286,10 +228,10 @@ if (activeIssue) {
 
 When multiple contexts are relevant:
 
-1. **Active work item** (in `work/issues/`)
-2. **Current feature** (referenced in git branch)
+1. **Active increment** (in `.specweave/increments/####-xxx/`)
+2. **Current branch** (git branch name features/###-xxx)
 3. **User-specified** context
-4. **Global** context (specs/overview.md, principles.md)
+4. **Global** context (.specweave/docs/internal/strategy/overview.md, principles.md)
 
 ## Skill Orchestration
 
@@ -329,17 +271,17 @@ Each step waits for previous to complete
 If a skill fails:
 
 ```
-User: "Implement feature 005"
+User: "Implement increment 0005"
     ↓
-specweave-detector: Route to developer
+specweave-detector: Route to implementation
     ↓
-developer: ERROR - Feature 005 not found
+ERROR: Increment 0005 not found
     ↓
 specweave-detector: Catch error, suggest:
-"Feature 005 doesn't exist. Would you like to:
-1. Create it first (increment-planner)
-2. List existing features
-3. Implement a different feature"
+"Increment 0005 doesn't exist. Would you like to:
+1. Create it first (/create-increment)
+2. List existing increments (/list-increments)
+3. Implement a different increment"
 ```
 
 ## Configuration Awareness
@@ -353,14 +295,17 @@ principles:
   context_precision: true         # Use context manifests
   routing_accuracy_target: 0.90   # Accuracy threshold
 
-skills:
-  install_location: "local"       # Where skills are installed
-  auto_install: true              # Auto-install missing skills
+# All components pre-installed in 0.1.5+ (no auto_install setting needed)
+# Agents and skills are in .claude/ folder, ready to use
 
 integrations:
   github:
     enabled: true
-    sync_issues: true             # Sync features ↔ GitHub issues
+    sync_issues: true             # Sync increments ↔ GitHub issues
+  jira:
+    enabled: false
+  ado:
+    enabled: false
 ```
 
 When `auto_role_routing: false`, this skill still activates but prompts user for explicit skill selection.
@@ -379,21 +324,35 @@ This helps users know SpecWeave framework is orchestrating their request.
 
 ## Skill Discovery
 
-List available skills:
+List available skills (all pre-installed):
 
 ```bash
 User: "What can SpecWeave do?"
     ↓
-specweave-detector: List installed skills
+specweave-detector: List all pre-installed skills
 
-SpecWeave Skills:
+SpecWeave Framework Skills (35+, all ready):
 ✅ increment-planner - Plan implementation features
 ✅ context-loader - Selective specification loading
 ✅ skill-router - Route ambiguous intents
-📦 spec-author - Create specifications (install with: npx specweave install spec-author)
-📦 architect - System design (install with: npx specweave install architect)
-
-Custom Skills:
+✅ nodejs-backend - Node.js/Express/NestJS backend
+✅ python-backend - Python/FastAPI/Django backend
+✅ nextjs - Next.js App Router specialist
+✅ frontend - React/Vue/Angular frontend
+✅ diagrams-generator - C4 Model diagrams
+✅ github-sync - GitHub integration
+✅ jira-sync - JIRA integration
+... and 25+ more!
+
+SpecWeave Agents (10, all ready):
+✅ pm - Product Manager (requirements, user stories)
+✅ architect - System Architect (design, ADRs)
+✅ security - Security Engineer (threat modeling)
+✅ qa-lead - QA Lead (test strategy)
+✅ devops - DevOps Engineer (deployment)
+... and 5+ more!
+
+Custom Skills (user-created):
 ✅ newrelic-monitor - New Relic integration
 ✅ cqrs-implementer - CQRS pattern implementation
 ```
@@ -410,38 +369,38 @@ Custom Skills:
 
 2. Route to increment-planner:
    Input: "Real-time chat feature"
-   Output: features/004-realtime-chat/
+   Output: .specweave/increments/0004-realtime-chat/
            - spec.md (5 user stories)
            - plan.md (WebSocket architecture)
            - tasks.md (78 tasks)
            - tests.md (20 test cases)
 
 3. Detect next request: User likely wants to implement
-   Prompt: "Feature 004 created. Would you like to:
+   Prompt: "Increment 0004 created. Would you like to:
            1. Review the plan
            2. Start implementation
-           3. Load context for this feature"
+           3. Load context for this increment"
 
 4. User chooses 2 (Start implementation)
 
 5. Route to context-loader:
-   Load: features/004-realtime-chat/context-manifest.yaml
+   Load: .specweave/increments/0004-realtime-chat/context-manifest.yaml
    Output: Loaded specs/modules/realtime/**, architecture/websockets.md
 
-6. Route to developer:
-   Input: features/004-realtime-chat/tasks.md
+6. Route to implementation:
+   Input: .specweave/increments/0004-realtime-chat/tasks.md
    Context: Loaded specs
    Output: Implement Phase 1 (Setup WebSocket server)
 
-7. After implementation, route to qa-engineer:
-   Input: features/004-realtime-chat/tests.md
-   Output: Generate test suite
+7. After implementation, coordinate testing:
+   Input: .specweave/increments/0004-realtime-chat/tests.md
+   Output: Generate test suite (E2E with Playwright)
 
-8. Finally, route to docs-updater:
-   Update: docs/reference/api.md (add WebSocket endpoints)
+8. Finally, update documentation:
+   Update: .specweave/docs/internal/architecture/api.md (add WebSocket endpoints)
 
 9. Return to user:
-   ✅ Feature 004 implemented, tested, and documented
+   ✅ Increment 0004 implemented, tested, and documented
 ```
 
 ## Best Practices
@@ -466,11 +425,11 @@ For multi-step operations, confirm before proceeding:
 You want to "create and implement a payment feature".
 
 This will:
-1. Create Feature 003 (increment-planner)
-2. Load relevant specs (context-loader)
-3. Implement code (developer)
-4. Generate tests (qa-engineer)
-5. Update documentation (docs-updater)
+1. Create Increment 0003 (increment-planner skill)
+2. Load relevant specs (context-loader skill)
+3. Implement code (nodejs-backend skill + security agent)
+4. Generate tests (QA Lead agent)
+5. Update documentation (Docs Writer agent)
 
 Estimated time: 15-30 minutes
 
@@ -529,12 +488,12 @@ if (specweaveDetectorActive()) {
 - Given: User says "Plan a feature for authentication"
 - When: specweave-detector parses request
 - Then: Routes to increment-planner
-- And: increment-planner creates Feature 00X
+- And: increment-planner creates Increment 000X (.specweave/increments/000X-authentication/)
 
 ### TC-003: Route Complex Request
 - Given: User says "Create and implement payment feature"
 - When: specweave-detector parses request
-- Then: Orchestrates: increment-planner → context-loader → developer → qa-engineer → docs-updater
+- Then: Orchestrates: increment-planner → context-loader → implementation (with agents) → testing → documentation
 - And: All steps complete successfully
 
 ### TC-004: Handle Ambiguous Request

package/src/templates/CLAUDE.md.template

@@ -142,10 +142,10 @@ project-root/
 │   │       └── reports/         # ✅ Analysis, reports
 │   └── tests/                   # Centralized test repository
 │
-├── .claude/                     # Installed agents/skills
-│   ├── agents/                  # Selective installation
-│   ├── skills/                  # Selective installation
-│   └── commands/                # Slash commands
+├── .claude/                     # Pre-installed components
+│   ├── agents/                  # 10 agents ready to use
+│   ├── skills/                  # 35+ skills ready to use
+│   └── commands/                # 10 slash commands
 │
 ├── CLAUDE.md                    # This file (ONLY file we add)
 └── src/                         # Your source code (unchanged)
@@ -197,7 +197,7 @@ backlog → planned → in-progress → completed → closed
 
 ## Agents (Activate Automatically)
 
-**Strategic Agents** (installed for all projects):
+**Strategic Agents** (pre-installed & ready to use):
 
 | Agent | Purpose | Activates When |
 |-------|---------|----------------|
@@ -206,23 +206,14 @@ backlog → planned → in-progress → completed → closed
 | `security` | Threat modeling | Security review |
 | `qa-lead` | Test strategy | Testing |
 | `devops` | Infrastructure, deployment | Deployment needed |
+| `tech-lead` | Code review | Code review |
+| `sre` | Incident response | Troubleshooting |
+| `docs-writer` | Documentation | Writing docs |
+| `performance` | Performance optimization | Optimization needed |
 
-**Implementation Agents** (installed based on your tech stack):
+**All 10 agents are pre-installed** - Claude uses the right one based on your request!
 
-{#IF_PYTHON}
-- `python-backend` - Python APIs (FastAPI, Django)
-{#ENDIF}
-{#IF_NODEJS}
-- `nodejs-backend` - Node.js APIs (Express, NestJS)
-{#ENDIF}
-{#IF_NEXTJS}
-- `nextjs` - Next.js applications
-{#ENDIF}
-{#IF_FRONTEND}
-- `frontend` - React/Vue/Angular frontend
-{#ENDIF}
-
-**See**: `.claude/agents/` for all installed agents
+**See**: `.claude/agents/` for complete list
 
 ---
 
@@ -237,13 +228,25 @@ backlog → planned → in-progress → completed → closed
 | `context-loader` | Load context selectively | Working on increments |
 | `skill-router` | Route to appropriate skill | Ambiguous requests |
 
-**Integration Skills** (optional, install when needed):
+**Technology Skills** (all pre-installed):
+
+| Skill | Purpose | Activates When |
+|-------|---------|----------------|
+| `nodejs-backend` | Node.js/Express/NestJS | Node.js backend requests |
+| `python-backend` | Python/FastAPI/Django | Python backend requests |
+| `nextjs` | Next.js App Router | Next.js requests |
+| `frontend` | React/Vue/Angular | Frontend requests |
+| `dotnet-backend` | ASP.NET Core | .NET requests |
+
+**Integration Skills** (all pre-installed):
+
+| Skill | Purpose | Activates When |
+|-------|---------|----------------|
+| `jira-sync` | Sync with JIRA | JIRA integration needed |
+| `github-sync` | Sync with GitHub | GitHub integration needed |
+| `hetzner-provisioner` | Deploy to Hetzner | Hetzner deployment needed |
 
-| Skill | Purpose | Install Command |
-|-------|---------|-----------------|
-| `jira-sync` | Sync with JIRA | `npx specweave install jira-sync` |
-| `github-sync` | Sync with GitHub | `npx specweave install github-sync` |
-| `hetzner-provisioner` | Deploy to Hetzner | `npx specweave install hetzner-provisioner` |
+**See**: `.claude/skills/` for complete list of 35+ skills!
 
 ---
 

package/src/templates/README.md.template

@@ -20,13 +20,13 @@ Your project is initialized! Now describe what you want to build.
 
 3. **SpecWeave will automatically**:
    - Detect your tech stack (or ask you to choose)
-   - Install needed agents & skills on-demand
+   - Use the right agents & skills (all pre-installed!)
    - Create strategic documentation
    - Generate specifications
    - Build the implementation
    - Write tests
 
-That's it! No manual configuration needed.
+That's it! All components ready - just describe what you want!
 
 ---
 
@@ -40,14 +40,14 @@ That's it! No manual configuration needed.
 │   ├── docs/               # Documentation (generated)
 │   └── tests/              # Tests (generated)
 ├── .claude/
-│   ├── commands/           # Slash commands (/create-increment, etc.)
-│   ├── agents/             # AI agents (auto-installed on-demand)
-│   └── skills/             # AI skills (auto-installed on-demand)
+│   ├── commands/           # Slash commands (10 installed)
+│   ├── agents/             # AI agents (9 installed & ready)
+│   └── skills/             # AI skills (30+ installed & ready)
 ├── CLAUDE.md               # Instructions for Claude
 └── README.md               # This file
 ```
 
-**Note**: Agents and skills are NOT pre-installed. They install automatically when you describe your project!
+**Note**: All agents and skills are pre-installed and ready to use!
 
 ---
 
@@ -56,7 +56,7 @@ That's it! No manual configuration needed.
 SpecWeave is a spec-driven development framework where:
 - **Specifications are the source of truth** (code follows specs)
 - **AI agents work autonomously** (PM, Architect, Security, QA, DevOps)
-- **Components auto-install on-demand** (no manual setup)
+- **All components pre-installed** (10 agents + 35+ skills ready!)
 - **Works with ANY tech stack** (TypeScript, Python, Go, Rust, etc.)
 
 ---