Governance policies, with the boundary made clear.

Rule. Controllers must not contain business logic.

Current boundary. The Decision Index can preserve and retrieve this policy, but the rule engine cannot reliably determine what constitutes business logic or follow data flow between layers.

@app.post("/checkout")
def checkout():
    # pricing logic
    # tax logic
    # inventory logic

Desired pattern. The controller stays thin and delegates pricing, tax, and inventory to a service.

# compliant - business logic lives in the service layer
@app.post("/checkout")
def checkout(cart: Cart):
    return checkout_service.place_order(cart)

Rule. Billing agent cannot modify the auth package.

Current boundary. Path applicability controls where a rule is evaluated. It is not an agent-identity or ownership ACL that authorizes one agent and denies another.

# AI agent edits
packages/auth/*

Desired pattern. The billing agent edits only its own package and consumes auth through its published interface.

# compliant - edits stay inside the owned package
packages/billing/*
# auth is imported, never modified
import { verifyToken } from "@org/auth";

Rule. Codegen agents cannot write directly to production migration folders.

Current boundary. Mneme does not yet enforce general agent-by-path mutation permissions. This requires identity-aware authorization semantics beyond path-scoped literal matching.

# Agent modifies
db/prod/migrations/*

Desired pattern. The agent writes proposed migrations to a staging directory; promotion to the production path is a human-gated step.

# compliant - agent writes to the reviewable staging path only
db/staging/migrations/*
# a maintainer promotes to db/prod/migrations/ after review

Rule. No raw SQL string concatenation.

Current boundary. Reliable detection requires syntax or data-flow analysis to distinguish unsafe construction from legitimate SQL. Exact literal matching is not equivalent to this security rule.

query = f"SELECT * FROM users WHERE id = {user_id}"

Desired pattern. The user input is bound as a parameter, never interpolated into the SQL string.

# compliant - parameterized query, no string interpolation
cursor.execute(
    "SELECT * FROM users WHERE id = %s",
    (user_id,),
)

Rule. No GPL dependencies.

Current boundary. Mneme does not resolve package-to-license metadata today. Teams can forbid specifically named packages, but cannot enforce the GPL license class generically.

// AI adds to package.json
"some-gpl-library": "^2.1.0"

Desired pattern. The dependency is swapped for an approved permissively-licensed (MIT or Apache-2.0) equivalent.

// compliant - MIT-licensed library from the approved list
"some-mit-library": "^3.0.0"

Rule. Internal APIs must version under /v1/.

Current boundary. This is a positive requirement: proving the required prefix is present. Today's prohibition-focused rule does not provide general absence detection.

@app.route("/users")

Desired pattern. The route is namespaced under the required /v1/ version prefix.

# compliant - versioned under /v1/
@app.route("/v1/users")

Rule. All services must emit OpenTelemetry traces.

Current boundary. This also requires proving that instrumentation is present. Mneme can preserve and retrieve the decision today, but cannot mechanically establish that every service emits traces.

# AI creates a new service with no tracing middleware
def create_app():
    app = FastAPI()
    return app

Desired pattern. The service is instrumented with OpenTelemetry before it is returned.

# compliant - emits OpenTelemetry traces
def create_app():
    app = FastAPI()
    FastAPIInstrumentor.instrument_app(app)
    return app