FallNode — the sovereign runtime

Layer 3 of the sovereign-node factory. Your minted SLM, running on your own metal — the runtime refuses to serve any mint whose signed manifest doesn't verify, gates every ask behind a real capability grant (budget-bounded; a refusal charges nothing), escalates to a bigger limb only on a deterministic format failure — labelled and priced, never silent — and writes every ask, refusal and escalation to a hash-chained service ledger. Own once, not rent. Data never leaves.

A real served session — captured from the runtime, ledger re-verified in your browser

The runtime below served triage-1b (the node minted by layer 2) with qwen2.5:7b as the limb, to a holder with a signed token worth 8 units. Five acts, exactly as they happened:

loading transcript…

The service ledger — every act, hash-chained

loading ledger…

How the runtime works

The trust chain, enforced at boot. The server loads a mint manifest, recomputes its hash, and verifies its Ed25519 signature. No verified manifest — no serving. The node you run is the node that was gated.
Access is a capability, not a password. The owner's key signs grant tokens: holder, scope, budget — kernel-pinned bytes. The server enforces scope and budget; a forged token dies on the signature; a refusal charges 0.
The limb is a rule, not a vibe. If the node's answer fails its declared format (e.g. required JSON fields missing), the runtime may ask the limb — and the answer comes back labelled escalated: true, by: <limb> at limb price. The small model is the default; the big one is a tool it borrows.
Everything lands on the ledger. Serve, ask, refusal, escalation — hash-chained, tamper-evident, verifiable by anyone (this page just did).

Run it on your own metal

git clone https://github.com/sjgant80-hub/fallnode && cd fallnode
node --test kernel.test.mjs
node server.mjs --manifest ../fallforge-mint/out/manifest.json \
  --port 8788 --limb qwen2.5:7b --format json:category,urgency,order
node grant.mjs --node triage-1b --holder ada --scope ask,limb --budget 8   # mint a token
curl -X POST http://127.0.0.1:8788/ask -H 'content-type: application/json' \
  -d '{"token": <token>, "message": "double-charged on order 5512, please refund"}'

Needs a local Ollama and a minted node. The server binds 127.0.0.1 only, by design — exposing it to a network is your decision and your firewall.

Verify a ledger yourself

Honest limits (v1)

The server is local-only by design — this page is the product's window and verifier, never the server. Your node, your metal, your firewall.
Charges are internal capability units, not money. The money rail is a separate, gated decision that waits for legal counsel — nothing here bills anyone.
A token proves the owner's key issued it, not who is holding it. Key-to-identity binding is a later layer. Tokens are replayable by whoever holds them — treat a token like cash.
Escalation is a format rule, deterministic on purpose. It catches "the node failed to answer in shape", not "the node was subtly wrong" — a wrong-but-well-formed answer stands (act two below the fold shows exactly that: a lost parcel triaged as refund, format held, served). Quality is the gate's job at mint time; the runtime enforces shape, budget and provenance.
The kernel is mutation-witnessed in CI (61/64, three argued equivalents); the served manifest is re-verified on every boot, not just in CI.