Reasoning becomes accountable.

ClisTa is not where reasoning happens. ClisTa is where reasoning becomes accountable. A normal decision system records approved / rejected. ClisTa records the shape that made the decision accountable: the evidence carried in, the assumptions that shaped it, the objections that survived approval, minority reports, authority trails, provenance, bounded scope, and verification state.

The operating law is one line: Conversation is input. Reasoning state is output. Anyone holding the append-only event log can reconstruct the decision shape deterministically — no privileged server, no trusted memory.

Events in, accountable state out.

State is never written directly. It is projected from an append-only log and then verified. The pipeline is fixed:

conversation → event log → projection → verification → accountable state

Append-only event log

The log is the single source of truth — verifiable history, not just readable data. A clean-room replay re-ingests the session and must produce a record byte-identical to the committed log. Determinism is the floor.

Projection

The reasoning state is reconstructed from events alone — decision, answer, scope, evidence, claims, surviving objections, governance reviews, minority reports. Re-run it anywhere and you get the same state.

Verification

Every capability is a command that fails closed. Green never means endorsement. Each verifier keeps trusted: false until something outside the protocol grants trust.

Report verification

Chain verification proves the log is true; it says nothing about whether prose about the log is true. So reports follow the protocol too: a sealed report is the thread's final event, structured as claims-with-citations — every claim carries the hash of the event(s) that witnessed it, and a claim that cannot cite a witness is deleted. report verify checks three things mechanically: the chain verifies, every cited hash exists, and no claim lacks a citation. A report becomes verifiable without being read.

The primitives the protocol governs.

Set in letterspaced caps in prose; carried as fields and IDs in mono.

Claim

An assertion entered into the decision, attributable to a participant and event-time authority.

Objection

A challenge to a claim. It can survive an approval — recorded, not resolved away.

Severity

The weight a verifier or reviewer assigns to an objection or risk.

Evidence

An item carried into the decision, bound to a source whose lineage is auditable.

Authority

The boundary that routes governance reviews without turning them into approval.

Provenance

The source lineage and transformation of each contribution. Provenance is not truth ranking.

Minority report

A dissent preserved alongside the decision, never overwritten by it.

Verification

The fail-closed check that a boundary holds. Success is not trust; trust is granted outside the protocol.

Precedent

A prior conclusion reused by citation — original execution ID, context hash, age — re-grounded against the live query. Reusing a prior justification as fresh reasoning is fabrication; the protocol calls it ventriloquism and types against it (PrecedentReference).

Sealed report

The thread's final event: claims-with-citations as structure, prose as rendering. Verifiable without being read (SealedReport).

Gate rejection

A refused append, witnessed. Gates record their refusals (GateRejectionRecorded) — silence is a first-class defect, and anything that shapes an output emits a typed event.

Eighteen layers, each verifying one boundary.

Each capability is a command that proves a single thing and fails closed. Six are shown; the spine has eighteen.

+ 12 more layers

Defined by what it is not.

• Provenance is not truth ranking. Learning is not reputation. Review is not approval.
• Continuity is not transcript replay — a successor resumes settled state, it does not re-read the conversation.
• Export is not trust or approval. Release is not attestation.
• A documented resumeStatus: "degraded" is a boundary reached, not a broken install.
• Verification proves the record; adversarial challenge pressures the content. A wrong number, perfectly witnessed, is still wrong — the maker–checker loop is what catches it, and the architecture requires both.
• The home is one monorepo — protocol, ThreadHub notary, and the app.clista.ai cockpit (lati-cooki/clista). The chain proves what was recorded and when, never that the decision was good.

Clone and replay.

The fastest way to understand the protocol is to reproduce the bundled scenario in a clean room.

Or verify a real sealed run with no dependencies at all: the fraud-threshold reference run re-verifies with python3 gate.py verify, and the case study walks the full evidence chain it belongs to.

Then explore the command surface on cli.clista.ai, or climb the on-ramps on learn.clista.ai.