Session changes can lose decisions, verification evidence, and unfinished implementation work. This skill guides human-controlled integration, durable pause records, and resumption checked against the current repository.

Long implementation plans can lose task state and accumulate unreviewed changes. This skill coordinates scoped subagents, review gates, and durable records across execution and recovery.

Conflicting documents can carry incorrect decisions into later development phases. This skill coordinates independent audits, scoped repairs, and fresh re-audits before phase clearance.

Long coding projects lose context, decisions, and review evidence across sessions. Executor records initiative state and coordinates phase routing, task dispatch, and approval gates.

NestJS changes can introduce incompatible syntax, hidden side effects, and public API regressions. This skill guides repository inspection, focused implementation, and evidence-based verification.

Unclear responsibilities and unnecessary abstractions make NestJS code difficult to change and test. This skill guides evidence-based object design, pattern selection, and behavior-preserving refactoring.

Mixed changes and unclear publication requests can produce misleading commits or unintended remote updates. This skill guides verified Git changes and accurate messages within authorized scope.

NestJS runtime changes can create latency, security, and deployment failures when teams lack clear contracts and measurements. This skill guides component selection, bottleneck diagnosis, and reliable implementation using repository evidence and focused tests.

Source code alone cannot establish whether a NestJS feature satisfies its roadmap. This skill compares requirements with revision-specific evidence and reports completed work, gaps, legacy paths, bugs, and blockers.

NestJS repositories can hide boundary flaws and runtime risks that lint results alone cannot reveal. This skill combines local evidence collection and semantic review into one prioritized report.

Unclear module boundaries make NestJS changes harder to test and coordinate. This skill guides evidence-based architecture decisions, explicit ownership, and incremental boundary repairs.

Many application features need semantic judgments, but free-form model responses are difficult to combine reliably in code. TypeSafe helps developers design small typed judgments and compose them into routing, ranking, extraction, verification, and interactive workflows.

iOS testing often requires switching between agent tools, simulator controls, and evidence collection. This skill routes simulator interaction through Orca and loads guidance matched to the active CLI.

Development teams can lose requirement evidence across planning, implementation, review, and release. This skill adds RVTF traceability while preserving Superpowers task boundaries and control.

Teams can lose requirements when agent-skill work moves from planning to implementation and review. This skill keeps requirements, acceptance evidence, review state, and completion claims connected through a clear traceability process.

Embedding web interfaces in Windows desktop apps requires careful initialization, messaging, and asset packaging. This skill guides WebView2 integration with local content mapping and explicit security boundaries.

Slow loading and delayed interactions require different fixes, and laboratory scores can hide real user problems. This skill guides measurement and targeted browser performance improvements.

Browser GPU workloads can fail across devices or lose performance through inefficient resource handling. This skill guides WebGPU implementation with capability checks, usable fallbacks, validation, and targeted measurement.

Raw WebGL rendering can slow down through excessive draw calls, state changes, and texture bandwidth. This skill guides context setup, resource handling, and targeted optimization.

Compute-heavy browser workloads can suffer from JavaScript processing costs and frequent data transfers. This skill guides Rust WebAssembly integration and optimization based on measured bottlenecks.