ma-agents 1.9.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ma-agents",
-  "version": "1.9.0",
+  "version": "2.0.0",
   "description": "NPX tool to install skills for AI coding agents (Claude Code, Gemini, Copilot, Kilocode, Cline, Cursor)",
   "main": "index.js",
   "bin": {

package/skills/README.md

@@ -240,6 +240,68 @@ Enforces Modern C++ practices (RAII, Smart Pointers) to prevent memory leaks and
 
 ---
 
+### 9. C++ Robust Interfaces
+**Directory:** `cpp-robust-interfaces/`
+
+Enforces contract-based design and strong typing in C++ signatures (C++14+).
+
+**Key Features:**
+- ✅ **Contracts**: Enforces `Expects()` and `Ensures()` validation.
+- ✅ **Strong Typing**: Discourages boolean blindness in favor of enums.
+- ✅ **Ownership Clarity**: Forbids owning raw pointers in interfaces.
+- ✅ **Span Support**: Uses `gsl::span` for safe sequence passing.
+
+---
+
+### 10. C++ Modern Composition
+**Directory:** `cpp-modern-composition/`
+
+Replaces legacy C-style patterns with modern STL and Ranges-based composition (C++14+).
+
+**Key Features:**
+- ✅ **STL Algorithms**: Mandates `<algorithm>` over manual loops.
+- ✅ **Zero Macros/C-Casts**: Enforces `constexpr` and `static_cast`.
+- ✅ **Universal Init**: Uses `{}` to prevent narrowing and parsing errors.
+
+---
+
+### 11. C++ Const-Correctness & Logic
+**Directory:** `cpp-const-correctness/`
+
+Enforces immutability-by-default and pushes logic to compile-time (C++14+).
+
+**Key Features:**
+- ✅ **Immutable Default**: Mandates `const` for all local variables.
+- ✅ **Const Members**: Ensures inspectors are correctly marked `const`.
+- ✅ **constexpr Logic**: Pushes mathematical and config logic to compile-time.
+
+---
+
+### 12. C++ Safety-First Concurrency
+**Directory:** `cpp-concurrency-safety/`
+
+Enforces safe multi-threading using RAII locking and task-based parallelism (C++14+).
+
+**Key Features:**
+- ✅ **RAII Locking**: Mandates `std::lock_guard` and `std::scoped_lock`.
+- ✅ **Task-Based**: Prefers `std::async` over raw `std::thread`.
+- ✅ **Race Prevention**: Enforces "No shared mutable state" policies.
+
+---
+
+### 13. Modern CMake Best Practices
+**Directory:** `cmake-best-practices/`
+
+Enforces target-based, property-oriented CMake patterns (CMake 3.0+ philosophy).
+
+**Key Features:**
+- ✅ **Target-Centric**: Bans global commands (e.g., `include_directories`) in favor of `target_*`.
+- ✅ **Visibility Hygiene**: Enforces `PUBLIC`, `PRIVATE`, and `INTERFACE` scopes.
+- ✅ **Feature-Based**: Uses `target_compile_features` for C++ standard management.
+- ✅ **Clean Flags**: Bans global `CMAKE_CXX_FLAGS` manipulation.
+
+---
+
 ## Requirements
 
 ### All Skills

package/skills/cmake-best-practices/SKILL.md

@@ -0,0 +1,60 @@
+# Modern CMake Best Practices (Target-Based Approach)
+
+This skill ensures that CMake definitions follow the "Modern CMake" philosophy (3.0+), focusing on targets and properties rather than global variables.
+
+## Policies
+
+### 1. Target-Centric Philosophy
+*   **Rule**: Treat targets as objects. Use `target_*` commands instead of global commands.
+*   **Action**: 
+    - **Forbidden**: `include_directories()`, `link_libraries()`, `add_definitions()`.
+    - **Mandatory**: `target_include_directories()`, `target_link_libraries()`, `target_compile_definitions()`.
+*   **Rationale**: Encapsulates requirements and prevents property leakage to unrelated targets.
+
+### 2. Visibility Hygiene (`PUBLIC`, `PRIVATE`, `INTERFACE`)
+*   **Rule**: Always specify the scope of target properties.
+*   **Action**:
+    - `PRIVATE`: Requirement only for building the target.
+    - `INTERFACE`: Requirement only for consumers of the target.
+    - `PUBLIC`: Requirement for both.
+*   **Rationale**: Ensures that internal dependencies (like a private logging library) don't bleed into the usage requirements of your high-level API.
+
+### 3. Feature-Based C++ Standards
+*   **Rule**: Do not manually set `CMAKE_CXX_STANDARD` or `-std=c++XX` flags.
+*   **Action**: Use `target_compile_features(my_target PUBLIC cxx_std_17)`.
+*   **Rationale**: Allows CMake to handle compiler-specific flags and ensures the compiler actually supports the requested features.
+
+### 4. No Global Variable Manipulation
+*   **Rule**: Ban direct modification of `CMAKE_CXX_FLAGS` or `CMAKE_EXE_LINKER_FLAGS`.
+*   **Action**: Use `target_compile_options()` for specific compiler warnings or flags.
+*   **Rationale**: Global flags make it impossible to have different settings for different targets in the same project.
+
+### 5. Namespaced Alias Targets
+*   **Rule**: Always provide an alias for library targets using a namespace.
+*   **Action**: `add_library(MyLib::MyLib ALIAS my_lib_target)`.
+*   **Rationale**: Makes exported targets look consistent with external dependencies (like those found via `find_package`).
+
+## Examples
+
+### Before (Legacy Procedural CMake)
+```cmake
+include_directories(${PROJECT_SOURCE_DIR}/include)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall")
+add_library(mylib mylib.cpp)
+```
+
+### After (Modern Target-Based CMake)
+```cmake
+add_library(mylib mylib.cpp)
+
+target_compile_features(mylib PUBLIC cxx_std_17)
+target_compile_options(mylib PRIVATE -Wall)
+
+target_include_directories(mylib 
+    PUBLIC 
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+)
+
+add_library(MyProject::MyLib ALIAS mylib)
+```

package/skills/cmake-best-practices/examples/cmake.md

@@ -0,0 +1,59 @@
+# Modern CMake Examples
+
+### 1. Project Structure and App
+```cmake
+cmake_minimum_required(VERSION 3.14)
+project(MyAwesomeApp VERSION 1.0 LANGUAGES CXX)
+
+# Use target_compile_features for the whole project standard if needed
+# but target-specific is better.
+add_executable(app main.cpp)
+
+target_compile_features(app PRIVATE cxx_std_17)
+target_link_libraries(app PRIVATE MyProject::Core)
+```
+
+### 2. Library with Internal/External Dependencies
+```cmake
+add_library(core src/core.cpp)
+
+# Internal include dir
+target_include_directories(core 
+    PUBLIC  include
+    PRIVATE src
+)
+
+# Link against a 3rd party library found via find_package
+find_package(fmt REQUIRED)
+target_link_libraries(core 
+    PUBLIC  fmt::fmt
+    PRIVATE Threads::Threads
+)
+
+add_library(MyProject::Core ALIAS core)
+```
+
+### 3. Proper Header-Only Library
+```cmake
+add_library(utils INTERFACE)
+
+target_include_directories(utils 
+    INTERFACE 
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+)
+
+# Requirement: anyone using utils MUST have C++14
+target_compile_features(utils INTERFACE cxx_std_14)
+
+add_library(MyProject::Utils ALIAS utils)
+```
+
+### 4. Compiler-Specific Options Safely
+```cmake
+if(MSVC)
+    target_compile_options(core PRIVATE /W4 /WX)
+else()
+    target_compile_options(core PRIVATE -Wall -Wextra -Werror)
+endif()
+```

package/skills/cmake-best-practices/skill.json

@@ -0,0 +1,18 @@
+{
+    "name": "Modern CMake Best Practices",
+    "description": "Enforce target-based, property-oriented CMake patterns (CMake 3.0+).",
+    "version": "1.0.0",
+    "author": "Antigravity",
+    "tags": [
+        "cmake",
+        "cpp",
+        "build-system",
+        "devops"
+    ],
+    "applies_when": [
+        "creating or modifying CMakeLists.txt files",
+        "managing C++ project dependencies via CMake",
+        "defining C++ build configurations"
+    ],
+    "always_load": true
+}

package/skills/cpp-concurrency-safety/SKILL.md

@@ -0,0 +1,56 @@
+# C++ Safety-First Concurrency (Core Guidelines Section CP)
+
+This skill prevents common multi-threading defects like data races, deadlocks, and shared-state corruption.
+
+## Policies
+
+### 1. RAII Locking Only
+*   **Rule**: Never call `mutex.lock()` or `mutex.unlock()` manually.
+*   **Action**: 
+    - Use `std::lock_guard` for single mutexes.
+    - Use `std::unique_lock` if you need deferred locking or condition variables.
+    - Use `std::scoped_lock` (C++17) for multiple mutexes to avoid deadlocks.
+*   **Rationale**: Ensures locks are released even if an exception is thrown.
+
+### 2. Task-Based Parallelism
+*   **Rule**: Prefer tasks (`std::async`, `std::packaged_task`, `std::future`) over raw threads (`std::thread`).
+*   **Action**: Use `auto result = std::async(std::launch::async, func, args...);`
+*   **Rationale**: Automates thread management and handles value return/exception propagation naturally.
+
+### 3. Minimize Shared Mutable State
+*   **Rule**: Data should ideally be either "Thread-Local" or "Read-Only".
+*   **Action**:
+    - Pass data to threads by value where possible.
+    - Use `const` for data shared between threads.
+    - Group mutexes with the data they protect (e.g., in a struct).
+*   **Rationale**: If data isn't shared or isn't mutable, it cannot have a race condition.
+
+### 4. Never Sleep/Wait without a Condition
+*   **Rule**: Avoid `std::this_thread::sleep_for` for synchronization.
+*   **Action**: Use `std::condition_variable` with a predicate to wait for work.
+*   **Rationale**: Sleeping is inefficient and bug-prone; condition variables are precise and responsive.
+
+## Examples
+
+### Before (Dangerous Concurrency)
+```cpp
+std::mutex mtx;
+int sharedData = 0;
+
+void worker() {
+    mtx.lock();
+    sharedData++;
+    mtx.unlock(); // What if an exception happened above?
+}
+```
+
+### After (Safe Concurrency)
+```cpp
+std::mutex mtx;
+int sharedData = 0;
+
+void worker() {
+    std::lock_guard<std::mutex> lock(mtx);
+    sharedData++;
+} // Lock automatically released here
+```

package/skills/cpp-concurrency-safety/examples/concurrency.md

@@ -0,0 +1,73 @@
+# Concurrency Safety Examples (C++14+)
+
+### 1. Task-Based Parallelism (Async)
+Avoids manual thread joining and handles return values safely.
+
+```cpp
+#include <future>
+#include <vector>
+#include <numeric>
+
+int computeLargeSum(const std::vector<int>& data) {
+    auto part1 = std::async(std::launch::async, [&data]() {
+        return std::accumulate(data.begin(), data.begin() + data.size()/2, 0);
+    });
+    
+    auto part2 = std::accumulate(data.begin() + data.size()/2, data.end(), 0);
+    
+    return part1.get() + part2;
+}
+```
+
+### 2. Multi-Lock Safety (C++17 scoped_lock)
+Prevents deadlocks when acquiring multiple resources.
+
+```cpp
+#include <mutex>
+
+struct Account {
+    std::mutex mtx;
+    double balance;
+};
+
+void transfer(Account& from, Account& to, double amount) {
+    // Acquire both locks simultaneously in a deadlock-free manner
+    std::scoped_lock lock(from.mtx, to.mtx);
+    
+    if (from.balance >= amount) {
+        from.balance -= amount;
+        to.balance += amount;
+    }
+}
+```
+
+### 3. Condition Variables with Predicates
+Always use a predicate to protect against "spurious wakeups."
+
+```cpp
+#include <mutex>
+#include <condition_variable>
+#include <queue>
+
+std::queue<int> workQueue;
+std::mutex workMtx;
+std::condition_variable workCv;
+bool finished = false;
+
+void consumer() {
+    while (true) {
+        std::unique_lock<std::mutex> lock(workMtx);
+        
+        // Wait until there is work OR we are finished
+        workCv.wait(lock, []{ return !workQueue.empty() || finished; });
+        
+        if (workQueue.empty() && finished) break;
+        
+        int task = workQueue.front();
+        workQueue.pop();
+        lock.unlock(); // Release lock before processing
+        
+        process(task);
+    }
+}
+```

package/skills/cpp-concurrency-safety/skill.json

@@ -0,0 +1,19 @@
+{
+    "name": "C++ Safety-First Concurrency",
+    "description": "Enforce safe multi-threading patterns using RAII locking and task-based parallelism (C++14+).",
+    "version": "1.0.0",
+    "author": "Antigravity",
+    "tags": [
+        "cpp",
+        "concurrency",
+        "threads",
+        "mutex",
+        "raii"
+    ],
+    "applies_when": [
+        "working with C++ threads",
+        "using C++ mutexes or locking primitives",
+        "performing C++ asynchronous operations",
+        "designing multi-threaded C++ systems"
+    ]
+}

package/skills/cpp-const-correctness/SKILL.md

@@ -0,0 +1,59 @@
+# C++ Const-Correctness & Logic (Core Guidelines Section Con & ES)
+
+This skill ensures that C++ code is "immutable by default," reducing side effects and enabling better compiler optimizations.
+
+## Policies
+
+### 1. By Default, Make Objects Immutable
+*   **Rule**: Declare all variables `const` unless they *must* be modified.
+*   **Action**: 
+    - Use `const auto x = ...;` instead of `auto x = ...;`.
+    - Use `const` for function results that won't be modified.
+*   **Rationale**: Prevents accidental state mutation and improves code reasoning.
+
+### 2. Const Member Functions
+*   **Rule**: Any member function that does not modify the object's observable state must be `const`.
+*   **Action**: Append `const` to the function signature: `T getValue() const { ... }`.
+*   **Rationale**: Necessary for calling functions on `const` objects and `const&` parameters.
+
+### 3. Compute at Compile-Time (`constexpr`)
+*   **Rule**: Prefer `constexpr` for any value or simple logic that *can* be computed at compile-time.
+*   **Action**:
+    - Use `constexpr` for constants.
+    - Declare mathematical or configuration functions as `constexpr` (C++14 allows complex logic in `constexpr`).
+*   **Rationale**: Moves work from runtime to compile-time, reducing binary size and execution time.
+
+### 4. Consistent Parameter Logic
+*   **Rule**: Avoid passing by value for large types; avoid passing by non-const reference unless it's an "out" or "in-out" parameter.
+*   **Action**:
+    - **In parameters**: Pass cheap types (int, double, pointers, `string_view`) by value. Pass large types by `const&`.
+    - **Out/In-out parameters**: Pass by `T&`.
+    - **Sinks**: Pass by `T&&` (rvalue reference).
+
+## Examples
+
+### Before (Mutable/Runtime Logic)
+```cpp
+int getMultiplier(int x) {
+    return x * 10;
+}
+
+void process() {
+    auto data = loadData();
+    auto mult = getMultiplier(5); // mutable by accident
+    data.apply(mult);
+}
+```
+
+### After (Const/Compile-time Logic)
+```cpp
+constexpr int getMultiplier(int x) {
+    return x * 10;
+}
+
+void process() {
+    const auto data = loadData(); // data won't change
+    constexpr auto mult = getMultiplier(5); // computed at compile time
+    data.apply(mult);
+}
+```

package/skills/cpp-const-correctness/examples/const_correctness.md

@@ -0,0 +1,54 @@
+# Const-Correctness Examples (C++14+)
+
+### 1. Complex Const Initialization (Lambda)
+Sometimes you need to conditionally initialize a variable, but you want it to be `const` afterward.
+
+**Modern (C++14):**
+```cpp
+const auto path = []() {
+    if (auto env = std::getenv("APP_PATH")) {
+        return std::string(env);
+    }
+    return std::string("/default/path");
+}(); // Immediately invoked lambda
+```
+
+### 2. Const-Correct Member Functions
+Ensure getters and inspectors are `const`.
+
+```cpp
+class Config {
+    int timeout = 30;
+public:
+    // This is an inspector, must be const
+    int getTimeout() const { return timeout; }
+    
+    // This is a mutator, cannot be const
+    void setTimeout(int t) { timeout = t; }
+};
+```
+
+### 3. C++14 constexpr Logic
+C++14 expanded `constexpr` significantly (loops, branches allowed).
+
+```cpp
+constexpr int fibonacci(int n) {
+    if (n <= 1) return n;
+    int a = 0, b = 1;
+    for (int i = 2; i <= n; ++i) {
+        int next = a + b;
+        a = b;
+        b = next;
+    }
+    return b;
+}
+
+// Result is computed by the compiler
+constexpr int fib10 = fibonacci(10);
+```
+
+### 4. Parameter Passing Guide
+- `void f(int)` : Fast to copy (Value)
+- `void f(const LargeObject&)` : Expensive to copy (Const Ref)
+- `void f(LargeObject&)` : I will modify this (Ref)
+- `void f(LargeObject&&)` : I will MOVE/OWN this (Rvalue Ref)

package/skills/cpp-const-correctness/skill.json

@@ -0,0 +1,19 @@
+{
+    "name": "C++ Const-Correctness & Logic",
+    "description": "Enforce immutability-by-default and push logic to compile-time using constexpr (C++14+).",
+    "version": "1.0.0",
+    "author": "Antigravity",
+    "tags": [
+        "cpp",
+        "const",
+        "constexpr",
+        "immutability",
+        "optimization"
+    ],
+    "applies_when": [
+        "declaring C++ variables",
+        "defining C++ member functions",
+        "performing C++ compile-time calculations",
+        "optimizing C++ logic"
+    ]
+}

package/skills/cpp-modern-composition/SKILL.md

@@ -0,0 +1,60 @@
+# C++ Modern Composition (Core Guidelines Section STL, CPL, ES)
+
+This skill forces the transition from legacy "C-style" C++ to modern, declarative, and safer C++ idioms.
+
+## Policies
+
+### 1. STL Algorithms over Manual Loops
+*   **Rule**: Never write a raw `for` or `while` loop for operations supported by `<algorithm>` or `<numeric>`.
+*   **Action**: 
+    - Use `std::any_of`, `std::all_of`, `std::find_if`, `std::transform`, `std::accumulate`.
+    - In C++20 projects, prefer `std::ranges` versions.
+*   **Rationale**: Reduces "off-by-one" errors and improves intent readability.
+
+### 2. Eradicate C-style Casts and Macros
+*   **Rule**: Ban `(type)value` and `#define` for logic/constants.
+*   **Action**:
+    - Use `static_cast`, `reinterpret_cast`, or `const_cast`.
+    - Replace macros with `constexpr` variables or `inline` functions/templates.
+*   **Rationale**: Named casts are searchable and safer; `constexpr` respects namespaces and scopes.
+
+### 3. Universal Initialization
+*   **Rule**: Prefer `{}` initialization to avoid the "Most Vexing Parse".
+*   **Action**: Use `auto x = Type{args...};` or `Type x{args...};`.
+*   **Rationale**: Prevents narrowing conversions (e.g., `int x{3.5}` is a compiler error, while `int x = 3.5` is not).
+
+### 4. Zero Raw Memory Manipulation
+*   **Rule**: Ban `memset`, `memcpy`, and `malloc`.
+*   **Action**:
+    - Use `std::fill`, `std::copy`, or `container.assign()`.
+    - Use `std::vector` or `std::array` instead of raw arrays.
+*   **Rationale**: Standard containers are bounds-checked (via `.at()`) and manage their own memory.
+
+## Examples
+
+### Before (C-style C++)
+```cpp
+#define MAX_BUFFER 1024
+int arr[MAX_BUFFER];
+memset(arr, 0, sizeof(arr));
+
+bool found = false;
+for (int i = 0; i < MAX_BUFFER; ++i) {
+    if (arr[i] == (int)someFloat) {
+        found = true;
+        break;
+    }
+}
+```
+
+### After (Modern C++)
+```cpp
+constexpr size_t MaxBuffer = 1024;
+std::array<int, MaxBuffer> arr;
+arr.fill(0);
+
+auto target = static_cast<int>(someFloat);
+bool found = std::any_of(arr.begin(), arr.end(), [target](int v) {
+    return v == target;
+});
+```

package/skills/cpp-modern-composition/examples/composition.md

@@ -0,0 +1,51 @@
+# Modern Composition Examples (C++14+)
+
+### 1. Data Transformation (Transform)
+**Legacy:**
+```cpp
+std::vector<int> inputs = {1, 2, 3};
+std::vector<int> outputs;
+for (size_t i = 0; i < inputs.size(); ++i) {
+    outputs.push_back(inputs[i] * 2);
+}
+```
+
+**Modern (C++14):**
+```cpp
+std::vector<int> inputs = {1, 2, 3};
+std::vector<int> outputs;
+outputs.reserve(inputs.size());
+std::transform(inputs.begin(), inputs.end(), std::back_inserter(outputs), 
+               [](int n) { return n * 2; });
+```
+
+### 2. Summation and Reduction (Accumulate)
+**Modern (C++14):**
+```cpp
+#include <numeric>
+
+std::vector<double> prices = {10.5, 20.0, 5.25};
+double total = std::accumulate(prices.begin(), prices.end(), 0.0);
+```
+
+### 3. Safe Narrowing Protection
+**Logic:**
+```cpp
+double d = 7.9;
+// int i{d}; // Error: narrowing conversion from 'double' to 'int'
+int i = static_cast<int>(d); // Explicit and safe
+```
+
+### 4. Replacing Function Macros
+**Legacy:**
+```cpp
+#define SQUARE(x) ((x)*(x))
+```
+
+**Modern (C++14):**
+```cpp
+template<typename T>
+constexpr T square(T t) {
+    return t * t;
+}
+```

package/skills/cpp-modern-composition/skill.json

@@ -0,0 +1,20 @@
+{
+    "name": "C++ Modern Composition",
+    "description": "Replace legacy C patterns with STL, Ranges, and modern C++ abstractions (C++14+).",
+    "version": "1.0.0",
+    "author": "Antigravity",
+    "tags": [
+        "cpp",
+        "stl",
+        "ranges",
+        "algorithms",
+        "refactoring"
+    ],
+    "applies_when": [
+        "writing C++ logic or algorithms",
+        "performing C++ refactoring",
+        "handling C++ data transformations",
+        "working with C++ collections"
+    ],
+    "always_load": true
+}

package/skills/cpp-robust-interfaces/SKILL.md

@@ -0,0 +1,51 @@
+# C++ Robust Interfaces (Core Guidelines Section I & E)
+
+This skill ensures that C++ interfaces follow contract-based design principles to improve safety, clarity, and maintainability.
+
+## Policies
+
+### 1. Make Interfaces Explicit
+*   **Rule**: Functions must explicitly state their requirements (pre-conditions) and guarantees (post-conditions).
+*   **Action**: Use `Expects()` and `Ensures()` (from GSL) or standardized comments if GSL is unavailable.
+*   **Rationale**: Detects integration bugs at the call site rather than deep in the implementation.
+
+### 2. Strong Typing over Primitive Types
+*   **Rule**: Avoid "Boolean Blindness" and `void*`.
+*   **Action**: 
+    - Use `enum class` for options instead of `bool`.
+    - Use `std::chrono` for time instead of `int`.
+    - Use specific types/structs instead of a long list of primitive arguments.
+
+### 3. Clear Ownership and Lifetime
+*   **Rule**: A raw pointer (`T*`) in an interface **must never** represent ownership.
+*   **Action**: 
+    - Use `gsl::not_null<T*>` for pointers that cannot be null.
+    - Use `std::unique_ptr` or `std::shared_ptr` ONLY if the function is participating in ownership/lifetime management.
+    - Prefer `T&` for arguments that must exist and aren't owned by the callee.
+
+### 4. Sequence Safety
+*   **Rule**: Never pass an array as a raw pointer + size.
+*   **Action**:
+    - Use `gsl::span<T>` (C++14/17 via GSL) or `std::span<T>` (C++20).
+    - Use `std::string_view` for read-only strings.
+
+## Examples
+
+### Before (Fragile Interface)
+```cpp
+// What does 'flag' mean? Is data allowed to be null? Is it an array?
+void processData(char* data, int size, bool flag);
+```
+
+### After (Robust Interface)
+```cpp
+#include <gsl/gsl>
+
+enum class ProcessingMode { Fast, Thorough };
+
+// Explicit contract: data must not be null, size is handled by span
+void processData(gsl::span<const char> data, ProcessingMode mode) {
+    Expects(!data.empty());
+    // ...
+}
+```

package/skills/cpp-robust-interfaces/examples/interfaces.md

@@ -0,0 +1,56 @@
+# Robust Interface Examples (C++14+)
+
+### 1. Avoiding Boolean Blindness
+**Incorrect:**
+```cpp
+void setWindowVisible(bool visible, bool animate);
+// Call site: setWindowVisible(true, false); // What is false?
+```
+
+**Correct (C++14):**
+```cpp
+enum class Visibility { Visible, Hidden };
+enum class Animation { Enabled, Disabled };
+
+void setWindowVisible(Visibility v, Animation a);
+// Call site: setWindowVisible(Visibility::Visible, Animation::Disabled);
+```
+
+### 2. Contract-Based Validation
+Using GSL (Guidelines Support Library) style:
+
+```cpp
+#include <gsl/gsl>
+
+class User {
+public:
+    // Ensure name is never null or empty
+    void setName(gsl::not_null<const char*> name) {
+        Expects(std::strlen(name) > 0);
+        this->name = name;
+    }
+private:
+    std::string name;
+};
+```
+
+### 3. Safe Sequences with Span
+Replaces pointer + length pairs which are prone to buffer overflows.
+
+```cpp
+#include <gsl/gsl> // Use gsl::span in C++14
+
+float calculateAverage(gsl::span<const float> values) {
+    Expects(!values.empty());
+    
+    float sum = 0.0f;
+    for (float v : values) {
+        sum += v;
+    }
+    return sum / values.size();
+}
+
+// Usage:
+// float arr[] = {1, 2, 3};
+// calculateAverage(arr); // Automatic conversion to span
+```

package/skills/cpp-robust-interfaces/skill.json

@@ -0,0 +1,18 @@
+{
+    "name": "C++ Robust Interfaces",
+    "description": "Enforce contract-based design and strong typing in C++ interfaces (C++14+).",
+    "version": "1.0.0",
+    "author": "Antigravity",
+    "tags": [
+        "cpp",
+        "interfaces",
+        "contracts",
+        "gsl",
+        "type-safety"
+    ],
+    "applies_when": [
+        "creating or modifying C++ header files",
+        "designing C++ function signatures",
+        "defining C++ APIs or public interfaces"
+    ]
+}