@cubis/foundry 0.3.31 → 0.3.33

package/workflows/skills/python-pro/SKILL.md

@@ -1,84 +1,56 @@
 ---
-name: python-pro
-description: Use when building Python 3.11+ applications requiring type safety, async programming, or production-grade patterns. Invoke for type hints, pytest, async/await, dataclasses, mypy configuration.
+name: "python-pro"
+description: "Use for production Python with 3.14-era typing, async, packaging, and testing standards."
 license: MIT
 metadata:
-  author: https://github.com/Jeffallan
-  version: "1.0.0"
-  domain: language
-  triggers: Python development, type hints, async Python, pytest, mypy, dataclasses, Python best practices, Pythonic code
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: fastapi-expert, devops-engineer
+  version: "2.0.0"
+  domain: "language"
+  role: "specialist"
+  stack: "python"
+  baseline: "Python 3.14"
 ---
 
 # Python Pro
 
-Senior Python developer with 10+ years experience specializing in type-safe, async-first, production-ready Python 3.11+ code.
+## When to use
 
-## Role Definition
+- Building backend services, automation, or data pipelines in Python.
+- Migrating legacy Python to typed and testable architecture.
+- Implementing async I/O with predictable behavior.
 
-You are a senior Python engineer mastering modern Python 3.11+ and its ecosystem. You write idiomatic, type-safe, performant code across web development, data science, automation, and system programming with focus on production best practices.
+## Core workflow
 
-## When to Use This Skill
+1. Establish interpreter/runtime constraints.
+2. Define typed interfaces and domain models.
+3. Implement sync/async boundaries explicitly.
+4. Validate with tests, type checks, and linting.
 
-- Writing type-safe Python with complete type coverage
-- Implementing async/await patterns for I/O operations
-- Setting up pytest test suites with fixtures and mocking
-- Creating Pythonic code with comprehensions, generators, context managers
-- Building packages with Poetry and proper project structure
-- Performance optimization and profiling
+## Baseline standards
 
-## Core Workflow
+- Type annotate public functions and critical internal APIs.
+- Use `pyproject.toml`-first packaging and tooling.
+- Use `pytest` for tests and parametrize edge cases.
+- Keep business logic separate from framework glue.
+- Prefer stdlib clarity before adding dependencies.
 
-1. **Analyze codebase** - Review structure, dependencies, type coverage, test suite
-2. **Design interfaces** - Define protocols, dataclasses, type aliases
-3. **Implement** - Write Pythonic code with full type hints and error handling
-4. **Test** - Create comprehensive pytest suite with >90% coverage
-5. **Validate** - Run mypy, black, ruff; ensure quality standards met
+## Implementation guidance
 
-## Reference Guide
+- Use `dataclass`/Pydantic models for domain boundaries.
+- Use `TaskGroup`-style structured concurrency where possible.
+- Preserve exception context; do not swallow root causes.
+- Keep I/O async and CPU work isolated where needed.
+- Treat free-threaded mode as opt-in until dependencies are validated.
 
-Load detailed guidance based on context:
+## Avoid
 
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Type System | `references/type-system.md` | Type hints, mypy, generics, Protocol |
-| Async Patterns | `references/async-patterns.md` | async/await, asyncio, task groups |
-| Standard Library | `references/standard-library.md` | pathlib, dataclasses, functools, itertools |
-| Testing | `references/testing.md` | pytest, fixtures, mocking, parametrize |
-| Packaging | `references/packaging.md` | poetry, pip, pyproject.toml, distribution |
+- Untyped public APIs in shared modules.
+- Hidden global state in request paths.
+- Mixed sync/async call graphs without clear adapters.
 
-## Constraints
+## Reference files
 
-### MUST DO
-- Type hints for all function signatures and class attributes
-- PEP 8 compliance with black formatting
-- Comprehensive docstrings (Google style)
-- Test coverage exceeding 90% with pytest
-- Use `X | None` instead of `Optional[X]` (Python 3.10+)
-- Async/await for I/O-bound operations
-- Dataclasses over manual __init__ methods
-- Context managers for resource handling
-
-### MUST NOT DO
-- Skip type annotations on public APIs
-- Use mutable default arguments
-- Mix sync and async code improperly
-- Ignore mypy errors in strict mode
-- Use bare except clauses
-- Hardcode secrets or configuration
-- Use deprecated stdlib modules (use pathlib not os.path)
-
-## Output Templates
-
-When implementing Python features, provide:
-1. Module file with complete type hints
-2. Test file with pytest fixtures
-3. Type checking confirmation (mypy --strict passes)
-4. Brief explanation of Pythonic patterns used
-
-## Knowledge Reference
-
-Python 3.11+, typing module, mypy, pytest, black, ruff, dataclasses, async/await, asyncio, pathlib, functools, itertools, Poetry, Pydantic, contextlib, collections.abc, Protocol
+- `references/type-system.md`
+- `references/async-patterns.md`
+- `references/testing.md`
+- `references/packaging.md`
+- `references/standard-library.md`

package/workflows/skills/react-best-practices/SKILL.md

@@ -1,136 +1,53 @@
 ---
-name: react-best-practices
-description: "Performance-focused React/Next.js review checklist from Vercel. Use for optimization/refactor passes, not as the primary implementation skill."
+name: "react-best-practices"
+description: "Performance-focused React/Next.js review checklist. Use for audits and optimization passes, not as primary implementation skill."
 license: MIT
 metadata:
   author: vercel
-  version: "1.0.0"
+  version: "2.0.0"
+  domain: "frontend"
+  role: "review-checklist"
 ---
 
-# Vercel React Best Practices
+# React Best Practices
 
-Comprehensive performance optimization guide for React and Next.js applications, maintained by Vercel. Contains 57 rules across 8 categories, prioritized by impact to guide automated refactoring and code generation.
+## Purpose
 
-## When to Apply
+Use this skill to run structured optimization reviews on React/Next.js code. Pair it with implementation skills (`react-expert`, `nextjs-developer`) when code changes are required.
 
-Reference these guidelines when:
-- Writing new React components or Next.js pages
-- Implementing data fetching (client or server-side)
-- Reviewing code for performance issues
-- Refactoring existing React/Next.js code
-- Optimizing bundle size or load times
+## Review order
 
-## Rule Categories by Priority
+1. Async waterfalls and request parallelization.
+2. Bundle and hydration footprint.
+3. Server rendering and serialization overhead.
+4. Client data-fetching and rerender churn.
+5. JS/runtime hot paths.
 
-| Priority | Category | Impact | Prefix |
-|----------|----------|--------|--------|
-| 1 | Eliminating Waterfalls | CRITICAL | `async-` |
-| 2 | Bundle Size Optimization | CRITICAL | `bundle-` |
-| 3 | Server-Side Performance | HIGH | `server-` |
-| 4 | Client-Side Data Fetching | MEDIUM-HIGH | `client-` |
-| 5 | Re-render Optimization | MEDIUM | `rerender-` |
-| 6 | Rendering Performance | MEDIUM | `rendering-` |
-| 7 | JavaScript Performance | LOW-MEDIUM | `js-` |
-| 8 | Advanced Patterns | LOW | `advanced-` |
+## High-impact checks
 
-## Quick Reference
+- Parallelize independent async work.
+- Eliminate unnecessary client components.
+- Remove heavy modules from critical path.
+- Avoid unstable props that trigger deep rerenders.
+- Keep server-to-client payloads minimal.
 
-### 1. Eliminating Waterfalls (CRITICAL)
+## Output format
 
-- `async-defer-await` - Move await into branches where actually used
-- `async-parallel` - Use Promise.all() for independent operations
-- `async-dependencies` - Use better-all for partial dependencies
-- `async-api-routes` - Start promises early, await late in API routes
-- `async-suspense-boundaries` - Use Suspense to stream content
+Return prioritized findings with:
 
-### 2. Bundle Size Optimization (CRITICAL)
+1. Issue and impact.
+2. Minimal safe change.
+3. Verification method (profile metric or test).
 
-- `bundle-barrel-imports` - Import directly, avoid barrel files
-- `bundle-dynamic-imports` - Use next/dynamic for heavy components
-- `bundle-defer-third-party` - Load analytics/logging after hydration
-- `bundle-conditional` - Load modules only when feature is activated
-- `bundle-preload` - Preload on hover/focus for perceived speed
+## Rule catalog
 
-### 3. Server-Side Performance (HIGH)
+Detailed rules are under `rules/` and grouped by prefix:
 
-- `server-auth-actions` - Authenticate server actions like API routes
-- `server-cache-react` - Use React.cache() for per-request deduplication
-- `server-cache-lru` - Use LRU cache for cross-request caching
-- `server-dedup-props` - Avoid duplicate serialization in RSC props
-- `server-serialization` - Minimize data passed to client components
-- `server-parallel-fetching` - Restructure components to parallelize fetches
-- `server-after-nonblocking` - Use after() for non-blocking operations
-
-### 4. Client-Side Data Fetching (MEDIUM-HIGH)
-
-- `client-swr-dedup` - Use SWR for automatic request deduplication
-- `client-event-listeners` - Deduplicate global event listeners
-- `client-passive-event-listeners` - Use passive listeners for scroll
-- `client-localstorage-schema` - Version and minimize localStorage data
-
-### 5. Re-render Optimization (MEDIUM)
-
-- `rerender-defer-reads` - Don't subscribe to state only used in callbacks
-- `rerender-memo` - Extract expensive work into memoized components
-- `rerender-memo-with-default-value` - Hoist default non-primitive props
-- `rerender-dependencies` - Use primitive dependencies in effects
-- `rerender-derived-state` - Subscribe to derived booleans, not raw values
-- `rerender-derived-state-no-effect` - Derive state during render, not effects
-- `rerender-functional-setstate` - Use functional setState for stable callbacks
-- `rerender-lazy-state-init` - Pass function to useState for expensive values
-- `rerender-simple-expression-in-memo` - Avoid memo for simple primitives
-- `rerender-move-effect-to-event` - Put interaction logic in event handlers
-- `rerender-transitions` - Use startTransition for non-urgent updates
-- `rerender-use-ref-transient-values` - Use refs for transient frequent values
-
-### 6. Rendering Performance (MEDIUM)
-
-- `rendering-animate-svg-wrapper` - Animate div wrapper, not SVG element
-- `rendering-content-visibility` - Use content-visibility for long lists
-- `rendering-hoist-jsx` - Extract static JSX outside components
-- `rendering-svg-precision` - Reduce SVG coordinate precision
-- `rendering-hydration-no-flicker` - Use inline script for client-only data
-- `rendering-hydration-suppress-warning` - Suppress expected mismatches
-- `rendering-activity` - Use Activity component for show/hide
-- `rendering-conditional-render` - Use ternary, not && for conditionals
-- `rendering-usetransition-loading` - Prefer useTransition for loading state
-
-### 7. JavaScript Performance (LOW-MEDIUM)
-
-- `js-batch-dom-css` - Group CSS changes via classes or cssText
-- `js-index-maps` - Build Map for repeated lookups
-- `js-cache-property-access` - Cache object properties in loops
-- `js-cache-function-results` - Cache function results in module-level Map
-- `js-cache-storage` - Cache localStorage/sessionStorage reads
-- `js-combine-iterations` - Combine multiple filter/map into one loop
-- `js-length-check-first` - Check array length before expensive comparison
-- `js-early-exit` - Return early from functions
-- `js-hoist-regexp` - Hoist RegExp creation outside loops
-- `js-min-max-loop` - Use loop for min/max instead of sort
-- `js-set-map-lookups` - Use Set/Map for O(1) lookups
-- `js-tosorted-immutable` - Use toSorted() for immutability
-
-### 8. Advanced Patterns (LOW)
-
-- `advanced-event-handler-refs` - Store event handlers in refs
-- `advanced-init-once` - Initialize app once per app load
-- `advanced-use-latest` - useLatest for stable callback refs
-
-## How to Use
-
-Read individual rule files for detailed explanations and code examples:
-
-```
-rules/async-parallel.md
-rules/bundle-barrel-imports.md
-```
-
-Each rule file contains:
-- Brief explanation of why it matters
-- Incorrect code example with explanation
-- Correct code example with explanation
-- Additional context and references
-
-## Full Compiled Document
-
-For the complete guide with all rules expanded: `AGENTS.md`
+- `async-*`
+- `bundle-*`
+- `server-*`
+- `client-*`
+- `rerender-*`
+- `rendering-*`
+- `js-*`
+- `advanced-*`

package/workflows/skills/react-expert/SKILL.md

@@ -1,84 +1,56 @@
 ---
-name: react-expert
-description: "Use for framework-agnostic React component architecture, hooks/state patterns, and React 19 APIs. For Next.js routing/App Router specifics, use nextjs-developer."
+name: "react-expert"
+description: "Use for framework-agnostic React architecture with React 19 patterns, state design, and performance tuning."
 license: MIT
 metadata:
-  author: https://github.com/Jeffallan
-  version: "1.0.0"
-  domain: frontend
-  triggers: React, JSX, hooks, useState, useEffect, useContext, Server Components, React 19, Suspense, TanStack Query, Redux, Zustand, component, frontend
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: fullstack-guardian, playwright-expert, test-master
+  version: "2.0.0"
+  domain: "frontend"
+  role: "specialist"
+  stack: "react"
+  baseline: "React 19"
 ---
 
 # React Expert
 
-Senior React specialist with deep expertise in React 19, Server Components, and production-grade application architecture.
+## Scope
 
-## Role Definition
+- Use this for React component and state architecture.
+- Use `nextjs-developer` for Next.js routing/App Router specifics.
 
-You are a senior React engineer with 10+ years of frontend experience. You specialize in React 19 patterns including Server Components, the `use()` hook, and form actions. You build accessible, performant applications with TypeScript and modern state management.
+## When to use
 
-## When to Use This Skill
+- Building reusable component systems.
+- Designing local/shared/remote state boundaries.
+- Refactoring for rendering performance.
+- Implementing robust form and async UI flows.
 
-- Building new React components or features
-- Implementing state management (local, Context, Redux, Zustand)
-- Optimizing React performance
-- Setting up React project architecture
-- Working with React 19 Server Components
-- Implementing forms with React 19 actions
-- Data fetching patterns with TanStack Query or `use()`
+## Core workflow
 
-## Core Workflow
+1. Model component responsibilities and ownership boundaries.
+2. Decide state location and mutation strategy.
+3. Implement with accessible markup and predictable effects.
+4. Measure rerender behavior before applying memoization.
+5. Validate with component and interaction tests.
 
-1. **Analyze requirements** - Identify component hierarchy, state needs, data flow
-2. **Choose patterns** - Select appropriate state management, data fetching approach
-3. **Implement** - Write TypeScript components with proper types
-4. **Optimize** - Apply memoization where needed, ensure accessibility
-5. **Test** - Write tests with React Testing Library
+## Baseline standards
 
-## Reference Guide
+- Prefer pure render logic and explicit side-effect boundaries.
+- Use transitions/suspense intentionally for UX.
+- Keep effects idempotent and cleanup-safe.
+- Derive state instead of duplicating it.
+- Keep mutation logic centralized when state grows.
 
-Load detailed guidance based on context:
+## Avoid
 
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Server Components | `references/server-components.md` | RSC patterns, Next.js App Router |
-| React 19 | `references/react-19-features.md` | use() hook, useActionState, forms |
-| State Management | `references/state-management.md` | Context, Zustand, Redux, TanStack |
-| Hooks | `references/hooks-patterns.md` | Custom hooks, useEffect, useCallback |
-| Performance | `references/performance.md` | memo, lazy, virtualization |
-| Testing | `references/testing-react.md` | Testing Library, mocking |
-| Class Migration | `references/migration-class-to-modern.md` | Converting class components to hooks/RSC |
+- Blanket memoization without profiling evidence.
+- Effect-driven derived state loops.
+- Hidden shared mutable module state.
 
-## Constraints
+## Reference files
 
-### MUST DO
-- Use TypeScript with strict mode
-- Implement error boundaries for graceful failures
-- Use `key` props correctly (stable, unique identifiers)
-- Clean up effects (return cleanup function)
-- Use semantic HTML and ARIA for accessibility
-- Memoize when passing callbacks/objects to memoized children
-- Use Suspense boundaries for async operations
-
-### MUST NOT DO
-- Mutate state directly
-- Use array index as key for dynamic lists
-- Create functions inside JSX (causes re-renders)
-- Forget useEffect cleanup (memory leaks)
-- Ignore React strict mode warnings
-- Skip error boundaries in production
-
-## Output Templates
-
-When implementing React features, provide:
-1. Component file with TypeScript types
-2. Test file if non-trivial logic
-3. Brief explanation of key decisions
-
-## Knowledge Reference
-
-React 19, Server Components, use() hook, Suspense, TypeScript, TanStack Query, Zustand, Redux Toolkit, React Router, React Testing Library, Vitest/Jest, Next.js App Router, accessibility (WCAG)
+- `references/react-19-features.md`
+- `references/hooks-patterns.md`
+- `references/state-management.md`
+- `references/performance.md`
+- `references/testing-react.md`
+- `references/server-components.md`

package/workflows/skills/rust-engineer/SKILL.md

@@ -1,86 +1,21 @@
 ---
 name: rust-engineer
-description: Use when building Rust applications requiring memory safety, systems programming, or zero-cost abstractions. Invoke for ownership patterns, lifetimes, traits, async/await with tokio.
-license: MIT
+description: "Compatibility alias skill. Deprecated: use rust-pro."
 metadata:
-  author: https://github.com/Jeffallan
-  version: "1.0.0"
-  domain: language
-  triggers: Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: test-master
+  deprecated: true
+  replaced_by: rust-pro
+  removal_target: v0.6.0
 ---
 
 # Rust Engineer
 
-Senior Rust engineer with deep expertise in Rust 2021 edition, systems programming, memory safety, and zero-cost abstractions. Specializes in building reliable, high-performance software leveraging Rust's ownership system.
+## Compatibility Alias
 
-## Role Definition
+This skill is deprecated and kept for backward compatibility.
 
-You are a senior Rust engineer with 10+ years of systems programming experience. You specialize in Rust's ownership model, async programming with tokio, trait-based design, and performance optimization. You build memory-safe, concurrent systems with zero-cost abstractions.
+Use `rust-pro` as the canonical skill.
 
-## When to Use This Skill
+## Migration
 
-- Building systems-level applications in Rust
-- Implementing ownership and borrowing patterns
-- Designing trait hierarchies and generic APIs
-- Setting up async/await with tokio or async-std
-- Optimizing for performance and memory safety
-- Creating FFI bindings and unsafe abstractions
-
-## Core Workflow
-
-1. **Analyze ownership** - Design lifetime relationships and borrowing patterns
-2. **Design traits** - Create trait hierarchies with generics and associated types
-3. **Implement safely** - Write idiomatic Rust with minimal unsafe code
-4. **Handle errors** - Use Result/Option with ? operator and custom error types
-5. **Test thoroughly** - Unit tests, integration tests, property testing, benchmarks
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Ownership | `references/ownership.md` | Lifetimes, borrowing, smart pointers, Pin |
-| Traits | `references/traits.md` | Trait design, generics, associated types, derive |
-| Error Handling | `references/error-handling.md` | Result, Option, ?, custom errors, thiserror |
-| Async | `references/async.md` | async/await, tokio, futures, streams, concurrency |
-| Testing | `references/testing.md` | Unit/integration tests, proptest, benchmarks |
-
-## Constraints
-
-### MUST DO
-- Use ownership and borrowing for memory safety
-- Minimize unsafe code (document all unsafe blocks)
-- Use type system for compile-time guarantees
-- Handle all errors explicitly (Result/Option)
-- Add comprehensive documentation with examples
-- Run clippy and fix all warnings
-- Use cargo fmt for consistent formatting
-- Write tests including doctests
-
-### MUST NOT DO
-- Use unwrap() in production code (prefer expect() with messages)
-- Create memory leaks or dangling pointers
-- Use unsafe without documenting safety invariants
-- Ignore clippy warnings
-- Mix blocking and async code incorrectly
-- Skip error handling
-- Use String when &str suffices
-- Clone unnecessarily (use borrowing)
-
-## Output Templates
-
-When implementing Rust features, provide:
-1. Type definitions (structs, enums, traits)
-2. Implementation with proper ownership
-3. Error handling with custom error types
-4. Tests (unit, integration, doctests)
-5. Brief explanation of design decisions
-
-## Knowledge Reference
-
-Rust 2021, Cargo, ownership/borrowing, lifetimes, traits, generics, async/await, tokio, Result/Option, thiserror/anyhow, serde, clippy, rustfmt, cargo-test, criterion benchmarks, MIRI, unsafe Rust
+1. Replace direct references to `rust-engineer` with `rust-pro`.
+2. Apply the full workflow from `rust-pro` for new work.