Agent Law & Project Governance

Relevant source files

The following files were used as context for generating this wiki page:

• AGENTS.md
• README.md
• pyproject.toml
• src/flext_tap_ldap/_utilities/_processor.py
• src/flext_tap_ldap/streams.py

Introduction

The flext-tap-ldap project operates under a strict governance model defined by the Universal Agent Law. This law serves as an inviolable core of engineering conduct that binds all AI agents (such as Claude, Cursor, or GitHub Copilot) and human contributors to a standard of "Zero-Tolerance" and "Strict-Total" quality. The governance framework ensures that every modification maintains the project's integrity, prevents technical debt, and enforces a single source of truth (SSOT).

Project governance is technically integrated through pyproject.toml configurations, quality gates defined in the README.md, and specific implementation patterns in the source code that enforce strict typing and validation. These rules apply across all session types and cannot be relaxed for convenience or speed.

Sources: AGENTS.md:1-12, README.md:1-35, pyproject.toml:1-50

Universal Agent Law Core

The "Universal Agent Law" is a portable core of engineering conduct designed to ensure consistency across multi-agent environments. It establishes a set of non-negotiable rules for code modification and validation.

Core Mandates

Law Component	Description
Zero-Tolerance	Root causes must be fixed generically; superseded code must be removed immediately; no guesses allowed.
Fix-Forward-Only	Reverting shared work is forbidden; contributors must accept the current state and fix issues moving forward.
No Workarounds	Prohibition of TODOs, stubs, fakes, or suppression directives (e.g., # type: ignore) without justification.
Stay In Scope	Only requested changes are permitted; no unrequested refactors or adjacent fixes.
Evidence Before Done	"Done" requires objective evidence (commands, exit codes, output) rather than speculative results.

Sources: AGENTS.md:15-58

Operational Protocols

The governance model includes specific protocols for blocked operations and multi-agent coordination. If a tool or edit is blocked by security hooks or sandboxes, agents must stop immediately and hand the exact command to the user rather than seeking a bypass. Coordination is handled through a committed task board, ensuring no agent overwrites another's in-flight work.

Sources: AGENTS.md:65-94

Engineering Principles (SSOT & SOLID)

The project adheres to four primary engineering principles to maintain high-quality codebases.

1. SSOT (Single Source of Truth): One authoritative source per fact. The project enforces this by failing loudly when identity, config, or contracts are absent.
2. SOLID: Adherence to standard object-oriented design principles (SRP, OCP, LSP, ISP, DIP).
3. YAGNI (You Ain't Gonna Need It): No speculative parameters or dead branches; build only what is currently required.
4. DI / DIP (Dependency Injection): Business logic must depend on abstractions (protocols/interfaces) rather than hard-wired construction.

Sources: AGENTS.md:96-109

Technical Governance Implementation

The governance is not merely documentation but is enforced through the project structure and build system.

Quality Gates and Validation

The project utilizes a set of canonical make verbs—check, test, val, and docs—to enforce quality thresholds. These gates are integrated with tools defined in pyproject.toml, such as ruff, mypy, and pytest.

The flow above illustrates the mandatory validation chain required before any work is considered "Done" under Agent Law.

Sources: README.md:32-35, pyproject.toml:120-250

Strict Typing and Validation Logic

Code-level governance is reflected in the use of strict, most-restrictive typing and Pydantic-based validation. For example, in the LDAP stream configuration, connection parameters are strictly validated through models to prevent "guessing" or fallback behavior.

@staticmethod
def parse_connection_config(
    raw_value: t.JsonValue,
) -> m.TapLdap.LdapConnectionParams:
    """Validate LDAP connection payload through Pydantic."""
    try:
        parsed = m.TapLdap.LdapConnectionParams.model_validate(
            raw_value,
            strict=True,
        )
    except c.ValidationError as exc:
        msg = f"Invalid LDAP connection configuration: {exc}"
        raise ValueError(msg) from exc
    # ... implementation continues

Sources: src/flext_tap_ldap/streams.py:41-55, src/flext_tap_ldap/_utilities/_processor.py:200-215

Multi-Agent Execution Flow

When multiple agents interact with the repository, they must follow a sequence of state verification and lease management to avoid destructive history rewrites.

This sequence ensures that work is landed immediately after validation, following the "Fix-Forward-Only" mandate.

Sources: AGENTS.md:111-124

Summary

Agent Law and Project Governance in flext-tap-ldap establish a high-bar environment for both human and AI developers. By mandating root-cause fixes, strict typing, and objective evidence for completion, the project ensures that the LDAP directory integration remains stable, maintainable, and free of "acceptable legacy" defects. The reliance on SSOT and SOLID principles, combined with automated quality gates, creates a self-correcting development lifecycle.