@rubix0270/arboris 1.0.2 → 1.0.3

package/prisma/skills/dotnet-patterns/SKILL.md

@@ -1,322 +0,0 @@
----
-name: dotnet-patterns
-description: Idiomatic C# and .NET patterns, conventions, dependency injection, async/await, and best practices for building robust, maintainable .NET applications.
-metadata:
-  origin: ECC
----
-
-# .NET Development Patterns
-
-Idiomatic C# and .NET patterns for building robust, performant, and maintainable applications.
-
-## When to Activate
-
-- Writing new C# code
-- Reviewing C# code
-- Refactoring existing .NET applications
-- Designing service architectures with ASP.NET Core
-
-## Core Principles
-
-### 1. Prefer Immutability
-
-Use records and init-only properties for data models. Mutability should be an explicit, justified choice.
-
-```csharp
-// Good: Immutable value object
-public sealed record Money(decimal Amount, string Currency);
-
-// Good: Immutable DTO with init setters
-public sealed class CreateOrderRequest
-{
-    public required string CustomerId { get; init; }
-    public required IReadOnlyList<OrderItem> Items { get; init; }
-}
-
-// Bad: Mutable model with public setters
-public class Order
-{
-    public string CustomerId { get; set; }
-    public List<OrderItem> Items { get; set; }
-}
-```
-
-### 2. Explicit Over Implicit
-
-Be clear about nullability, access modifiers, and intent.
-
-```csharp
-// Good: Explicit access modifiers and nullability
-public sealed class UserService
-{
-    private readonly IUserRepository _repository;
-    private readonly ILogger<UserService> _logger;
-
-    public UserService(IUserRepository repository, ILogger<UserService> logger)
-    {
-        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
-        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-    }
-
-    public async Task<User?> FindByIdAsync(Guid id, CancellationToken cancellationToken)
-    {
-        return await _repository.FindByIdAsync(id, cancellationToken);
-    }
-}
-```
-
-### 3. Depend on Abstractions
-
-Use interfaces for service boundaries. Register via DI container.
-
-```csharp
-// Good: Interface-based dependency
-public interface IOrderRepository
-{
-    Task<Order?> FindByIdAsync(Guid id, CancellationToken cancellationToken);
-    Task<IReadOnlyList<Order>> FindByCustomerAsync(string customerId, CancellationToken cancellationToken);
-    Task AddAsync(Order order, CancellationToken cancellationToken);
-}
-
-// Registration
-builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
-```
-
-## Async/Await Patterns
-
-### Proper Async Usage
-
-```csharp
-// Good: Async all the way, with CancellationToken
-public async Task<OrderSummary> GetOrderSummaryAsync(
-    Guid orderId,
-    CancellationToken cancellationToken)
-{
-    var order = await _repository.FindByIdAsync(orderId, cancellationToken)
-        ?? throw new NotFoundException($"Order {orderId} not found");
-
-    var customer = await _customerService.GetAsync(order.CustomerId, cancellationToken);
-
-    return new OrderSummary(order, customer);
-}
-
-// Bad: Blocking on async
-public OrderSummary GetOrderSummary(Guid orderId)
-{
-    var order = _repository.FindByIdAsync(orderId, CancellationToken.None).Result; // Deadlock risk
-    return new OrderSummary(order);
-}
-```
-
-### Parallel Async Operations
-
-```csharp
-// Good: Concurrent independent operations
-public async Task<DashboardData> LoadDashboardAsync(CancellationToken cancellationToken)
-{
-    var ordersTask = _orderService.GetRecentAsync(cancellationToken);
-    var metricsTask = _metricsService.GetCurrentAsync(cancellationToken);
-    var alertsTask = _alertService.GetActiveAsync(cancellationToken);
-
-    await Task.WhenAll(ordersTask, metricsTask, alertsTask);
-
-    return new DashboardData(
-        Orders: await ordersTask,
-        Metrics: await metricsTask,
-        Alerts: await alertsTask);
-}
-```
-
-## Options Pattern
-
-Bind configuration sections to strongly-typed objects.
-
-```csharp
-public sealed class SmtpOptions
-{
-    public const string SectionName = "Smtp";
-
-    public required string Host { get; init; }
-    public required int Port { get; init; }
-    public required string Username { get; init; }
-    public bool UseSsl { get; init; } = true;
-}
-
-// Registration
-builder.Services.Configure<SmtpOptions>(
-    builder.Configuration.GetSection(SmtpOptions.SectionName));
-
-// Usage via injection
-public class EmailService(IOptions<SmtpOptions> options)
-{
-    private readonly SmtpOptions _smtp = options.Value;
-}
-```
-
-## Result Pattern
-
-Return explicit success/failure instead of throwing for expected failures.
-
-```csharp
-public sealed record Result<T>
-{
-    public bool IsSuccess { get; }
-    public T? Value { get; }
-    public string? Error { get; }
-
-    private Result(T value) { IsSuccess = true; Value = value; }
-    private Result(string error) { IsSuccess = false; Error = error; }
-
-    public static Result<T> Success(T value) => new(value);
-    public static Result<T> Failure(string error) => new(error);
-}
-
-// Usage
-public async Task<Result<Order>> PlaceOrderAsync(CreateOrderRequest request)
-{
-    if (request.Items.Count == 0)
-        return Result<Order>.Failure("Order must contain at least one item");
-
-    var order = Order.Create(request);
-    await _repository.AddAsync(order, CancellationToken.None);
-    return Result<Order>.Success(order);
-}
-```
-
-## Repository Pattern with EF Core
-
-```csharp
-public sealed class SqlOrderRepository : IOrderRepository
-{
-    private readonly AppDbContext _db;
-
-    public SqlOrderRepository(AppDbContext db) => _db = db;
-
-    public async Task<Order?> FindByIdAsync(Guid id, CancellationToken cancellationToken)
-    {
-        return await _db.Orders
-            .Include(o => o.Items)
-            .AsNoTracking()
-            .FirstOrDefaultAsync(o => o.Id == id, cancellationToken);
-    }
-
-    public async Task<IReadOnlyList<Order>> FindByCustomerAsync(
-        string customerId,
-        CancellationToken cancellationToken)
-    {
-        return await _db.Orders
-            .Where(o => o.CustomerId == customerId)
-            .OrderByDescending(o => o.CreatedAt)
-            .AsNoTracking()
-            .ToListAsync(cancellationToken);
-    }
-
-    public async Task AddAsync(Order order, CancellationToken cancellationToken)
-    {
-        _db.Orders.Add(order);
-        await _db.SaveChangesAsync(cancellationToken);
-    }
-}
-```
-
-## Middleware and Pipeline
-
-```csharp
-// Custom middleware
-public sealed class RequestTimingMiddleware
-{
-    private readonly RequestDelegate _next;
-    private readonly ILogger<RequestTimingMiddleware> _logger;
-
-    public RequestTimingMiddleware(RequestDelegate next, ILogger<RequestTimingMiddleware> logger)
-    {
-        _next = next;
-        _logger = logger;
-    }
-
-    public async Task InvokeAsync(HttpContext context)
-    {
-        var stopwatch = Stopwatch.StartNew();
-        try
-        {
-            await _next(context);
-        }
-        finally
-        {
-            stopwatch.Stop();
-            _logger.LogInformation(
-                "Request {Method} {Path} completed in {ElapsedMs}ms with status {StatusCode}",
-                context.Request.Method,
-                context.Request.Path,
-                stopwatch.ElapsedMilliseconds,
-                context.Response.StatusCode);
-        }
-    }
-}
-```
-
-## Minimal API Patterns
-
-```csharp
-// Organized with route groups
-var orders = app.MapGroup("/api/orders")
-    .RequireAuthorization()
-    .WithTags("Orders");
-
-orders.MapGet("/{id:guid}", async (
-    Guid id,
-    IOrderRepository repository,
-    CancellationToken cancellationToken) =>
-{
-    var order = await repository.FindByIdAsync(id, cancellationToken);
-    return order is not null
-        ? TypedResults.Ok(order)
-        : TypedResults.NotFound();
-});
-
-orders.MapPost("/", async (
-    CreateOrderRequest request,
-    IOrderService service,
-    CancellationToken cancellationToken) =>
-{
-    var result = await service.PlaceOrderAsync(request, cancellationToken);
-    return result.IsSuccess
-        ? TypedResults.Created($"/api/orders/{result.Value!.Id}", result.Value)
-        : TypedResults.BadRequest(result.Error);
-});
-```
-
-## Guard Clauses
-
-```csharp
-// Good: Early returns with clear validation
-public async Task<ProcessResult> ProcessPaymentAsync(
-    PaymentRequest request,
-    CancellationToken cancellationToken)
-{
-    ArgumentNullException.ThrowIfNull(request);
-
-    if (request.Amount <= 0)
-        throw new ArgumentOutOfRangeException(nameof(request.Amount), "Amount must be positive");
-
-    if (string.IsNullOrWhiteSpace(request.Currency))
-        throw new ArgumentException("Currency is required", nameof(request.Currency));
-
-    // Happy path continues here without nesting
-    var gateway = _gatewayFactory.Create(request.Currency);
-    return await gateway.ChargeAsync(request, cancellationToken);
-}
-```
-
-## Anti-Patterns to Avoid
-
-| Anti-Pattern | Fix |
-|---|---|
-| `async void` methods | Return `Task` (except event handlers) |
-| `.Result` or `.Wait()` | Use `await` |
-| `catch (Exception) { }` | Handle or rethrow with context |
-| `new Service()` in constructors | Use constructor injection |
-| `public` fields | Use properties with appropriate accessors |
-| `dynamic` in business logic | Use generics or explicit types |
-| Mutable `static` state | Use DI scoping or `ConcurrentDictionary` |
-| `string.Format` in loops | Use `StringBuilder` or interpolated string handlers |

package/prisma/skills/dynamic-workflow-mode/SKILL.md

@@ -1,124 +0,0 @@
----
-name: dynamic-workflow-mode
-description: "Design task-local harnesses, eval gates, and reusable skill extraction for Claude dynamic workflow mode and other adaptive agent harnesses."
-metadata:
-  origin: ECC
----
-
-# Dynamic Workflow Mode
-
-Use this skill when a coding agent can generate or adapt a task-local harness instead of only following a static command flow. The goal is to turn dynamic workflow mode into a disciplined system: temporary harnesses for one-off work, shared skill extraction for repeated work, and observable control pane checkpoints for teams.
-
-## When To Activate
-
-- The user mentions dynamic workflows, custom harnesses, harness-per-task, adaptive workflows, or Claude Code dynamic workflow mode.
-- A task needs a custom loop, evaluator, crawler, fixture generator, watcher, or local dashboard.
-- Multiple agents need the same repeatable process but the process is not yet captured as a shared skill.
-- A workflow needs durable handoff artifacts, eval evidence, or operator approval before merge.
-
-## Core Contract
-
-Dynamic workflow mode should produce a task-local harness only when the harness is cheaper and safer than manually driving the same steps. The harness must have:
-
-- **Objective**: the outcome it owns and the outcome it explicitly does not own.
-- **Inputs**: files, URLs, prompts, data sources, credentials policy, and user-provided constraints.
-- **Outputs**: commits, reports, screenshots, status files, or control pane snapshots.
-- **Eval**: at least one pass/fail check tied to the task, not only "it ran".
-- **Handoff**: a short artifact that tells the next operator what happened, what is blocked, and how to resume.
-
-## Dynamic Harness Decision Tree
-
-1. **One-shot task**: keep it inline. Do not invent a harness.
-2. **Repeated task with changing inputs**: create a task-local harness and keep it under a temp or project-local working area.
-3. **Repeated task across teammates or repos**: extract the pattern into a shared skill.
-4. **Task with external state, queueing, or approvals**: add control pane visibility before adding more automation.
-5. **Task with safety risk**: add an eval gate and a human merge gate before autonomous execution.
-
-## Task-Local Harness Template
-
-Use this structure before writing code:
-
-```markdown
-# Dynamic Workflow Harness
-
-Objective:
-- Ship:
-- Do not ship:
-
-Inputs:
-- Repo or workspace:
-- External systems:
-- Credentials policy:
-
-Loop:
-1. Discover current state.
-2. Generate or update the smallest useful artifact.
-3. Run eval checks.
-4. Record status and handoff.
-5. Stop on failed gate, unclear ownership, or unsafe external action.
-
-Eval:
-- Command:
-- Expected pass signal:
-- Failure owner:
-
-Handoff:
-- Status:
-- Evidence:
-- Next action:
-```
-
-## Shared Skill Extraction
-
-Promote a task-local harness into a shared skill only when at least two of these are true:
-
-- The same workflow appears in multiple sessions, repos, teams, or launches.
-- The workflow needs specific language, tool, or safety sequencing.
-- Failures repeat because operators skip a gate or lose context.
-- The workflow has a stable input/output contract.
-- The workflow benefits from a control pane, status board, or team handoff.
-
-When extracting, write the skill first in `skills/<name>/SKILL.md`. Add command shims only if a legacy slash-entry surface is still required.
-
-## Control Pane Checkpoints
-
-Dynamic workflow mode becomes team-usable when it exposes state. Record these checkpoints whenever the task spans more than one session:
-
-- **Plan**: objective, owner, acceptance criteria, and risky external systems.
-- **Queue**: work items, assigned agent role, branch/worktree, and dependency edges.
-- **Run**: active harness, current loop step, recent eval result, and token/cost signal if available.
-- **Gate**: test results, browser screenshots, security review, and merge readiness.
-- **Handoff**: what is done, what failed, what needs a human decision.
-
-If the repo has ECC2 state enabled, prefer adding or reading checkpoints through the ECC control pane or state-store-backed scripts instead of scattering untracked notes.
-
-## Eval Gates
-
-Every dynamic harness needs a task-specific eval. Pick the cheapest reliable gate:
-
-| Work Type | Eval Gate |
-| --- | --- |
-| Code feature | Focused test, lint, coverage, and one integration path |
-| UI/control pane | Browser smoke with screenshot and overflow/error checks |
-| Agent workflow | Fixture transcript or seeded work item with expected routing |
-| Research/content | Source-neutral brief, claim checklist, and publish-ready outline |
-| Integration | Dry-run command, config validation, and no-secret scan |
-
-Do not claim a dynamic workflow is reusable until the eval can be rerun by another teammate.
-
-## Anti-Patterns
-
-- Generating scripts that hide the real decision logic from the operator.
-- Treating dynamic workflow mode as permission to skip tests.
-- Creating one-off docs when a shared skill or status artifact is the real product.
-- Running multiple agents without ownership, merge gate, or conflict policy.
-- Letting raw private research data leak into public docs.
-
-## Output Standard
-
-Finish with:
-
-- The harness or skill path.
-- The eval commands and results.
-- The control pane or handoff artifact path.
-- The next reusable extraction candidate.