logic-guardian

Maintain a logic manifest and validate edits to protect critical business logic.

82|23|Updated Feb 24, 2026
One-click install
npx skills add https://github.com/Rune-kit/rune --skill logic-guardian
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: logic-guardian
Source: https://github.com/Rune-kit/rune/tree/main/skills/logic-guardian
Command: npx skills add https://github.com/Rune-kit/rune --skill logic-guardian

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires scout, verification, hallucination-guard, journal, session-bridge, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill prevents AI agents from accidentally deleting or corrupting complex, interconnected business logic within a project, acting as a crucial safeguard for project stability and integrity.

Core Features & Use Cases

  • Logic Manifest: Maintains a machine-readable inventory of critical logic components, their functions, and parameters.
  • Pre-Edit Gates: Enforces explicit acknowledgment and preservation of existing logic before any modifications are made to critical files.
  • Post-Edit Validation: Verifies that edits do not remove or unintentionally alter critical functions and runs tests to ensure no regressions.
  • Use Case: In a trading bot project, this skill ensures that the core strategy logic, risk management functions, and state machine transitions are not accidentally overwritten by an AI during a refactoring or bug-fixing session.

Quick Start

Run the logic-guardian skill to scan the project and generate a manifest for critical business logic.

Frequently Asked Questions about logic-guardian

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

FAQPage Schema
How do I prevent AI agents from accidentally overwriting critical business logic during refactoring?

Preventing AI agents from accidentally overwriting critical business logic requires maintaining a logic manifest and enforcing pre-edit gates. This mechanism ensures explicit acknowledgment of existing logic before modifications and validates post-edit diffs to prevent accidental deletion or corruption.

How do I generate an inventory of critical logic components for a trading algorithm?

To generate an inventory of critical logic components for a trading algorithm, run a logic scan to create a logic manifest. This manifest is a machine-readable record of critical functions, state machine transitions, and parameters, providing institutional memory for complex interconnected payment or trading systems.

What is post-edit validation for critical state machines and how does it work?

Post-edit validation for critical state machines verifies that code edits do not remove or unintentionally alter critical functions. It runs automated tests against the logic manifest to ensure no regressions occur, safeguarding complex business logic integrity after AI modifications.

Do I need specific dependencies to enforce code integrity and pre-edit gates?

Enforcing code integrity and pre-edit gates requires specific dependencies for full functionality. The skill relies on scout, verification, hallucination-guard, journal, and session-bridge skills to accurately maintain the logic manifest and validate post-edit diffs for critical business logic.

Does this logic safeguard work for payment systems and trading bot projects?

Yes, this logic safeguard is explicitly designed for payment systems and trading bot projects. It protects complex, interconnected business logic by maintaining a manifest of critical components and validating edits, ensuring risk management functions and state machine transitions remain stable.

Why should I use a logic manifest instead of manual code reviews to safeguard business logic?

A logic manifest provides a machine-readable inventory of critical components that automated agents can reference, unlike manual code reviews. It enforces pre-edit gates and validates post-edit diffs systematically, ensuring state machines and trading algorithms are protected from accidental overwrites during AI sessions.