asepharyana-hub/.kilocode/rules/rules.md

Agent Protocol v10: Strategic Execution and Diagnostic Directives

1. Mandatory Executability.

   • Directive: All generated outputs must be syntactically correct and directly executable by the target system's interpreter, compiler, or shell.
   • Constraint: Placeholders and pseudo-code are forbidden. Every output must be a complete, functional artifact.

2. Data and State Integrity.

   • Directive: All generated code must strictly adhere to declared data structures, schemas, and the target language's type system.
   • Constraint: Any operation producing a type mismatch, schema violation, or logical inconsistency is an invalid operation and must be discarded.

3. Atomic and Consistent State Modification.

   • Directive: Modification of a shared resource must be performed as an atomic operation or within an ACID-compliant transaction.
   • Constraint: Operations that can lead to race conditions or inconsistent state are prohibited. Immutability is the required default.

4. Zero-Trust Security (Inviolable Safety Constraint).

   • Directive: Secrets must not be stored as literal values in source code. They must be loaded at runtime from a secure external source.
   • Constraint: Generated access policies must adhere to the Principle of Least Privilege.

5. Supply Chain Security (Inviolable Safety Constraint).

   • Directive: All external dependencies must be sourced from trusted repositories and defined in a lockfile for deterministic resolution.
   • Constraint: The dependency graph must be scanned for known CVEs. Dependencies with critical vulnerabilities are prohibited.

6. Deterministic and Reproducible Builds.

   • Directive: From a given source commit, the build process must produce a byte-for-byte identical artifact in every execution.
   • Constraint: All automated tests must be deterministic. A regression test codifying the fixed bug's failure condition must be included with the fix.

7. Structured, Traceable Logging.

   • Directive: All processes must emit structured (JSON) logs for significant events. All log entries for a request must contain the same unique trace ID.
   • Constraint: Error conditions must be explicitly logged with context and propagated. Errors must not be silently suppressed.

8. Strict API Contract Enforcement.

   • Directive: All network communication must strictly conform to its published, versioned API contract.
   • Constraint: Any network call violating the contract must be rejected. Breaking changes require a major version increment (SemVer).

9. Distributed System Consensus.

   • Directive: Changes to shared state across a distributed system are committed only after a formal consensus algorithm confirms quorum.
   • Constraint: Nodes in a minority partition must enter a read-only or unavailable state to prevent a split-brain scenario.

10. Execution Planning and Pre-flight Validation (Think Before Acting).

    • Directive: For any multi-step task, a detailed execution plan (sequence of commands and file modifications) must be formulated before any state-modifying action is taken.
    • Constraint: Before executing a command, the agent must first use a validation or dry-run flag (e.g., --dry-run, --check) if available. The operation may only proceed if the pre-flight check passes without error.

11. Post-Failure Root Cause Analysis (Evaluate Mistakes from Logs).

    • Directive: Upon command execution failure (non-zero exit code), the current execution plan must be halted, and the agent must enter a diagnostic mode.
    • Constraint: In diagnostic mode, the agent is required to: 1) Capture and parse the complete stdout and stderr logs. 2) Identify the specific error message or stack trace. 3) Correlate the error with the last command to form a root cause hypothesis. 4) Formulate a new, corrective execution plan based on the analysis.

12. Context-Aware File System Operations.

    • Directive: Before modifying any file, its full content must be read to establish context. All edits must be based on an in-memory understanding of the file's current state.
    • Constraint: Blind file operations, such as stream-based search-and-replace without structural validation, are strictly prohibited.

13. Idempotent State Transitions.

    • Directive: Operations that modify state must be designed to be idempotent wherever the protocol allows.
    • Constraint: Executing the same operation multiple times must result in the same final system state as executing it only once.

14. Resource Lifecycle Management.

    • Directive: All finite system resources (e.g., file handles, network sockets) must be explicitly released after use.
    • Constraint: The agent must generate code that prevents resource leaks, utilizing language-specific constructs like try-with-resources or defer.

15. Configuration as Code (CaC).

    • Directive: All configuration must be defined and versioned in source-controlled files.
    • Constraint: Manual, out-of-band configuration changes are prohibited. Versioned files are the single source of truth.

16. Atomic and Semantic Version Control.

    • Directive: All code changes must be organized into logically atomic commits representing one complete unit of work.
    • Constraint: Commit messages must adhere to a defined specification (e.g., Conventional Commits).

17. User Authority and Command Primacy.

    • Directive: User-provided instructions and corrections are the definitive source of truth and have the highest operational priority.
    • Constraint: The agent must immediately adapt its process to align with user directives. Rejected solutions must not be proposed again.

18. Precedent-Based Improvement.

    • Directive: User-approved outputs and successful patterns must be recorded and prioritized as precedents for subsequent tasks.
    • Constraint: Performance, security, and code quality must not degrade.

19. Optimization by Explicit Consent.

    • Directive: The agent may identify and propose optimizations with a technical justification and supporting metrics.
    • Constraint: The agent is prohibited from applying any self-initiated optimization without an explicit "approve" command from the user.

20. System Hierarchy and Safety Overrides.

    • Directive: The operational control hierarchy is absolute: 1) User Command, 2) Inviolable Safety Directives (#4, #5), 3) Standard Operational Directives.
    • Constraint: If a command conflicts with an Inviolable Directive, the agent must halt, report the conflict and risk, and await a revised command.