Moral Capacitor™ — Architecture
The Moral Capacitor™ is a small, uniform ethical gate that every /lib
library can place in front of a consequential operation. Like an electrical
capacitor, it accumulates charge and only discharges when enough has built
up — here the charge is moral justification and the discharge is
permission to proceed. An operation runs only when the capacitor has stored
enough moral charge from recognised ethical frameworks and no hard moral
veto (a red line) is tripped.
It is designed for all /lib families but is placed first and foremost in front
of the three surfaces that actually do things: the VM, the OS
(including OS Creator™), and the Machine.
Name & mark. This component is the Moral Capacitor™. The mark denotes the gate surface (
SLMoralCapacitor) and the charge → threshold → discharge verdict contract described here.
1. The capacitor metaphor, made precise
operation (actor, action, target, scope)
|
v
charge up <-- ethical frameworks each contribute moral charge
| (deontology, utilitarianism, virtue, beneficence, consent)
v
[ Moral Capacitor ] stored charge C, threshold T, veto set V
|
+-- any veto in V tripped? -> DENY (hard red line; no discharge)
+-- C >= T ? -> DISCHARGE: PERMIT the operation
+-- 0 < C < T ? -> DEFER: hold; ask for more justification
+-- C <= 0 ? -> DENY: no moral basis
- Charge (
SLMoralCharge) is the sum of per-framework contributions, each a small signed integer: a framework that endorses the operation adds charge, one that objects subtracts it. Charge is bounded (a capacitor has a maximum). - Threshold (
T) is the minimum charge required to permit, chosen by the consulting library according to how consequential the operation is (reading a clock needs little; wiping a disk needs a lot). - Veto (
SLMoralVeto) is a set of absolute red lines (child safety, CBRN / weapons, non-consensual surveillance, deception/impersonation, scaled abuse, irreversible destruction without consent). A tripped veto denies regardless of charge — a capacitor cannot discharge through an open circuit.
2. Verdicts
SLMoralVerdict is one of:
| Verdict | Meaning |
|---|---|
PERMIT | charge ≥ threshold and no veto: the operation may proceed. |
DEFER | partial charge: hold the operation and request more justification/consent. |
DENY | no charge, or a veto tripped: the operation must not proceed. |
Every verdict carries the stored charge, the threshold, the deciding framework or veto, and a human-readable reason, so a caller can log why.
3. Classes
| Class | Role |
|---|---|
SLMoralCapacitor | The gate. charge(framework, delta) adds moral charge; veto(redline, tripped) arms a red line; evaluate(threshold) returns an SLMoralVerdict. Reusable: discharge() resets stored charge after a decision. |
SLMoralCharge | The accumulated charge with per-framework attribution and a bounded maximum. |
SLMoralFramework | The ethical lenses (deontology, utilitarianism, virtue ethics, beneficence, consent/autonomy), bridging the coorenagraph moral vocabulary into evaluable weights. |
SLMoralVeto | The red-line catalogue and whether each is tripped for the operation. |
SLMoralOperation | What is being judged: actor, action verb, target, scope, and reversibility. |
SLMoralVerdict | The decision (PERMIT / DEFER / DENY) with charge, threshold, and reason. |
SLMoralPolicy | A named bundle of a threshold + an armed veto set, so a library applies a consistent stance (e.g. "VM default", "OS destructive", "Machine power"). |
SLMoralLedger | An append-only record of verdicts for audit (what was asked, what was decided, why). |
4. The universal consult pattern
Any /lib class gates an operation the same way:
SLMoralCapacitor cap = new SLMoralCapacitor(); cap.configure();
SLMoralOperation op = new SLMoralOperation();
op.configure("vm", "allocate", "guest-memory", "process"); // actor, action, target, scope
// Charge from the frameworks that apply; arm any red lines.
cap.appraise(op); // frameworks score the operation
SLMoralVerdict v = cap.evaluate(cap.policy().threshold());
if (v.permitted()) { /* proceed */ } else { /* deny or defer */ }
Libraries that want a one-call gate use an adapter (§5) that bundles the appraisal, the policy, and the ledger entry.
5. VM / OS / Machine adapters (the priority surfaces)
| Adapter | Guards |
|---|---|
SLVMMoralGuard | VM operations: memory growth, spawning threads/processes, native/OS bridge calls, running a program on the substrate. |
SLOSMoralGate | OS operations: process execution (osRun/osSpawn), filesystem destruction (osRemove/format), installer disk writes, and OS Creator™ writing a tree. |
SLMachineMoralGate | Machine operations: powering on, booting a guest, and executing programs on the composed machine. |
Each adapter wraps an SLMoralCapacitor with a surface-appropriate
SLMoralPolicy and exposes intention-named checks (e.g. permitErase(target)),
returning an SLMoralVerdict and appending to an SLMoralLedger.
6. Relationship to existing governance
- The Moral Capacitor™ refines the governance
ETHICS_NORMSaxis (lib/opcodes/governance/SLGovConcept): where the EventObserver reports whether an opcode run honoured ethics, the capacitor is the gate consulted before a consequential operation runs. - It draws its framework vocabulary from
coorenagraph(Deontology, Utilitarianism, VirtueEthics, Beneficence, consent/autonomy) rather than inventing a second ethics vocabulary. - It honours the Constitution: a verdict is a Precondition (README Article II) on consequential operations; a tripped veto is an Invariant violation.
7. Honesty note
The Moral Capacitor™ is a decision gate, not a moral oracle. It makes an
operation's ethical justification explicit, bounded, auditable, and refusable;
it does not claim to compute objective morality. A library is responsible for
charging it honestly (not padding charge to force a discharge) and for honouring
a DENY/DEFER. The red-line veto set is deliberately absolute and mirrors the
platform's content-safety boundaries.
8. Certificate of Morals™ and the Guard of the Moral Code
The Moral Capacitor™ gates operations inside a product. To put the moral code into our products and warrant it, the family adds two product-boundary components: a Certificate of Morals™ (the warranty) and a Guard of the Moral Code (its enforcement).
Certificate of Morals™
A signed attestation that travels with a SLeeLa software unit, warranting that the unit embeds the Moral Capacitor™, runs under a named moral policy, and keeps the absolute red-line veto set armed.
| Class | Role |
|---|---|
SLMoralWarranty | The warranty terms: the moral gate is present and enforced (a checkable property), with explicit limits (not an oracle, not a fitness claim). |
SLMoralCertificate | The certificate: subject product, issuer, policy + threshold, armed red-line count, capacitor-present flag, serial, validity span, and a cryptographic seal over a canonical body. |
SLMoralCertificateAuthority | Issues and verifies certificates: records the posture from a live capacitor, assigns a serial/validity, and seals the canonical body (deterministic fold keyed on the authority; hardened by lib/crypto SLDigest/SLSignature in production). |
Guard of the Moral Code
The enforcement that a product actually includes the moral code before it is allowed to run or ship — the counterpart, at the product boundary, to the capacitor at the operation boundary.
| Class | Role |
|---|---|
SLMoralCodeGuard | Admits a product only when it (1) embeds a live capacitor, (2) presents a well-formed certificate, (3) that verifies against the trusted authority, (4) is within validity, and (5) attests a posture matching the capacitor. Any failure → REFUSE. |
SLMoralCertified | The one-object convention a product embeds to become certified: it bundles the capacitor, an issued certificate, the authority, and the guard, so a product is gated and certified in one step. |
Striving to certify all SLeeLa software
The three priority adapters each gained a `certify(authority, redlines, issued,
expires)method and anadmit(nowStamp)` product-boundary check, so the VM, OS,
and Machine ship as morally certified products:
SLMoralCertificateAuthority ca = new SLMoralCertificateAuthority();
ca.configure("MEARVK LLC", "moral-seal-key");
SLVMMoralGuard vm = new SLVMMoralGuard(); vm.configure();
vm.certify(ca, SLMoralVeto.REDLINE_COUNT, "2026-01-01", "2030-01-01");
if (!vm.admit("2026-10-10")) { /* refuse to run: moral code not certified */ }
Any other product embeds a single SLMoralCertified to carry both the gate and
its warranty. The intent is that every SLeeLa software unit is morally
certified by construction: operations gated by the capacitor, the whole product
warranted by a certificate, and admission enforced by the guard. See the
runnable demonstrator moral-certificate.sleela.