rust-feature-impl

Implement Rust features in the envctl workspace with engine-first development and fail-closed checks.

Updated Jun 2, 2026
One-click install
npx skills add https://github.com/FlexNetOS/envctl --skill rust-feature-impl
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-feature-impl
Source: https://github.com/FlexNetOS/envctl/tree/main/.agents/skills/rust-feature-impl
Command: npx skills add https://github.com/FlexNetOS/envctl --skill rust-feature-impl

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

The Skill solves the problem of how to implement a feature/upgrade cleanly within the pure-Rust envctl workspace. It provides a framework to ensure consistency, reliability, and safety in feature development and deployment.

Core Features & Use Cases

  • Engine-first Development: Focuses on building new features in the shared engine, ensuring front-end parity and code reuse.
  • Non-C Trust Boundary: Enforces strict policies against the use of C code, ensuring a secure and reliable system.
  • Fail-closed Destructive Operations: Guards against harmful changes through strict checks and fails when conditions are unsafe.
  • Reproducible State: Ensures the integrity of the system by maintaining a locked and verified state for dependencies and configurations.

Quick Start

To start implementing a new feature in envctl, use the following steps:

  1. Ensure your development environment meets the Rust requirements.
  2. Add a new method or Event variant to the Engine in the crates/engine directory.
  3. Implement and wire the method in the crates/cli and crates/gui directories, maintaining front-end parity.
  4. Add comprehensive tests to verify the feature's behavior.

Frequently Asked Questions about rust-feature-impl

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a new feature cleanly within a pure-Rust workspace?

To implement a Rust feature cleanly, you should follow an engine-first development approach by adding methods to the shared engine, ensuring front-end parity by wiring them into CLI and GUI components, and enforcing strict non-C trust boundaries for system security.

What is the best way to maintain front-end parity when adding Rust engine features?

The best way to maintain front-end parity is engine-first development: implement the new method or Event variant in the shared engine, then wire the implementation simultaneously across both the CLI and GUI directories to ensure consistent user interfaces.

Does the envctl platform allow integrating C code for feature development?

No, the envctl platform enforces a strict non-C trust boundary that prohibits the use of C code during feature development, ensuring a secure and reliable pure-Rust system without relying on unsafe external bindings.

How do you handle destructive operations safely in a Rust workspace?

You handle destructive operations safely by applying a fail-closed policy that guards against harmful changes through strict checks, causing the system to fail deliberately when conditions are deemed unsafe.

What steps are required to verify dependencies and maintain a reproducible state in Rust?

To maintain a reproducible state, you must ensure the integrity of the system by keeping dependencies and configurations in a locked and verified state, using Rust tooling and CI processes to enforce invariant-guardian guidelines.