The mneme command-line interface

$ pipx install "mneme-hq==0.9.0"
# Include the optional MCP runtime:
$ pipx install "mneme-hq[mcp]==0.9.0"

Installs the mneme entry point on your PATH. Scaffold a new corpus with mneme init; every other subcommand requires --memory pointing at a project_memory.json file. An example corpus ships at examples/project_memory.json.

From source (contributors): git clone https://github.com/MnemeHQ/mneme && cd mneme && pip install -e .

Creates the memory file (including its parent directory) containing a valid, empty decision corpus — deliberately zero seeded decisions, because every recorded decision is enforceable and sample content would create phantom rules. Exits non-zero without writing if the target file already exists, unless --force is supplied.

$ mneme init
Created .mneme/project_memory.json

Lists every decision in the corpus with id, summary, scope, and constraints. Read-only.

$ mneme list_decisions --memory examples/project_memory.json

Writes a new decision directly to the JSON file. The Pipeline runtime is never mutated — this is a file operation only. Fails with exit code 2 if the id already exists.

$ mneme add_decision --memory examples/project_memory.json \
    --id mneme_042 \
    --decision "Use JSON storage" \
    --scope storage \
    --constraint "no postgres" \
    --anti-pattern "sqlalchemy"

Useful for debugging which decisions are surfaced for a given task description before you wire enforcement into a workflow. Prints every decision ranked by score, plus the top-N context packet that would actually be injected.

$ mneme test_query --memory examples/project_memory.json \
    --query "should I add postgres?"

Reads an input file (a prompt, a generated diff, a draft), retrieves the relevant decisions for --query, and runs the enforcer. Prints any violations and exits with a code that reflects the verdict.

$ mneme check --memory examples/project_memory.json \
    --input draft.md \
    --query "working on storage layer" \
    --mode strict

Classifies every active decision in the corpus — Protected, Mneme-ready, Requires modelling, or Guidance — and reports the protection summary and per-decision detail. This is the classification surface mneme protect consumes; the tiers are frozen P1.2 semantics that activation never reinterprets.

$ mneme audit --memory .mneme/project_memory.json --repo-root .

Creates project state in setup mode: context and non-blocking checks only — never enforcement. Enabling protection is always a separate, explicit decision (mneme protect activate). Optionally records an opaque Architecture Audit setup reference, taken verbatim and resolved by Audit pairing.

$ mneme setup --memory .mneme/project_memory.json

Lists decisions that are active, currently unprotected, and canonically Mneme-ready. Already-Protected, Requires-modelling, Guidance, and superseded decisions are never candidates, and no model decides eligibility — the audit's frozen classification decides it.

$ mneme protect list --memory .mneme/project_memory.json

Shows one decision's canonical tier, guardrail, evidence, and whether the activation rule is installed — all derived from the repository, never stored.

$ mneme protect status <decision-id> --memory .mneme/project_memory.json

Deterministically validates a decision's proposed protection against the existing enforcement engine — without writing anything and without enabling protection. Four checks: prohibited input detected as a typed FAIL; permitted input not blocked; path applicability respected (canonical policy sources exempt); unrelated paths unaffected.

$ mneme protect validate <decision-id> --memory .mneme/project_memory.json

Activation is an explicit user action — the only command that installs enforcement. It appends the typed FORBID_LITERAL rule to that one decision's record in project memory (idempotent; refuses on any unsafe or unsupported state), then re-loads from disk and re-runs the canonical assessment. Only an independently observed Protected tier is reported as verified.

$ mneme protect activate <decision-id> --memory .mneme/project_memory.json

Starts the local server with proposal storage enabled. Add a schema-valid ADR directory when canonical decision reads are required. The server exposes proposal and read tools only; no MCP authority operation exists.

$ mneme decision-mcp
$ mneme decision-mcp --proposals .mneme/decision_proposals.json --adr-dir docs/adr

Requires mneme-hq[mcp]. Full tool, storage, error, and authority reference: MCP server.

$ mneme decision proposals
$ mneme decision show <proposal-id>
$ mneme decision accept <proposal-id> --memory .mneme/project_memory.json
$ mneme decision reject <proposal-id>

proposals and show are read-only. accept materializes a canonical decision into project memory but does not run Audit or activate protection. reject makes no project-memory change. All four default to .mneme/decision_proposals.json; accept also accepts --decision-id.

Full lifecycle, provenance, flags, exit codes, and known 0.9.0 limitations: Decision proposals.

Generates a Cursor-compatible rules file scoped to the supplied query. Writes the corpus into a format the Cursor agent reads directly, so the same decisions are surfaced to the IDE agent as to the rest of the toolchain. See the Cursor integration page for end-to-end setup.

$ mneme cursor generate --memory examples/project_memory.json \
    --query "working on storage layer" \
    --output .cursor/rules/mneme.mdc

Runs every scenario in the supplied directory against the decision corpus and prints a terminal report. Optional --json and --markdown flags emit machine- and human-readable reports for CI artifacts. Scenario categories map onto the governance violation hierarchy; the benchmark methodology is documented at /benchmark/.

$ mneme benchmark examples/benchmarks/ \
    --memory examples/project_memory.json \
    --json reports/bench.json \
    --markdown reports/bench.md

Parses every ADR markdown file in a directory (YAML frontmatter required), validates the corpus, resolves precedence, and writes compiled decisions into the target memory. Runs as a preview by default; nothing is written until --apply. Full walkthrough: ADR import guide.

$ mneme adr import docs/adr \
    --memory .mneme/project_memory.json \
    --dry-run
$ mneme adr import docs/adr \
    --memory .mneme/project_memory.json \
    --apply