Skip to content

Signed history (the DAG)

Every change you make in Altretta becomes a hash-linked, Ed25519-signed action in a DAG — an append-only, tamper-evident record of your knowledge.

When you write a note, rename it, link it, or remove it, Altretta's engine doesn't just update a file — it appends an action to a directed acyclic graph (DAG). Each action is chained to the ones before it by cryptographic hash and signed with your key. The result is a distributed-ledger-style history you can verify, but that lives entirely on your own machine, over your own Markdown files.

"DAG" just means the actions link backward to their predecessors, forming a graph that only ever grows forward — never a loop, never a rewrite. It's the same structure that makes a signed ledger tamper-evident.

How a change becomes a signed action

1

You edit

You save a note, move a file, add a link, or delete something. Ordinary work — nothing extra to do.

2

Altretta records an action

The change is captured as a discrete action: what changed, and a hash linking it to the previous action in the chain.

3

It's signed

The action is signed with an Ed25519 key. The signature covers the action and its link to history, so the whole chain is sealed together.

4

It's appended, never overwritten

The signed action is added to the tip of the DAG. Earlier actions are untouched — the past is immutable.

Why hash-linked and signed matters

Because each action includes the hash of the previous one, the history is a chain: change any past action and every hash after it stops matching, so tampering is immediately detectable. Because each action is signed, no one can forge a new entry or quietly rewrite an old one without the key.

This is exactly what a Git-based history can't promise. Git commits can be amended, rebased, squashed, or force-pushed — the log is mutable by design. Altretta's log is append-only and signed: the only way to change the record is to add a new, signed action to the end.

This is not a blockchain. There's no consensus network, no mining, and no token. It's a local, signed action log with built-in provenance — the integrity guarantees of a ledger without any of the overhead.

Removal is retraction, not erasure

This is a core principle of Altretta's engine: knowledge that goes away is retracted, not erased.

Three distinct things happen when you delete a note, and it's worth keeping them apart:

  • The file is moved into the vault's own .trash/ folder, keeping its original path. It is still on disk and still recoverable — it is simply no longer part of the indexed vault.
  • The facts it contributed to the semantic graph are retracted with signed actions on the next indexing pass. The retraction is a new entry in the chain, not a hole in it.
  • The history of what that note said is untouched. Anything that cited it keeps its provenance.

That means a removal is an accountable, signed event: you can prove when and that it happened.

Incremental re-ingestion works the same way: new content supersedes old content with a fresh signed action rather than deleting the previous state.

Two things do genuinely remove data, and the docs would be dishonest not to name them. Note version history is capped — past the cap, the oldest version's bytes are discarded (a record of the discard is kept; the text is not). See Time-travel. And a connected AI granted write access has tools that delete graph facts or prune history outright; both are refused under the default read-only access level. See the MCP tool reference.

Inspecting the chain

Altretta exposes the signed DAG to your connected AI and tools over MCP, so you (or your assistant) can query the history directly:

  • aingle_dag_history — walk the recorded actions.
  • aingle_dag_chain — follow the hash-linked chain from an action.
  • aingle_dag_tips — see the current tips (latest actions) of the DAG.
  • aingle_dag_stats — summary statistics about the action history.

When you ingest a code repository, the git provenance of that ingest is recorded into the signed DAG too — so even imported knowledge carries a verifiable record of where it came from and when it entered your vault.

Next

Verifiable knowledge

Back to the verifiable section overview.

Activity log & revert

Because AI edits are signed DAG actions, any one can be reverted in a click.

Ingest a code repository

How imported code carries its git provenance into the signed DAG.

The semantic graph

The graph these signed actions build up over time.

MCP tools reference

The aingle_dag_* tools for querying the chain.

Glossary

DAG, hash-link, tombstone, Ed25519 — defined.

Previous
Overview
Next
Provenance & proofs