UVLM IntegrityLock Community Edition — Technical Manual

A matching hash establishes byte correspondence with the declared artifact. It does not establish truth, authorship, consent, legality, safety, malware absence, certification, or release authority.

IntegrityLock is a local artifact-integrity, packaging, and provenance toolkit. It helps a user or research workflow:

• hash text, files, and directories;
• create closed file indexes and SHA256SUMS ledgers;
• create deterministic ZIP archives;
• create and verify detached SHA-256 sidecars;
• generate user-owned Ed25519 key pairs;
• sign canonical manifests and verify signatures;
• create and open AES-256-GCM .uvlock package vaults;
• initialize, append, and verify hash-chained provenance events;
• compare predecessor and successor file indexes;
• invoke bounded operations through a CLI, Python SDK, strict JSONL bridge, or loopback-only API.

The central object is not a claim of truth. It is a replayable relationship between declared bytes, manifests, signatures, events, and versions.

IntegrityLock is not:

• full-disk encryption;
• a backup system;
• a malware scanner;
• an identity service;
• a legal chain-of-custody certification;
• proof that content is true;
• proof of authorship, consent, authority, or lawful use;
• a remote storage service;
• an AI model;
• a model trainer;
• a production-ready or FIPS-validated cryptographic product.

Package vault encryption protects an IntegrityLock package when used correctly. It does not replace operating-system security, endpoint security, access control, key custody, or backups.

User-selected local files
        ↓
path and input policy
        ↓
hash / index / manifest
        ↓
deterministic seal
        ↓
optional signature
        ↓
optional package vault
        ↓
provenance chain and lineage comparison
        ↓
human-readable and JSON evidence

Public interfaces:

CLI
Python SDK
strict UTF-8/LF JSONL bridge
loopback-only local HTTP API

Community Edition contains no activation, entitlement, storefront, phone-home, analytics, update check, model call, or persistent AI memory write.

Ordinary operations read and write only paths supplied by the user. The release does not send file content, hashes, prompts, telemetry, identifiers, or update queries to UVLM.

The optional HTTP interface accepts only loopback peers and loopback Host headers. Writes through machine interfaces require explicit user permission. A malicious local process running with the same user permissions can still observe local files or loopback traffic.

On Windows PowerShell:

Get-FileHash -Algorithm SHA256 ".\DOWNLOADED_FILE.zip"

Compare the result with the exact SHA-256 published by UVLM. A filename is not an identity. A website button is not an identity. Recalculate the bytes.

For a detached sidecar, verify that the sidecar names the same artifact and contains the published digest.

Windows portable

1. Download the exact portable ZIP.
2. Verify SHA-256.
3. Extract to a user-owned directory.
4. Read README_FIRST.md, QUICK_START.md, and KNOWN_LIMITATIONS.md.
5. Run IntegrityLock.exe --json doctor.

The binary is unsigned. Windows SmartScreen or organizational policy may warn or block it.

Python wheel

python -m venv .venv
python -m pip install uvlm_integritylock-0.2.0a5-py3-none-any.whl
python -m pip check
integritylock doctor

Source

python -m venv .venv
python -m pip install .
integritylock doctor

Do not install from an unverified archive while assuming that a matching name means matching bytes.

$IL = 'C:\path with spaces\IntegrityLock.exe'

& $IL --json doctor
& $IL --json hash file .\examples\sample_source.txt
& $IL --json index directory .\examples\sample_directory `
  --out .\sample.FILE_INDEX.json
& $IL --json seal directory .\examples\sample_directory `
  --out .\sample.zip --bundle-id SAMPLE
& $IL --json verify artifact .\sample.zip `
  --sidecar .\sample.zip.sha256

The result says what bytes were observed and whether declared relationships verify. It does not judge the meaning of the files.

Generate user-owned Ed25519 keys:

& $IL --json key generate `
  --private .\local-private.key `
  --public .\local-public.key

Sign and verify a manifest:

& $IL --json manifest sign .\sample.FILE_INDEX.json `
  --private-key .\local-private.key

& $IL --json signature verify `
  .\sample.FILE_INDEX.json `
  .\sample.FILE_INDEX.json.sig.json `
  --public-key .\local-public.key

A signature proves that a particular key signed particular bytes, assuming the key and verification process are trustworthy. It does not prove who controlled the key, whether the signer told the truth, or whether the artifact was authorized.

Never commit private keys.

$env:IL_DEMO_PASSPHRASE = 'replace-with-a-local-passphrase'

& $IL --json vault encrypt .\sample.zip `
  --out .\sample.uvlock `
  --passphrase-env IL_DEMO_PASSPHRASE

& $IL --json vault decrypt .\sample.uvlock `
  --out .\sample-restored.zip `
  --passphrase-env IL_DEMO_PASSPHRASE

Remove-Item Env:IL_DEMO_PASSPHRASE

The original plaintext is not deleted. Maintain independent backups and passphrase custody. Loss of the passphrase may make the vault unrecoverable.

& $IL --json chain init .\events.jsonl `
  --subject-sha256 ('0' * 64) --label SAMPLE

& $IL --json chain append .\events.jsonl `
  --event-type ARTIFACT_HASHED `
  --subject-sha256 ('1' * 64)

& $IL --json chain verify .\events.jsonl

& $IL --json lineage diff `
  .\before.FILE_INDEX.json `
  .\after.FILE_INDEX.json

A chain can reveal malformed or broken links. It cannot prove that every intended event was recorded. Serialize writers externally; multiple processes must not append concurrently.

JSONL bridge

An orchestrator may request bounded operations using one strict UTF-8/LF JSON object per line. Write operations require explicit --allow-write.

PowerShell string pipelines often emit CRLF, which the strict bridge rejects. Create an exact request file:

$Request = Join-Path $PWD 'agent-request.jsonl'

[IO.File]::WriteAllText(
  $Request,
  '{"request_id":"demo","operation":"HASH_TEXT","text":"hello"}' + "`n",
  [Text.UTF8Encoding]::new($false)
)

Start-Process -FilePath $IL `
  -ArgumentList @('agent','--allow-root',('"{0}"' -f $PWD.Path)) `
  -RedirectStandardInput $Request `
  -NoNewWindow -Wait

Remove-Item -LiteralPath $Request

Loopback API

& $IL api --allow-root $PWD.Path --host 127.0.0.1 --port 8771

No remote bind option is provided. A model adapter's ability to call an operation is not authorization to perform it.

IntegrityLock does not include or call a model. It can sit beside an Ollama, llama.cpp, LM Studio, desktop model, Python pipeline, or another local tool.

Pattern A — Seal a model experiment

model binary / model manifest
prompt template
system instructions
source documents
retrieval index
adapter configuration
generation settings
random seed when available
raw candidate output
human-reviewed output
evaluation results
        ↓
IntegrityLock file index
        ↓
deterministic experiment archive
        ↓
signature and provenance chain

This lets another researcher determine whether they possess the same declared experiment bytes.

Pattern B — Predecessor/successor comparison

Seal a baseline local-model run and a governed or modified run. Compare indexes to identify which prompts, sources, adapters, settings, or outputs changed.

Pattern C — Tool call through JSONL

A local model orchestrator can request hash, verify, index, chain, or lineage operations through the JSONL bridge. Keep roots narrow. Require explicit writes. Do not let the model select arbitrary paths or treat verification as truth.

Pattern D — Research bundle

Create a package containing:

RUN_MANIFEST.json
MODEL_IDENTITY.json
PROMPTS/
SOURCES/
CONFIG/
RAW_OUTPUTS/
REVIEWED_OUTPUTS/
METRICS/
LIMITATIONS.md
FILE_INDEX.json
SHA256SUMS.txt

Seal the directory and publish the digest with the research result.

IntegrityLock does not improve model weights or make a model more intelligent. It can improve the experimental and operational system around the model.

Reasonable measured outcomes include:

• higher experiment replay success;
• fewer lost or mismatched files;
• lower time to identify configuration drift;
• higher artifact completeness;
• faster verification;
• better rollback;
• clearer prompt/source/output lineage;
• lower accidental use of the wrong model or dataset version;
• improved reviewer confidence in byte identity.

Do not report those gains as improved benchmark accuracy unless benchmark accuracy was separately measured.

Baseline

Run the local model normally and record:

task score
source-supported claim rate
unsupported claim rate
human review time
latency
CPU/RAM use
network events
artifact completeness
repeat-run drift

Integrity-managed run

Repeat the same tasks while IntegrityLock records and seals model, prompt, source, configuration, output, and evaluation identities.

Compare

Report:

exact model and quantization
hardware and operating system
prompt and source hashes
adapter version
settings
task set
metric definitions
uncertainty
negative and null findings
all changed artifacts

IntegrityLock should improve reproducibility and traceability. Whether it improves task accuracy is an empirical question.

Local model
    ↓
TIAIP candidate quarantine and human governance
    ↓
CECP continuity / rights-floor receipt
    ↓
Human decision
    ↓
IntegrityLock experiment and release sealing

The Global Philosophy Governance Atlas may optionally provide retrieval context or plural governance lenses. It must not become a truth oracle, cultural certifier, identity score, or automatic policy authority.

• Windows packages are unsigned.
• SmartScreen and antivirus responses vary.
• A bounded scan is not proof of malware absence.
• Cross-host and future-toolchain reproducibility are not universally claimed.
• Conservative path policy rejects some complex names, links, ADS, depth, and path lengths.
• The loopback API is not isolation from a malicious process running as the same user.
• Chain writers must be serialized.
• JSONL requires exact UTF-8/LF.
• The software does not itself create an external-penetration, formal accessibility, legal, chain-of-title, export-control, malware-absence, or production-readiness conclusion.
• Package vaults are not full-disk encryption or backups.
• Hashes and signatures do not establish truth or authority.

Read CONTRIBUTING.md, CODE_OF_CONDUCT.md, TRADEMARK_POLICY.md, and the MPL-2.0 license.

Contributions should include:

• provenance;
• compatible licensing;
• tests;
• documentation;
• no secrets, private keys, customer data, confidential source, or held-out review materials;
• DCO-style sign-off or the project's current contributor mechanism.

A fork may exercise its open-source rights but may not misrepresent itself as an official UVLM release or UVLM certification.

Report reproducible defects through the release's documented support route. Include:

exact artifact filename and SHA-256
operating system
Python version where applicable
command or interface
minimal synthetic reproduction
expected behavior
observed behavior
logs with secrets and personal data removed

Do not send private keys, vault passphrases, customer records, or sensitive source files.

This manual is version-bound. A future software version receives a new manual revision and artifact identity. Do not silently update technical claims while leaving an old manual version attached to a new release.

Publication binding for this manual:

• the exact download URLs and sidecars are maintained on the Product Overview;
• the public-source logged-out retrieval and SHA-256 result are maintained on Assurance & Verification;
• the sent source-notice boundary is maintained on Assurance & Verification;
• support and security reports use info@ultraverbaluxmentis.org with prepared subject lines;
• future IntegrityLock versions receive a new manual identity and must not silently inherit these commands or claims.