Command reference

A friendly tour of the engram command line. Every command here is real — try engram <command> -h for the exact flags on any of them.

Most days you only need the four in the first section. Everything below that is there when you reach for it.

The store. Commands operate on your store at ~/.engram/store by default (or wherever $ENGRAM_STORE points). Pass --store <path> to any command to use a different one.

Everyday commands

These are the daily loop. If you learn only these, you have Engram.

engram init

One-command setup that checks its own work. Creates and locks down your store, writes a default config, and self-tests (index builds, integrity chain verifies, permissions are owner-only). Safe to re-run.

engram init

engram reindex

Rebuild the catalog that recall reads first. Run it after adding or editing pages.

engram reindex

engram ask "<question>"

Index-first recall. Ask in plain language; Engram returns the pages that answer, each cited with where it came from, and records that the pages were used.

engram ask "how did we handle the rate-limit retries"

engram lint

Health-check your store. Finds broken links (a reference to a page that does not exist), orphan pages (nothing links to them), and stale claims. Broken links are real defects; orphans are just a gentle heads-up.

engram lint

Recall, everywhere you code

engram mcp

Run the universal editor adapter. Speaks the Model Context Protocol over standard input/output, so one server plugs Engram into Claude Code, Codex, Gemini, Cursor, and more. You rarely run this by hand — your editor launches it for you. See Using it in your editor.

engram mcp

Integrity and trust

engram seal

Snapshot every page into the hash chain, recording that its current content existed at this moment. This is a provenance snapshot — proof of existence in time — not a claim that the content is correct.

engram seal

engram attest <page> --method <method> --evidence <pointer>

Vouch for a page's current content. Records who or what backs the page and by what method, bound to the page's exact text. Strong methods must point at evidence that actually resolves — you cannot self-assert trust:

• --method traced --evidence path/to/file.py:12 — a source line that exists.
• --method tested --evidence <test-id> — a registered test that currently passes.
• weaker methods (a human vouch, a cross-reference, a reasoned default) carry no pointer.

engram attest retry-backoff-policy --method traced --evidence app/webhooks.py:88

Run it with no page to instead check your whole store for pages whose trust claim no longer matches their current content:

engram attest

engram verify-chain [--against-anchor]

Prove the memory log is untampered. Recomputes the whole hash chain. With --against-anchor, it also checks against the externally anchored records — which catches a full malicious rewrite that plain hash-linkage alone cannot.

engram verify-chain --against-anchor

Growing your memory

engram digest <transcript> --project <name>

Distill a session transcript into a new linked page. This is what runs automatically at the end of a wired session; you can also run it by hand. --no-llm produces a deterministic outline with no API cost.

engram digest ./session.jsonl --project web-api --no-llm

engram idea "<one line>" --origin <who>

Record an idea or optimization with honest attribution — claude, maker, or joint. Speculative until it ships; mark it --status implemented --implements <ref> when it does.

engram idea "cache the index between reindexes" --origin claude

engram note <chain> "<text>"

Jot a quick note onto a typed note stream — proc (how-to), epi (experience), idea, or mile (milestone).

engram note epi "the flaky test was a clock-skew race, not our code"

engram atomize <page>

Split a sprawling page that covers many topics into small, focused pages, so narrow questions pull precise answers. The original becomes a small index of its atoms, and provenance is preserved.

engram atomize big-architecture-notes

engram suggest-links

Propose latent links between pages that are clearly about the same subject but do not yet link to each other. It only suggests — a link becomes real when you write it into a page.

engram suggest-links --backend auto

Sessions and coordination

Useful when several sessions (or several people) work in parallel.

engram sessions

Report session history — how long each ran, which ran at the same time, and the gaps between them.

engram sessions

engram work-list

Show what live sessions are touching right now, and flag contention — two open sessions working on the same area, so you can coordinate before you collide.

engram work-list

Related: engram work-claim / engram work-release mark a subsystem as claimed or freed, and engram work-auto syncs your claims to whatever your working tree is actually changing.

Backups and export

engram backup [--out <file>]

Write an encrypted snapshot of your store. A copy that leaves your machine is opaque without the key.

engram backup

engram restore <encrypted-file> <destination> reverses it.

engram export --okf <dir>

Export your store as an Open Knowledge Format bundle — the interoperable, standard Markdown format that other knowledge tools can read. Engram is a superset: the export conforms cleanly to the format, and your provenance and decay layers stay in the native store.

engram export --okf ./okf-bundle

Anchoring and the daemon

engram anchor

Seal a summary block over all your chains and anchor it to Bitcoin — an environment-independent timestamp of your memory's state. Use --no-stamp to seal locally without the network call. (The Bitcoin step needs an optional package; if it is missing, Engram tells you and seals locally anyway.)

engram anchor

engram anchor-status <root> reports the Bitcoin-attestation status of a given anchor.

engram daemon

Run the maintenance loop on a cadence — sealing blocks, running lint, rolling the daily anchor, and serving recall. Usually installed to run in the background for you by engram init; engram tick runs a single maintenance cycle by hand.

engram daemon

A few more

• engram telemetry [--report] — summarize Engram's own logged metrics (greps avoided, bytes saved, net of any LLM cost).
• engram session-start / session-end / session-catchup — the automatic hooks that surface memory at the start of a session and capture it at the end. You do not normally call these directly; your editor's hooks do.

Run engram with no arguments, or engram -h, for the built-in getting-started pointer and the full list.