@ketecode/loom 0.0.0-stage → 0.2.0

package/skills/cpp-patterns/references/cmake-and-tooling.md

@@ -0,0 +1,88 @@
+# CMake warnings, sanitizers and clang-tidy
+
+Read this when setting up a new C++ project or adding sanitizer and lint builds to an existing one.
+
+## Warnings as a reusable interface target
+
+```cmake
+add_library(project_warnings INTERFACE)
+if(MSVC)
+  target_compile_options(project_warnings INTERFACE /W4 /permissive-)
+else()
+  target_compile_options(project_warnings INTERFACE
+    -Wall -Wextra -Wpedantic -Wshadow -Wconversion -Wsign-conversion -Wnon-virtual-dtor)
+endif()
+
+target_link_libraries(core PRIVATE project_warnings)
+```
+
+Turn warnings into errors in CI only (`-Werror` / `/WX`, or CMake's `CMAKE_COMPILE_WARNING_AS_ERROR` on CMake 3.24+), so a new compiler version cannot break a developer's local build.
+
+## Sanitizer option
+
+```cmake
+option(ENABLE_SANITIZERS "Build with ASan and UBSan" OFF)
+if(ENABLE_SANITIZERS AND NOT MSVC)
+  add_compile_options(-fsanitize=address,undefined -fno-omit-frame-pointer -fno-sanitize-recover=undefined)
+  add_link_options(-fsanitize=address,undefined)
+endif()
+# add_compile_options is deliberate here: every target, including fetched dependencies, must be instrumented.
+```
+
+MSVC supports AddressSanitizer with `/fsanitize=address`; it has no UBSan. Configure: `cmake -S . -B build-asan -DENABLE_SANITIZERS=ON -DCMAKE_BUILD_TYPE=Debug`.
+
+Useful runtime options:
+
+- `ASAN_OPTIONS=detect_leaks=1:abort_on_error=1` (LeakSanitizer is on by default on Linux; Apple Clang on macOS may not support it, so drop `detect_leaks=1` there if ASan rejects it)
+- `UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1`
+- `TSAN_OPTIONS=halt_on_error=1`
+
+## CMakePresets.json
+
+```json
+{
+  "version": 3,
+  "configurePresets": [
+    { "name": "debug", "binaryDir": "build/debug", "cacheVariables": { "CMAKE_BUILD_TYPE": "Debug" } },
+    { "name": "asan", "inherits": "debug", "binaryDir": "build/asan", "cacheVariables": { "ENABLE_SANITIZERS": "ON" } },
+    { "name": "release", "binaryDir": "build/release", "cacheVariables": { "CMAKE_BUILD_TYPE": "Release" } }
+  ],
+  "buildPresets": [
+    { "name": "debug", "configurePreset": "debug" },
+    { "name": "asan", "configurePreset": "asan" }
+  ],
+  "testPresets": [
+    { "name": "asan", "configurePreset": "asan", "output": { "outputOnFailure": true } }
+  ]
+}
+```
+
+Run: `cmake --preset asan && cmake --build --preset asan && ctest --preset asan`.
+
+## clang-tidy
+
+A starting `.clang-tidy` (only add one if the project has none and the user agrees):
+
+```yaml
+Checks: >
+  -*,
+  bugprone-*,
+  cppcoreguidelines-*,
+  modernize-*,
+  performance-*,
+  readability-*,
+  -modernize-use-trailing-return-type,
+  -readability-identifier-length,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -readability-magic-numbers
+WarningsAsErrors: ''
+HeaderFilterRegex: '/(include|src)/'
+```
+
+Header names are usually absolute paths, so do not anchor the regex with `^`. Run on changed files (skipping deleted ones): `clang-tidy -p build $(git diff --name-only --diff-filter=d -- '*.cpp' '*.hpp')`. To run during the build instead, set `CMAKE_CXX_CLANG_TIDY` to `clang-tidy` (slows builds; best in a dedicated CI preset).
+
+## Dependencies
+
+- **vcpkg (manifest mode):** a `vcpkg.json` lists dependencies; configure with `-DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake`, then `find_package(fmt CONFIG REQUIRED)` and link the imported target (`fmt::fmt`).
+- **Conan 2:** a `conanfile.txt` or `conanfile.py` with the `CMakeDeps` and `CMakeToolchain` generators; run `conan install . --build=missing`, then configure CMake with the generated `conan_toolchain.cmake` (its folder depends on the layout; Conan prints it).
+- **FetchContent:** good for test frameworks and small header-only libraries; pin a tag or commit hash, never a moving branch.

package/skills/cpp-patterns/references/undefined-behaviour.md

@@ -0,0 +1,75 @@
+# Undefined behaviour: common cases and fixes
+
+Read this when writing or reviewing code that does arithmetic on input, holds references or views, or shares data between threads.
+
+## Lifetime and dangling
+
+```cpp
+// BAD: view into a temporary string
+std::string_view name = get_name();   // get_name() returns std::string by value
+use(name);                            // dangling
+
+// GOOD
+std::string name = get_name();
+```
+
+```cpp
+// BAD: reference into a vector, then the vector grows
+int& first = v[0];
+v.push_back(42);    // may reallocate; `first` now dangles
+first = 1;          // UB
+
+// GOOD: re-index after growth, or reserve() first if the size is known
+```
+
+```cpp
+// BAD: lambda outlives the locals it captured by reference
+std::function<void()> make_cb() {
+  int count = 0;
+  return [&] { ++count; };   // dangling
+}
+// GOOD: capture by value, or move ownership in: [count = 0]() mutable { ++count; }
+```
+
+```cpp
+// BAD: erasing while iterating
+for (auto it = v.begin(); it != v.end(); ++it) if (bad(*it)) v.erase(it);
+// GOOD (C++20)
+std::erase_if(v, bad);
+```
+
+Range-for over a temporary's member is a classic trap before C++23 (P2718 extends the temporary's lifetime from C++23 on): `for (auto& x : make_obj().items())` dangles if `items()` returns a reference into the temporary. Bind the object to a named variable first.
+
+## Arithmetic
+
+- Signed overflow is UB; unsigned wraps. Check before adding untrusted values, or compute in a wider type.
+- `x << n` with `n < 0` or `n >=` bit width is UB.
+- Division or modulo by zero is UB, and `INT_MIN / -1` overflows.
+- Converting a floating value outside the target integer's range is UB.
+- Mixing signed and unsigned in comparisons gives wrong results (not UB, but a bug). `-Wsign-compare` and C++20 `std::cmp_less` help.
+
+## Objects and types
+
+- Reading an uninitialised scalar is UB. Use `T x{};`.
+- `reinterpret_cast<float*>(&some_int)` then reading violates strict aliasing. Use `std::memcpy` or `std::bit_cast`.
+- Deleting a derived object through a base pointer whose destructor isn't `virtual` is UB.
+- Calling a virtual function from a constructor or destructor dispatches to the current class, not the derived one (defined, but almost always a bug).
+- Dereferencing `nullptr`, a moved-from `unique_ptr`, or an empty `std::optional` with `*` is UB. Use `.value()` or check first.
+
+## Concurrency
+
+- Two threads accessing the same memory, at least one writing, without synchronisation is a data race and UB.
+- `std::shared_ptr`'s control block is thread-safe; the pointed-to object is not.
+- A detached `std::thread` that touches locals of the spawning scope dangles. Prefer `std::jthread` (C++20) or join explicitly.
+- Static local initialisation is thread-safe; lazily initialised globals using a plain flag are not.
+
+## Finding it
+
+| Tool | Catches | Flag |
+|---|---|---|
+| AddressSanitizer | use-after-free, out-of-bounds, double free, leaks (LeakSanitizer, where supported) | `-fsanitize=address` |
+| UndefinedBehaviorSanitizer | overflow, bad shifts, misaligned access, null deref, bad casts | `-fsanitize=undefined` |
+| ThreadSanitizer | data races, lock-order inversions | `-fsanitize=thread` (separate build) |
+| MemorySanitizer (Clang, Linux) | reads of uninitialised memory | `-fsanitize=memory` (needs all code instrumented) |
+
+Add `-fno-omit-frame-pointer -g` for readable stack traces, and `-fno-sanitize-recover=undefined` so UBSan findings fail the run instead of only printing.

package/skills/cpp-testing/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: cpp-testing
+description: Writes and runs C++ unit tests with GoogleTest or Catch2 - test fixtures, parameterised cases, gMock mocks behind interfaces, CTest registration via gtest_discover_tests or catch_discover_tests, and running the suite under AddressSanitizer and UBSan. Use when adding tests to a C++ codebase, wiring a test framework into CMake and CTest, mocking a C++ dependency, or chasing a flaky or crashing C++ test.
+license: MIT
+compatibility: Any Agent Skills host. Needs CMake with CTest and a C++ compiler; GoogleTest or Catch2 is fetched or found by CMake.
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: testing
+  kete-loom/risk: runs-commands
+  kete-loom/requires: "cmake, ctest"
+  kete-loom/owner: "Kete-org"
+---
+
+# C++ testing
+
+Tests that build with the project, register with CTest, and run clean under sanitizers.
+
+## 0. Before you start
+
+1. Find the existing framework: search `CMakeLists.txt` files for `GTest`, `gtest_discover_tests`, `Catch2`, `catch_discover_tests`, `doctest` or `add_test`. **Use what the project already uses.** Only pick a framework when there is none, and then ask the user: GoogleTest (+ gMock) if they need mocking, Catch2 v3 if they prefer BDD-style sections.
+2. Configure, build and run the current suite once: `cmake -S . -B build && cmake --build build && ctest --test-dir build --output-on-failure`. If it already fails, **stop and tell the user** which tests fail before changing anything.
+3. List the behaviours to cover as concrete input -> expected output examples, including the error path.
+
+## 1. Wire the framework into CMake (only if missing)
+
+GoogleTest with FetchContent (pin a release tag or commit hash):
+
+```cmake
+include(FetchContent)
+FetchContent_Declare(googletest
+  GIT_REPOSITORY https://github.com/google/googletest.git
+  GIT_TAG <release-tag>)
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)  # MSVC: match the project's runtime
+FetchContent_MakeAvailable(googletest)
+
+enable_testing()
+add_executable(core_tests tests/parser_test.cpp)
+target_link_libraries(core_tests PRIVATE core GTest::gtest_main GTest::gmock)
+include(GoogleTest)
+gtest_discover_tests(core_tests)
+```
+
+Catch2 v3 (installed via vcpkg/Conan, or FetchContent):
+
+```cmake
+find_package(Catch2 3 REQUIRED)
+enable_testing()
+add_executable(core_tests tests/parser_test.cpp)
+target_link_libraries(core_tests PRIVATE core Catch2::Catch2WithMain)
+include(Catch)
+catch_discover_tests(core_tests)
+```
+
+`enable_testing()` must be in the top-level `CMakeLists.txt` (or `include(CTest)`), or `ctest` finds nothing. Link tests against the library target under test; do not recompile its sources into the test binary.
+
+## 2. Write tests
+
+GoogleTest essentials:
+
+- `TEST(Suite, Name)` for plain tests; `TEST_F(Fixture, Name)` when several tests share setup. The fixture derives from `::testing::Test` and uses `SetUp()`/`TearDown()` or its constructor/destructor.
+- `EXPECT_*` keeps going after a failure; `ASSERT_*` stops the test. Use `ASSERT_*` when later lines would crash (null pointer, empty container).
+- Floating point: `EXPECT_DOUBLE_EQ` or `EXPECT_NEAR(a, b, tol)`, never `EXPECT_EQ`.
+- Exceptions: `EXPECT_THROW(stmt, Type)`, `EXPECT_NO_THROW(stmt)`.
+- Table tests: `TEST_P` with `INSTANTIATE_TEST_SUITE_P(Name, Fixture, ::testing::Values(...))`.
+
+Catch2 essentials:
+
+- `TEST_CASE("parser rejects empty input", "[parser]")` with `SECTION`s; each section re-runs the setup above it.
+- `REQUIRE` stops, `CHECK` continues. Floats: `REQUIRE_THAT(x, Catch::Matchers::WithinRel(1.0, 1e-6))`.
+- Data-driven: `auto n = GENERATE(0, 1, 255);`.
+
+Both: test through the public header, one behaviour per test, names that read as a sentence about behaviour.
+
+## 3. Mock with gMock (only at boundaries)
+
+gMock mocks virtual functions, so the dependency needs an interface:
+
+```cpp
+class Clock { public: virtual ~Clock() = default; virtual std::int64_t now_ms() const = 0; };
+
+class MockClock : public Clock {
+ public:
+  MOCK_METHOD(std::int64_t, now_ms, (), (const, override));
+};
+
+TEST(RateLimiter, RejectsSecondCallInSameWindow) {
+  ::testing::NiceMock<MockClock> clock;
+  ON_CALL(clock, now_ms()).WillByDefault(::testing::Return(1000));
+  RateLimiter limiter{clock, /*per_second=*/1};
+  EXPECT_TRUE(limiter.try_acquire());
+  EXPECT_FALSE(limiter.try_acquire());
+}
+```
+
+- Use `EXPECT_CALL(...).Times(n)` only when the call itself is the behaviour under test; otherwise `ON_CALL` + `NiceMock` keeps tests from breaking on harmless refactors.
+- Mock the clock, network, filesystem and other slow or external boundaries. Never mock the class under test, and do not add an interface to a value type just to mock it.
+- If adding an interface would change a public API, **stop and ask the user** first; a template parameter or a constructor-injected `std::function` may be less invasive.
+
+## 4. Run tests
+
+- All: `ctest --test-dir build --output-on-failure -j 8`.
+- Filter by CTest name: `ctest --test-dir build -R Parser`.
+- Directly: `./build/core_tests --gtest_filter='Parser.*'` or `./build/core_tests "[parser]"`.
+- Flakiness: `--gtest_repeat=100 --gtest_shuffle`, or `ctest --repeat until-fail:50 -R <name>`.
+
+## 5. Run under sanitizers
+
+Build a separate sanitizer tree so the normal build stays fast:
+
+```sh
+cmake -S . -B build-asan -DCMAKE_BUILD_TYPE=Debug \
+  -DCMAKE_CXX_FLAGS="-fsanitize=address,undefined -fno-omit-frame-pointer -fno-sanitize-recover=undefined" \
+  -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=address,undefined" \
+  -DCMAKE_SHARED_LINKER_FLAGS="-fsanitize=address,undefined"
+cmake --build build-asan
+ASAN_OPTIONS=detect_leaks=1 ctest --test-dir build-asan --output-on-failure
+```
+
+If the project already has a sanitizer option or preset, use that instead. For concurrent code, repeat with `-fsanitize=thread` in another build tree (TSan cannot be combined with ASan). LeakSanitizer is on by default on Linux; Apple Clang on macOS may not support `detect_leaks=1`, so drop it there and say leaks were not checked. A sanitizer report is a real bug: fix the code, not the test. If the `cpp-patterns` skill is installed, its undefined-behaviour reference lists the common causes.
+
+## Rules
+
+- Never delete, disable (`DISABLED_`, `[.]`, `GTEST_SKIP()`) or loosen an existing test to get green without the user's agreement.
+- No sleeps for synchronisation; use a mocked clock, a latch or a condition variable with a timeout.
+- No real network, no dependency on test order, no writing outside a temporary directory (`std::filesystem::temp_directory_path()`).
+- Death tests (`EXPECT_DEATH`) only for genuine abort paths, and name the suite `*DeathTest`.
+- If you can't get to green after three focused attempts, stop and report what you tried and the exact failure.
+
+## Report back
+
+End with: tests added (suite and name), the build and `ctest` commands you ran, pass/fail counts for the normal and sanitizer runs, and any behaviours left untested.

package/skills/cpp-testing/evals/triggers.json

@@ -0,0 +1,16 @@
+{
+  "should_trigger": [
+    "Add GoogleTest unit tests for the RingBuffer class",
+    "How do I mock this NetworkClient dependency with gMock in my C++ tests?",
+    "Hook our Catch2 tests into CTest so ctest actually runs them",
+    "Our C++ test suite crashes randomly, run it under ASan and UBSan and find out why",
+    "Write a test fixture that sets up a temp directory for the config loader tests in C++"
+  ],
+  "should_not_trigger": [
+    "Convert this C++ class from raw pointers to unique_ptr ownership",
+    "CMake can't find the vcpkg package for fmt, fix the configure step",
+    "Review this C++ diff for lifetime bugs and ABI breaks",
+    "Write pytest fixtures for the database layer",
+    "Add table-driven tests with t.Run to this Go package"
+  ]
+}

package/skills/csharp-patterns/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: csharp-patterns
+description: Idiomatic modern C# on .NET 8 and later, covering nullable reference types, records, pattern matching, async/await with CancellationToken, LINQ deferred-execution traps, IDisposable and IAsyncDisposable, Microsoft.Extensions.DependencyInjection lifetimes, the dotnet CLI and Roslyn analyzers. Use when writing or restructuring C# application or library code, enabling nullable or analyzers in a .NET project, or choosing how a class, service or async API should be shaped.
+license: MIT
+compatibility: Any Agent Skills host. Needs the .NET 8+ SDK (dotnet CLI) to build and run checks.
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: runs-commands
+  kete-loom/requires: "dotnet"
+  kete-loom/owner: "Kete-org"
+---
+
+# C# patterns
+
+Write C# that the compiler and analyzers can check for you. Most C# production bugs are nulls, blocked async calls, leaked disposables and LINQ queries that run more than once; the rules below close those doors.
+
+## 0. Before you write code
+
+1. Find the target framework and language settings: open the `.csproj` (and `Directory.Build.props` if present) and note `TargetFramework`, `Nullable`, `LangVersion`, `ImplicitUsings`, `TreatWarningsAsErrors`, `AnalysisLevel`.
+2. Run `dotnet build` once and record the warning count. Do not add new warnings.
+3. Match the code style already in the repo (`.editorconfig`, file-scoped namespaces, `var` usage). Don't reformat files you aren't changing.
+4. If the project targets anything older than `net8.0` (`netstandard2.0`, `net48`, `net6.0`), **stop and ask** before using newer language features or APIs (`required`, `TimeProvider`, `ArgumentNullException.ThrowIfNull`); they may not exist there, and the user may have consumers on that framework.
+
+## 1. Nullable reference types
+
+- New projects: `<Nullable>enable</Nullable>`. Existing projects without it: enable per file with `#nullable enable` in files you touch, and **ask the user** before flipping it project-wide (it can produce hundreds of warnings).
+- A non-nullable type is a promise. Validate at trust boundaries (public API, deserialised input, config): `ArgumentNullException.ThrowIfNull(x)`, `ArgumentException.ThrowIfNullOrEmpty(s)`.
+- Never silence a warning with `!` (null-forgiving) unless you can name the guarantee in a one-line comment. `!` on `FirstOrDefault()` or a dictionary lookup is a bug.
+- Required members: use `required` properties or constructor parameters instead of `= null!` initialisers (CS8618).
+- Use `[NotNullWhen(true)]`, `[MaybeNullWhen(false)]` on `TryGet...` methods so callers get correct flow analysis.
+
+## 2. Types: records, classes, structs
+
+| Need | Use |
+|---|---|
+| Immutable data with value equality (DTOs, messages, keys) | `record` or `sealed record` with positional or `init` properties |
+| Small value (≤16 bytes), no identity | `readonly record struct` |
+| Identity, mutable state, behaviour | `sealed class` (seal by default; unseal when you design for inheritance) |
+| Closed set of cases | abstract `record` base plus sealed derived records, matched with `switch` |
+
+- Records give value equality over **all** fields; a record holding a `List<T>` compares the list by reference. `ImmutableArray<T>` also compares by reference; if value equality over the collection matters, override `Equals`/`GetHashCode` (with `SequenceEqual`) yourself.
+- Prefer primary constructors for DI-only classes; don't mutate the captured parameters.
+
+## 3. Pattern matching
+
+- Use `is null` / `is not null`, not `== null` (operators can be overloaded).
+- Use switch expressions for mapping and dispatch; end with a discard arm that throws (`_ => throw new UnreachableException()`) only when the input set is truly closed.
+- Property and list patterns (`{ Status: OrderStatus.Paid, Total: > 0 }`, `[var first, ..]`) beat chains of `&&` checks.
+
+## 4. Async and cancellation
+
+1. Async all the way. Never call `.Result`, `.Wait()` or `.GetAwaiter().GetResult()` on a task in application code: it deadlocks under a synchronization context and starves the thread pool under load.
+2. Never write `async void` except for event handlers. Return `Task` or `ValueTask`.
+3. Every public async method that does I/O takes a `CancellationToken cancellationToken = default` as the **last** parameter and passes it to every call that accepts one. In ASP.NET Core, use `HttpContext.RequestAborted` or the action's token parameter.
+4. Library code (NuGet packages, shared libraries): `await x.ConfigureAwait(false)`. ASP.NET Core application code has no synchronization context, so it doesn't need it; UI apps (WPF, WinForms, MAUI) must not use it before touching UI.
+5. Don't wrap synchronous work in `Task.Run` inside a server request. Use `Task.Run` only to move CPU-bound work off a UI thread.
+6. Run independent calls concurrently with `Task.WhenAll`; don't `await` in a loop when the calls are independent.
+7. `ValueTask` only for hot paths that often complete synchronously; never await a `ValueTask` twice.
+8. Timeouts: `using var cts = CancellationTokenSource.CreateLinkedTokenSource(token); cts.CancelAfter(timeout);`.
+9. Catch `OperationCanceledException` only to clean up or translate; let it propagate otherwise.
+
+## 5. LINQ
+
+- `IEnumerable<T>` is lazy. Enumerating it twice runs the query twice (and hits the database twice for `IQueryable<T>`). Materialise once with `ToList()` / `ToArray()` when you'll iterate more than once.
+- `Any()` not `Count() > 0`; `FirstOrDefault` returns `null`/`default` and needs a null check.
+- With EF Core `IQueryable`, keep filters before `ToListAsync()`. A `.AsEnumerable()` or a client-side method call in `Where` pulls whole tables into memory.
+- Don't use LINQ for side effects (`Select` that mutates). Use `foreach`.
+- Hot paths: avoid LINQ allocations in tight loops; measure first.
+
+## 6. Disposal
+
+- Anything `IDisposable` you create, you dispose: `using var stream = ...;` or `await using var conn = ...;` for `IAsyncDisposable`.
+- Don't dispose objects you didn't create (injected services, `HttpClient` from `IHttpClientFactory`).
+- `HttpClient`: get it from `IHttpClientFactory` (`services.AddHttpClient<T>()`) or reuse one static instance; never `new HttpClient()` per request (socket exhaustion).
+- Implement `IDisposable` only when you own an unmanaged resource or another disposable. Seal the class and skip the full dispose pattern unless it's designed for inheritance.
+
+## 7. Dependency injection
+
+- Register in `Program.cs` or an `IServiceCollection` extension method per feature (`services.AddOrders()`).
+- Lifetimes: `Singleton` for stateless or thread-safe shared state, `Scoped` for per-request things (`DbContext`), `Transient` for lightweight stateless services.
+- A singleton must never depend on a scoped service (captive dependency). Development builds validate this (`ValidateScopes`); keep it on.
+- Inside a singleton or `BackgroundService` that needs a scoped service, create a scope: `using var scope = scopeFactory.CreateScope();`.
+- Config: bind with `services.AddOptions<T>().Bind(config.GetSection("X")).ValidateDataAnnotations().ValidateOnStart();` and inject `IOptions<T>`. Never read secrets from code or committed `appsettings.json`.
+- Constructor injection only. No service locator (`IServiceProvider.GetService` in business code).
+
+## 8. Errors
+
+- Throw specific exceptions; `throw;` to rethrow (never `throw ex;`, it loses the stack).
+- Don't catch `Exception` except at a boundary (middleware, background loop) where you log and keep going.
+- Log with structured templates: `logger.LogInformation("Order {OrderId} paid", id)`, never string interpolation in the template.
+
+## 9. Tooling (dotnet CLI and analyzers)
+
+- Build: `dotnet build -warnaserror` in CI. Format check: `dotnet format --verify-no-changes`.
+- Packages: `dotnet add package <Id>`; check with `dotnet list package --outdated` and `dotnet list package --vulnerable`.
+- Turn on the built-in analyzers in `.csproj` or `Directory.Build.props`. Settings and the rules most worth enforcing are in `references/analyzers.md`.
+- Don't add third-party analyzer packages or change `AnalysisLevel` without asking the user; they can break the build for the whole team.
+
+## Never
+
+- `async void`, `.Result`, `.Wait()` in request or UI code.
+- `catch { }` or `catch (Exception) { }` that swallows errors.
+- `!` to silence a nullable warning you don't understand.
+- `#pragma warning disable` or `<NoWarn>` to make a build pass without telling the user.
+- `new HttpClient()` per call, or `DateTime.Now` in testable logic (inject `TimeProvider`).
+
+## Report back
+
+End with: files changed, the `dotnet build` warning count before and after, analyzer or nullable settings you changed (if any), and anything you chose not to fix.

package/skills/csharp-patterns/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "should_trigger": [
+    "Turn on nullable reference types in our .NET 8 class library and fix the warnings in the files I touched",
+    "Should this C# DTO be a record or a class, and how do I make it immutable?",
+    "Refactor this C# service so every async method takes a CancellationToken and stops calling .Result",
+    "How should I register a DbContext and a background worker in Microsoft.Extensions.DependencyInjection without a captive dependency?",
+    "Rewrite this C# if/else chain with a switch expression and property patterns"
+  ],
+  "should_not_trigger": [
+    "Add a unit test project for the C# billing library with xUnit",
+    "My .NET solution stopped compiling after a NuGet update, CS0246 everywhere",
+    "Review my C# pull request for async void and disposal leaks",
+    "Add an EF Core migration for the new Invoices table",
+    "Set up a minimal API endpoint with ASP.NET Core authentication and rate limiting",
+    "Write idiomatic F# discriminated unions for the payment states"
+  ]
+}

package/skills/csharp-patterns/references/analyzers.md

@@ -0,0 +1,59 @@
+# .NET analyzer settings and high-value rules
+
+Read this when enabling nullable or analyzers, or when a build reports `CA` / `CS86xx` / `IDE` diagnostics.
+
+## Project settings
+
+Put shared settings in `Directory.Build.props` at the repo root so every project gets them:
+
+```xml
+<Project>
+  <PropertyGroup>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <AnalysisLevel>latest-recommended</AnalysisLevel>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+</Project>
+```
+
+- `AnalysisLevel` values: `latest`, `latest-minimum`, `latest-recommended`, `latest-all` (also numeric, for example `8.0-recommended`). Start at `recommended`; `all` is noisy.
+- `EnforceCodeStyleInBuild` makes `IDE` rules configured in `.editorconfig` run during `dotnet build`.
+- Turning on `TreatWarningsAsErrors` in an existing repo can break the build. Ask first; a softer start is `<WarningsAsErrors>nullable</WarningsAsErrors>`.
+
+## Per-rule severity in `.editorconfig`
+
+```ini
+[*.cs]
+dotnet_diagnostic.CA2007.severity = none      # ConfigureAwait: off in ASP.NET Core apps, warning in libraries
+dotnet_diagnostic.CA2000.severity = warning   # dispose objects before losing scope
+dotnet_diagnostic.CA1849.severity = warning   # call async methods when in an async method
+```
+
+Prefer `.editorconfig` over `<NoWarn>`; it is scoped and reviewable. Every suppression needs a reason in a comment.
+
+## Rules worth enforcing
+
+| Id | Meaning | Usual fix |
+|---|---|---|
+| CS8600-CS8604 | Possible null assignment, dereference, or argument | Check for null, or change the type to `T?` |
+| CS8618 | Non-nullable member uninitialised when constructor exits | `required` member or constructor parameter |
+| CS8625 | `null` literal passed to non-nullable | Make the parameter nullable or stop passing null |
+| CS4014 | Call not awaited | `await` it, or assign to a variable and await later |
+| CS1998 | `async` method with no `await` | Remove `async` and return `Task.CompletedTask` / `Task.FromResult` |
+| CA2007 | Missing `ConfigureAwait` | `ConfigureAwait(false)` in libraries |
+| CA2000 | Disposable not disposed | `using` / `await using` |
+| CA2016 | `CancellationToken` not forwarded | Pass the token through |
+| CA1849 | Sync call with async alternative in async method | Use the `...Async` method |
+| CA1848 / CA2254 | Logging performance / non-constant template | Constant templates, or `LoggerMessage` source generator on hot paths |
+| CA1822 | Member can be static | Mark `static` if it touches no instance state |
+| CA1305 / CA1307 | Culture or string comparison not specified | Pass `CultureInfo.InvariantCulture` / `StringComparison.Ordinal` |
+| CA5394 | Insecure randomness | `RandomNumberGenerator` for security values |
+
+## Commands
+
+- `dotnet build -warnaserror` : fail on any warning.
+- `dotnet format --verify-no-changes` : CI check for whitespace, style and analyzer fixes.
+- `dotnet format analyzers --diagnostics CA1822` : apply one rule's code fix across the solution. Review the diff before keeping it.

package/skills/csharp-testing/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: csharp-testing
+description: Writes and fixes .NET tests in C# with xUnit (or the NUnit or MSTest framework already in the repo), FluentAssertions or built-in asserts, Moq or NSubstitute test doubles, WebApplicationFactory in-memory API tests and Testcontainers-backed database tests, all run through dotnet test. Use when adding unit or integration tests to a C# project, setting up a new .NET test project, mocking a dependency, or debugging a flaky or failing dotnet test run.
+license: MIT
+compatibility: Any Agent Skills host. Needs the .NET 8+ SDK. Testcontainers tests also need a running Docker-compatible engine.
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: testing
+  kete-loom/risk: runs-commands
+  kete-loom/requires: "dotnet"
+  kete-loom/owner: "Kete-org"
+---
+
+# C# testing
+
+Tests that run with `dotnet test`, fail for one reason, and don't depend on the machine, the clock or test order.
+
+## 0. Discover before writing
+
+1. Find the test projects: search for `*.Tests.csproj` / `*Tests.csproj` and look at their `PackageReference`s.
+2. **Use the framework, assertion and mocking libraries the repo already uses.** Do not add a second one. Detect by package:
+   - xUnit: `xunit` (v2) or `xunit.v3`. NUnit: `NUnit` + `NUnit3TestAdapter`. MSTest: `MSTest` or `MSTest.TestFramework`.
+   - Assertions: `FluentAssertions`, `Shouldly`, or framework asserts.
+   - Doubles: `Moq`, `NSubstitute`, `FakeItEasy`.
+3. Run `dotnet test` once and record pass/fail counts. If tests already fail, **stop and tell the user** before changing anything.
+4. New test project with nothing to match: xUnit, built-in `Assert`, NSubstitute. Before adding FluentAssertions, tell the user that versions 8 and later need a paid Xceed licence for commercial use (version 7 is Apache 2.0); let them choose.
+
+## 1. New test project
+
+```bash
+dotnet new xunit -n MyApp.Tests -o tests/MyApp.Tests
+dotnet sln add tests/MyApp.Tests/MyApp.Tests.csproj
+dotnet add tests/MyApp.Tests/MyApp.Tests.csproj reference src/MyApp/MyApp.csproj
+```
+
+Mirror the production namespace and folder structure. One test class per class under test (`OrderServiceTests`).
+
+## 2. Unit test shape
+
+- Name: `Method_Scenario_ExpectedResult` or the repo's convention.
+- Arrange / Act / Assert, one behaviour per test. Several asserts are fine if they describe one outcome.
+- Data-driven: xUnit `[Theory]` + `[InlineData]` / `[MemberData]`; NUnit `[TestCase]`; MSTest `[DataRow]`.
+- Async tests return `Task` (never `async void`). Assert exceptions with `await Assert.ThrowsAsync<T>(() => sut.RunAsync())`.
+- xUnit v3: pass `TestContext.Current.CancellationToken` to async calls (analyzer xUnit1051 flags it).
+- Time: inject `TimeProvider` and use `FakeTimeProvider` (package `Microsoft.Extensions.TimeProvider.Testing`). Never `Thread.Sleep` or `DateTime.Now` in tests.
+- Logging: `NullLogger<T>.Instance`, or `FakeLogger<T>` from `Microsoft.Extensions.Diagnostics.Testing` when you assert on logs.
+
+## 3. Test doubles
+
+- Mock only boundaries you own an interface for: repositories, HTTP clients, message buses, clocks. Never mock the class under test or simple value types.
+- NSubstitute: `var repo = Substitute.For<IOrderRepository>(); repo.GetAsync(id, Arg.Any<CancellationToken>()).Returns(order);` verify with `await repo.Received(1).SaveAsync(...)`.
+- Moq: `var repo = new Mock<IOrderRepository>(); repo.Setup(r => r.GetAsync(id, It.IsAny<CancellationToken>())).ReturnsAsync(order);` verify with `repo.Verify(..., Times.Once)`.
+- Prefer asserting on the result over verifying calls. Verify a call only when the call **is** the behaviour (an email was sent).
+- `HttpClient`: don't mock `HttpClient`. Use a fake `HttpMessageHandler`, or test through `WebApplicationFactory`.
+- EF Core: don't mock `DbContext` or `DbSet`. The InMemory provider doesn't enforce constraints or transactions; use SQLite in-memory for quick tests and Testcontainers for real behaviour.
+
+## 4. Integration tests
+
+- ASP.NET Core APIs: `WebApplicationFactory<Program>` from `Microsoft.AspNetCore.Mvc.Testing`; swap services in `ConfigureTestServices`.
+- Real databases, queues and caches: Testcontainers (`Testcontainers.PostgreSql`, `Testcontainers.MsSql`, `Testcontainers.Redis`), one container per test class or collection fixture, never per test.
+- Full examples, fixture sharing and auth stubbing are in `references/integration-tests.md`.
+- If Docker isn't available, **stop and tell the user**; don't silently replace a Testcontainers test with the InMemory provider.
+
+## 5. Run and filter
+
+- All: `dotnet test`. One project: `dotnet test tests/MyApp.Tests`.
+- Filter: `dotnet test --filter "FullyQualifiedName~OrderServiceTests"` or `--filter "Category=Integration"` (xUnit `[Trait("Category","Integration")]`, NUnit `[Category]`, MSTest `[TestCategory]`). Under Microsoft.Testing.Platform (common with xUnit v3) the filter options differ by framework; always confirm the run reports a non-zero test count.
+- Coverage: `dotnet test --collect:"XPlat Code Coverage"` (coverlet.collector), or the repo's existing coverage setup.
+- Verbose failure output: `dotnet test --logger "console;verbosity=detailed"`.
+
+## 6. Flaky tests
+
+1. Run the single test 20 times in a loop. If it fails sometimes, look for: shared static state, test order dependence, real time or timers, unawaited tasks, ports or files shared between parallel tests.
+2. xUnit runs test **classes** in parallel. Tests that share a resource go in one `[Collection("Name")]`.
+3. Fix the cause. Do not add retries, `Skip`, or longer sleeps.
+
+## Rules
+
+- Never delete, skip (`[Fact(Skip=...)]`, `[Ignore]`) or weaken an existing test to make the suite pass without the user's agreement.
+- No real network calls, real external services or production connection strings in tests.
+- Don't add test packages beyond what the job needs, and match the version style the repo uses (central `Directory.Packages.props` or per-project).
+
+## Report back
+
+End with: tests added (names and files), the exact `dotnet test` command run, pass/fail/skip counts, packages added, and what is still untested.

package/skills/csharp-testing/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "should_trigger": [
+    "Write xUnit tests for OrderService and mock the repository with NSubstitute",
+    "Add an integration test that boots our ASP.NET Core API with WebApplicationFactory and checks the 404",
+    "Spin up Postgres with Testcontainers for our EF Core repository tests",
+    "This NUnit test passes locally but fails randomly in CI, help me find out why",
+    "Create a new .NET test project for MyApp and wire it into the solution"
+  ],
+  "should_not_trigger": [
+    "Review my C# pull request for async void and disposal leaks",
+    "Make this C# service use CancellationToken everywhere and stop blocking on .Result",
+    "Restore fails in CI with NU1102, the package version can't be found on our feed",
+    "Write pytest fixtures for the Django models",
+    "Add Playwright end-to-end tests for the checkout page",
+    "Raise test coverage on the whole repo to 80 percent"
+  ]
+}