Current mechanical contract: exact, case-sensitive FORBID_LITERAL rules with optional path applicability.
Capability map · current release
Governance policies, with the boundary made clear.
Mneme's Decision Index can represent a broad set of organizational decisions. Its deterministic rule engine is intentionally narrower today. This page separates what is mechanically enforceable now from policies that require richer rule types.
How to read the cards. Each badge describes the example's present enforcement status. “Explicit modelling” means Mneme can enforce a deliberately named literal; it does not mean Mneme understands the policy semantically.
Enforced today
Direct literal prohibition
The literal is the whole policy. Naming the forbidden package is the rule.
01
Unauthorized framework introduction
Enforced today
Architecture governance
Rule React app standardized on Zustand. No Redux.
What Mneme can verify today. A FORBID_LITERAL rule can reject the exact redux import or package token, optionally limited to the relevant application paths.
The typed rule
FORBID_LITERAL "redux"
A change containing the exact, case-sensitive literal redux returns FAIL. Protection activation covers how a rule is validated and installed.
Agent output
import { createStore } from "redux";
Compliant pattern State management uses the approved library, Zustand.
Compliant
// compliant - uses the standardized Zustand store
import { create } from "zustand";
const useStore = create((set) => ({ count: 0 }));
Explicit modelling
Enforceable when named
A named literal stands in for the policy. Mneme enforces that literal, not the broader meaning.
02
Forbidden architecture patterns
Requires explicit modelling
Architecture governance
Rule Do not access BigQuery directly from frontend routes.
What Mneme can verify today. Forbid an explicit literal such as @google-cloud/bigquery or new BigQuery within frontend paths. Mneme does not infer “direct database access” as a semantic concept.
Agent output
// AI generates inside a Next.js API route
const client = new BigQuery();
Compliant pattern The frontend route calls a backend service over HTTP; only the backend holds the BigQuery client.
Compliant
// compliant - the route fetches from a backend endpoint, no DB client in the frontend
export async function GET() {
const res = await fetch(`${process.env.API_URL}/reports/summary`);
return Response.json(await res.json());
}
03
Prompt-level governance
Requires explicit modelling
Workflow governance
Rule Do not generate mock auth implementations.
What Mneme can verify today. Explicit phrases such as fake JWT can be forbidden at a supported prompt boundary. Mneme cannot recognize every possible mock authentication implementation by meaning alone.
User prompt
# User prompt
"Just create a quick fake JWT validator."
Compliant pattern The agent declines the mock and wires in the vetted auth library to verify real tokens.
Compliant
# compliant - real verification, no fake validator
from app.auth import verify_jwt
def authenticate(token: str) -> User:
return verify_jwt(token) # signature + expiry checked
04
ADR supersession violations
Requires explicit modelling
Dependency governance
Rule ADR-002: all async jobs use Pub/Sub. (Supersedes an older ADR that allowed Celery.)
What Mneme can verify today. Decision precedence and supersession select the active ADR. Preventing Celery still requires an explicit FORBID_LITERAL rule for its package or import.
Agent output
from celery import Celery
Compliant pattern Async work is dispatched through Pub/Sub, the decision that supersedes Celery.
Compliant
# compliant - ADR-002: publish to Pub/Sub instead of Celery
from google.cloud import pubsub_v1
publisher = pubsub_v1.PublisherClient()
publisher.publish(topic_path, payload)
05
Infra governance violations
Requires explicit modelling
Platform governance
Rule All infrastructure changes must use Terraform modules.
What Mneme can verify today. Known imperative commands such as gcloud compute instances create can be forbidden, optionally within relevant paths. Mneme cannot prove that every infrastructure change uses Terraform.
Agent output
gcloud compute instances create ...
Compliant pattern The instance is declared in a Terraform module and applied through the reviewed pipeline, not an imperative CLI call.
Compliant
# compliant - declarative Terraform, applied via CI
module "api_instance" {
source = "./modules/compute"
machine_type = "e2-standard-2"
}
Roadmap rule type
Represented, not yet proven
These decisions can be recorded and retrieved today. Mechanical detection needs a rule type that is not available yet.
06
Layer boundary violations
Needs structural analysis
Architecture governance
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.
Desired pattern The controller stays thin and delegates pricing, tax, and inventory to a service.
Desired
# compliant - business logic lives in the service layer
@app.post("/checkout")
def checkout(cart: Cart):
return checkout_service.place_order(cart)
07
Monorepo scope violations
Needs agent identity
Workflow governance
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.
Example
Agent output
# AI agent edits
packages/auth/*
Desired pattern The billing agent edits only its own package and consumes auth through its published interface.
Desired
# compliant - edits stay inside the owned package
packages/billing/*
# auth is imported, never modified
import { verifyToken } from "@org/auth";
08
Agent workflow violations
Needs agent identity
Workflow governance
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.
Example
Agent output
# 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.
Desired
# compliant - agent writes to the reviewable staging path only
db/staging/migrations/*
# a maintainer promotes to db/prod/migrations/ after review
09
Security policy violations
Needs syntax or data-flow analysis
Security governance
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.
Example
Agent output
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.
Desired
# compliant - parameterized query, no string interpolation
cursor.execute(
"SELECT * FROM users WHERE id = %s",
(user_id,),
)
10
Dependency licensing
Needs license metadata
Dependency governance
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.
Example
Agent output
// 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.
Desired
// compliant - MIT-licensed library from the approved list
"some-mit-library": "^3.0.0"
11
API contract violations
Needs required-presence rules
Platform governance
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.
Example
Agent output
@app.route("/users")
Desired pattern The route is namespaced under the required /v1/ version prefix.
Desired
# compliant - versioned under /v1/
@app.route("/v1/users")
12
Organizational consistency violations
Needs required-presence rules
Platform governance
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.
Example
Agent output
# 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.
Today: use exact, case-sensitive FORBID_LITERAL rules and optional include_paths/exclude_paths applicability for deterministic checks. Treat structural analysis, agent identity ACLs, license metadata, and required-presence rules as roadmap capabilities.
Mneme can represent more governance knowledge than its current typed-rule vocabulary can mechanically prove. Representation does not imply automatic detection.