rebar-mcp 2.0.0

package/ccboot-PRD-v1.0.docx.md

@@ -0,0 +1,732 @@
+
+
+**PRODUCT REQUIREMENTS**
+
+**DOCUMENT**
+
+ccboot-mcp-server
+
+*Claude Code Bootstrapper MCP Server*
+
+Version 1.0 — March 2026
+
+Vaspera Capital
+
+*Includes: Claude Code Setup Guide • Architecture • Tool Specifications • CLAUDE.md • Implementation Plan*
+
+# **Table of Contents**
+
+# **1\. Product Overview**
+
+## **1.1 Product Name**
+
+ccboot-mcp-server (npm package: @vaspera/ccboot-mcp-server)
+
+## **1.2 Problem Statement**
+
+Claude Code is the most customizable AI coding tool available, with seven distinct configuration artifact types: CLAUDE.md files, skills, subagents, hooks, slash commands, MCP configurations, and knowledge base documents. However, setting up these artifacts correctly for enterprise-grade development requires deep knowledge of Claude Code internals, MCP protocol conventions, and software engineering best practices. Most teams either skip configuration entirely (getting mediocre results) or spend days manually crafting these files (wasting engineering time).
+
+## **1.3 Solution**
+
+An MCP server that Claude Code itself connects to, providing tools that generate, validate, and manage the full suite of Claude Code configuration artifacts. When a developer runs /init-project or asks Claude to bootstrap their workspace, the MCP server generates production-ready configurations tailored to their tech stack, team size, and compliance requirements.
+
+## **1.4 Target Users**
+
+* **Primary:** Engineering leads and staff engineers at companies with 10–200 developers using Claude Code, who need standardized AI coding configurations across their team.
+
+* **Secondary:** Individual developers who want enterprise-quality Claude Code setups without spending hours on manual configuration.
+
+* **Tertiary:** Regulated industry teams (fintech, healthtech, defense) who need compliance-aware AI coding configurations.
+
+# **2\. Claude Code Environment Setup**
+
+| Purpose This section provides the exact steps to set up your Claude Code development environment before starting implementation. Follow these steps in order. |
+| :---- |
+
+## **2.1 Prerequisites**
+
+**Required Accounts**
+
+* Claude Pro ($20/month) or Claude Max ($100–$200/month) subscription, OR an Anthropic API key with credits
+
+* GitHub account with SSH keys configured
+
+* npm account (for publishing the package later)
+
+**Required Software**
+
+* Node.js 18+ (LTS recommended — download from nodejs.org)
+
+* Git for version control
+
+* A code editor (VS Code recommended, with Claude Code extension)
+
+## **2.2 Install Claude Code**
+
+Run the native installer (no Node.js dependency for the CLI itself):
+
+\# macOS / Linux
+
+curl \-fsSL https://claude.ai/install.sh | sh
+
+\# Windows (PowerShell)
+
+irm https://claude.ai/install.ps1 | iex
+
+\# Alternative: install via npm
+
+npm install \-g @anthropic-ai/claude-code
+
+Authenticate by running claude in your terminal and following the browser OAuth flow, or set your API key:
+
+export ANTHROPIC\_API\_KEY="your-api-key-here"
+
+Verify installation:
+
+claude \--version
+
+claude /doctor
+
+## **2.3 Create the Project Repository**
+
+mkdir ccboot-mcp-server && cd ccboot-mcp-server
+
+git init
+
+npm init \-y
+
+Install dependencies:
+
+npm install @modelcontextprotocol/sdk zod
+
+npm install \-D typescript @types/node tsx
+
+## **2.4 Create tsconfig.json**
+
+{
+
+  "compilerOptions": {
+
+    "target": "ES2022",
+
+    "module": "Node16",
+
+    "moduleResolution": "Node16",
+
+    "outDir": "./dist",
+
+    "rootDir": "./src",
+
+    "strict": true,
+
+    "esModuleInterop": true,
+
+    "skipLibCheck": true,
+
+    "forceConsistentCasingInFileNames": true,
+
+    "resolveJsonModule": true,
+
+    "declaration": true,
+
+    "declarationMap": true,
+
+    "sourceMap": true
+
+  },
+
+  "include": \["src/\*\*/\*"\],
+
+  "exclude": \["node\_modules", "dist"\]
+
+}
+
+## **2.5 Configure package.json Scripts**
+
+Update your package.json with these fields:
+
+"type": "module",
+
+"main": "dist/index.js",
+
+"bin": { "ccboot-mcp-server": "dist/index.js" },
+
+"scripts": {
+
+  "build": "tsc",
+
+  "dev": "tsx watch src/index.ts",
+
+  "start": "node dist/index.js",
+
+  "lint": "tsc \--noEmit",
+
+  "test": "node \--test dist/\*\*/\*.test.js"
+
+}
+
+## **2.6 Create the Project CLAUDE.md**
+
+| Critical Step This is the most important configuration for your Claude Code development session. Place this file at the project root. The full CLAUDE.md content is provided in Section 7 of this document. |
+| :---- |
+
+## **2.7 Create Project Directory Structure**
+
+ccboot-mcp-server/
+
+├── CLAUDE.md
+
+├── package.json
+
+├── tsconfig.json
+
+├── .claudeignore
+
+├── .mcp.json
+
+├── .claude/
+
+│   ├── settings.json
+
+│   ├── agents/
+
+│   │   ├── template-writer.md
+
+│   │   └── test-runner.md
+
+│   └── skills/
+
+│       └── mcp-dev/
+
+│           └── SKILL.md
+
+├── src/
+
+│   ├── index.ts
+
+│   ├── types.ts
+
+│   ├── constants.ts
+
+│   ├── tools/
+
+│   │   ├── scaffolding.ts
+
+│   │   ├── knowledge.ts
+
+│   │   ├── management.ts
+
+│   │   └── enterprise.ts
+
+│   ├── templates/
+
+│   │   ├── claudemd/
+
+│   │   ├── skills/
+
+│   │   ├── agents/
+
+│   │   ├── hooks/
+
+│   │   └── knowledge/
+
+│   ├── services/
+
+│   │   ├── file-ops.ts
+
+│   │   ├── template-engine.ts
+
+│   │   └── validation.ts
+
+│   └── schemas/
+
+│       ├── scaffolding.ts
+
+│       └── common.ts
+
+├── templates/          (raw template files)
+
+│   ├── claudemd/
+
+│   ├── skills/
+
+│   ├── agents/
+
+│   ├── hooks/
+
+│   └── knowledge/
+
+└── dist/               (compiled output)
+
+## **2.8 Configure Claude Code Permissions**
+
+Create .claude/settings.json to pre-approve safe development commands:
+
+{
+
+  "permissions": {
+
+    "allow": \[
+
+      "Bash(npm run build)", "Bash(npm run lint)",
+
+      "Bash(npm run test \*)", "Bash(npm run dev)",
+
+      "Bash(npx tsc \--noEmit)",
+
+      "Bash(git status)", "Bash(git diff \*)",
+
+      "Bash(git log \*)", "Bash(git add \*)",
+
+      "Bash(git commit \*)"
+
+    \],
+
+    "deny": \[
+
+      "Bash(rm \-rf \*)",
+
+      "Read(./.env)", "Read(./.env.\*)"
+
+    \]
+
+  }
+
+}
+
+## **2.9 Create .claudeignore**
+
+Exclude irrelevant files from Claude Code context:
+
+node\_modules/
+
+dist/
+
+.git/
+
+\*.lock
+
+coverage/
+
+## **2.10 Register the MCP Server for Local Testing**
+
+During development, register your server locally so Claude Code can test it:
+
+claude mcp add \--scope local ccboot \-- npx tsx src/index.ts
+
+Verify with:
+
+claude mcp list
+
+/mcp    \# inside Claude Code session
+
+# **3\. Functional Requirements**
+
+## **3.1 Tool Inventory**
+
+The MCP server must expose the following tools. All tool names use the ccboot\_ prefix and snake\_case convention per MCP best practices.
+
+**Tier 1: Core Scaffolding (MVP)**
+
+| Tool Name | Description | Key Inputs | Annotations |
+| :---- | :---- | :---- | :---- |
+| **ccboot\_init\_project** | Full project bootstrap. Generates CLAUDE.md, .claude/ directory, skills, hooks, .mcp.json, .claudeignore, and settings.json tailored to the detected or specified tech stack. | project\_path (string), tech\_stack (enum\[\]), team\_size (number), compliance (enum\[\]) | readOnly: false, destructive: false, idempotent: false |
+| **ccboot\_generate\_claudemd** | Creates or updates a CLAUDE.md file. Analyzes existing codebase for framework detection, build commands, and test patterns. Merges with existing CLAUDE.md if present. | project\_path, scope (root|subdir), tech\_stack?, merge\_existing (bool) | readOnly: false, destructive: false, idempotent: true |
+| **ccboot\_create\_skill** | Scaffolds a new skill directory with SKILL.md, optional scripts/, references/, and assets/ folders. Sets correct YAML frontmatter. | name, description, invocation (user|auto|both), context (inline|fork), agent\_type?, allowed\_tools\[\] | readOnly: false, destructive: false, idempotent: false |
+| **ccboot\_create\_agent** | Scaffolds a subagent definition in .claude/agents/. Configures tools, model preferences, and system prompt. | name, description, role (explore|plan|general|custom), allowed\_tools\[\], model\_hint? | readOnly: false, destructive: false, idempotent: false |
+| **ccboot\_create\_hook** | Generates a hook configuration for settings.json. Supports all 17 Claude Code lifecycle events. | event (enum), matcher?, command, exit\_behavior (block|notify), description | readOnly: false, destructive: false, idempotent: true |
+| **ccboot\_create\_command** | Creates a slash command/prompt template as a skill with user invocation. | name, description, prompt\_body, arguments\[\] | readOnly: false, destructive: false, idempotent: false |
+
+**Tier 2: Knowledge Base and Management**
+
+| Tool Name | Description | Key Inputs | Annotations |
+| :---- | :---- | :---- | :---- |
+| **ccboot\_create\_knowledge** | Adds a reference document to .claude/docs/ or docs/ directory. Generates properly formatted markdown with frontmatter. | title, category (adr|runbook|api|schema|style), content, tags\[\] | readOnly: false, destructive: false, idempotent: false |
+| **ccboot\_create\_adr** | Generates an Architecture Decision Record following the standard ADR template (context, decision, consequences). | title, status (proposed|accepted|deprecated), context, decision, consequences | readOnly: false, destructive: false, idempotent: false |
+| **ccboot\_list\_artifacts** | Lists all Claude Code configuration artifacts in the current project with type, location, and status. | project\_path, type\_filter? (skill|agent|hook|command|knowledge|all) | readOnly: true, destructive: false, idempotent: true |
+| **ccboot\_validate\_config** | Validates all Claude Code configuration files. Checks YAML frontmatter, JSON structure, file references, and naming conventions. | project\_path, fix\_mode (report|auto\_fix) | readOnly: varies, destructive: false, idempotent: true |
+| **ccboot\_audit\_context** | Analyzes total context window budget consumption across all skills and CLAUDE.md files. Warns if exceeding the 2% skill budget. | project\_path | readOnly: true, destructive: false, idempotent: true |
+
+**Tier 3: Enterprise and Compliance**
+
+| Tool Name | Description | Key Inputs | Annotations |
+| :---- | :---- | :---- | :---- |
+| **ccboot\_apply\_compliance** | Applies a compliance template pack (HIPAA, SOX, PCI-DSS, SOC2) to the project. Adds appropriate hooks, skills, and CLAUDE.md sections. | project\_path, standard (enum), scope (full|hooks\_only|skills\_only) | readOnly: false, destructive: false, idempotent: true |
+| **ccboot\_create\_ci\_workflow** | Generates a GitHub Actions workflow for Claude Code PR review using @claude mentions. | repo\_path, review\_focus (security|performance|style|all), branch\_pattern | readOnly: false, destructive: false, idempotent: true |
+| **ccboot\_create\_security\_hook** | Generates safety hooks that block dangerous commands (force push, rm \-rf, env exposure, secret leaks). | project\_path, strictness (standard|strict|paranoid) | readOnly: false, destructive: false, idempotent: true |
+| **ccboot\_generate\_mcp\_config** | Creates a .mcp.json file with recommended MCP server configurations for the project stack. | project\_path, services\[\] (github|sentry|postgres|slack|etc), scope (project|user) | readOnly: false, destructive: false, idempotent: true |
+
+# **4\. Template Specifications**
+
+## **4.1 Template Engine Requirements**
+
+* Templates are stored as raw markdown/YAML/JSON files in the templates/ directory
+
+* The template engine performs variable substitution using {{variable}} syntax
+
+* Conditional sections use {{\#if condition}}...{{/if}} blocks
+
+* Templates must be composable — a CLAUDE.md template can include sections from sub-templates
+
+* All templates must pass validation against the relevant schema (YAML frontmatter for skills, JSON for hooks)
+
+## **4.2 Required Template Packs (MVP)**
+
+**CLAUDE.md Templates**
+
+* Generic full-stack project (Next.js \+ Prisma \+ Tailwind)
+
+* Python/FastAPI backend
+
+* Spring Boot / Java enterprise
+
+* React SPA with REST or GraphQL
+
+* Monorepo with subdirectory CLAUDE.md files
+
+**Skill Templates**
+
+* Code review skill (auto-invoked on PR-related tasks)
+
+* Test writer skill (generates tests for changed files)
+
+* Documentation skill (generates/updates docs from code changes)
+
+* Security scan skill (runs OWASP checks on code changes)
+
+* Performance audit skill (identifies N+1 queries, memory leaks)
+
+**Agent Templates**
+
+* Explore agent (read-only codebase investigation)
+
+* Plan agent (architecture planning without code changes)
+
+* Test runner agent (executes and analyzes test suites)
+
+* Security auditor agent (scans for vulnerabilities)
+
+**Hook Templates**
+
+* Format-on-write (Prettier, Black, gofmt based on file extension)
+
+* Lint-on-write (ESLint, Ruff, Clippy based on file extension)
+
+* Dangerous command blocker (rm \-rf, git push \--force, DROP TABLE)
+
+* Secret leak detector (blocks commits with API keys or passwords)
+
+# **5\. Non-Functional Requirements**
+
+## **5.1 Performance**
+
+* ccboot\_init\_project must complete in under 5 seconds for a standard project
+
+* Individual tool calls (create\_skill, create\_hook) must complete in under 1 second
+
+* Template rendering must not block — use async file I/O throughout
+
+## **5.2 Reliability**
+
+* All file writes must be atomic — write to temp file, then rename
+
+* Never overwrite existing files without explicit merge\_existing or force flag
+
+* All tool errors must return actionable messages with suggested fixes
+
+## **5.3 Security**
+
+* Never read or expose .env files, API keys, or secrets
+
+* Sanitize all file paths to prevent directory traversal
+
+* Validate all inputs with Zod schemas using .strict() enforcement
+
+* Log to stderr only (required for stdio MCP transport)
+
+## **5.4 Compatibility**
+
+* Must work with Claude Code on macOS, Linux, and Windows (via Git Bash or WSL)
+
+* Must support both stdio (local) and streamable HTTP (remote) transports
+
+* Generated artifacts must be valid for Claude Code v1.0+
+
+* Generated skills must follow the Agent Skills open standard (agentskills.io)
+
+## **5.5 Distribution**
+
+* Published as an npm package: @vaspera/ccboot-mcp-server
+
+* Installable via: claude mcp add ccboot \-- npx @vaspera/ccboot-mcp-server
+
+* Must include proper bin entry in package.json
+
+* Must include \#\!/usr/bin/env node shebang in compiled entry point
+
+# **6\. Technical Architecture**
+
+## **6.1 Stack**
+
+* **Language:** TypeScript (strict mode)
+
+* **Runtime:** Node.js 18+
+
+* **MCP SDK:** @modelcontextprotocol/sdk (latest)
+
+* **Validation:** Zod with .strict() schemas
+
+* **Transport:** stdio (primary) \+ streamable HTTP (optional)
+
+* **Template Engine:** Custom lightweight engine (no Handlebars dependency to minimize install size)
+
+## **6.2 Architecture Patterns**
+
+**Server Initialization (src/index.ts)**
+
+The entry point creates the McpServer instance, registers all tools from the tools/ directory, and connects to the transport. Each tool module exports a function that takes the server instance and registers its tools.
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+import { registerScaffoldingTools } from "./tools/scaffolding.js";
+
+import { registerKnowledgeTools } from "./tools/knowledge.js";
+
+// ... register all tool modules
+
+**Tool Registration Pattern**
+
+Each tool uses server.registerTool() with Zod input schemas, comprehensive descriptions, and proper annotations. Never use deprecated APIs like server.tool() or manual handler registration.
+
+**Template Rendering Pipeline**
+
+1. Load raw template from templates/ directory
+
+2. Merge user-provided variables with detected defaults (tech stack, project name)
+
+3. Resolve conditional sections (compliance blocks, framework-specific sections)
+
+4. Validate output against schema (YAML parse for skills, JSON.parse for hooks)
+
+5. Write to target file with atomic file operations
+
+**Error Handling**
+
+All tools follow the MCP error pattern: return { isError: true, content: \[...\] } for recoverable errors. Use specific, actionable error messages that guide Claude toward the correct usage.
+
+# **7\. CLAUDE.md for This Project**
+
+| Copy This File Create this file at the root of your ccboot-mcp-server repository as CLAUDE.md before starting your Claude Code session. This is the most critical step for implementation quality. |
+| :---- |
+
+Contents of CLAUDE.md:
+
+\# ccboot-mcp-server
+
+\#\# Project Overview
+
+An MCP server that generates, validates, and manages Claude Code
+
+configuration artifacts (CLAUDE.md, skills, agents, hooks, commands,
+
+MCP configs, knowledge docs) for enterprise-grade development.
+
+\#\# Tech Stack
+
+\- TypeScript (strict mode) targeting ES2022
+
+\- Node.js 18+ runtime
+
+\- @modelcontextprotocol/sdk for MCP server
+
+\- Zod for input validation
+
+\- stdio transport (primary), streamable HTTP (secondary)
+
+\#\# Architecture Rules
+
+\- ALWAYS use server.registerTool() (never deprecated server.tool())
+
+\- All tool names use ccboot\_ prefix with snake\_case
+
+\- All Zod schemas use .strict() enforcement
+
+\- No use of \`any\` type \- use \`unknown\` or proper types
+
+\- All async functions have explicit Promise\<T\> return types
+
+\- Log to stderr ONLY (stdout is reserved for MCP protocol)
+
+\- Never use console.log() \- use console.error() for debug output
+
+\- All file writes are atomic (write to temp, then rename)
+
+\- Never overwrite files without checking merge\_existing flag
+
+\#\# Tool Annotations
+
+Every tool MUST include annotations:
+
+\- readOnlyHint: true for read operations, false for writes
+
+\- destructiveHint: false (we never delete without explicit request)
+
+\- idempotentHint: true if re-running produces same result
+
+\- openWorldHint: false (we only touch local filesystem)
+
+\#\# File Structure
+
+\- src/index.ts          \- Entry point, server init, transport
+
+\- src/types.ts          \- Shared TypeScript interfaces
+
+\- src/constants.ts      \- Enums, defaults, limits
+
+\- src/tools/\*.ts        \- Tool implementations (one file per domain)
+
+\- src/services/\*.ts     \- Shared utilities (file ops, templates, validation)
+
+\- src/schemas/\*.ts      \- Zod schemas
+
+\- templates/\*\*/\*.md     \- Raw template files
+
+\#\# Build & Test
+
+\- Build: npm run build (must pass with zero errors)
+
+\- Lint: npx tsc \--noEmit
+
+\- Test: npm run test
+
+\- Dev: npx tsx src/index.ts (for local MCP testing)
+
+\#\# Template Conventions
+
+\- Variables: {{variable\_name}} (double curly braces)
+
+\- Conditionals: {{\#if condition}}...{{/if}}
+
+\- Templates are plain markdown with substitution markers
+
+\- All generated YAML must parse cleanly
+
+\- All generated JSON must be valid
+
+\- Skills MUST have name (max 64 chars) and description (max 200 chars)
+
+\#\# Code Quality
+
+\- Extract common functionality into src/services/
+
+\- DRY: if logic appears twice, extract to a function
+
+\- Every tool description includes: purpose, args, return schema, examples
+
+\- Error messages suggest next steps (not just what failed)
+
+\- No hardcoded paths \- use path.join() and respect project\_path input
+
+# **8\. Implementation Plan**
+
+## **8.1 Phase 1: Foundation (Days 1–3)**
+
+1. **Project scaffolding:** Create repo, install deps, configure tsconfig, package.json, and CLAUDE.md.
+
+2. **Server entry point:** Implement src/index.ts with McpServer init, transport selection, and tool module registration pattern.
+
+3. **Shared services:** Build src/services/file-ops.ts (atomic writes, directory creation, file existence checks), template-engine.ts (variable substitution, conditionals), and validation.ts (YAML parse, JSON parse, frontmatter check).
+
+4. **Types and schemas:** Define all TypeScript interfaces in types.ts, all Zod schemas in schemas/, and all constants/enums in constants.ts.
+
+## **8.2 Phase 2: Core Tools (Days 4–8)**
+
+1. **ccboot\_init\_project:** The flagship tool. Detects tech stack from existing files (package.json, Cargo.toml, etc.), generates all artifacts, creates directory structure.
+
+2. **ccboot\_generate\_claudemd:** Template-based CLAUDE.md generation with merge support for existing files.
+
+3. **ccboot\_create\_skill:** Skill scaffolding with correct YAML frontmatter, directory structure, and optional script stubs.
+
+4. **ccboot\_create\_agent:** Subagent creation with tool permissions and role-based defaults.
+
+5. **ccboot\_create\_hook:** Hook configuration generation supporting all 17 lifecycle events.
+
+6. **ccboot\_create\_command:** Slash command creation as a skill with user invocation mode.
+
+## **8.3 Phase 3: Templates (Days 9–12)**
+
+6. Create 5 CLAUDE.md templates (Next.js, Python/FastAPI, Spring Boot, React SPA, monorepo)
+
+7. Create 5 skill templates (code review, test writer, docs, security, performance)
+
+8. Create 4 agent templates (explore, plan, test runner, security auditor)
+
+9. Create 4 hook templates (format-on-write, lint-on-write, danger blocker, secret detector)
+
+## **8.4 Phase 4: Management Tools (Days 13–15)**
+
+10. Implement ccboot\_list\_artifacts, ccboot\_validate\_config, ccboot\_audit\_context
+
+11. Implement ccboot\_create\_knowledge and ccboot\_create\_adr
+
+## **8.5 Phase 5: Enterprise \+ Testing (Days 16–20)**
+
+12. Implement ccboot\_apply\_compliance with HIPAA and SOC2 packs
+
+13. Implement ccboot\_create\_security\_hook and ccboot\_create\_ci\_workflow
+
+14. Implement ccboot\_generate\_mcp\_config
+
+15. Write integration tests for all tools
+
+16. Build and validate: npm run build must pass cleanly
+
+17. Test with MCP Inspector: npx @modelcontextprotocol/inspector
+
+# **9\. Acceptance Criteria**
+
+## **9.1 MVP Acceptance (Tiers 1–2)**
+
+* All 11 Tier 1 and Tier 2 tools are registered and functional
+
+* npm run build completes with zero errors
+
+* Server starts via stdio transport and responds to tool/list
+
+* ccboot\_init\_project generates a valid, complete Claude Code project setup
+
+* All generated CLAUDE.md files parse as valid markdown
+
+* All generated SKILL.md files have valid YAML frontmatter with name and description
+
+* All generated hook configs are valid JSON matching Claude Code settings.json schema
+
+* All generated agent definitions are valid markdown with correct placement
+
+* ccboot\_validate\_config catches at least: missing name in skill frontmatter, invalid JSON in hooks, CLAUDE.md exceeding 500 lines
+
+* ccboot\_audit\_context correctly calculates token estimates and warns at 2% budget
+
+## **9.2 Enterprise Acceptance (Tier 3\)**
+
+* ccboot\_apply\_compliance generates HIPAA pack with: audit logging hook, PHI handling skill, data classification CLAUDE.md section
+
+* ccboot\_create\_security\_hook blocks: rm \-rf, git push \--force, env variable exposure, secret patterns in commits
+
+* ccboot\_create\_ci\_workflow produces a working GitHub Actions YAML
+
+## **9.3 Distribution Acceptance**
+
+* Package published to npm as @vaspera/ccboot-mcp-server
+
+* Installable via: claude mcp add ccboot \-- npx @vaspera/ccboot-mcp-server
+
+* README.md with installation instructions, tool documentation, and examples
+
+* MCP Inspector test passes for all tools
+
+*End of Requirements Document*
+
+*ccboot-mcp-server v1.0 — Vaspera Capital — March 2026*