--- url: /mimus/tutorials/first-run.md --- # Tutorial: your first audit Goal: point mimus at a repo's docs and see which claims are still true — docs-as-tests, in minutes. ## 1. Init ```sh cd your-repo mimus init ``` Writes a commented `mimus.toml` and a `rules/` dir. Defaults: ```toml [sources] docs = ["README.md", "docs/**/*.md", "AGENTS.md", "project/**/*.md"] comments = true cards = ".kuda/modules/*.yaml" [check] mechanical = true semantic = false ``` ## 2. Check ```sh mimus check ``` Claim extraction scans every configured doc: backticked paths, shell commands, symbol names, counts, links. Each claim is verified against reality — the filesystem, PATH, the kuda index (symbol claims need `kuda sync`; without an index they're silence, not failures): ``` README.md:42 [error] `src/old_api.rs` — ./src/old_api.rs does not exist docs/guide.md:17 [warn] `cargo bench` — binary `cargo-bench` not found in PATH 2 violation(s) ``` Exit code is `1` on any `error`-severity violation — docs drift becomes a gateable signal. ## 3. Make a claim and watch it get caught Add a line to your README referencing a file that does not exist: ```md See `nonexistent/dead.rs` for the implementation. ``` ```sh mimus check ``` ``` README.md:N [error] `nonexistent/dead.rs` — ./nonexistent/dead.rs does not exist ``` Every violation is claim + evidence + (when mechanical) a fix — the evidence bar is the design rule, see [architecture](../explanation/architecture.md). ## 4. Author a convention `rules/` is data. Add `rules/no-todos.toml`: ```toml name = "no-todos" message = "TODO left in committed source" severity = "warn" files = "src/**/*.rs" [match] kind = "source-pattern" pattern = "TODO|FIXME" ``` `mimus check` now flags every TODO — a convention encoded as a file, not a code change. See [authoring rules](../how-to/rules-authoring.md). ## 5. Audit the memory layer If the repo is kuda-indexed: ```sh kuda sync && mimus audit ``` ``` fresh kuda-store drifted kuda-core 20 fresh, 1 drifted, 0 contradicted ``` Cards whose `verify:` files changed since sync report `drifted`; missing files report `contradicted`. ## You have built A falsification layer: every factual claim in your docs is now a test that fails loudly when reality moves. Next: [gate CI on it](../how-to/ci-gate.md), [write rules](../how-to/rules-authoring.md). --- --- url: /mimus/how-to/multi-repo.md --- # How-to: multi-repo checking Docs in one repo make claims about sibling repos — moved crates, `see ../`, cross-repo commands. mimus verifies those claims where it can reach reality. ## Per-repo config Each repo keeps its own `mimus.toml` and `rules/` — conventions are repo-scoped (a rule that is right for `platform` is noise in `lsp`). Run `mimus check` per repo, or script the sweep: ```sh for r in ~/GitHub/handl-lang/*/; do [ -f "$r/mimus.toml" ] && (cd "$r" && mimus check) done ``` ## Cross-repo claims today * **Paths** are resolved relative to the repo root — a ../sibling/crate claim in docs verifies if the sibling exists. * **Commands** check PATH, which is host-global — a doc telling users to run `hnl` is verified wherever `hnl` is installed. * **Symbols** need a kuda index per repo; the `symbol` checker reads `.kuda/index.sqlite` of the *current* root. Cross-repo symbol resolution rides on kuda workspace mode. ## Rules at scale Keep org-wide conventions in one place and symlink or vendor them per repo — a shared rules/org/ directory fetched in CI works today; first-class rule inheritance is a backlog item. ## Where it goes next `kuda sync --workspace` produces per-root indexes across the sibling set; the `symbol` checker then resolves claims like `` `hnl` lives in the cli repo`` against the merged stores — the "which repo owns this" question becomes verifiable. --- --- url: /mimus/how-to/kuda-audit.md --- # How-to: audit kuda memory `mimus audit` is the falsifier for the memory layer: it verifies every `.kuda/modules/*.yaml` card against source — memory audited, not just generated. ## Run ```sh kuda sync # (re)generate the index first mimus audit ``` ``` fresh kuda-store fresh kuda-core drifted kuda-cli 20 fresh, 1 drifted, 0 contradicted ``` ## Scores | score | meaning | | -------------- | ---------------------------------------------------- | | `fresh` | every `provenance.files` hash still matches | | `drifted` | a verify file's content changed since sync | | `contradicted` | a provenance file no longer exists | Audit recomputes git `hash-object` per `provenance.files` entry and compares with what the card recorded at sync time — the same provenance model `kuda status` uses, checked from the outside. ## Exit semantics Audit is report-tier: exit `0` even with contradictions. It is diagnosis, not a gate — pair it with `mimus check` if you want drift to fail CI, or keep it in a scheduled report job. The fix is upstream anyway: `kuda sync`, not a hand-edit. ## What it does not check (yet) Audit verifies *freshness* (provenance hashes), not *accuracy* of the card's prose fields — `api`/`deps` drift beyond their recorded inputs, or a hand-written `notes:` that has gone stale, is the semantic tier's job when it lands. --- --- url: /mimus/how-to/rules-authoring.md --- # How-to: author rules Conventions live in `rules/*.toml` — data, not code. A new rule is a new file; the engine vocabulary stays fixed. Rules run in `mimus check` alongside the claim checkers. ## The format ```toml name = "no-positional-dispatch" message = "dispatch via lang.eval roles — never kind == shape checks" severity = "error" # error (gates check) | warn (report only) files = "crates/plugin-engine-*/src/**/*.rs" [match] kind = "source-pattern" pattern = 'kind\s*==\s*"(assign|block|paren|return)"' ``` | field | meaning | | ---------- | -------------------------------------------------- | | `name` | identifier — shown in output + rules listing | | `message` | the *evidence* attached to each finding | | `severity` | `error` fails `mimus check`; `warn` reports | | `files` | glob under the repo root | | `[match]` | `kind = "source-pattern"` + a regex | ## Semantics Every line matching `pattern` in every file matching `files` becomes a `Behavior` violation carrying `message` as evidence. Lines are matched individually — craft patterns for what a single line can express. ## The evidence bar applies to rules too A rule that cannot cite a specific line emits nothing — there is no "file smells wrong" rule kind. And an invalid regex is not a finding either: it is silence plus a `mimus doctor` complaint. If your rule keeps flagging real code, the rule is wrong — narrow the `files` glob or the pattern. ## Examples Ban a deprecated API in a bound region: ```toml [match] kind = "source-pattern" pattern = '\bold_api::' ``` `files = "crates/**/src/**/*.rs"` — one file, one convention, reviewable in PRs like code. Require README badges? That is a *presence* check — not what `source-pattern` does; absence-of-pattern rules are a planned `kind`, deliberately out until the evidence story is right. ## Verify ```sh mimus check # runs rules + claim checkers mimus report --format json | jq '.[] | select(.claim.kind=="behavior")' ``` --- --- url: /mimus/how-to/ci-gate.md --- # How-to: gate CI on docs `mimus check` is the mechanical tier — deterministic, offline, safe to gate. Exit `1` when any `error`-severity violation exists. ## The gate ```sh mimus check ``` Wire it like a test: run in CI on every PR. Doc paths, commands, symbols and your `rules/*.toml` conventions all gate the same way. ## `--no-cmd` — never execute anything The `cmd` checker verifies documented commands exist on PATH — it does **not** run them. But if you want to be explicit that a job runs nothing executable: ```sh mimus check --no-cmd ``` `--no-cmd` skips the command checker entirely; path/symbol/rules checks still run. ## Severity is the gate boundary * `error` — mechanical, reproducible: dead paths, missing binaries, rule violations marked `severity = "error"`. * `warn` — env-dependent or heuristic: shown in output and `--format json`, never fails the run. Tune per rule in `rules/*.toml` (`severity = "warn"`). ## Report for humans ```sh mimus report # always exits 0 — full list mimus check --format json # machine-readable for tooling ``` `report` is the audit-view command: same violations, never a gate. `reconcile`-style tooling consumes the JSON. ## Recommended setup ```yaml # whatever your CI is - run: mimus check --no-cmd ``` Docs that can drift silently are docs that will. One line keeps them honest. ### Gating only new drift (large backlogs) `mimus check --diff ` runs the same checkers but only over claims in files matching `git diff --name-only ` — PR checks fail on *new* drift while the existing backlog is paid down: ```yaml - run: mimus check --diff "origin/${{ github.base_ref }}...HEAD" ``` `--diff` needs a git checkout — outside a repo it exits 2. See [claims & tiers](../explanation/claims.md) for why the semantic tier can never be this gate. --- --- url: /mimus/reference/cli.md --- # Command-Line Help for `mimus` This document contains the help content for the `mimus` command-line program. **Command Overview:** * [`mimus`↴](#mimus) * [`mimus init`↴](#mimus-init) * [`mimus check`↴](#mimus-check) * [`mimus fix`↴](#mimus-fix) * [`mimus audit`↴](#mimus-audit) * [`mimus report`↴](#mimus-report) * [`mimus doctor`↴](#mimus-doctor) * [`mimus coverage`↴](#mimus-coverage) * [`mimus claims`↴](#mimus-claims) ## `mimus` Spots the cuckoo eggs in your repo — claim verification: docs-as-tests, memory audit **Usage:** `mimus [OPTIONS] ` ###### **Subcommands:** * `init` — Detect sources -> mimus.toml + rules/ scaffold * `check` — Verify claims. Mechanical tier by default * `fix` — Apply mechanical rewrites for confirmed violations * `audit` — Trust-score .kuda/ cards vs source * `report` — Full violations list with evidence * `doctor` — Checker/config/kuda-index health * `coverage` — Doc coverage — which indexed symbols no doc ever names. The reverse direction of `check`: code has it, docs silent * `claims` — Dump extracted claims (kind/source/line) — tuning aid for the extractor's precision on real docs ###### **Options:** * `--config ` — Config path (else $MIMUS_CONFIG, ./mimus.toml, ~/.config/mimus/mimus.toml) * `--format ` — Output format: human | json Default value: `human` ## `mimus init` Detect sources -> mimus.toml + rules/ scaffold **Usage:** `mimus init` ## `mimus check` Verify claims. Mechanical tier by default **Usage:** `mimus check [OPTIONS]` ###### **Options:** * `--all` — Include the semantic tier (advisory only, never gates) * `--no-cmd` — Skip command claims — the PATH probe is machine-dependent * `--diff ` — Only check claims in files matching `git diff` SPEC — e.g. `--diff origin/main...HEAD` gates a PR on new drift ## `mimus fix` Apply mechanical rewrites for confirmed violations **Usage:** `mimus fix [OPTIONS]` ###### **Options:** * `--dry` — Show the plan, write nothing * `--semantic` — Agentic tier: agent proposes corrected claim text for semantic (REFUTED) findings. Needs \[check].acp_cmd ## `mimus audit` Trust-score .kuda/ cards vs source **Usage:** `mimus audit` ## `mimus report` Full violations list with evidence **Usage:** `mimus report` ## `mimus doctor` Checker/config/kuda-index health **Usage:** `mimus doctor` ## `mimus coverage` Doc coverage — which indexed symbols no doc ever names. The reverse direction of `check`: code has it, docs silent **Usage:** `mimus coverage` ## `mimus claims` Dump extracted claims (kind/source/line) — tuning aid for the extractor's precision on real docs **Usage:** `mimus claims [OPTIONS]` ###### **Options:** * `--all` — Include card-prose Behavior claims too This document was generated automatically by clap-markdown. --- --- url: /mimus/reference/config.md --- # Config — `mimus.toml` ## Top level | field | type | required | notes | |---|---|---|---| | `sources` | `SourcesCfg` | optional | — | | `check` | `CheckCfg` | optional | — | | `rules` | `RulesCfg` | optional | — | | `report` | `ReportCfg` | optional | — | ## `[sources]` | field | type | required | notes | |---|---|---|---| | `docs` | `list` | optional | Doc glob patterns mined for claims. | | `comments` | `bool` | optional | Extract claims from code comments too. | | `cards` | `string` | optional | Glob for memory cards to audit (empty = skip). | ## `[check]` | field | type | required | notes | |---|---|---|---| | `mechanical` | `bool` | optional | Mechanical tier — deterministic, CI-gateable. | | `semantic` | `bool` | optional | Semantic tier — advisory only, can never gate. | | `kuda_index` | `path` | optional | kuda index path for the symbol checker. | | `acp_cmd` | `string` | optional | ACP agent command for the semantic checker (e.g. "cline --acp"). Semantic tier is advisory only. | | `base_dirs` | `Vec` | optional | Extra repo-relative roots path claims resolve against — for docs that reference paths relative to a component root (e.g. "infrastructure/postgres"). | | `kinds` | `Vec` | optional | Only check claims of these kinds (empty = all). | | `ignore_prefixes` | `list` | optional | Skip claims whose text starts with any of these prefixes. | | `binaries` | `list` | optional | Tool prerequisites the repo declares — commands invoking these skip the PATH probe (docs may legitimately require tools the checker's machine lacks). | ## `[rules]` | field | type | required | notes | |---|---|---|---| | `dir` | `path` | optional | Dir of \*.toml rule files. | | `strict` | `bool` | optional | Rule violations also fail `check` (not just report). | ## `[report]` | field | type | required | notes | |---|---|---|---| | `format` | `string` | optional | "human" | "json". | | `min_confidence` | `string` | optional | Suppress low-evidence findings ("high" | "all"). | ## Constraints * `queue = "all"` rejects `cancel_running = true` at load — killing a run would silently drop a promised commit. * `runner.kind` and `trigger.kind`/`status.kind` resolve to impl crates; unknown kinds fail at `mimus doctor`/startup. * `deny_unknown_fields`: typos in field names fail the load. --- --- url: /mimus/reference/violations.md --- # Reference: violation format `mimus check --format json` (and `mimus report --format json`) emit a JSON array of violations — the contract anything consuming mimus output (reconcile, CI annotations, dashboards) should code against. ## Shape ```json [ { "claim": { "kind": "path", "text": "crates/old-crate/src/lib.rs", "source": "docs/guide.md", "line": 17 }, "evidence": "./crates/old-crate/src/lib.rs does not exist", "fix": "remove the reference, or restore the file", "severity": "error" } ] ``` ## Fields | field | meaning | | ----------------- | -------------------------------------------------- | | `claim.kind` | `path` `command` `symbol` `count` `link` `behavior` | | `claim.text` | the claim as written in the source | | `claim.source` | file the claim was extracted from | | `claim.line` | 1-based line number | | `evidence` | what reality says instead — the proof | | `fix` | suggested correction, or `null` | | `severity` | `error` (gates `check`) | `warn` (report only) | ## Human format Default output is one line per violation: ``` docs/guide.md:17 [error] `crates/old-crate/src/lib.rs` — ./crates/old-crate/src/lib.rs does not exist N violation(s) ``` `source:line [severity] `claim` — evidence` — stable enough to grep, intended for terminals not parsers. ## Exit codes | code | meaning | | ---- | ----------------------------------------------- | | 0 | clean — or `report`, which never gates | | 1 | `error`-severity violation(s), or usage failure | `audit` always exits 0 — its scores are report-tier. ## What is silence, not a violation mimus's rule is evidence-or-silence: a claim a checker cannot prove false emits nothing. Concretely, none of these produce a violation: * `/leading-slash` spans — read as URL routes or host-absolute paths, never repo-relative claims * `a/b`-shaped misses (`application/pdf`, `tools/list`) — two lowercase-word segments read as MIME types / RPC methods * `VAR=value` env assignments, `...`-/brace-/`<>`-template spans, bare extensions (`.md`), serial placeholders (`adr-mkt-0N.md`) * `~`- and `$`-prefixed paths, and globs verified by expansion * command claims whose binary is declared in `[check].binaries`, or all command claims under `--no-cmd` ## Tuning and suppression * `[check].kinds` / `[check].ignore_prefixes` / `base_dirs` — see [config](config.md) * `` — alone on a line, suppresses the next line's claims; inline, suppresses its own line. `` skips the whole file. * the `cmd` checker probes the machine's PATH — results vary across machines by design (missing binary = `warn`, never `error`). Declare prerequisites in `[check].binaries`, or run `check --no-cmd`. --- --- url: /mimus/reference/crate-api.md --- # Crate API Rustdoc for every workspace crate — public APIs are documented at source (doc comments). * [mimus-core](/mimus/api/mimus_core/index.html) — domain * [mimus-config](/mimus/api/mimus_config/index.html) — port * [mimus-secret](/mimus/api/mimus_secret/index.html) — port * [mimus-vcs](/mimus/api/mimus_vcs/index.html) — port * [mimus-check](/mimus/api/mimus_check/index.html) — impl * [mimus-check-acp](/mimus/api/mimus_check_acp/index.html) — impl * [mimus-check-cmd](/mimus/api/mimus_check_cmd/index.html) — impl * [mimus-check-fs](/mimus/api/mimus_check_fs/index.html) — impl * [mimus-check-symbol](/mimus/api/mimus_check_symbol/index.html) — impl * [mimus-claims](/mimus/api/mimus_claims/index.html) — impl * [mimus-config-toml](/mimus/api/mimus_config_toml/index.html) — impl * [mimus-dotenv](/mimus/api/mimus_dotenv/index.html) — impl * [mimus-git](/mimus/api/mimus_git/index.html) — impl * [mimus-keyring](/mimus/api/mimus_keyring/index.html) — impl * [mimus-rules](/mimus/api/mimus_rules/index.html) — impl * [mimus](/mimus/api/mimus/index.html) — binary --- --- url: /mimus/explanation/architecture.md --- # Explanation: architecture mimus is the falsification half of the ecosystem: *"every claim in your docs, comments, and memory — still true?"* It exists because memory without doubt decays into confident confabulation. ## The pipeline ``` sources ──► extract ──► classify ──► verify ──► emit │ │ │ │ │ docs/*.md claims kinds: checkers: human | comments +lines path… fs cmd json .kuda/ behavior symbol exit 1 cards rules ``` **Extract** pulls claim candidates (backticked spans, code blocks, prose patterns) with source+line. **Classify** sorts them into the taxonomy — conservatively: a span that might be a command but isn't in the binary allowlist is *not* a command claim. **Verify** runs the mechanical checkers plus `rules/*.toml`. **Emit** reports violations — or exits 1 to gate CI. ## Ports and adapters `mimus-core` holds domain types only (`Claim`, `Violation`, `TrustScore`, config). Every concern is a trait crate + adapter crates: * `mimus-check` (the checker port) → `mimus-check-fs`, `mimus-check-cmd`, `mimus-check-symbol` (against kuda's index) * claim sources: markdown today, comments/cards wired in config * `mimus-rules` — conventions as `rules/*.toml` data * `mimus-vcs`→`mimus-git`, `mimus-config`→`mimus-config-toml`, `mimus-secret`→`mimus-keyring`/`mimus-dotenv` A new checker = new adapter crate; a new convention = a new rule file. ## The evidence bar A violation is claim + evidence + suggested fix. No evidence, no finding — false positives kill a critic faster than false negatives. The semantic tier can never gate CI: it reports, a human adjudicates. Style opinions are never emitted at all. ## Position in the ecosystem * `kuda` builds the index; `mimus` doubts it — `audit` trust-scores cards against source via provenance hashes. * `reconcile` (planned third tool) auto-fixes what mimus confirms: claims rewritten to match reality — it consumes the JSON violation contract, not the checkers. See [claims & tiers](claims.md) for the taxonomy and why the two tiers can never merge. --- --- url: /mimus/explanation/claims.md --- # Explanation: claims, tiers, and the evidence bar mimus is built on one observation: documentation is full of *claims* — statements that are either still true or quietly false. A critic's job is to enumerate them and prove each one, or stay silent. ## Claim taxonomy Extraction classifies backticked spans, code blocks and prose patterns into: | kind | example claim | verified by | | --------- | ------------------------------------ | -------------------------- | | `path` | `` `src/lib.rs` `` | filesystem | | `command` | `` `cargo test -p foo` `` | binary on PATH (no exec) | | `symbol` | `` `IndexStore` `` | kuda index (symbol checker)| | `count` | "357 suites / 4,298 tests" | recomputation | | `link` | `[docs](https://…)` | link checker | | `behavior`| prose asserting code does X | rules + semantic tier | Command claims are conservative by design: only spans whose first token is a known binary (`cargo`, `git`, `npm`, `dagger`, `kuda`, `mimus`, …) classify as commands — otherwise `pub fn` and `data Eq` get read as shell. ## Verification tiers * **Mechanical** — deterministic and offline: paths, commands, rules. This is the `mimus check` gate; if it flags something, the evidence is reproducible by anyone. * **Semantic** — advisory: the `acp` checker spawns an ACP agent (`acp_cmd`, e.g. `env CLINE_PROVIDER=cline-pass CLINE_MODEL=cline-free/mimo-v2.6-flash cline --acp` — provider/model are env vars; -P/-m flags are ignored in ACP mode) to verify `behavior` claims — including kuda card prose. Runs with `--all` or `[check].semantic`; every finding is `warn` + evidence. **Can never gate** — that is load-bearing, not a limitation. Claims fold into one prompt per batch, and each prompt is debounced — polite to the provider. Style opinions are never emitted at all. ## The evidence bar Every violation is `claim + evidence + fix(optional)`. If a checker cannot cite its proof, it emits nothing — false positives kill a critic faster than false negatives ever could. This is why `command` has an allowlist, why a bad rule regex is silence + a doctor complaint, and why the semantic tier exists separately from the gate. ## Sources `[sources]` in `mimus.toml`: `docs` (glob list), `comments` (code comments — TODOs, claims in `///`), and `cards` — the kuda artifacts get audited as claims too, closing the loop: kuda remembers, mimus doubts, even about the memory itself. --- --- url: /mimus/explanation/release-model.md --- # The release model mimus releases itself — there is no hosted CI and no release tool in the loop. Two deliberate phases: ## Phase 1 — the explicit seed `mimus deploy release` runs once, by hand: it reads cargo metadata, topologically orders the workspace's path-dependency graph, `cargo publish`es every member, tags `{repo}-v{version}`, and pushes the tag. Why explicit? Publishing is the **only irreversible step** in the whole system. Queues, runs, and statuses are all idempotent and local; a crate version on crates.io is forever. Everything else in mimus fires on push — the seed doesn't. (`--dry-run` prints the order and tag without touching anything.) ## Phase 2 — push-driven forever after From then on a release is *just another mimus job*: a push to `main` hits the webhook, queues latest-wins, and runs `scripts/release.sh` in a detached worktree under the shell runner. The script: 1. diffs crate paths since the last `mimus-v*` tag 2. `cargo set-version --bump patch` on touched crates only (the cli republishes on any change — it's the install artifact) 3. `cargo publish`es them in dep order 4. tags `mimus-vX.Y.Z`, builds host-arch binaries with `cargo dist`, uploads to a GitHub Release via `gh` The 5-minute sleep at the top isn't a hack — it's the debounce window. Combined with `queue = "latest"` + `cancel_running`, rapid push bursts collapse to one release of the newest sha; killed runs get an honest "cancelled" status. ## Why this shape * **No release-plz / GHA**: the point of the project is that CI is a local loop — depending on hosted CI to ship it would be self-defeating. `scripts/release.sh` is deliberately boring bash so it can run as a plain `cmd` under `runner.kind = "shell"`. * **Latest-wins, not `all`**: a release that misses an intermediate push loses nothing — the tag lands on HEAD, which contains everything. `queue = "all"` is for pipelines where each sha's run is individually meaningful. * **Explicit over automatic**: a wrong tag or half-published workspace is far worse than a delayed release; the boundary sits exactly at irreversibility. Host prerequisites: `cargo-edit`, `cargo-dist`, `gh`, and `CARGO_REGISTRY_TOKEN` (env → keyring → env file). Multi-arch binaries arrive when the remote-runner pair lands — see TODO. --- --- url: /mimus/comparison.md --- # mimus vs the alternatives ## vs linters | | linters | mimus | | ------------------- | -------------------- | ----------------------------- | | checks | code shape | claims about reality | | docs | mostly ignored | first-class source | | output | style/correctness | claim + evidence + fix | | rules | per-language config | `rules/*.toml`, evidence-bound| They complement each other — a linter says the code is shaped right; mimus says the docs tell the truth. ## vs LLM doc review | | "review the docs" prompt | mimus | | ------------------- | ------------------------ | -------------------------- | | coverage | broad, vague | only what's checkable | | false positives | high | evidence-or-silence | | CI gate | unsafe | mechanical tier is safe | | cost | per-run | mechanical tier is free | The LLM still has a role — as the `check-llm` adapter for the semantic tier, where findings are advisory by design. ## vs doctest-style tools | | doctests/link-checkers | mimus | | ------------------- | ---------------------- | ----------------------------- | | scope | code blocks only | all factual prose | | claim types | one or two | path/cmd/symbol/count/link | | memory audit | n/a | `.kuda/` card trust scores | --- --- url: /mimus/getting-started.md --- # Getting started Pick by what you need to do. * **Tutorials** (learn): [first-run](tutorials/first-run.md) * **How-to** (tasks): [memory audit](how-to/kuda-audit.md) · [rules authoring](how-to/rules-authoring.md) * **Reference** (lookup): [cli](reference/cli.md) · [config](reference/config.md) · [crate api](reference/crate-api.md) * **Explanation** (why): [architecture](explanation/architecture.md) · [release model](explanation/release-model.md) · [comparison](comparison.md) — vs linters / LLM review Install: ```sh cargo install --git https://github.com/9aia/mimus mimus ``` First check: ```sh cd your-repo mimus init # detect claim sources -> mimus.toml + rules/ mimus check # mechanical tier: paths, commands, symbols mimus report # violations with claim + evidence + fix ``` `symbol` claims, `audit`, and `coverage` need a [kuda](https://github.com/9aia/kuda) index (`kuda sync`) — without one, the mechanical tier is paths + commands + rules. --- --- url: /mimus/public/api/static.files/SourceSerif4-LICENSE-a2cfd9d5.md --- Copyright 2014-2021 Adobe (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe in the United States and/or other countries. Copyright 2014 - 2023 Adobe (http://www.adobe.com/), with Reserved Font Name ‘Source’. All Rights Reserved. Source is a trademark of Adobe in the United States and/or other countries. This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL *** ## SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 PREAMBLE The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. DEFINITIONS "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. "Reserved Font Name" refers to any names specified as such after the copyright statement(s). "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. PERMISSION & CONDITIONS Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 1. Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 2. Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 3. No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 4. The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 5. The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. TERMINATION This license becomes null and void if any of the above conditions are not met. DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.