DigiEmu Core

CORE / DETERMINISTIC KNOWLEDGE INFRASTRUCTURE

DigiEmu Core provides a deterministic snapshot and verification layer for knowledge states. It is designed so that relevant state can be reconstructed, replayed and independently verified instead of being trusted only as a log or post-hoc explanation.

v1.0.0 BASELINEGOPUBLIC REPOSITORYBSL 1.1

View source on GitHub ↗Quickstart →Security ↗

What Core does

01 / SNAPSHOTCapture deterministic state

Represent knowledge state through canonical, reproducible snapshot artifacts.

02 / REPLAYReconstruct what was used

Replay a fixed bundle and reconstruct the state and trace used by the system.

03 / VERIFYCheck integrity independently

Compare deterministic hashes and verification results without relying on application claims.

Application → Snapshot → Canonical State → SHA-256 → Bundle → Replay → Verify → Evidence

Boundary

Core verifies decision-state integrity — not real-world truth.

Core can verify deterministic state, canonical representation, cryptographic integrity and replay behavior. It does not by itself certify agent identity, trustworthiness, authorization, action legitimacy or legal compliance.

That separation is intentional. DigiEmu Core provides a deterministic verification layer that other governance, trust, compliance and operational systems can consume.

Install from source

Requirements

Git
Go
a local shell such as PowerShell, Bash or zsh

Clone the public repository:

git clone https://github.com/DigiEmu/core.git
cd core

Run the test suite:

go test ./...

Build the CLI:

go build -o digiemu ./cmd/digiemu

On Windows you can explicitly create an executable:

go build -o digiemu.exe ./cmd/digiemu

Stable v1 CLI workflow

The deterministic v1 tool core is centered on verify and replay.

Verify a bundle

./digiemu verify --bundle <bundle-path> --json

Windows:

.\digiemu.exe verify --bundle <bundle-path> --json

When JSON output is requested, verification exposes stable machine-readable fields such as:

ref

expected

got

hash_alg

canonical_scope

trace

message

For a fixed bundle, deterministic verification covers computed hash values, exit behavior, JSON field values and trace ordering.

Replay a bundle

./digiemu replay --bundle <bundle-path> --json

Windows:

.\digiemu.exe replay --bundle <bundle-path> --json

Replay JSON contains the reconstructed snapshot, any associated claims, and a deterministic trace.

Snapshot workflow

The repository also exposes the higher-level snapshot workflow:

digiemu snapshot file input.json

A generated snapshot bundle can then be verified and replayed:

digiemu verify bundle snapshots/.../bundle.json
digiemu replay bundle snapshots/.../bundle.json
digiemu verify replay snapshots/.../bundle.json

Signatures and transport

Core also provides bundle signing and transport operations.

Sign a bundle:

digiemu sign bundle bundle.json

Verify its signature:

digiemu verify signature bundle.json

Export a portable bundle:

digiemu export bundle bundle.json <directory>

Import it again:

digiemu import bundle <directory>

Architecture

The public repository currently separates major functionality into areas such as:

cmd/digiemu
pkg/snapshot
pkg/replay
pkg/verify
pkg/claims
pkg/meaning
pkg/uncertainty

The conceptual pipeline is:

capture explicit state
create a canonical representation
derive deterministic state identity
preserve the bundle
replay from the preserved state
independently verify the result
optionally sign and transport the artifact

Core 2.0 evaluation

DRAFT / PRE-RELEASE

Core 2.0 Draft 1 is partner-testable, but it is not a stable release. The v1.0 behavior remains the compatibility baseline.

Developers evaluating the draft can run the experimental conformance suite:

go test ./...
go run ./cmd/digiemu experimental conformance run testdata/core_2_conformance

Expected conformance summary:

Conformance run summary: total=11 passed=11 failed=0

Machine-readable result:

go run ./cmd/digiemu experimental conformance run testdata/core_2_conformance --json

Optional Docker evaluation:

docker build -t digiemu-core .
docker run --rm digiemu-core experimental conformance run /opt/testdata/core_2_conformance

Experimental Core 2.0 commands remain under the experimental namespace until they are explicitly promoted to a stable release.

Security model

Core treats security as a function of determinism, integrity and auditability.

Integrity-sensitive behavior is designed around principles including:

explicit state over hidden mutable state
deterministic behavior over convenience
canonical serialization over serializer defaults
fail-closed integrity-sensitive behavior
replay and verification test coverage
controlled expected-hash updates

Security issues should be reported through the repository’s coordinated disclosure process rather than through public exploit disclosure.

Source and contribution

The source repository is public:

GitHub: github.com/DigiEmu/core

Useful developer destinations:

If this is your first interaction with Core, continue with the Core Quickstart →.

If you are integrating a verification workflow, continue with Proof & Verification →.