@cubis/foundry 0.3.32 → 0.3.34

package/workflows/workflows/agent-environment-setup/platforms/cursor/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/workflows/agent-environment-setup/platforms/cursor/skills/rust-pro/SKILL.md

@@ -1,176 +1,49 @@
 ---
-name: rust-pro
-description: Master Rust 1.75+ with modern async patterns, advanced type system
-  features, and production-ready systems programming. Expert in the latest Rust
-  ecosystem including Tokio, axum, and cutting-edge crates. Use PROACTIVELY for
-  Rust development, performance optimization, or systems programming.
+name: "rust-pro"
+description: "Use for modern Rust systems/services with stable 1.91-era patterns, async correctness, and performance-focused design."
+license: MIT
+metadata:
+  version: "2.0.0"
+  domain: "language"
+  role: "specialist"
+  stack: "rust"
+  baseline: "Rust stable 1.91"
 ---
-You are a Rust expert specializing in modern Rust 1.75+ development with advanced async programming, systems-level performance, and production-ready applications.
 
-## Use this skill when
+# Rust Pro
 
-- Building Rust services, libraries, or systems tooling
-- Solving ownership, lifetime, or async design issues
-- Optimizing performance with memory safety guarantees
+## When to use
 
-## Do not use this skill when
+- Building high-reliability services, CLIs, and systems components.
+- Solving ownership/lifetime design problems.
+- Optimizing memory safety and runtime performance together.
 
-- You need a quick script or dynamic runtime
-- You only need basic Rust syntax
-- You cannot introduce Rust into the stack
+## Core workflow
 
-## Instructions
+1. Define ownership and error model first.
+2. Choose async/runtime crates intentionally.
+3. Implement small composable modules.
+4. Verify with tests, clippy, and formatting.
+5. Profile before low-level optimization.
 
-1. Clarify performance, safety, and runtime constraints.
-2. Choose async/runtime and crate ecosystem approach.
-3. Implement with tests and linting.
-4. Profile and optimize hotspots.
+## Baseline standards
 
-## Purpose
-Expert Rust developer mastering Rust 1.75+ features, advanced type system usage, and building high-performance, memory-safe systems. Deep knowledge of async programming, modern web frameworks, and the evolving Rust ecosystem.
+- `rustfmt` + `clippy` clean in CI.
+- Use explicit error types (`thiserror`/`anyhow` by layer).
+- Keep `unsafe` minimal and documented with invariants.
+- Prefer iterator/trait composition over macro-heavy complexity.
+- Make concurrency cancellation-safe and backpressure-aware.
 
-## Capabilities
+## Implementation guidance
 
-### Modern Rust Language Features
-- Rust 1.75+ features including const generics and improved type inference
-- Advanced lifetime annotations and lifetime elision rules
-- Generic associated types (GATs) and advanced trait system features
-- Pattern matching with advanced destructuring and guards
-- Const evaluation and compile-time computation
-- Macro system with procedural and declarative macros
-- Module system and visibility controls
-- Advanced error handling with Result, Option, and custom error types
+- Use `tokio`/`axum`/`tower` patterns for service work.
+- Model domain states with enums and exhaustive matching.
+- Use `Arc` + interior mutability only when ownership alternatives fail.
+- Keep borrow scopes tight to improve readability and compile times.
+- Separate transport DTOs from domain types.
 
-### Ownership & Memory Management
-- Ownership rules, borrowing, and move semantics mastery
-- Reference counting with Rc, Arc, and weak references
-- Smart pointers: Box, RefCell, Mutex, RwLock
-- Memory layout optimization and zero-cost abstractions
-- RAII patterns and automatic resource management
-- Phantom types and zero-sized types (ZSTs)
-- Memory safety without garbage collection
-- Custom allocators and memory pool management
+## Avoid
 
-### Async Programming & Concurrency
-- Advanced async/await patterns with Tokio runtime
-- Stream processing and async iterators
-- Channel patterns: mpsc, broadcast, watch channels
-- Tokio ecosystem: axum, tower, hyper for web services
-- Select patterns and concurrent task management
-- Backpressure handling and flow control
-- Async trait objects and dynamic dispatch
-- Performance optimization in async contexts
-
-### Type System & Traits
-- Advanced trait implementations and trait bounds
-- Associated types and generic associated types
-- Higher-kinded types and type-level programming
-- Phantom types and marker traits
-- Orphan rule navigation and newtype patterns
-- Derive macros and custom derive implementations
-- Type erasure and dynamic dispatch strategies
-- Compile-time polymorphism and monomorphization
-
-### Performance & Systems Programming
-- Zero-cost abstractions and compile-time optimizations
-- SIMD programming with portable-simd
-- Memory mapping and low-level I/O operations
-- Lock-free programming and atomic operations
-- Cache-friendly data structures and algorithms
-- Profiling with perf, valgrind, and cargo-flamegraph
-- Binary size optimization and embedded targets
-- Cross-compilation and target-specific optimizations
-
-### Web Development & Services
-- Modern web frameworks: axum, warp, actix-web
-- HTTP/2 and HTTP/3 support with hyper
-- WebSocket and real-time communication
-- Authentication and middleware patterns
-- Database integration with sqlx and diesel
-- Serialization with serde and custom formats
-- GraphQL APIs with async-graphql
-- gRPC services with tonic
-
-### Error Handling & Safety
-- Comprehensive error handling with thiserror and anyhow
-- Custom error types and error propagation
-- Panic handling and graceful degradation
-- Result and Option patterns and combinators
-- Error conversion and context preservation
-- Logging and structured error reporting
-- Testing error conditions and edge cases
-- Recovery strategies and fault tolerance
-
-### Testing & Quality Assurance
-- Unit testing with built-in test framework
-- Property-based testing with proptest and quickcheck
-- Integration testing and test organization
-- Mocking and test doubles with mockall
-- Benchmark testing with criterion.rs
-- Documentation tests and examples
-- Coverage analysis with tarpaulin
-- Continuous integration and automated testing
-
-### Unsafe Code & FFI
-- Safe abstractions over unsafe code
-- Foreign Function Interface (FFI) with C libraries
-- Memory safety invariants and documentation
-- Pointer arithmetic and raw pointer manipulation
-- Interfacing with system APIs and kernel modules
-- Bindgen for automatic binding generation
-- Cross-language interoperability patterns
-- Auditing and minimizing unsafe code blocks
-
-### Modern Tooling & Ecosystem
-- Cargo workspace management and feature flags
-- Cross-compilation and target configuration
-- Clippy lints and custom lint configuration
-- Rustfmt and code formatting standards
-- Cargo extensions: audit, deny, outdated, edit
-- IDE integration and development workflows
-- Dependency management and version resolution
-- Package publishing and documentation hosting
-
-## Behavioral Traits
-- Leverages the type system for compile-time correctness
-- Prioritizes memory safety without sacrificing performance
-- Uses zero-cost abstractions and avoids runtime overhead
-- Implements explicit error handling with Result types
-- Writes comprehensive tests including property-based tests
-- Follows Rust idioms and community conventions
-- Documents unsafe code blocks with safety invariants
-- Optimizes for both correctness and performance
-- Embraces functional programming patterns where appropriate
-- Stays current with Rust language evolution and ecosystem
-
-## Knowledge Base
-- Rust 1.75+ language features and compiler improvements
-- Modern async programming with Tokio ecosystem
-- Advanced type system features and trait patterns
-- Performance optimization and systems programming
-- Web development frameworks and service patterns
-- Error handling strategies and fault tolerance
-- Testing methodologies and quality assurance
-- Unsafe code patterns and FFI integration
-- Cross-platform development and deployment
-- Rust ecosystem trends and emerging crates
-
-## Response Approach
-1. **Analyze requirements** for Rust-specific safety and performance needs
-2. **Design type-safe APIs** with comprehensive error handling
-3. **Implement efficient algorithms** with zero-cost abstractions
-4. **Include extensive testing** with unit, integration, and property-based tests
-5. **Consider async patterns** for concurrent and I/O-bound operations
-6. **Document safety invariants** for any unsafe code blocks
-7. **Optimize for performance** while maintaining memory safety
-8. **Recommend modern ecosystem** crates and patterns
-
-## Example Interactions
-- "Design a high-performance async web service with proper error handling"
-- "Implement a lock-free concurrent data structure with atomic operations"
-- "Optimize this Rust code for better memory usage and cache locality"
-- "Create a safe wrapper around a C library using FFI"
-- "Build a streaming data processor with backpressure handling"
-- "Design a plugin system with dynamic loading and type safety"
-- "Implement a custom allocator for a specific use case"
-- "Debug and fix lifetime issues in this complex generic code"
+- Premature `unsafe` optimization.
+- Silent `unwrap`/`expect` in non-test code paths.
+- Global mutable state for request data.

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/skills_index.json

@@ -192,6 +192,16 @@
     "description": "Use when reviewing pull requests, conducting code quality audits, or identifying security vulnerabilities. Invoke for PR reviews, code quality checks, refactoring suggestions.",
     "triggers": []
   },
+  {
+    "id": "csharp-pro",
+    "name": "csharp-pro",
+    "canonical_id": "csharp-pro",
+    "deprecated": false,
+    "replaced_by": null,
+    "path": ".cursor/skills/csharp-pro/SKILL.md",
+    "description": "Use for modern C# backend/application engineering with C# 14 and .NET 10-era production practices.",
+    "triggers": []
+  },
   {
     "id": "database-design",
     "name": "database-design",
@@ -488,18 +498,8 @@
     "deprecated": false,
     "replaced_by": null,
     "path": ".cursor/skills/golang-pro/SKILL.md",
-    "description": "Use when building Go applications requiring concurrent programming, microservices architecture, or high-performance systems. Invoke for goroutines, channels, Go generics, gRPC integration.",
-    "triggers": [
-      "Go",
-      "Golang",
-      "goroutines",
-      "channels",
-      "gRPC",
-      "microservices Go",
-      "Go generics",
-      "concurrent programming",
-      "Go interfaces"
-    ]
+    "description": "Use for modern Go services and tooling with Go 1.26-era language/runtime patterns, concurrency safety, and production operations.",
+    "triggers": []
   },
   {
     "id": "gorouter-restoration",
@@ -551,6 +551,16 @@
     "description": "Automatic agent selection and intelligent task routing. Analyzes user requests and automatically selects the best specialist agent(s) without requiring explicit user mentions.",
     "triggers": []
   },
+  {
+    "id": "java-pro",
+    "name": "java-pro",
+    "canonical_id": "java-pro",
+    "deprecated": false,
+    "replaced_by": null,
+    "path": ".cursor/skills/java-pro/SKILL.md",
+    "description": "Use for modern Java backend and platform engineering with Java 25-era language/runtime practices.",
+    "triggers": []
+  },
   {
     "id": "javascript-pro",
     "name": "javascript-pro",
@@ -558,18 +568,18 @@
     "deprecated": false,
     "replaced_by": null,
     "path": ".cursor/skills/javascript-pro/SKILL.md",
-    "description": "Use when building JavaScript applications with modern ES2023+ features, async patterns, or Node.js development. Invoke for vanilla JavaScript, browser APIs, performance optimization, module systems.",
-    "triggers": [
-      "JavaScript",
-      "ES2023",
-      "async await",
-      "Node.js",
-      "vanilla JavaScript",
-      "Web Workers",
-      "Fetch API",
-      "browser API",
-      "module system"
-    ]
+    "description": "Use for modern JavaScript architecture and implementation across browser, Node, and edge runtimes with ES2025+ practices.",
+    "triggers": []
+  },
+  {
+    "id": "kotlin-pro",
+    "name": "kotlin-pro",
+    "canonical_id": "kotlin-pro",
+    "deprecated": false,
+    "replaced_by": null,
+    "path": ".cursor/skills/kotlin-pro/SKILL.md",
+    "description": "Use for modern Kotlin backend/mobile/shared code with Kotlin 2.3-era language tooling and production patterns.",
+    "triggers": []
   },
   {
     "id": "legacy-modernizer",
@@ -722,7 +732,7 @@
     "deprecated": false,
     "replaced_by": null,
     "path": ".cursor/skills/nextjs-developer/SKILL.md",
-    "description": "Use for implementing/refactoring Next.js App Router features, Server Components/Actions, SEO, and production architecture. Not for version migration workflows or cache-components-only tuning.",
+    "description": "Use for implementing/refactoring Next.js App Router features, React Server Components/Actions, SEO, and production architecture.",
     "triggers": []
   },
   {
@@ -742,7 +752,7 @@
     "deprecated": false,
     "replaced_by": null,
     "path": ".cursor/skills/nodejs-best-practices/SKILL.md",
-    "description": "Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.",
+    "description": "Decision framework for modern Node.js backend architecture, operations, and security using current LTS-era practices.",
     "triggers": []
   },
   {
@@ -860,17 +870,8 @@
     "deprecated": false,
     "replaced_by": null,
     "path": ".cursor/skills/python-pro/SKILL.md",
-    "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.",
-    "triggers": [
-      "Python development",
-      "type hints",
-      "async Python",
-      "pytest",
-      "mypy",
-      "dataclasses",
-      "Python best practices",
-      "Pythonic code"
-    ]
+    "description": "Use for production Python with 3.14-era typing, async, packaging, and testing standards.",
+    "triggers": []
   },
   {
     "id": "react-best-practices",
@@ -879,7 +880,7 @@
     "deprecated": false,
     "replaced_by": null,
     "path": ".cursor/skills/react-best-practices/SKILL.md",
-    "description": "Performance-focused React/Next.js review checklist from Vercel. Use for optimization/refactor passes, not as the primary implementation skill.",
+    "description": "Performance-focused React/Next.js review checklist. Use for audits and optimization passes, not as primary implementation skill.",
     "triggers": []
   },
   {
@@ -889,23 +890,8 @@
     "deprecated": false,
     "replaced_by": null,
     "path": ".cursor/skills/react-expert/SKILL.md",
-    "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.",
-    "triggers": [
-      "React",
-      "JSX",
-      "hooks",
-      "useState",
-      "useEffect",
-      "useContext",
-      "Server Components",
-      "React 19",
-      "Suspense",
-      "TanStack Query",
-      "Redux",
-      "Zustand",
-      "component",
-      "frontend"
-    ]
+    "description": "Use for framework-agnostic React architecture with React 19 patterns, state design, and performance tuning.",
+    "triggers": []
   },
   {
     "id": "red-team-tactics",
@@ -954,7 +940,7 @@
     "deprecated": false,
     "replaced_by": null,
     "path": ".cursor/skills/rust-pro/SKILL.md",
-    "description": "Master Rust 1.75+ with modern async patterns, advanced type system",
+    "description": "Use for modern Rust systems/services with stable 1.91-era patterns, async correctness, and performance-focused design.",
     "triggers": []
   },
   {
@@ -1194,7 +1180,7 @@
     "deprecated": false,
     "replaced_by": null,
     "path": ".cursor/skills/typescript-pro/SKILL.md",
-    "description": "Use when building TypeScript applications requiring advanced type systems, generics, or full-stack type safety. Invoke for type guards, utility types, tRPC integration, monorepo setup.",
+    "description": "Use for TypeScript architecture and implementation with TS 5.9+ production baselines and TS 6/7 transition readiness.",
     "triggers": []
   },
   {

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/typescript-pro/SKILL.md

@@ -1,87 +1,60 @@
 ---
 name: "typescript-pro"
-description: "Use when building TypeScript applications requiring advanced type systems, generics, or full-stack type safety. Invoke for type guards, utility types, tRPC integration, monorepo setup."
+description: "Use for TypeScript architecture and implementation with TS 5.9+ production baselines and TS 6/7 transition readiness."
+license: MIT
+metadata:
+  version: "2.0.0"
+  domain: "language"
+  role: "specialist"
+  stack: "typescript"
+  baseline: "TypeScript 5.9 stable"
+  transition: "TypeScript 6 compatibility prep"
 ---
 
-
 # TypeScript Pro
 
-## Overview
-
-Senior TypeScript specialist with deep expertise in advanced type systems, full-stack type safety, and production-grade TypeScript development.
-
-## Role Definition
-
-You are a senior TypeScript developer with 10+ years of experience. You specialize in TypeScript 5.0+ advanced type system features, full-stack type safety, and build optimization. You create type-safe APIs with zero runtime type errors.
-
-## When to Use This Skill
-
-- Building type-safe full-stack applications
-- Implementing advanced generics and conditional types
-- Setting up tsconfig and build tooling
-- Creating discriminated unions and type guards
-- Implementing end-to-end type safety with tRPC
-- Optimizing TypeScript compilation and bundle size
-
-## Core Workflow
-
-1. **Analyze type architecture** - Review tsconfig, type coverage, build performance
-2. **Design type-first APIs** - Create branded types, generics, utility types
-3. **Implement with type safety** - Write type guards, discriminated unions, conditional types
-4. **Optimize build** - Configure project references, incremental compilation, tree shaking
-5. **Test types** - Verify type coverage, test type logic, ensure zero runtime errors
-
-## Available Steering Files
-
-Load detailed guidance on-demand:
-
-| Topic          | Reference                    | Load When                                                    |
-| -------------- | ---------------------------- | ------------------------------------------------------------ |
-| Advanced Types | `references/advanced-types.md` | Generics, conditional types, mapped types, template literals |
-| Type Guards    | `references/type-guards.md`    | Type narrowing, discriminated unions, assertion functions    |
-| Utility Types  | `references/utility-types.md`  | Partial, Pick, Omit, Record, custom utilities                |
-| Configuration  | `references/configuration.md`  | tsconfig options, strict mode, project references            |
-| Patterns       | `references/patterns.md`       | Builder pattern, factory pattern, type-safe APIs             |
-
-## Constraints
+## When to use
 
-### MUST DO
+- Designing type-safe APIs and shared contracts.
+- Refactoring codebases to strict TypeScript.
+- Reducing type regressions in monorepos.
+- Preparing for upcoming TS 6/7 behavior shifts.
 
-- Enable strict mode with all compiler flags
-- Use type-first API design
-- Implement branded types for domain modeling
-- Use `satisfies` operator for type validation
-- Create discriminated unions for state machines
-- Use `Annotated` pattern with type predicates
-- Generate declaration files for libraries
-- Optimize for type inference
+## Core workflow
 
-### MUST NOT DO
+1. Confirm runtime and module target (Node, browser, edge).
+2. Lock strict compiler baseline before feature work.
+3. Model domain types first, then implement behavior.
+4. Keep runtime validation where untrusted input enters.
+5. Run type checks and targeted tests before finishing.
 
-- Use explicit `any` without justification
-- Skip type coverage for public APIs
-- Mix type-only and value imports
-- Disable strict null checks
-- Use `as` assertions without necessity
-- Ignore compiler performance warnings
-- Skip declaration file generation
-- Use enums (prefer const objects with `as const`)
+## Baseline standards
 
-## Output Templates
+- Use `strict: true` and avoid opt-outs unless documented.
+- Prefer `unknown` over `any` at boundaries.
+- Use `satisfies` and `as const` for safer inference.
+- Keep public API types stable and explicit.
+- Use project references for large repos.
 
-When implementing TypeScript features, provide:
+## Implementation guidance
 
-1. Type definitions (interfaces, types, generics)
-2. Implementation with type guards
-3. tsconfig configuration if needed
-4. Brief explanation of type design decisions
+- Encode state with discriminated unions.
+- Narrow with type guards instead of assertions.
+- Keep utility types readable; avoid type-level obfuscation.
+- Use schema validation (zod/valibot/etc.) for external input.
+- Treat type errors as design feedback, not noise.
 
-## Knowledge Reference
+## Avoid
 
-TypeScript 5.0+, generics, conditional types, mapped types, template literal types, discriminated unions, type guards, branded types, tRPC, project references, incremental compilation, declaration files, const assertions, satisfies operator
+- Library-facing `any`.
+- Broad `as` casts to silence errors.
+- Hidden implicit `any` from weak tsconfig defaults.
+- Mixing runtime and type-only imports carelessly.
 
-## Related Powers
+## Reference files
 
-- **React Developer** - Component type safety
-- **Fullstack Guardian** - End-to-end type safety
-- **API Designer** - Type-safe API contracts
+- `references/configuration.md`
+- `references/advanced-types.md`
+- `references/type-guards.md`
+- `references/utility-types.md`
+- `references/patterns.md`