Every command, explained.

Graft Aura onto the current Git repository: installs the hooks, registers the MCP server, and starts the file watcher. Commit, push and branch exactly as before.

Show the semantic state: logic nodes tracked, the active agent session, the latest checkpoint, and whether strict mode is on.

Manage global settings: telemetry consent, strict mode, dev mode, API keys.

Diagnose repo health: stuck sessions, orphaned snapshots, missing hooks, shadow-branch issues, and offer to fix them.

Generate a dense, token-optimized context block for cross-agent handoff: hand work from one agent to another without re-reading the repo.

Run the work-loop: agents claim unblocked tasks from the backlog, work them in dependency order, and prove each goal before it merges.

Lay a backlog out as a dependency graph and drive it: durable, team-visible, collision-aware tasks that survive the session.

Read the live awareness plane: who is editing or just committed which symbol, so parallel agents never collide.

Trace the logic paths in the AST graph and verify a behavioral goal: which paths are wired, partially wired, or missing.

Semantic review with risk scoring: catches logical renames, layer violations, forbidden calls, and accidental deletions an agent slipped in.

Post the semantic review back to the PR as AST-anchored inline comments, anchored to the exact symbol that changed.

Read the proof ledger: every goal, its runs, and the verdict tying each commit to the goal it was meant to deliver.

Surgically revert a single function or class to its last safe state at the AST level: zero merge conflicts, the good code untouched.

Trace any code back to its origin: git blame → checkpoint → agent session → conversation transcript. See exactly why it was written.

Ask the provenance-anchored memory for the reasoning behind a piece of code: code-grounded recall an agent can query before it edits.

Browse a human-readable directory of every symbol in the repo: files, functions and classes, with the meaning of each.

Pack the signed why-and-proof for a range of work into a portable bundle a teammate, reviewer or auditor can verify without your machine.

Bring a teammate's signed proof bundle into your repo and apply it at the AST level.

List and verify the cryptographically sealed genuine-records for the repo: provenance you can check, not take on trust.

What Aura is, and why it exists

The problem semantic version control solves, and what it does not try to be.

• Why Aura exists
• How Aura differs from Git
• The principles it is built on

Installing Aura and making your first save

Every platform, then a first repository with intent attached to the first commit.

• Installing on Linux
• Setting up your first repository
• Your first commit with intent

How semantic tracking works

What Aura records instead of line diffs, and how a function keeps its identity through a rename.

• How intent is tracked and checked
• Function-level identity
• What shadow branches hold

The commands, one page each

The long-form version of the reference above: every flag, every failure mode, worked examples.

• Proving a goal with aura prove
• Rewinding one function with aura rewind
• Tracing a change back to its reasoning

Merging at the AST level

How two agents editing one file merge without a text conflict, and where that stops working.

• Resolving a semantic conflict
• Deep-merging JSON and config
• The cases AST merge cannot handle

Running a team server

The Mothership: what it stores, how a teammate joins it, and what happens offline.

• How join tokens are secured
• Working with no server reachable
• Choosing a team topology

Keeping parallel agents off each other

Sentinel: collision detection, zone claims, and how agents pass each other messages.

• Detecting an agent collision
• Claiming a zone of the codebase
• Running several agents at once

Live sync, function by function

How a teammate’s change reaches you as a function rather than a file, and what is never sent.

• Impact alerts across branches
• Choosing what syncs
• What live sync sends and what it does not

Wiring Aura into your agents and tools

The MCP server, the coding agents that speak to it, and the CI and forge integrations.

• Using Aura with Claude Code
• Connecting a GitHub repository
• Running Aura in CI

Self-hosting, compliance and migration

Running Aura on your own infrastructure, including air-gapped, and moving an existing repo onto it.

• Deploying Aura yourself
• Installing with no internet
• Migrating an existing Git repository

Where Aura does not help

The honest limits chapter: the claims Aura does not make, and the projects it suits badly.

• When not to use Aura
• Why not CRDTs
• What migrating actually costs

Security and cryptographic design

The threat model, what is signed, where data lives, and how to report a vulnerability.

• How commits and records are signed
• Catching a secret before it lands
• Reading the audit trail