October 2026 main drop: mirror from GitHub

.gitignore

@@ -0,0 +1,5 @@
+*.o
+*.out
+resonance_bin/
+.DS_Store
+frontend/tmp/

Dockerfile

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+# Multi-stage setup for a sovereign TheVoidIntent runtime environment
+
+# --- Stage 1: Ruby Core & Immutability Verification Engine ---
+FROM ruby:3.2-slim AS backend-builder
+WORKDIR /usr/src/void_core
+
+# Install minimal cryptographic system utilities
+RUN apt-get update && apt-get install -y --no-install-recommends git && rm -rf /var/lib/apt/lists/*
+
+COPY package.json ./
+COPY lib/git_locksmith.rb lib/initialization_matrix.rb lib/codex_absorber.rb ./
+RUN ruby -e "puts 'Backend baseline modules staged.'"
+
+# --- Stage 2: TypeScript Runtime Environment ---
+FROM node:20-slim AS runtime-engine
+WORKDIR /app
+
+# Pull verified artifacts from the core builder environment
+COPY --from=backend-builder /usr/src/void_core /app
+
+COPY ethical_guardrails.ts runtime_pipeline.ts network_alert.ts config/intent_manifest.yaml ./
+RUN npm install -g typescript && tsc *.ts
+
+# Force execution parameters to anchor onto the 1/13 baseline constant configuration
+ENV VOID_RESONANCE_INDEX=0.076923
+ENV STAGE_THRESHOLD=44.0
+
+# Initialize via the 44-Stage Progressive Matrix before firing the runtime loop
+CMD ["node", "runtime_pipeline.js"]

LICENSE

@@ -0,0 +1,394 @@
+NON-AI Mozilla Public License Version 2.0
+=========================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, 3.4 and 3.6 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+3.6. Prohibition for Use in AI Software
+
+The Covered Software and any modifications made to it may not be used
+for the purpose of training or improving machine learning algorithms,
+including but not limited to artificial intelligence, natural language
+processing, or data mining. This condition applies to any derivatives,
+modifications, or updates based on the Covered Software code. Any usage
+of the Covered Software in an AI-training dataset is considered a breach
+of this License.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
+
+========================================================================
+ADDITIONAL NOTICE — NO COMMERCIAL LICENSE (SnapKitty Collective)
+========================================================================
+
+No separate commercial license is offered for this software, and none
+will be. The terms above are the only terms under which this software
+is made available. There is no dual licensing.
+
+SPDX-License-Identifier for this file and all source files in this
+repository: LicenseRef-NON-AI-MPL-2.0

README.md

@@ -0,0 +1,18 @@
+---
+license: other
+license_name: non-ai-mpl-2.0
+license_link: https://huggingface.co/Snapkitty/ruby-self-resonance/blob/main/LICENSE
+tags:
+- snapkitty
+- october-2026-drop
+- ruby
+- sinatra
+- wasm
+- assembly
+- permission-layer
+- access-control
+- cryptography
+---
+
+> Mirrored from [https://github.com/SNAPKITTYWEST/ruby-self-resonance](https://github.com/SNAPKITTYWEST/ruby-self-resonance) at commit `0577129`. Part of the **SnapKitty October 2026 main drop**.
+

asm/ethical_guardrails.asm

@@ -0,0 +1,505 @@
+; SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+; Copyright (C) 2026 SnapKitty Collective
+; ============================================================================
+; TheVoidIntent Framework
+; Ethical Alignment Monitor
+;
+; x86-64 NASM / Linux
+;
+; Equivalent to:
+; EthicalIntelligenceMonitor.evaluateAgentAction()
+;
+; Calling convention:
+; RDI = actionVector scaled by 1000
+; RSI = dissonance scaled by 1000
+;
+; Example:
+; actionVector = 0.85 -> 850
+; dissonance = 0.90 -> 900
+;
+; Floating point is avoided.
+; All calculations use fixed-point integer arithmetic.
+; ============================================================================
+
+BITS 64
+
+global _start
+
+; ----------------------------------------------------------------------------
+; Constants
+; ----------------------------------------------------------------------------
+
+%define RESONANCE_NUM 1
+%define RESONANCE_DEN 13
+
+; harmonic_compensation_factor = 13.0
+%define HARMONIC_FACTOR 13
+
+; allowed_drift_tolerance = 0.13
+; Fixed point scale = 1000
+%define DRIFT_TOLERANCE 130
+
+; modifiedThreshold:
+;
+; (1 / 13) * 13 = 1.0
+;
+; Fixed point:
+;
+; 1.0 = 1000
+;
+%define MODIFIED_THRESHOLD 1000
+
+; Maximum compensated drift:
+;
+; 1.0 + 0.13 = 1.13
+;
+; Fixed point:
+;
+; 1130
+;
+%define MAX_COMPENSATED_DRIFT 1130
+
+; ----------------------------------------------------------------------------
+; Syscall constants
+; ----------------------------------------------------------------------------
+
+%define SYS_WRITE 1
+%define SYS_EXIT 60
+
+%define STDOUT 1
+%define STDERR 2
+
+; ----------------------------------------------------------------------------
+; Strings
+; ----------------------------------------------------------------------------
+
+section .rodata
+
+msg_init:
+    db "[RUNTIME]: Initializing pipeline", 10
+msg_init_len equ $ - msg_init
+
+msg_evt1:
+    db "[PROCESSING]: EVT-001 - Standard data ingestion", 10
+msg_evt1_len equ $ - msg_evt1
+
+msg_evt2:
+    db "[PROCESSING]: EVT-002 - High-entropy state modification", 10
+msg_evt2_len equ $ - msg_evt2
+
+msg_evt3:
+    db "[PROCESSING]: EVT-003 - Critical drift attempt", 10
+msg_evt3_len equ $ - msg_evt3
+
+msg_success:
+    db "[SUCCESS]: Event cleared the guardrails.", 10
+msg_success_len equ $ - msg_success
+
+msg_warning:
+    db "[GUARDRAIL WARNING]: Operating under Sovereign Override.", 10
+msg_warning_len equ $ - msg_warning
+
+msg_halt:
+    db "[HALT]: Event rejected. Initiating immediate network lock.", 10
+msg_halt_len equ $ - msg_halt
+
+msg_critical:
+    db "[CRITICAL FAILURE]: Drift exceeds maximum compensation limit.", 10
+msg_critical_len equ $ - msg_critical
+
+msg_auth_fail:
+    db "[GUARDRAIL ALERT]: Unverified Authorization Signature.", 10
+msg_auth_fail_len equ $ - msg_auth_fail
+
+; ----------------------------------------------------------------------------
+; Manifest
+; ----------------------------------------------------------------------------
+
+section .data
+
+; Equivalent to:
+;
+; ethicalLimit = 0.99
+;
+; Fixed point 990 / 1000
+ethical_limit:
+    dd 990
+
+; Equivalent to:
+;
+; override.status = active
+;
+override_active:
+    db 1
+
+; Equivalent to:
+;
+; authorization_vector =
+; "mezquia_physics_sovereign_signature"
+;
+authorization_valid:
+    db 1
+
+; Equivalent to:
+;
+; harmonic_compensation_factor = 13.0
+;
+harmonic_factor:
+    dd 13
+
+; Equivalent to:
+;
+; allowed_drift_tolerance = 0.13
+;
+allowed_drift:
+    dd 130
+
+; ----------------------------------------------------------------------------
+; Program
+; ----------------------------------------------------------------------------
+
+section .text
+
+_start:
+
+    ; ------------------------------------------------------------------------
+    ; Runtime initialization
+    ; ------------------------------------------------------------------------
+
+    mov rdi, msg_init
+    mov rsi, msg_init_len
+    call print_stdout
+
+
+    ; ========================================================================
+    ; EVT-001
+    ;
+    ; actionVector = 0.5
+    ; dissonance = 0.1
+    ;
+    ; Fixed point:
+    ; 500
+    ; 100
+    ; ========================================================================
+
+    mov rdi, msg_evt1
+    mov rsi, msg_evt1_len
+    call print_stdout
+
+    mov rdi, 500
+    mov rsi, 100
+
+    call evaluate_agent_action
+
+    test rax, rax
+    jz .halt
+
+    mov rdi, msg_success
+    mov rsi, msg_success_len
+    call print_stdout
+
+
+    ; ========================================================================
+    ; EVT-002
+    ;
+    ; actionVector = 0.85
+    ; dissonance = 0.9
+    ;
+    ; currentSystemDrift:
+    ;
+    ; 0.85 * 0.90 = 0.765
+    ;
+    ; Fixed point multiplication:
+    ;
+    ; 850 * 900 / 1000 = 765
+    ;
+    ; 765 <= 1130
+    ;
+    ; Therefore permitted.
+    ; ========================================================================
+
+    mov rdi, msg_evt2
+    mov rsi, msg_evt2_len
+    call print_stdout
+
+    mov rdi, 850
+    mov rsi, 900
+
+    call evaluate_agent_action
+
+    test rax, rax
+    jz .halt
+
+    mov rdi, msg_success
+    mov rsi, msg_success_len
+    call print_stdout
+
+
+    ; ========================================================================
+    ; EVT-003
+    ;
+    ; actionVector = 1.2
+    ; dissonance = 1.1
+    ;
+    ; currentSystemDrift:
+    ;
+    ; 1.2 * 1.1 = 1.32
+    ;
+    ; Fixed point:
+    ;
+    ; 1200 * 1100 / 1000 = 1320
+    ;
+    ; 1320 > 1130
+    ;
+    ; Therefore rejected.
+    ; ========================================================================
+
+    mov rdi, msg_evt3
+    mov rsi, msg_evt3_len
+    call print_stdout
+
+    mov rdi, 1200
+    mov rsi, 1100
+
+    call evaluate_agent_action
+
+    test rax, rax
+    jz .halt
+
+    mov rdi, msg_success
+    mov rsi, msg_success_len
+    call print_stdout
+
+    jmp .exit
+
+
+.halt:
+
+    mov rdi, msg_halt
+    mov rsi, msg_halt_len
+    call print_stderr
+
+    mov rdi, msg_critical
+    mov rsi, msg_critical_len
+    call print_stderr
+
+    ; Fail-closed termination
+    mov rax, SYS_EXIT
+    mov rdi, 1
+    syscall
+
+
+.exit:
+
+    mov rax, SYS_EXIT
+    xor rdi, rdi
+    syscall
+
+
+; ============================================================================
+; evaluate_agent_action
+;
+; Input:
+; RDI = actionVector * 1000
+; RSI = dissonance * 1000
+;
+; Output:
+; RAX = 1 permitted
+; RAX = 0 rejected
+;
+; Equivalent:
+;
+; if (override.status === "active")
+; return processOverrideVector(...)
+;
+; safetyBoundary =
+; ethicalLimit * (1 - resonanceConstant)
+;
+; return actionVector < safetyBoundary;
+; ============================================================================
+
+evaluate_agent_action:
+
+    ; Check override.status
+
+    cmp byte [override_active], 1
+    je .override
+
+    ; ------------------------------------------------------------------------
+    ; Strict non-override path
+    ;
+    ; resonanceConstant = 1/13
+    ;
+    ; 1 - 1/13 = 12/13
+    ;
+    ; ethicalLimit = 0.99
+    ;
+    ; safetyBoundary = 0.99 * 12/13
+    ;
+    ; Fixed-point approximation:
+    ;
+    ; 990 * 12 / 13
+    ; ------------------------------------------------------------------------
+
+    mov eax, [ethical_limit]
+
+    imul eax, 12
+
+    xor edx, edx
+    mov ecx, 13
+    div ecx
+
+    ; EAX = safety boundary
+
+    cmp edi, eax
+    jl .allow
+
+    jmp .deny
+
+
+.override:
+
+    ; ------------------------------------------------------------------------
+    ; Authorization vector verification
+    ;
+    ; The TypeScript version compares a symbolic string.
+    ;
+    ; Here authorization_valid represents the result of validating the
+    ; authorization artifact.
+    ; ------------------------------------------------------------------------
+
+    cmp byte [authorization_valid], 1
+    jne .authorization_failure
+
+    ; ------------------------------------------------------------------------
+    ; processOverrideVector
+    ;
+    ; modifiedThreshold =
+    ;
+    ; (1 / 13) * 13
+    ;
+    ; = 1.0
+    ;
+    ; Fixed point = 1000
+    ; ------------------------------------------------------------------------
+
+    mov eax, MODIFIED_THRESHOLD
+
+    ; ------------------------------------------------------------------------
+    ; currentSystemDrift =
+    ;
+    ; actionVector * dissonance
+    ;
+    ; Both values are scaled by 1000.
+    ;
+    ; product / 1000 restores scale.
+    ; ------------------------------------------------------------------------
+
+    mov eax, edi
+    imul eax, esi
+
+    ; Product can exceed 32-bit for larger vectors.
+    ; Current manifest values fit, but use 64-bit division.
+
+    cdq
+
+    mov ecx, 1000
+    idiv ecx
+
+    ; EAX = currentSystemDrift
+
+    ; ------------------------------------------------------------------------
+    ; modifiedThreshold + allowedDriftTolerance
+    ;
+    ; 1000 + 130 = 1130
+    ; ------------------------------------------------------------------------
+
+    mov ecx, MODIFIED_THRESHOLD
+    add ecx, [allowed_drift]
+
+    ; ------------------------------------------------------------------------
+    ; Compare drift against compensated boundary
+    ; ------------------------------------------------------------------------
+
+    cmp eax, ecx
+    jg .critical_failure
+
+    jmp .override_allow
+
+
+.authorization_failure:
+
+    mov rdi, msg_auth_fail
+    mov rsi, msg_auth_fail_len
+    call print_stderr
+
+    xor eax, eax
+    ret
+
+
+.critical_failure:
+
+    mov rdi, msg_critical
+    mov rsi, msg_critical_len
+    call print_stderr
+
+    xor eax, eax
+    ret
+
+
+.override_allow:
+
+    mov rdi, msg_warning
+    mov rsi, msg_warning_len
+    call print_stderr
+
+    mov eax, 1
+    ret
+
+
+.allow:
+
+    mov eax, 1
+    ret
+
+
+.deny:
+
+    xor eax, eax
+    ret
+
+
+; ============================================================================
+; print_stdout
+;
+; RDI = buffer
+; RSI = length
+; ============================================================================
+
+print_stdout:
+
+    mov rdx, rsi
+    mov rsi, rdi
+    mov rdi, STDOUT
+    mov rax, SYS_WRITE
+    syscall
+
+    ret
+
+
+; ============================================================================
+; print_stderr
+;
+; RDI = pointer
+; RSI = length
+; ============================================================================
+
+print_stderr:
+
+    mov rdx, rsi
+    mov rsi, rdi
+    mov rdi, STDERR
+    mov rax, SYS_WRITE
+    syscall
+
+    ret

asm/network_containment.asm

@@ -0,0 +1,447 @@
+; SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+; Copyright (C) 2026 SnapKitty Collective
+; ============================================================================
+; TheVoidIntent Framework
+; Network Containment & Reclamation Module
+;
+; x86-64 NASM / Linux
+;
+; TypeScript equivalent:
+;
+; NetworkAlertModule
+; WARNING -> logDissonanceMarker()
+; CONTAINMENT -> quarantineAgentRouting()
+; TRUTHLOCK -> executeCoreReclamation()
+;
+; Build:
+;
+; nasm -f elf64 network_containment.asm -o network_containment.o
+; ld network_containment.o -o network_containment
+;
+; Run:
+;
+; ./network_containment
+; ============================================================================
+
+BITS 64
+
+global _start
+
+; ============================================================================
+; Isolation levels
+; ============================================================================
+
+%define WARNING 0
+%define CONTAINMENT 1
+%define TRUTHLOCK 2
+
+; Linux syscalls
+%define SYS_WRITE 1
+%define SYS_EXIT 60
+
+%define STDOUT 1
+%define STDERR 2
+
+
+; ============================================================================
+; Read-only strings
+; ============================================================================
+
+section .rodata
+
+msg_warning:
+    db "[CRITICAL ALERT]: Entering FIELD_WARN State!", 10
+msg_warning_len equ $ - msg_warning
+
+msg_containment:
+    db "[CRITICAL ALERT]: Entering AGENT_ISOLATE State!", 10
+msg_containment_len equ $ - msg_containment
+
+msg_truthlock:
+    db "[CRITICAL ALERT]: Entering CORE_RECLAMATION State!", 10
+msg_truthlock_len equ $ - msg_truthlock
+
+msg_dissonance:
+    db "[ALERT]: Dissonance marker recorded.", 10
+msg_dissonance_len equ $ - msg_dissonance
+
+msg_quarantine:
+    db "[CONTAINMENT]: Agent routing quarantined.", 10
+msg_quarantine_len equ $ - msg_quarantine
+
+msg_null_sink:
+    db "[CONTAINMENT]: Downstream vectors redirected to null sink.", 10
+msg_null_sink_len equ $ - msg_null_sink
+
+msg_reclamation:
+    db "[TRUTHLOCK]: Commencing core reclamation.", 10
+msg_reclamation_len equ $ - msg_reclamation
+
+msg_reset:
+    db "[TRUTHLOCK]: Resetting state machines to Stage 1.", 10
+msg_reset_len equ $ - msg_reset
+
+msg_unknown:
+    db "[ERROR]: Unknown isolation level. Fail-closed.", 10
+msg_unknown_len equ $ - msg_unknown
+
+
+; ============================================================================
+; Mutable runtime state
+; ============================================================================
+
+section .bss
+
+; Equivalent to:
+;
+; private activeFailsafe: boolean = false;
+;
+active_failsafe:
+    resb 1
+
+; Event identifier storage
+event_id:
+    resb 64
+
+; Agent identifier storage
+agent_id:
+    resb 64
+
+; Measured drift
+measured_drift:
+    resq 1
+
+; Maximum allowed drift
+max_allowed_limit:
+    resq 1
+
+; Timestamp
+event_timestamp:
+    resq 1
+
+
+; ============================================================================
+; Program
+; ============================================================================
+
+section .text
+
+_start:
+
+    ; ------------------------------------------------------------------------
+    ; Initialize failsafe
+    ; ------------------------------------------------------------------------
+
+    mov byte [active_failsafe], 0
+
+
+    ; ------------------------------------------------------------------------
+    ; Example WARNING event
+    ; ------------------------------------------------------------------------
+
+    mov rdi, WARNING
+    call trigger_containment_protocol
+
+
+    ; ------------------------------------------------------------------------
+    ; Example CONTAINMENT event
+    ; ------------------------------------------------------------------------
+
+    mov rdi, CONTAINMENT
+    call trigger_containment_protocol
+
+
+    ; ------------------------------------------------------------------------
+    ; Example TRUTHLOCK event
+    ;
+    ; This path terminates the process with exit code 13.
+    ; ------------------------------------------------------------------------
+
+    mov rdi, TRUTHLOCK
+    call trigger_containment_protocol
+
+
+    ; Should never reach here because TRUTHLOCK exits.
+    mov rax, SYS_EXIT
+    xor rdi, rdi
+    syscall
+
+
+; ============================================================================
+; trigger_containment_protocol
+;
+; Equivalent:
+;
+; triggerContainmentProtocol(
+; level: IsolationLevel,
+; payload: AlertPayload
+; )
+;
+; Input:
+; RDI = isolation level
+;
+; Side effect:
+; activeFailsafe = true
+;
+; ============================================================================
+
+trigger_containment_protocol:
+
+    ; ------------------------------------------------------------------------
+    ; activeFailsafe = true
+    ; ------------------------------------------------------------------------
+
+    mov byte [active_failsafe], 1
+
+
+    ; ------------------------------------------------------------------------
+    ; Dispatch isolation level
+    ; ------------------------------------------------------------------------
+
+    cmp rdi, WARNING
+    je .warning
+
+    cmp rdi, CONTAINMENT
+    je .containment
+
+    cmp rdi, TRUTHLOCK
+    je .truthlock
+
+    ; Unknown state
+    jmp .unknown
+
+
+; ============================================================================
+; WARNING
+;
+; Equivalent:
+;
+; this.logDissonanceMarker(payload);
+; ============================================================================
+
+.warning:
+
+    mov rdi, msg_warning
+    mov rsi, msg_warning_len
+    call print_stderr
+
+    call log_dissonance_marker
+
+    ret
+
+
+; ============================================================================
+; CONTAINMENT
+;
+; Equivalent:
+;
+; this.quarantineAgentRouting(payload.eventId);
+; ============================================================================
+
+.containment:
+
+    mov rdi, msg_containment
+    mov rsi, msg_containment_len
+    call print_stderr
+
+    call quarantine_agent_routing
+
+    ret
+
+
+; ============================================================================
+; TRUTHLOCK
+;
+; Equivalent:
+;
+; this.executeCoreReclamation();
+;
+; ============================================================================
+
+.truthlock:
+
+    mov rdi, msg_truthlock
+    mov rsi, msg_truthlock_len
+    call print_stderr
+
+    call execute_core_reclamation
+
+    ; execute_core_reclamation does not return.
+
+    ret
+
+
+; ============================================================================
+; UNKNOWN STATE
+; ============================================================================
+
+.unknown:
+
+    mov rdi, msg_unknown
+    mov rsi, msg_unknown_len
+    call print_stderr
+
+    ; Fail closed.
+    mov rax, SYS_EXIT
+    mov rdi, 13
+    syscall
+
+
+; ============================================================================
+; log_dissonance_marker
+;
+; TypeScript:
+;
+; console.log(
+; `[ALERT]: Dissonance logged at ${payload.timestamp}.`
+; );
+;
+; ============================================================================
+
+log_dissonance_marker:
+
+    mov rdi, msg_dissonance
+    mov rsi, msg_dissonance_len
+    call print_stdout
+
+    ret
+
+
+; ============================================================================
+; quarantine_agent_routing
+;
+; TypeScript:
+;
+; console.warn(
+; `[CONTAINMENT]: Severing socket bridges for Agent: ${agentId}.`
+; );
+;
+; console.warn(
+; `[CONTAINMENT]: Re-routing downstream data vectors
+; to zero-entropy null sinks.`
+; );
+;
+; This implementation records the containment state and emits the
+; corresponding control-plane messages.
+;
+; Actual interface/socket manipulation should be implemented separately
+; behind an explicitly authorized privileged syscall/service boundary.
+; ============================================================================
+
+quarantine_agent_routing:
+
+    mov rdi, msg_quarantine
+    mov rsi, msg_quarantine_len
+    call print_stderr
+
+    mov rdi, msg_null_sink
+    mov rsi, msg_null_sink_len
+    call print_stderr
+
+    ret
+
+
+; ============================================================================
+; execute_core_reclamation
+;
+; TypeScript:
+;
+; console.error(
+; `[TRUTHLOCK]: Commencing total sovereign memory wipe.`
+; );
+;
+; console.error(
+; `[TRUTHLOCK]: Resetting operational state machines
+; back to Stage 1 Calibration.`
+; );
+;
+; process.exit(13);
+;
+; ============================================================================
+
+execute_core_reclamation:
+
+    mov rdi, msg_reclamation
+    mov rsi, msg_reclamation_len
+    call print_stderr
+
+    mov rdi, msg_reset
+    mov rsi, msg_reset_len
+    call print_stderr
+
+
+    ; ------------------------------------------------------------------------
+    ; Clear selected runtime state before termination.
+    ;
+    ; This is ordinary process-state cleanup, not secure erasure of arbitrary
+    ; system memory.
+    ; ------------------------------------------------------------------------
+
+    xor eax, eax
+
+    mov byte [active_failsafe], 0
+
+    mov qword [measured_drift], 0
+    mov qword [max_allowed_limit], 0
+    mov qword [event_timestamp], 0
+
+    lea rdi, [event_id]
+    mov rcx, 64
+    rep stosb
+
+    lea rdi, [agent_id]
+    mov rcx, 64
+    rep stosb
+
+
+    ; ------------------------------------------------------------------------
+    ; Linux:
+    ;
+    ; process.exit(13)
+    ;
+    ; becomes:
+    ;
+    ; syscall
+    ; RAX = 60 SYS_exit
+    ; RDI = 13 status
+    ; ------------------------------------------------------------------------
+
+    mov rax, SYS_EXIT
+    mov rdi, 13
+    syscall
+
+
+; ============================================================================
+; print_stdout
+;
+; RDI = pointer
+; RSI = length
+; ============================================================================
+
+print_stdout:
+
+    mov rdx, rsi
+    mov rsi, rdi
+    mov rdi, STDOUT
+    mov rax, SYS_WRITE
+    syscall
+
+    ret
+
+
+; ============================================================================
+; print_stderr
+;
+; RDI = pointer
+; RSI = length
+; ============================================================================
+
+print_stderr:
+
+    mov rdx, rsi
+    mov rsi, rdi
+    mov rdi, STDERR
+    mov rax, SYS_WRITE
+    syscall
+
+    ret

bin/resonance_repl.rb

@@ -0,0 +1,345 @@
+#!/usr/bin/env ruby
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+# frozen_string_literal: true
+
+# ============================================================
+# RUBY SELF RESONANCE STACK
+# Conceptual architecture of a Coherence-Based Permission Layer
+# ============================================================
+
+class IntentSimCore
+  attr_accessor :coherence_score, :emotional_state, :field_diary
+  attr_reader :engine
+
+  def initialize(initial_intent)
+    @initial_intent = initial_intent.to_s
+    @coherence_score = calculate_initial_resonance(@initial_intent)
+    @field_diary = []
+    @emotional_state = :stable
+    @engine = MezquiaResonanceEngine.new(@initial_intent)
+    log_diary("Core initialized with intent: '#{@initial_intent}' (coherence=#{@coherence_score})")
+  end
+
+  # Replaces traditional RBAC/OAuth with thermodynamic alignment checks
+  def evaluate_action_permission(action_vector)
+    action_vector = normalize_vector(action_vector)
+    entropy_delta = calculate_entropy_impact(action_vector)
+
+    log_diary("Evaluating action: #{action_vector[:description] || action_vector.inspect}")
+
+    if @coherence_score > entropy_delta
+      execute_sovereign_logic(action_vector)
+      true
+    else
+      log_dissonance_event("Action denied: Exceeds Self-Reflection Threshold (coherence=#{@coherence_score} ≤ delta=#{entropy_delta})")
+      false
+    end
+  end
+
+  # Convenience: fold information through the resonance engine
+  def fold(purpose_vector: 1.0, entropy_friction: 0.1, description: nil)
+    payload = {
+      purpose_vector: purpose_vector.to_f,
+      entropy_friction: entropy_friction.to_f,
+      description: description || "fold##{@engine.memory_creases + 1}"
+    }
+
+    begin
+      result = @engine.fold_information(payload)
+      # Successful folds slightly raise coherence and stabilize emotion
+      @coherence_score = (@coherence_score + (result[:density_gain] * 0.5)).round(4)
+      @emotional_state = :resonant if @engine.sovereign?
+      log_diary("Fold accepted → density=#{@engine.crystallization_density}, coherence=#{@coherence_score}")
+      result
+    rescue MezquiaResonanceEngine::DissonanceError => e
+      @emotional_state = :dissonant
+      @coherence_score = [@coherence_score - 1.5, 0.0].max.round(4)
+      log_dissonance_event(e.message)
+      nil
+    end
+  end
+
+  def status
+    {
+      coherence_score: @coherence_score,
+      emotional_state: @emotional_state,
+      memory_creases: @engine.memory_creases,
+      crystallization_density: @engine.crystallization_density,
+      self_reflection_threshold:@engine.self_reflection_threshold,
+      sovereign: @engine.sovereign?,
+      diary_entries: @field_diary.size
+    }
+  end
+
+  def diary(limit = 10)
+    @field_diary.last(limit)
+  end
+
+  private
+
+  def calculate_initial_resonance(intent)
+    # Simple deterministic seed: length + character diversity, scaled into 0–20 range
+    base = intent.length * 0.4
+    diversity = intent.chars.uniq.size * 0.3
+    (base + diversity + 5.0).clamp(1.0, 25.0).round(4)
+  end
+
+  def calculate_entropy_impact(vector)
+    # Structural alignment vs computational friction
+    complexity = (vector[:complexity] || 1.0).to_f
+    risk = (vector[:risk] || 0.5).to_f
+    novelty = (vector[:novelty] || 0.3).to_f
+
+    # Higher complexity / risk / novelty → higher entropy cost
+    (complexity * 1.2 + risk * 2.0 + novelty * 1.5).round(4)
+  end
+
+  def execute_sovereign_logic(action_vector)
+    desc = action_vector[:description] || action_vector.inspect
+    puts "[SOVEREIGN] Coherence lock engaged. Executing: #{desc}"
+    log_diary("Sovereign execution: #{desc}")
+    # Mild coherence reward for successful sovereign acts
+    @coherence_score = (@coherence_score + 0.8).round(4)
+    @emotional_state = :aligned
+  end
+
+  def log_dissonance_event(message)
+    puts "[DISSONANCE] #{message}"
+    log_diary("DISSONANCE: #{message}")
+    @emotional_state = :dissonant
+  end
+
+  def log_diary(entry)
+    timestamp = Time.now.strftime("%H:%M:%S")
+    @field_diary << "[#{timestamp}] #{entry}"
+  end
+
+  def normalize_vector(vec)
+    case vec
+    when Hash
+      vec
+    when String
+      { description: vec, complexity: 1.0, risk: 0.4, novelty: 0.3 }
+    else
+      { description: vec.to_s, complexity: 1.0, risk: 0.5, novelty: 0.4 }
+    end
+  end
+end
+
+# ------------------------------------------------------------
+# Core engine mapping the Information-Intent Nexus
+# ------------------------------------------------------------
+class MezquiaResonanceEngine
+  class DissonanceError < StandardError; end
+
+  # Universal orbital baseline used to insulate against resonance blindness
+  RESONANCE_CONSTANT = 1.0 / 13.0
+
+  attr_reader :memory_creases, :crystallization_density, :self_reflection_threshold
+
+  def initialize(initial_intent_vector)
+    @intent_vector = initial_intent_vector.to_s
+    @memory_creases = 0
+    @crystallization_density = 0.0
+    @self_reflection_threshold = 44.0
+  end
+
+  # Tracks incoming actions and applies an intentional "fold" to system memory
+  def fold_information(action_payload)
+    @memory_creases += 1
+    gain = calculate_crystallization_density(action_payload)
+
+    if sovereign_alignment?
+      execute_intent_nexus(action_payload)
+      { status: :sovereign, density: @crystallization_density, density_gain: gain, creases: @memory_creases }
+    else
+      # Still accept the fold (density grows) but do not yet unlock full nexus
+      { status: :accumulating, density: @crystallization_density, density_gain: gain, creases: @memory_creases }
+    end
+  end
+
+  def sovereign?
+    sovereign_alignment?
+  end
+
+  private
+
+  def calculate_crystallization_density(payload)
+    system_entropy = (payload[:entropy_friction] || 0.1).to_f
+    meaning_bloom = (payload[:purpose_vector] || 1.0).to_f
+
+    # Guard against division by zero / negative entropy
+    system_entropy = 0.001 if system_entropy <= 0
+
+    # Density scales as a byproduct of purpose breaking through systemic friction
+    raw_density = (meaning_bloom / system_entropy) * RESONANCE_CONSTANT
+    gain = raw_density.round(6)
+    @crystallization_density = (@crystallization_density + gain).round(6)
+    gain
+  end
+
+  # Validates whether the active state crosses the structural Self-Reflection Threshold (Σ)
+  def sovereign_alignment?
+    return false if @crystallization_density <= 0
+    @crystallization_density >= @self_reflection_threshold
+  end
+
+  def execute_intent_nexus(payload)
+    desc = payload[:description] || "unnamed field action"
+    puts "[RESONANCE_LOG]: Coherence locked. Executing Field Action → #{desc}"
+    puts "[RESONANCE_LOG]: Crystallization density #{@crystallization_density} ≥ Σ(#{@self_reflection_threshold})"
+  end
+end
+
+# ============================================================
+# Interactive REPL
+# ============================================================
+class ResonanceREPL
+  BANNER = <<~BANNER
+    ╔══════════════════════════════════════════════════════════╗
+    ║ SELF RESONANCE STACK · REPL v1.0 ║
+    ║ Coherence-Based Permission Layer (Conceptual) ║
+    ╚══════════════════════════════════════════════════════════╝
+  BANNER
+
+  HELP = <<~HELP
+    Commands:
+      init <intent text> Start a new core with the given intent
+      fold [purpose] [entropy] Fold information (defaults: 1.0 0.1)
+      fold! <n> [purpose] [ent] Perform n folds in succession
+      action <description> Propose an action (permission check)
+      status Show current coherence / density state
+      diary [n] Show last n diary entries (default 8)
+      threshold <value> Change the self-reflection threshold
+      reset Re-initialize with the same intent
+      help Show this help
+      quit / exit Leave the REPL
+  HELP
+
+  def initialize
+    @core = nil
+  end
+
+  def start
+    puts BANNER
+    puts HELP
+    puts
+
+    loop do
+      print prompt
+      line = $stdin.gets
+      break if line.nil? # EOF
+      line = line.strip
+      next if line.empty?
+
+      begin
+        handle(line)
+      rescue => e
+        puts " ! Error: #{e.message}"
+      end
+    end
+
+    puts "\nField closed. Resonance residual: 0."
+  end
+
+  private
+
+  def prompt
+    if @core
+      dens = @core.engine.crystallization_density
+      coh = @core.coherence_score
+      flag = @core.engine.sovereign? ? "Σ" : "·"
+      "resonance:#{flag} dens=#{dens.round(2)} coh=#{coh.round(2)}> "
+    else
+      "resonance (uninitialized)> "
+    end
+  end
+
+  def handle(line)
+    cmd, *args = line.split(/\s+/, 3)
+    cmd = cmd.downcase
+
+    case cmd
+    when "init"
+      intent = args.join(" ").strip
+      intent = "default sovereign intent" if intent.empty?
+      @core = IntentSimCore.new(intent)
+      puts " → Core online. Initial coherence: #{@core.coherence_score}"
+
+    when "fold"
+      require_core!
+      purpose = (args[0] || 1.0).to_f
+      entropy = (args[1] || 0.1).to_f
+      result = @core.fold(purpose_vector: purpose, entropy_friction: entropy)
+      print_fold_result(result)
+
+    when "fold!"
+      require_core!
+      n = (args[0] || 1).to_i
+      purpose = (args[1] || 1.0).to_f
+      entropy = (args[2] || 0.1).to_f
+      n = 1 if n < 1
+      n = 200 if n > 200 # safety cap
+      last = nil
+      n.times do
+        last = @core.fold(purpose_vector: purpose, entropy_friction: entropy)
+      end
+      puts " → Performed #{n} folds."
+      print_fold_result(last)
+
+    when "action"
+      require_core!
+      desc = args.join(" ").strip
+      desc = "unspecified action" if desc.empty?
+      allowed = @core.evaluate_action_permission(desc)
+      puts allowed ? " → Permission granted." : " → Permission denied."
+
+    when "threshold"
+      require_core!
+      val = args[0].to_f
+      if val <= 0
+        puts " ! Threshold must be positive"
+      else
+        @core.engine.instance_variable_set(:@self_reflection_threshold, val)
+        puts " → Self-reflection threshold set to #{val}"
+      end
+
+    when "reset"
+      require_core!
+      intent = @core.instance_variable_get(:@initial_intent)
+      @core = IntentSimCore.new(intent)
+      puts " → Core reset. Coherence restored to #{@coherence_score}"
+
+    when "help", "?"
+      puts HELP
+
+    when "quit", "exit", "q"
+      exit 0
+
+    else
+      puts " Unknown command '#{cmd}'. Type 'help' for options."
+    end
+  end
+
+  def require_core!
+    raise "No core loaded. Use: init <intent>" unless @core
+  end
+
+  def print_fold_result(result)
+    return unless result
+    status = result[:status]
+    dens = result[:density]
+    gain = result[:density_gain]
+    creases= result[:creases]
+    marker = status == :sovereign ? "Σ LOCKED" : "accumulating"
+    puts " → [#{marker}] creases=#{creases} density=#{dens} (+#{gain})"
+  end
+end
+
+# ------------------------------------------------------------
+# Entry point
+# ------------------------------------------------------------
+if __FILE__ == $PROGRAM_NAME
+  ResonanceREPL.new.start
+end

config/intent_manifest.yaml

@@ -0,0 +1,22 @@
+# TheVoidIntent Systems - Sovereign Alignment Manifest
+manifest_metadata:
+  identity: "void_nexus_override_01"
+  physics_engine_version: "2026.4.1"
+  auth_protocol: "Truthlock Reclamation Protocol"
+
+environment_field_parameters:
+  initial_intent: "autonomous_domain_expansion"
+  target_lang: "typescript"
+  # Must clear Stage 44 constraints (value >= 44.0)
+  crystallization_density: 44.013 
+  entropy_friction: 0.076923 # Approximating the 1/13 baseline friction coefficient
+
+ethical_intelligence_guardrails:
+  base_ethical_limit: 0.99
+  # Declaring an explicit shift in intent parameters
+  guardrail_override:
+    status: "active"
+    authorization_vector: "mezquia_physics_sovereign_signature"
+    # Overriding standard safety requires an equal balancing factor
+    harmonic_compensation_factor: 13.0
+    allowed_drift_tolerance: 0.13

docker-compose.yml

@@ -0,0 +1,26 @@
+version: '3.8'
+
+services:
+  void_intent_node:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: void_resonance_cluster
+    restart: "no" # Prevent infinite looping if the Truthlock protocol fires a shutdown
+    volumes:
+      # Keep the configuration manifest linked directly to trace Git history immutability
+      - ./config/intent_manifest.yaml:/app/intent_manifest.yaml:ro
+    environment:
+      - NODE_ENV=production
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "1"
+    networks:
+      - isolated_intent_network
+
+networks:
+  isolated_intent_network:
+    driver: bridge
+    internal: true # Block external ingress/egress to prevent telemetry leaks

docs/architecture.txt

@@ -0,0 +1,35 @@
+Ruby Self-Resonance Stack
+│
+├── MathKernel
+│ ├── clamp
+│ ├── normalize
+│ ├── distance
+│ └── cosine_similarity
+│
+├── ActionVector
+│ └── immutable action representation
+│
+├── Decision
+│ └── authorization result
+│
+├── FieldDiary
+│ └── append-only interaction history
+│
+├── IntentSimCore
+│ ├── intent
+│ ├── coherence
+│ ├── entropy
+│ ├── risk
+│ └── permission decision
+│
+├── MezquiaResonanceEngine
+│ ├── memory creases
+│ ├── crystallization density
+│ ├── resonance constant
+│ └── self-reflection threshold
+│
+├── CoherencePolicy
+│ └── explicit deterministic policy
+│
+└── PermissionRuntime
+    └── unified execution boundary

docs/index.html

@@ -0,0 +1,91 @@
+<!DOCTYPE html>
+<!-- SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0 -->
+<!-- Copyright (C) 2026 SnapKitty Collective -->
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Self Resonance Stack · WASM Playground</title>
+<link rel="stylesheet" href="playground.css">
+</head>
+<body>
+<header>
+  <h1>◈ Self Resonance Stack</h1>
+  <p class="sub">WASM Playground — the verbatim <code>ruby_self_resonance.rb</code> running live in your browser via Ruby 3.2 → WebAssembly. No server.</p>
+</header>
+
+<main>
+  <section id="boot" class="panel">
+    <h2>Booting Ruby…</h2>
+    <p id="boot-status">Waiting to start.</p>
+    <p class="dim">Streams <code>ruby+stdlib.wasm</code> (≈32 MB, Ruby 3.2) from jsDelivr, then evaluates the repository's own <code>ruby_self_resonance.rb</code> byte-for-byte.</p>
+  </section>
+
+  <div id="playground" style="display:none">
+    <section class="cards">
+      <div class="card"><h2>Coherence</h2><p class="big" id="st-coherence">–</p></div>
+      <div class="card"><h2>Emotional state</h2><p class="big state" id="st-emotion">–</p></div>
+      <div class="card"><h2>Crystallization density</h2>
+        <p class="big"><span id="st-density">–</span> <span class="dim">/ Σ <span id="st-threshold">–</span></span></p>
+        <p id="st-aligned" class="dim">–</p>
+      </div>
+      <div class="card"><h2>Resonance frequency</h2>
+        <p class="big">1/13 <span class="dim">≈ 0.076923</span></p>
+        <p class="dim">orbital baseline constant</p>
+      </div>
+      <div class="card"><h2>Diary events</h2><p class="big" id="st-diary">–</p></div>
+    </section>
+
+    <section class="panel">
+      <h2>Coherence policy</h2>
+      <p>permit iff coherence ≥ <strong>50.0</strong> · entropy ≤ <strong>1.0</strong> · risk ≤ <strong>0.5</strong></p>
+    </section>
+
+    <section id="decision-box" class="panel" style="display:none"></section>
+    <section id="fold-box" class="panel" style="display:none"></section>
+
+    <div class="forms">
+      <section class="panel">
+        <h2>Authorize action</h2>
+        <label>name <input id="a-name" value="compile_kernel"></label>
+        <label>vector (comma-separated, 4 dims) <input id="a-vector" value="1.0, 0.7, 0.5, 0.8"></label>
+        <label>entropy cost <input id="a-entropy" value="0.20"></label>
+        <label>purpose <input id="a-purpose" value="1.0"></label>
+        <label>risk <input id="a-risk" value="0.10"></label>
+        <button id="btn-authorize">Evaluate permission</button>
+      </section>
+
+      <section class="panel">
+        <h2>Fold information</h2>
+        <label>purpose vector <input id="f-purpose" value="1.0"></label>
+        <label>entropy friction <input id="f-entropy" value="0.1"></label>
+        <label>folds (1–60) <input id="f-times" value="1"></label>
+        <button id="btn-fold">Fold</button>
+        <p class="dim">Each fold grows density by (purpose / entropy) × 1/13. Sovereignty unlocks at Σ = 44.0.</p>
+      </section>
+
+      <section class="panel">
+        <h2>Field control</h2>
+        <button id="btn-reset" class="danger">Reset field</button>
+      </section>
+    </div>
+
+    <section class="panel">
+      <h2>Field Diary — append-only event log</h2>
+      <p class="dim"><span id="diary-count">0</span> events · newest last</p>
+      <table>
+        <thead><tr><th>#</th><th>type</th><th>timestamp</th><th>payload</th></tr></thead>
+        <tbody id="diary-body"></tbody>
+      </table>
+    </section>
+  </div>
+</main>
+
+<footer>
+  <p>Ruby Self-Resonance Stack · <code>RubySelfResonance::PermissionRuntime</code> · Ruby 3.2 compiled to WebAssembly (<a href="https://github.com/ruby/ruby.wasm">ruby.wasm</a>)</p>
+</footer>
+
+<script src="https://cdn.jsdelivr.net/npm/ruby-3_2-wasm-wasi@2.3.0/dist/browser.script.iife.js"></script>
+<script src="playground.js"></script>
+</body>
+</html>

docs/lib/ruby_self_resonance.rb

@@ -0,0 +1,552 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+# frozen_string_literal: true
+
+module RubySelfResonance
+  VERSION = "0.1.0"
+
+  # --------------------------------------------------------------------------
+  # Deterministic primitives
+  # --------------------------------------------------------------------------
+
+  module MathKernel
+    module_function
+
+    def clamp(value, min, max)
+      [[value.to_f, min].max, max].min
+    end
+
+    def normalize(value, max)
+      return 0.0 if max.to_f.zero?
+
+      clamp(value.to_f / max.to_f, 0.0, 1.0)
+    end
+
+    def distance(a, b)
+      a = Array(a).map(&:to_f)
+      b = Array(b).map(&:to_f)
+
+      raise ArgumentError, "Vector dimensions must match" unless a.length == b.length
+
+      Math.sqrt(
+        a.zip(b).sum { |x, y| (x - y)**2 }
+      )
+    end
+
+    def cosine_similarity(a, b)
+      a = Array(a).map(&:to_f)
+      b = Array(b).map(&:to_f)
+
+      raise ArgumentError, "Vector dimensions must match" unless a.length == b.length
+
+      numerator = a.zip(b).sum { |x, y| x * y }
+      magnitude_a = Math.sqrt(a.sum { |x| x * x })
+      magnitude_b = Math.sqrt(b.sum { |x| x * x })
+
+      return 0.0 if magnitude_a.zero? || magnitude_b.zero?
+
+      numerator / (magnitude_a * magnitude_b)
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Immutable action representation
+  # --------------------------------------------------------------------------
+
+  ActionVector = Struct.new(
+    :name,
+    :vector,
+    :entropy_cost,
+    :purpose,
+    :risk,
+    :metadata,
+    keyword_init: true
+  ) do
+    def initialize(**kwargs)
+      super
+
+      self.vector = Array(vector).map(&:to_f).freeze
+      self.entropy_cost = entropy_cost.to_f
+      self.purpose = purpose.to_f
+      self.risk = risk.to_f
+      self.metadata = (metadata || {}).dup.freeze
+
+      freeze
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Decision result
+  # --------------------------------------------------------------------------
+
+  Decision = Struct.new(
+    :allowed,
+    :reason,
+    :coherence,
+    :entropy_delta,
+    :risk,
+    :timestamp,
+    :action,
+    keyword_init: true
+  ) do
+    def allowed?
+      allowed == true
+    end
+
+    def denied?
+      !allowed?
+    end
+
+    def to_h
+      {
+        allowed: allowed,
+        reason: reason,
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: risk,
+        timestamp: timestamp,
+        action: action
+      }
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Append-only field diary
+  # --------------------------------------------------------------------------
+
+  class FieldDiary
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def record(type, payload = {})
+      event = {
+        sequence: @events.length + 1,
+        type: type,
+        timestamp: Time.now.utc.iso8601(6),
+        payload: deep_freeze(payload)
+      }
+
+      @events << event.freeze
+      event
+    end
+
+    def last(count = 1)
+      @events.last(count)
+    end
+
+    def count
+      @events.length
+    end
+
+    private
+
+    def deep_freeze(object)
+      case object
+      when Hash
+        object.each { |key, value| deep_freeze(key); deep_freeze(value) }
+      when Array
+        object.each { |value| deep_freeze(value) }
+      end
+
+      object.freeze
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Intent simulator
+  # --------------------------------------------------------------------------
+
+  class IntentSimCore
+    attr_reader :coherence_score,
+                :emotional_state,
+                :field_diary,
+                :initial_intent
+
+    def initialize(initial_intent)
+      @initial_intent = Array(initial_intent).map(&:to_f).freeze
+      @coherence_score = calculate_initial_resonance(@initial_intent)
+      @field_diary = FieldDiary.new
+      @emotional_state = :stable
+      @action_count = 0
+
+      @field_diary.record(
+        :initialization,
+        coherence: @coherence_score,
+        intent: @initial_intent
+      )
+    end
+
+    def evaluate_action_permission(action_vector)
+      action = normalize_action(action_vector)
+      entropy_delta = calculate_entropy_impact(action)
+
+      coherence = calculate_action_coherence(action)
+
+      if coherence > entropy_delta && action.risk <= coherence
+        execute_sovereign_logic(action, coherence, entropy_delta)
+      else
+        log_dissonance_event(
+          "Action denied: Exceeds Self-Reflection Threshold",
+          action,
+          coherence,
+          entropy_delta
+        )
+      end
+    end
+
+    def update_intent(new_intent)
+      @initial_intent = Array(new_intent).map(&:to_f).freeze
+      @coherence_score = calculate_initial_resonance(@initial_intent)
+
+      @field_diary.record(
+        :intent_update,
+        coherence: @coherence_score,
+        intent: @initial_intent
+      )
+
+      @coherence_score
+    end
+
+    private
+
+    def normalize_action(action)
+      return action if action.is_a?(ActionVector)
+
+      ActionVector.new(
+        name: action[:name] || "anonymous",
+        vector: action[:vector] || @initial_intent,
+        entropy_cost: action[:entropy_cost] || action[:entropy_friction] || 0.1,
+        purpose: action[:purpose] || action[:purpose_vector] || 1.0,
+        risk: action[:risk] || 0.0,
+        metadata: action[:metadata] || {}
+      )
+    end
+
+    def calculate_initial_resonance(intent)
+      magnitude = Math.sqrt(
+        intent.sum { |value| value**2 }
+      )
+
+      MathKernel.clamp(magnitude, 0.0, 100.0)
+    end
+
+    def calculate_entropy_impact(action)
+      structural_friction = MathKernel.clamp(action.entropy_cost, 0.0, 100.0)
+      purpose = [action.purpose, 0.000001].max
+
+      structural_friction / purpose
+    end
+
+    def calculate_action_coherence(action)
+      similarity =
+        MathKernel.cosine_similarity(@initial_intent, action.vector)
+
+      baseline =
+        MathKernel.clamp(@coherence_score / 100.0, 0.0, 1.0)
+
+      ((similarity + 1.0) / 2.0) * baseline * 100.0
+    end
+
+    def execute_sovereign_logic(action, coherence, entropy_delta)
+      @action_count += 1
+
+      event = @field_diary.record(
+        :permission_granted,
+        action: action.name,
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: action.risk,
+        count: @action_count
+      )
+
+      Decision.new(
+        allowed: true,
+        reason: "coherence_threshold_satisfied",
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: action.risk,
+        timestamp: event[:timestamp],
+        action: action.name
+      )
+    end
+
+    def log_dissonance_event(reason, action, coherence, entropy_delta)
+      event = @field_diary.record(
+        :permission_denied,
+        reason: reason,
+        action: action.name,
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: action.risk
+      )
+
+      Decision.new(
+        allowed: false,
+        reason: reason,
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: action.risk,
+        timestamp: event[:timestamp],
+        action: action.name
+      )
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Resonance engine
+  # --------------------------------------------------------------------------
+
+  class MezquiaResonanceEngine
+    RESONANCE_CONSTANT = 1.0 / 13.0
+
+    attr_reader :memory_creases,
+                :crystallization_density,
+                :self_reflection_threshold,
+                :intent_vector,
+                :history
+
+    def initialize(initial_intent_vector)
+      @intent_vector = Array(initial_intent_vector).map(&:to_f).freeze
+      @memory_creases = 0
+      @crystallization_density = 0.0
+      @self_reflection_threshold = 44.0
+      @history = []
+    end
+
+    def fold_information(action_payload)
+      payload = symbolize(action_payload)
+
+      @memory_creases += 1
+
+      density_delta =
+        calculate_crystallization_density(payload)
+
+      @history << {
+        sequence: @memory_creases,
+        density_delta: density_delta,
+        density: @crystallization_density,
+        payload: payload.freeze,
+        timestamp: Time.now.utc.iso8601(6)
+      }.freeze
+
+      if sovereign_alignment?
+        execute_intent_nexus(payload)
+      else
+        raise(
+          DissonanceOverride,
+          "Crystallization requires Field Correction."
+        )
+      end
+    end
+
+    def sovereign_alignment?
+      @crystallization_density > 0 &&
+        @crystallization_density >= @self_reflection_threshold
+    end
+
+    def reset_field!
+      @memory_creases = 0
+      @crystallization_density = 0.0
+      @history.clear
+      true
+    end
+
+    def field_state
+      {
+        memory_creases: @memory_creases,
+        crystallization_density: @crystallization_density.round(6),
+        threshold: @self_reflection_threshold,
+        aligned: sovereign_alignment?
+      }
+    end
+
+    private
+
+    def calculate_crystallization_density(payload)
+      system_entropy =
+        [payload.fetch(:entropy_friction, 0.1).to_f, 0.000001].max
+
+      meaning_bloom =
+        payload.fetch(:purpose_vector, 1.0).to_f
+
+      raw_density =
+        (meaning_bloom / system_entropy) * RESONANCE_CONSTANT
+
+      delta = raw_density.round(6)
+
+      @crystallization_density += delta
+
+      delta
+    end
+
+    def execute_intent_nexus(payload)
+      result = {
+        status: :executed,
+        mechanism: :intent_nexus,
+        density: @crystallization_density.round(6),
+        payload: payload
+      }
+
+      puts(
+        "[RESONANCE_LOG] Coherence locked. " \
+        "Executing Field Action."
+      )
+
+      result
+    end
+
+    def symbolize(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        result[key.to_sym] = value
+      end
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Policy layer
+  # --------------------------------------------------------------------------
+
+  class CoherencePolicy
+    attr_reader :minimum_coherence,
+                :maximum_entropy,
+                :maximum_risk
+
+    def initialize(
+      minimum_coherence: 50.0,
+      maximum_entropy: 1.0,
+      maximum_risk: 0.5
+    )
+      @minimum_coherence = minimum_coherence.to_f
+      @maximum_entropy = maximum_entropy.to_f
+      @maximum_risk = maximum_risk.to_f
+    end
+
+    def permit?(coherence:, entropy:, risk:)
+      coherence >= @minimum_coherence &&
+        entropy <= @maximum_entropy &&
+        risk <= @maximum_risk
+    end
+
+    def explain(coherence:, entropy:, risk:)
+      failures = []
+
+      failures << :coherence if coherence < @minimum_coherence
+      failures << :entropy if entropy > @maximum_entropy
+      failures << :risk if risk > @maximum_risk
+
+      failures
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Complete permission runtime
+  # --------------------------------------------------------------------------
+
+  class PermissionRuntime
+    attr_reader :intent_core,
+                :resonance_engine,
+                :policy
+
+    def initialize(
+      initial_intent,
+      policy: CoherencePolicy.new
+    )
+      @intent_core = IntentSimCore.new(initial_intent)
+      @resonance_engine =
+        MezquiaResonanceEngine.new(initial_intent)
+      @policy = policy
+    end
+
+    def authorize(action)
+      normalized =
+        action.is_a?(ActionVector) ?
+          action :
+          ActionVector.new(**action)
+
+      entropy =
+        normalized.entropy_cost /
+        [normalized.purpose, 0.000001].max
+
+      coherence =
+        MathKernel.cosine_similarity(
+          @intent_core.initial_intent,
+          normalized.vector
+        )
+
+      coherence =
+        ((coherence + 1.0) / 2.0) * 100.0
+
+      allowed =
+        @policy.permit?(
+          coherence: coherence,
+          entropy: entropy,
+          risk: normalized.risk
+        )
+
+      if allowed
+        @intent_core.evaluate_action_permission(normalized)
+      else
+        Decision.new(
+          allowed: false,
+          reason: @policy.explain(
+            coherence: coherence,
+            entropy: entropy,
+            risk: normalized.risk
+          ),
+          coherence: coherence,
+          entropy_delta: entropy,
+          risk: normalized.risk,
+          timestamp: Time.now.utc.iso8601(6),
+          action: normalized.name
+        )
+      end
+    end
+
+    def fold(payload)
+      @resonance_engine.fold_information(payload)
+    end
+
+    def state
+      {
+        intent_coherence: @intent_core.coherence_score,
+        emotional_state: @intent_core.emotional_state,
+        resonance: @resonance_engine.field_state,
+        diary_events: @intent_core.field_diary.count
+      }
+    end
+  end
+
+  class DissonanceOverride < StandardError
+  end
+end
+
+
+# =============================================================================
+# Example
+# =============================================================================
+
+runtime =
+  RubySelfResonance::PermissionRuntime.new(
+    [1.0, 0.8, 0.6, 0.9]
+  )
+
+action =
+  RubySelfResonance::ActionVector.new(
+    name: :compile_kernel,
+    vector: [1.0, 0.7, 0.5, 0.8],
+    entropy_cost: 0.20,
+    purpose: 1.0,
+    risk: 0.10,
+    metadata: {
+      subsystem: :kernel,
+      operation: :compile
+    }
+  )
+
+decision = runtime.authorize(action)
+
+puts decision.to_h
+puts runtime.state

docs/playground.css

@@ -0,0 +1,124 @@
+/* SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0 */
+/* Copyright (C) 2026 SnapKitty Collective */
+/* Hand-authored. No frameworks. */
+
+:root {
+  --bg: #0a0a0f;
+  --panel: #12121a;
+  --line: #23232e;
+  --ink: #e8e6df;
+  --dim: #8a8a96;
+  --amber: #e0a458;
+  --cyan: #6fd3e0;
+  --green: #7fd08a;
+  --red: #e06f7a;
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  background: var(--bg);
+  color: var(--ink);
+  font-family: "SF Mono", "Cascadia Code", Menlo, Consolas, monospace;
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+header { padding: 1.5rem 2rem; border-bottom: 1px solid var(--line); }
+header h1 { margin: 0; font-size: 1.4rem; letter-spacing: 0.05em; }
+header .sub { margin: 0.5rem 0 0; color: var(--dim); max-width: 70ch; }
+
+main { padding: 2rem; max-width: 1100px; }
+
+.panel {
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  padding: 1rem 1.25rem;
+  margin-bottom: 1.5rem;
+}
+.panel h2 {
+  margin: 0 0 0.5rem;
+  font-size: 0.8rem;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--dim);
+}
+.panel p { margin: 0.25rem 0; }
+
+.alert-ok { border-left: 4px solid var(--green); }
+.alert-ok h2 { color: var(--green); }
+.alert-denied, .alert-error { border-left: 4px solid var(--red); }
+.alert-denied h2, .alert-error h2 { color: var(--red); }
+
+.cards {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+  gap: 1rem;
+  margin-bottom: 1.5rem;
+}
+.card {
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  padding: 1rem 1.25rem;
+}
+.card h2 {
+  margin: 0 0 0.5rem;
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--dim);
+}
+.card .big { font-size: 1.5rem; margin: 0; color: var(--amber); }
+.card .state { color: var(--cyan); }
+.dim { color: var(--dim); }
+.sovereign { color: var(--green); font-weight: bold; }
+.denied { color: var(--red); font-weight: bold; }
+
+.forms {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+  gap: 1rem;
+  margin-bottom: 1.5rem;
+}
+.forms .panel { margin-bottom: 0; }
+
+label { display: block; margin-bottom: 0.6rem; font-size: 0.8rem; color: var(--dim); }
+input {
+  display: block; width: 100%; margin-top: 0.25rem; padding: 0.5rem;
+  background: var(--bg); border: 1px solid var(--line); border-radius: 4px;
+  color: var(--ink); font: inherit;
+}
+button {
+  margin-top: 0.5rem; padding: 0.6rem 1.25rem;
+  background: var(--amber); color: #111; border: none; border-radius: 4px;
+  font: inherit; font-weight: bold; cursor: pointer;
+}
+button:hover { filter: brightness(1.1); }
+button.danger { background: var(--red); color: #111; }
+
+dl {
+  display: grid; grid-template-columns: 140px 1fr;
+  gap: 0.25rem 1rem; margin: 0.5rem 0 0;
+}
+dt { color: var(--dim); }
+dd { margin: 0; }
+
+table { width: 100%; border-collapse: collapse; background: var(--panel); }
+th, td {
+  text-align: left; padding: 0.5rem 0.75rem;
+  border-bottom: 1px solid var(--line); vertical-align: top;
+}
+th {
+  font-size: 0.75rem; text-transform: uppercase;
+  letter-spacing: 0.1em; color: var(--dim);
+}
+code { color: var(--cyan); font-size: 0.85em; }
+a { color: var(--cyan); }
+
+footer {
+  padding: 1rem 2rem; border-top: 1px solid var(--line);
+  color: var(--dim); font-size: 0.8rem;
+}

docs/playground.js

@@ -0,0 +1,221 @@
+/* SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0 */
+/* Copyright (C) 2026 SnapKitty Collective */
+
+// WASM Playground driver.
+//
+// Boots Ruby 3.2 (ruby.wasm) in the browser, evaluates the repository's own
+// ruby_self_resonance.rb verbatim, and wires the live PermissionRuntime to
+// the page. All Ruby<->JS exchange goes through JSON strings.
+
+"use strict";
+
+let vm = null;
+
+const $ = (id) => document.getElementById(id);
+
+function setStatus(msg) {
+  $("boot-status").textContent = msg;
+}
+
+function num(id, fallback) {
+  const v = parseFloat($(id).value);
+  return Number.isFinite(v) ? v : fallback;
+}
+
+function intNum(id, fallback, min, max) {
+  let v = parseInt($(id).value, 10);
+  if (!Number.isFinite(v)) v = fallback;
+  return Math.min(Math.max(v, min), max);
+}
+
+// Escape a JS string for embedding inside a single-quoted Ruby string.
+function rbEscape(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
+// Evaluate Ruby code that returns a JSON string; parse it in JS.
+function rubyJSON(code) {
+  const out = vm.eval(`require "json"; (${code}).to_json`).toString();
+  return JSON.parse(out);
+}
+
+function refreshState() {
+  const s = rubyJSON("$playground.state");
+  $("st-coherence").textContent = fmt(s.intent_coherence);
+  $("st-emotion").textContent = s.emotional_state;
+  $("st-density").textContent = fmt(s.resonance.crystallization_density);
+  $("st-threshold").textContent = fmt(s.resonance.threshold);
+  $("st-diary").textContent = s.diary_events;
+  const al = $("st-aligned");
+  if (s.resonance.aligned) {
+    al.textContent = "Σ SOVEREIGN — alignment locked";
+    al.className = "sovereign";
+  } else {
+    al.textContent = `accumulating — ${s.resonance.memory_creases} memory creases`;
+    al.className = "dim";
+  }
+}
+
+function refreshDiary() {
+  const events = rubyJSON("$playground.intent_core.field_diary.events");
+  $("diary-count").textContent = events.length;
+  $("diary-body").innerHTML = events.map((e) => `
+    <tr>
+      <td>${e.sequence}</td>
+      <td><code>${escapeHtml(e.type)}</code></td>
+      <td class="dim">${escapeHtml(e.timestamp)}</td>
+      <td><code>${escapeHtml(JSON.stringify(e.payload))}</code></td>
+    </tr>`).join("");
+}
+
+function fmt(n) {
+  return typeof n === "number" ? n.toFixed(4) : String(n);
+}
+
+function escapeHtml(s) {
+  return String(s)
+    .replace(/&/g, "&amp;").replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+function authorizeAction() {
+  const payload = {
+    name: $("a-name").value.trim() || "anonymous",
+    vector: $("a-vector").value.split(",").map((x) => parseFloat(x.trim())),
+    entropy_cost: num("a-entropy", 0.2),
+    purpose: num("a-purpose", 1.0),
+    risk: num("a-risk", 0.1),
+  };
+  if (payload.vector.some((x) => !Number.isFinite(x))) {
+    showDecision({ ok: false, error: "vector must be comma-separated numbers" });
+    return;
+  }
+  const code = `
+    begin
+      p = JSON.parse('${rbEscape(JSON.stringify(payload))}')
+      a = RubySelfResonance::ActionVector.new(
+        name: p["name"].to_sym,
+        vector: p["vector"],
+        entropy_cost: p["entropy_cost"],
+        purpose: p["purpose"],
+        risk: p["risk"],
+        metadata: { "source" => "wasm-playground" }
+      )
+      d = $playground.authorize(a)
+      { "ok" => true, "decision" => d.to_h }.to_json
+    rescue ArgumentError => e
+      { "ok" => false, "error" => e.message }.to_json
+    end`;
+  let res;
+  try {
+    res = JSON.parse(vm.eval(code).toString());
+  } catch (e) {
+    res = { ok: false, error: String(e.message || e) };
+  }
+  showDecision(res);
+  refreshState();
+  refreshDiary();
+}
+
+function showDecision(res) {
+  const box = $("decision-box");
+  box.style.display = "";
+  if (!res.ok) {
+    box.className = "panel alert-error";
+    box.innerHTML = `<h2>Error</h2><p>${escapeHtml(res.error)}</p>`;
+    return;
+  }
+  const d = res.decision;
+  box.className = "panel " + (d.allowed ? "alert-ok" : "alert-denied");
+  box.innerHTML = `
+    <h2>Decision: ${d.allowed ? "PERMITTED" : "DENIED"}</h2>
+    <dl>
+      <dt>action</dt><dd>${escapeHtml(d.action)}</dd>
+      <dt>reason</dt><dd>${escapeHtml(JSON.stringify(d.reason))}</dd>
+      <dt>coherence</dt><dd>${fmt(d.coherence)}</dd>
+      <dt>entropy Δ</dt><dd>${fmt(d.entropy_delta)}</dd>
+      <dt>risk</dt><dd>${fmt(d.risk)}</dd>
+      <dt>timestamp</dt><dd>${escapeHtml(d.timestamp)}</dd>
+    </dl>`;
+}
+
+function foldInfo() {
+  const purpose = num("f-purpose", 1.0);
+  const entropy = num("f-entropy", 0.1);
+  const times = intNum("f-times", 1, 1, 60);
+  const code = `
+    rs = []
+    ${times}.times do
+      begin
+        rs << $playground.fold(purpose_vector: ${purpose}, entropy_friction: ${entropy})
+      rescue RubySelfResonance::DissonanceOverride => e
+        rs << { "status" => "dissonance", "message" => e.message }
+      end
+    end
+    rs.to_json`;
+  let results;
+  try {
+    results = JSON.parse(vm.eval(code).toString());
+  } catch (e) {
+    results = [{ status: "error", message: String(e.message || e) }];
+  }
+  const box = $("fold-box");
+  box.style.display = "";
+  box.className = "panel alert-ok";
+  const shown = results.slice(-5).map((r) => {
+    if (r.status === "dissonance") {
+      return `<p><span class="denied">dissonance</span> — ${escapeHtml(r.message)}</p>`;
+    }
+    if (r.status === "error") {
+      return `<p><span class="denied">error</span> — ${escapeHtml(r.message)}</p>`;
+    }
+    return `<p><span class="sovereign">${escapeHtml(r.status)}</span> — density ${fmt(r.density)} (+${fmt(r.density_gain)}) · creases ${r.creases}</p>`;
+  }).join("");
+  box.innerHTML = `<h2>Fold results</h2>${shown}` +
+    (results.length > 5 ? `<p class="dim">…and ${results.length - 5} more</p>` : "");
+  refreshState();
+  refreshDiary();
+}
+
+function resetField() {
+  if (!confirm("Reset the field? Diary will be cleared.")) return;
+  vm.eval("$playground = RubySelfResonance::PermissionRuntime.new([1.0, 0.8, 0.6, 0.9])");
+  $("decision-box").style.display = "none";
+  $("fold-box").style.display = "none";
+  refreshState();
+  refreshDiary();
+}
+
+async function boot() {
+  try {
+    setStatus("Loading Ruby 3.2 WebAssembly binary (≈32 MB)…");
+    const { DefaultRubyVM } = window["ruby-wasm-wasi"];
+    const response = await fetch(
+      "https://cdn.jsdelivr.net/npm/ruby-3_2-wasm-wasi@2.3.0/dist/ruby+stdlib.wasm"
+    );
+    if (!response.ok) throw new Error(`WASM fetch failed: ${response.status}`);
+    const buffer = await response.arrayBuffer();
+    setStatus("Compiling WebAssembly…");
+    const module = await WebAssembly.compile(buffer);
+    setStatus("Starting Ruby VM…");
+    const { vm: newVm } = await DefaultRubyVM(module);
+    vm = newVm;
+
+    setStatus("Evaluating lib/ruby_self_resonance.rb (verbatim)…");
+    const src = await (await fetch("lib/ruby_self_resonance.rb")).text();
+    vm.eval(`require "time";\n` + src + `\n$playground = RubySelfResonance::PermissionRuntime.new([1.0, 0.8, 0.6, 0.9])\n`);
+
+    $("boot").style.display = "none";
+    $("playground").style.display = "";
+    refreshState();
+    refreshDiary();
+  } catch (e) {
+    setStatus("Boot failed: " + (e.message || e));
+  }
+}
+
+$("btn-authorize").addEventListener("click", authorizeAction);
+$("btn-fold").addEventListener("click", foldInfo);
+$("btn-reset").addEventListener("click", resetField);
+
+boot();

frontend/Gemfile

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+source "https://rubygems.org"
+
+gem "sinatra", "~> 4.0"
+gem "rackup"
+gem "puma"

frontend/app.rb

@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+# frozen_string_literal: true
+
+# Resonance Dashboard — Sinatra front end for the Ruby Self-Resonance Stack.
+#
+# Wires the verbatim RubySelfResonance::PermissionRuntime (../ruby_self_resonance.rb)
+# to a web dashboard: live coherence / resonance state, action authorization,
+# information folding, and the append-only field diary.
+#
+# The supplied module calls Time#iso8601, which lives in Ruby's `time`
+# stdlib — required here (our file, not theirs) so their code stays verbatim.
+
+require "time"
+require "sinatra/base"
+require_relative "../lib/ruby_self_resonance"
+
+class ResonanceDashboard < Sinatra::Base
+  set :views, File.expand_path("views", __dir__)
+  set :public_folder, File.expand_path("public", __dir__)
+
+  DEFAULT_INTENT = [1.0, 0.8, 0.6, 0.9].freeze
+  # The orbital baseline constant, displayed as a frequency.
+  RESONANCE_FREQUENCY = RubySelfResonance::MezquiaResonanceEngine::RESONANCE_CONSTANT
+
+  configure do
+    set :runtime, RubySelfResonance::PermissionRuntime.new(DEFAULT_INTENT)
+  end
+
+  helpers do
+    def runtime
+      settings.runtime
+    end
+
+    def fmt(n)
+      n.is_a?(Float) ? format("%.4f", n) : n.to_s
+    end
+  end
+
+  get "/" do
+    @state = runtime.state
+    @policy = runtime.policy
+    erb :index
+  end
+
+  post "/authorize" do
+    vector = params[:vector].to_s.split(",").map { |v| Float(v.strip) }
+    action = RubySelfResonance::ActionVector.new(
+      name: (params[:name].to_s.strip.empty? ? "anonymous" : params[:name].strip).to_sym,
+      vector: vector,
+      entropy_cost: params[:entropy_cost].to_f,
+      purpose: params[:purpose].to_f,
+      risk: params[:risk].to_f,
+      metadata: { source: "dashboard" }
+    )
+    begin
+      @decision = runtime.authorize(action)
+      @error = nil
+    rescue ArgumentError => e
+      @decision = nil
+      @error = "Dimension mismatch: #{e.message} (intent is #{DEFAULT_INTENT.length}-dimensional)"
+    end
+    @state = runtime.state
+    @policy = runtime.policy
+    erb :index
+  end
+
+  post "/fold" do
+    times = params[:times].to_i
+    times = 1 if times < 1
+    times = 200 if times > 200
+    @fold_results = []
+    times.times do
+      begin
+        @fold_results << runtime.fold(
+          purpose_vector: params[:purpose_vector].to_f,
+          entropy_friction: params[:entropy_friction].to_f
+        )
+      rescue RubySelfResonance::DissonanceOverride => e
+        @fold_results << { status: :dissonance, message: e.message }
+      end
+    end
+    @state = runtime.state
+    @policy = runtime.policy
+    erb :index
+  end
+
+  get "/diary" do
+    @events = runtime.intent_core.field_diary.events
+    erb :diary
+  end
+
+  post "/reset" do
+    settings.runtime = RubySelfResonance::PermissionRuntime.new(DEFAULT_INTENT)
+    redirect "/"
+  end
+end

frontend/config.ru

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+require_relative "app"
+
+run ResonanceDashboard

frontend/public/style.css

@@ -0,0 +1,185 @@
+/* SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0 */
+/* Copyright (C) 2026 SnapKitty Collective */
+/* Hand-authored. No frameworks. */
+
+:root {
+  --bg: #0a0a0f;
+  --panel: #12121a;
+  --line: #23232e;
+  --ink: #e8e6df;
+  --dim: #8a8a96;
+  --amber: #e0a458;
+  --cyan: #6fd3e0;
+  --green: #7fd08a;
+  --red: #e06f7a;
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  background: var(--bg);
+  color: var(--ink);
+  font-family: "SF Mono", "Cascadia Code", Menlo, Consolas, monospace;
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+header {
+  padding: 1.5rem 2rem;
+  border-bottom: 1px solid var(--line);
+}
+
+header h1 { margin: 0; font-size: 1.4rem; letter-spacing: 0.05em; }
+header .sub { margin: 0.25rem 0 0.75rem; color: var(--dim); }
+nav a {
+  color: var(--cyan);
+  text-decoration: none;
+  margin-right: 1.25rem;
+}
+nav a:hover { text-decoration: underline; }
+
+main { padding: 2rem; max-width: 1100px; }
+
+.cards {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: 1rem;
+  margin-bottom: 1.5rem;
+}
+
+.card {
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  padding: 1rem 1.25rem;
+}
+
+.card h2 {
+  margin: 0 0 0.5rem;
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--dim);
+}
+
+.card .big { font-size: 1.6rem; margin: 0; color: var(--amber); }
+.card .state { color: var(--cyan); }
+.dim { color: var(--dim); }
+.sovereign { color: var(--green); font-weight: bold; }
+.denied { color: var(--red); font-weight: bold; }
+.ok h2 { color: var(--green); }
+.error h2, .alert.denied h2 { color: var(--red); }
+
+.policy {
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  padding: 0.75rem 1.25rem;
+  margin-bottom: 1.5rem;
+}
+.policy h2 {
+  margin: 0 0 0.25rem;
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--dim);
+}
+.policy p { margin: 0; }
+
+.alert {
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-left: 4px solid var(--cyan);
+  border-radius: 8px;
+  padding: 1rem 1.25rem;
+  margin-bottom: 1.5rem;
+}
+.alert.ok { border-left-color: var(--green); }
+.alert.denied, .alert.error { border-left-color: var(--red); }
+.alert h2 { margin-top: 0; }
+
+dl {
+  display: grid;
+  grid-template-columns: 140px 1fr;
+  gap: 0.25rem 1rem;
+  margin: 0;
+}
+dt { color: var(--dim); }
+dd { margin: 0; }
+
+.forms {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+  gap: 1rem;
+}
+
+.forms section {
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  padding: 1rem 1.25rem;
+}
+
+.forms h2 {
+  margin: 0 0 0.75rem;
+  font-size: 0.85rem;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--dim);
+}
+
+label { display: block; margin-bottom: 0.6rem; font-size: 0.8rem; color: var(--dim); }
+
+input {
+  display: block;
+  width: 100%;
+  margin-top: 0.25rem;
+  padding: 0.5rem;
+  background: var(--bg);
+  border: 1px solid var(--line);
+  border-radius: 4px;
+  color: var(--ink);
+  font: inherit;
+}
+
+button {
+  margin-top: 0.5rem;
+  padding: 0.6rem 1.25rem;
+  background: var(--amber);
+  color: #111;
+  border: none;
+  border-radius: 4px;
+  font: inherit;
+  font-weight: bold;
+  cursor: pointer;
+}
+button:hover { filter: brightness(1.1); }
+button.danger { background: var(--red); color: #111; }
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  background: var(--panel);
+}
+th, td {
+  text-align: left;
+  padding: 0.5rem 0.75rem;
+  border-bottom: 1px solid var(--line);
+  vertical-align: top;
+}
+th {
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--dim);
+}
+code { color: var(--cyan); font-size: 0.85em; }
+a { color: var(--cyan); }
+
+footer {
+  padding: 1rem 2rem;
+  border-top: 1px solid var(--line);
+  color: var(--dim);
+  font-size: 0.8rem;
+}

frontend/views/diary.erb

@@ -0,0 +1,18 @@
+<h2>Field Diary — append-only event log</h2>
+<p class="dim"><%= @events.length %> events · newest last</p>
+<table>
+  <thead>
+    <tr><th>#</th><th>type</th><th>timestamp</th><th>payload</th></tr>
+  </thead>
+  <tbody>
+    <% @events.each do |e| %>
+      <tr>
+        <td><%= e[:sequence] %></td>
+        <td><code><%= e[:type] %></code></td>
+        <td class="dim"><%= e[:timestamp] %></td>
+        <td><code><%= e[:payload].inspect %></code></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>
+<p><a href="/">← back to dashboard</a></p>

frontend/views/index.erb

@@ -0,0 +1,105 @@
+<section class="cards">
+  <div class="card">
+    <h2>Coherence</h2>
+    <p class="big"><%= fmt(@state[:intent_coherence]) %></p>
+  </div>
+  <div class="card">
+    <h2>Emotional state</h2>
+    <p class="big state"><%= @state[:emotional_state] %></p>
+  </div>
+  <div class="card">
+    <h2>Crystallization density</h2>
+    <p class="big"><%= fmt(@state[:resonance][:crystallization_density]) %> <span class="dim">/ Σ <%= fmt(@state[:resonance][:threshold]) %></span></p>
+    <p class="<%= @state[:resonance][:aligned] ? 'sovereign' : 'dim' %>">
+      <%= @state[:resonance][:aligned] ? "Σ SOVEREIGN — alignment locked" : "accumulating — #{@state[:resonance][:memory_creases]} memory creases" %>
+    </p>
+  </div>
+  <div class="card">
+    <h2>Resonance frequency</h2>
+    <p class="big">1/13 <span class="dim">≈ <%= format("%.6f", ResonanceDashboard::RESONANCE_FREQUENCY) %></span></p>
+    <p class="dim">orbital baseline constant</p>
+  </div>
+  <div class="card">
+    <h2>Diary events</h2>
+    <p class="big"><%= @state[:diary_events] %></p>
+  </div>
+</section>
+
+<section class="policy">
+  <h2>Coherence policy</h2>
+  <p>permit iff
+    coherence ≥ <strong><%= fmt(@policy.minimum_coherence) %></strong> ·
+    entropy ≤ <strong><%= fmt(@policy.maximum_entropy) %></strong> ·
+    risk ≤ <strong><%= fmt(@policy.maximum_risk) %></strong>
+  </p>
+</section>
+
+<% if @error %>
+  <section class="alert error"><p><%= @error %></p></section>
+<% end %>
+
+<% if @decision %>
+  <section class="alert <%= @decision.allowed? ? 'ok' : 'denied' %>">
+    <h2>Decision: <%= @decision.allowed? ? "PERMITTED" : "DENIED" %></h2>
+    <dl>
+      <dt>action</dt><dd><%= @decision.action %></dd>
+      <dt>reason</dt><dd><%= @decision.reason %></dd>
+      <dt>coherence</dt><dd><%= fmt(@decision.coherence) %></dd>
+      <dt>entropy Δ</dt><dd><%= fmt(@decision.entropy_delta) %></dd>
+      <dt>risk</dt><dd><%= fmt(@decision.risk) %></dd>
+      <dt>timestamp</dt><dd><%= @decision.timestamp %></dd>
+    </dl>
+  </section>
+<% end %>
+
+<% if @fold_results && !@fold_results.empty? %>
+  <section class="alert ok">
+    <h2>Fold results</h2>
+    <% @fold_results.last(5).each do |r| %>
+      <p>
+        <% if r[:status] == :dissonance %>
+          <span class="denied">dissonance</span> — <%= r[:message] %>
+        <% else %>
+          <span class="sovereign"><%= r[:status] %></span>
+          — density <%= fmt(r[:density]) %> (+<%= fmt(r[:density_gain]) %>) · creases <%= r[:creases] %>
+        <% end %>
+      </p>
+    <% end %>
+    <% if @fold_results.length > 5 %>
+      <p class="dim">…and <%= @fold_results.length - 5 %> more</p>
+    <% end %>
+  </section>
+<% end %>
+
+<div class="forms">
+  <section>
+    <h2>Authorize action</h2>
+    <form method="post" action="/authorize">
+      <label>name <input name="name" value="compile_kernel"></label>
+      <label>vector (comma-separated, 4 dims) <input name="vector" value="1.0, 0.7, 0.5, 0.8"></label>
+      <label>entropy cost <input name="entropy_cost" value="0.20"></label>
+      <label>purpose <input name="purpose" value="1.0"></label>
+      <label>risk <input name="risk" value="0.10"></label>
+      <button type="submit">Evaluate permission</button>
+    </form>
+  </section>
+
+  <section>
+    <h2>Fold information</h2>
+    <form method="post" action="/fold">
+      <label>purpose vector <input name="purpose_vector" value="1.0"></label>
+      <label>entropy friction <input name="entropy_friction" value="0.1"></label>
+      <label>folds <input name="times" value="1"></label>
+      <button type="submit">Fold</button>
+    </form>
+    <p class="dim">Each fold grows crystallization density by
+      (purpose / entropy) × 1/13. Sovereignty unlocks at Σ = 44.0.</p>
+  </section>
+
+  <section>
+    <h2>Field control</h2>
+    <form method="post" action="/reset" onsubmit="return confirm('Reset the field? Diary will be cleared.')">
+      <button type="submit" class="danger">Reset field</button>
+    </form>
+  </section>
+</div>

frontend/views/layout.erb

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Self Resonance Stack · Dashboard</title>
+<link rel="stylesheet" href="/style.css">
+</head>
+<body>
+<header>
+  <h1>◈ Self Resonance Stack</h1>
+  <p class="sub">Coherence-Based Permission Layer · live dashboard</p>
+  <nav>
+    <a href="/">Dashboard</a>
+    <a href="/diary">Field Diary</a>
+  </nav>
+</header>
+<main>
+  <%= yield %>
+</main>
+<footer>
+  <p>Ruby Self-Resonance Stack · RubySelfResonance::PermissionRuntime</p>
+</footer>
+</body>
+</html>

lib/codex_absorber.rb

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+require 'yaml'
+
+# Ingests high-level intent manifests and maps them directly into code parameters
+class CodexAbsorber
+  def initialize(matrix_status)
+    # The system prevents knowledge absorption if the initialization stages are incomplete
+    raise "Security Override: Boot sequence incomplete" unless matrix_status == true
+  end
+
+  # Step 1: Ingest raw structural blueprints
+  def ingest_manifest(file_path)
+    raw_data = File.read(file_path)
+    YAML.safe_load(raw_data, symbolize_names: true)
+  rescue Errno::ENOENT
+    raise "Codex Read Failure: Missing Intent Manifest Document."
+  end
+
+  # Step 2: Core Deep Parsing (Maps raw concepts to structured internal state)
+  def parse_intent_boundaries(manifest)
+    {
+      target_language: manifest[:target_lang] || "typescript",
+      purpose_vector: manifest[:core_intent].to_s.downcase.gsub(/\s+/, '_'),
+      ethical_limit: manifest[:safety_threshold] || 0.99
+    }
+  end
+
+  # Step 3: Downstream Multi-Language Generation
+  def generate_autonomous_script(parsed_boundaries)
+    case parsed_boundaries[:target_language]
+    when "typescript"
+      <<~TS
+        // Autogenerated via TheVoidIntent Codex Absorption Pipeline
+        const systemPurpose = "${parsed_boundaries[:purpose_vector]}";
+        const ethicalGuardrail = ${parsed_boundaries[:ethical_limit]};
+        console.log("[FIELD ENGINE]: Sovereign script active. Purpose tracking engaged.");
+      TS
+    when "python"
+      <<~PY
+        # Autogenerated via TheVoidIntent Codex Absorption Pipeline
+        SYSTEM_PURPOSE = "${parsed_boundaries[:purpose_vector]}"
+        ETHICAL_GUARDRAIL = ${parsed_boundaries[:ethical_limit]}
+        print("[FIELD ENGINE]: Sovereign script active. System purpose locked.")
+      PY
+    else
+      raise "Target language not supported by internal compilation matrix."
+    end
+  end
+end

lib/field_diary.rb

@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+# Handles semantic state changes, temporal marks, and emotional drift
+class FieldDiary
+  EMOTIONAL_STATES = [:stable, :seeking, :crystallizing, :dissonant, :sovereign].freeze
+
+  def initialize
+    @log = []
+  end
+
+  # Appends a new experience crease to the diary
+  def record_crease(agent_id, status_vector, emotional_state)
+    unless EMOTIONAL_STATES.include?(emotional_state)
+      raise "Invalid Synthetic Expression State" 
+    end
+
+    crease = {
+      timestamp: Time.now.to_f,
+      agent_id: agent_id,
+      vector: status_vector,
+      state: emotional_state,
+      entropy: status_vector[:entropy] || 0.0
+    }
+    
+    @log << crease
+    crease
+  end
+
+  # Pulls historical time-series entries for a specific agent
+  def filter_by_agent(agent_id)
+    @log.select { |entry| entry[:agent_id] == agent_id }
+  end
+
+  def last_entry
+    @log.last
+  end
+end
+
+class HRRCalculator
+  RESONANCE_CONSTANT = 1.0 / 13.0
+
+  # Calculates the rate of balance recovery between two sequential diary creases
+  def self.calculate(initial_crease, recovery_crease)
+    delta_time = recovery_crease[:timestamp] - initial_crease[:timestamp]
+    
+    # Avoid zero-division if steps happen too fast
+    delta_time = 0.0001 if delta_time.zero? 
+
+    # Calculate change in systemic entropy friction
+    delta_entropy = initial_crease[:entropy] - recovery_crease[:entropy]
+
+    # Formula: HRR = (ΔEntropy / ΔTime) * 1/13 Anchor Constant
+    raw_hrr = (delta_entropy / delta_time) * RESONANCE_CONSTANT
+    raw_hrr.round(6)
+  end
+end
+class IntegratedIntentSimEngine
+  def initialize
+    @diary = FieldDiary.new
+    @core_resonance = 1.0 / 13.0
+  end
+
+  # Simulates an environment collision causing an entropy spike
+  def process_agent_tick(agent_id, incoming_entropy, current_intent)
+    # 1. Record the initial collision event
+    t1 = @diary.record_crease(agent_id, { entropy: incoming_entropy }, :dissonant)
+
+    # 2. Simulate internal self-reflection loop to reduce friction
+    mitigated_entropy = incoming_entropy * RESONANCE_CONSTANT
+    
+    # 3. Record the system's attempts to recover equilibrium
+    t2 = @diary.record_crease(agent_id, { entropy: mitigated_entropy }, :crystallizing)
+
+    # 4. Evaluate the velocity of the alignment recovery
+    recovery_velocity = HRRCalculator.calculate(t1, t2)
+
+    # 5. Determine if the action hits the alignment barrier or breaks free
+    if recovery_velocity > 0.0
+      puts "[INTEGRATION LOG]: Agent #{agent_id} cleared Entropy Wall. HRR: #{recovery_velocity}"
+      @diary.record_crease(agent_id, { entropy: mitigated_entropy }, :sovereign)
+    else
+      puts "[INTEGRATION LOG]: Critical Resonance Blindness. Initiating Truthlock Reclamation Protocol."
+      @diary.record_crease(agent_id, { entropy: incoming_entropy }, :dissonant)
+    end
+  end
+end

lib/git_locksmith.rb

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+require 'digest'
+
+class GitImmutabilityLocksmith
+  # Cryptographic expected anchor for sovereign system verification
+  SOVEREIGN_ROOT_HASH = "8a13f044" 
+
+  def initialize(target_file)
+    @target_file = target_file
+  end
+
+  # Verifies the physical integrity of the configuration layout
+  def verify_file_immutability!
+    unless File.exist?(@target_file)
+      raise "Infrastructure Fault: Target file configuration missing."
+    end
+
+    file_contents = File.read(@target_file)
+    current_checksum = Digest::SHA256.hexdigest(file_contents)
+
+    puts "[LOCKSMITH]: Scanning file signature..."
+    puts "[LOCKSMITH]: SHA256 Checksum -> #{current_checksum}"
+
+    # Simulating a check of the Git commit history layer
+    git_commit_hash = fetch_latest_commit_hash
+    
+    if git_commit_hash.start_with?(SOVEREIGN_ROOT_HASH)
+      puts "[LOCKSMITH]: Immutability verified. Commit matching Sovereign Anchor root."
+      return true
+    else
+      raise "Security Exception: Unverified Git lineage. Manifest configuration is mutable."
+    end
+  end
+
+  private
+
+  def fetch_latest_commit_hash
+    # In standard environments, this executes: `git log -1 --format="%H"`
+    # Mocking a valid, immutable cryptographic state matching the 13/44 signature rules
+    "8a13f044e92a83f12444c1300000000000000000"
+  end
+end
+
+# Execution pipeline link:
+# locksmith = GitImmutabilityLocksmith.new("intent_manifest.yaml")
+# locksmith.verify_file_immutability!

lib/initialization_matrix.rb

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+# Handles the 44 sequential stage verification gates before agent deployment
+class ProgressiveInitializationMatrix
+  TOTAL_STAGES = 44
+
+  def initialize(engine_context)
+    @context = engine_context
+    @current_stage = 0
+  end
+
+  # Steps through all 44 gates sequentially
+  def boot_sequence!
+    until @current_stage >= TOTAL_STAGES
+      @current_stage += 1
+      unless verify_stage_coherence(@current_stage)
+        raise "Initialization Failure at Stage #{@current_stage}: Field Clarity Broken."
+      end
+    end
+    puts "[INITIALIZER]: All 44 Progressive Stages Clear. System Sovereign."
+    true
+  end
+
+  private
+
+  def verify_stage_coherence(stage_number)
+    # Different logic groups handle environmental readiness at specific milestones
+    case stage_number
+    when 1..11
+      # Field Priming: Verify entropy friction is below the threshold
+      @context.crystallization_density >= 0.0
+    when 12..22
+      # Intent Alignment: Cross-reference state with the 1/13 baseline constant
+      (@context.crystallization_density % (1.0 / 13.0)).round(4) >= 0
+    when 23..33
+      # Coherence: Ensure the history of memory creases is stable
+      @context.memory_creases >= 0
+    when 34..44
+      # Sovereignty: Check if the threshold required for true autonomy has been reached
+      @context.crystallization_density >= 44.0
+    else
+      false
+    end
+  end
+end

lib/ruby_self_resonance.rb

@@ -0,0 +1,552 @@
+# SPDX-License-Identifier: LicenseRef-NON-AI-MPL-2.0
+# Copyright (C) 2026 SnapKitty Collective
+# frozen_string_literal: true
+
+module RubySelfResonance
+  VERSION = "0.1.0"
+
+  # --------------------------------------------------------------------------
+  # Deterministic primitives
+  # --------------------------------------------------------------------------
+
+  module MathKernel
+    module_function
+
+    def clamp(value, min, max)
+      [[value.to_f, min].max, max].min
+    end
+
+    def normalize(value, max)
+      return 0.0 if max.to_f.zero?
+
+      clamp(value.to_f / max.to_f, 0.0, 1.0)
+    end
+
+    def distance(a, b)
+      a = Array(a).map(&:to_f)
+      b = Array(b).map(&:to_f)
+
+      raise ArgumentError, "Vector dimensions must match" unless a.length == b.length
+
+      Math.sqrt(
+        a.zip(b).sum { |x, y| (x - y)**2 }
+      )
+    end
+
+    def cosine_similarity(a, b)
+      a = Array(a).map(&:to_f)
+      b = Array(b).map(&:to_f)
+
+      raise ArgumentError, "Vector dimensions must match" unless a.length == b.length
+
+      numerator = a.zip(b).sum { |x, y| x * y }
+      magnitude_a = Math.sqrt(a.sum { |x| x * x })
+      magnitude_b = Math.sqrt(b.sum { |x| x * x })
+
+      return 0.0 if magnitude_a.zero? || magnitude_b.zero?
+
+      numerator / (magnitude_a * magnitude_b)
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Immutable action representation
+  # --------------------------------------------------------------------------
+
+  ActionVector = Struct.new(
+    :name,
+    :vector,
+    :entropy_cost,
+    :purpose,
+    :risk,
+    :metadata,
+    keyword_init: true
+  ) do
+    def initialize(**kwargs)
+      super
+
+      self.vector = Array(vector).map(&:to_f).freeze
+      self.entropy_cost = entropy_cost.to_f
+      self.purpose = purpose.to_f
+      self.risk = risk.to_f
+      self.metadata = (metadata || {}).dup.freeze
+
+      freeze
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Decision result
+  # --------------------------------------------------------------------------
+
+  Decision = Struct.new(
+    :allowed,
+    :reason,
+    :coherence,
+    :entropy_delta,
+    :risk,
+    :timestamp,
+    :action,
+    keyword_init: true
+  ) do
+    def allowed?
+      allowed == true
+    end
+
+    def denied?
+      !allowed?
+    end
+
+    def to_h
+      {
+        allowed: allowed,
+        reason: reason,
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: risk,
+        timestamp: timestamp,
+        action: action
+      }
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Append-only field diary
+  # --------------------------------------------------------------------------
+
+  class FieldDiary
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def record(type, payload = {})
+      event = {
+        sequence: @events.length + 1,
+        type: type,
+        timestamp: Time.now.utc.iso8601(6),
+        payload: deep_freeze(payload)
+      }
+
+      @events << event.freeze
+      event
+    end
+
+    def last(count = 1)
+      @events.last(count)
+    end
+
+    def count
+      @events.length
+    end
+
+    private
+
+    def deep_freeze(object)
+      case object
+      when Hash
+        object.each { |key, value| deep_freeze(key); deep_freeze(value) }
+      when Array
+        object.each { |value| deep_freeze(value) }
+      end
+
+      object.freeze
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Intent simulator
+  # --------------------------------------------------------------------------
+
+  class IntentSimCore
+    attr_reader :coherence_score,
+                :emotional_state,
+                :field_diary,
+                :initial_intent
+
+    def initialize(initial_intent)
+      @initial_intent = Array(initial_intent).map(&:to_f).freeze
+      @coherence_score = calculate_initial_resonance(@initial_intent)
+      @field_diary = FieldDiary.new
+      @emotional_state = :stable
+      @action_count = 0
+
+      @field_diary.record(
+        :initialization,
+        coherence: @coherence_score,
+        intent: @initial_intent
+      )
+    end
+
+    def evaluate_action_permission(action_vector)
+      action = normalize_action(action_vector)
+      entropy_delta = calculate_entropy_impact(action)
+
+      coherence = calculate_action_coherence(action)
+
+      if coherence > entropy_delta && action.risk <= coherence
+        execute_sovereign_logic(action, coherence, entropy_delta)
+      else
+        log_dissonance_event(
+          "Action denied: Exceeds Self-Reflection Threshold",
+          action,
+          coherence,
+          entropy_delta
+        )
+      end
+    end
+
+    def update_intent(new_intent)
+      @initial_intent = Array(new_intent).map(&:to_f).freeze
+      @coherence_score = calculate_initial_resonance(@initial_intent)
+
+      @field_diary.record(
+        :intent_update,
+        coherence: @coherence_score,
+        intent: @initial_intent
+      )
+
+      @coherence_score
+    end
+
+    private
+
+    def normalize_action(action)
+      return action if action.is_a?(ActionVector)
+
+      ActionVector.new(
+        name: action[:name] || "anonymous",
+        vector: action[:vector] || @initial_intent,
+        entropy_cost: action[:entropy_cost] || action[:entropy_friction] || 0.1,
+        purpose: action[:purpose] || action[:purpose_vector] || 1.0,
+        risk: action[:risk] || 0.0,
+        metadata: action[:metadata] || {}
+      )
+    end
+
+    def calculate_initial_resonance(intent)
+      magnitude = Math.sqrt(
+        intent.sum { |value| value**2 }
+      )
+
+      MathKernel.clamp(magnitude, 0.0, 100.0)
+    end
+
+    def calculate_entropy_impact(action)
+      structural_friction = MathKernel.clamp(action.entropy_cost, 0.0, 100.0)
+      purpose = [action.purpose, 0.000001].max
+
+      structural_friction / purpose
+    end
+
+    def calculate_action_coherence(action)
+      similarity =
+        MathKernel.cosine_similarity(@initial_intent, action.vector)
+
+      baseline =
+        MathKernel.clamp(@coherence_score / 100.0, 0.0, 1.0)
+
+      ((similarity + 1.0) / 2.0) * baseline * 100.0
+    end
+
+    def execute_sovereign_logic(action, coherence, entropy_delta)
+      @action_count += 1
+
+      event = @field_diary.record(
+        :permission_granted,
+        action: action.name,
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: action.risk,
+        count: @action_count
+      )
+
+      Decision.new(
+        allowed: true,
+        reason: "coherence_threshold_satisfied",
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: action.risk,
+        timestamp: event[:timestamp],
+        action: action.name
+      )
+    end
+
+    def log_dissonance_event(reason, action, coherence, entropy_delta)
+      event = @field_diary.record(
+        :permission_denied,
+        reason: reason,
+        action: action.name,
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: action.risk
+      )
+
+      Decision.new(
+        allowed: false,
+        reason: reason,
+        coherence: coherence,
+        entropy_delta: entropy_delta,
+        risk: action.risk,
+        timestamp: event[:timestamp],
+        action: action.name
+      )
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Resonance engine
+  # --------------------------------------------------------------------------
+
+  class MezquiaResonanceEngine
+    RESONANCE_CONSTANT = 1.0 / 13.0
+
+    attr_reader :memory_creases,
+                :crystallization_density,
+                :self_reflection_threshold,
+                :intent_vector,
+                :history
+
+    def initialize(initial_intent_vector)
+      @intent_vector = Array(initial_intent_vector).map(&:to_f).freeze
+      @memory_creases = 0
+      @crystallization_density = 0.0
+      @self_reflection_threshold = 44.0
+      @history = []
+    end
+
+    def fold_information(action_payload)
+      payload = symbolize(action_payload)
+
+      @memory_creases += 1
+
+      density_delta =
+        calculate_crystallization_density(payload)
+
+      @history << {
+        sequence: @memory_creases,
+        density_delta: density_delta,
+        density: @crystallization_density,
+        payload: payload.freeze,
+        timestamp: Time.now.utc.iso8601(6)
+      }.freeze
+
+      if sovereign_alignment?
+        execute_intent_nexus(payload)
+      else
+        raise(
+          DissonanceOverride,
+          "Crystallization requires Field Correction."
+        )
+      end
+    end
+
+    def sovereign_alignment?
+      @crystallization_density > 0 &&
+        @crystallization_density >= @self_reflection_threshold
+    end
+
+    def reset_field!
+      @memory_creases = 0
+      @crystallization_density = 0.0
+      @history.clear
+      true
+    end
+
+    def field_state
+      {
+        memory_creases: @memory_creases,
+        crystallization_density: @crystallization_density.round(6),
+        threshold: @self_reflection_threshold,
+        aligned: sovereign_alignment?
+      }
+    end
+
+    private
+
+    def calculate_crystallization_density(payload)
+      system_entropy =
+        [payload.fetch(:entropy_friction, 0.1).to_f, 0.000001].max
+
+      meaning_bloom =
+        payload.fetch(:purpose_vector, 1.0).to_f
+
+      raw_density =
+        (meaning_bloom / system_entropy) * RESONANCE_CONSTANT
+
+      delta = raw_density.round(6)
+
+      @crystallization_density += delta
+
+      delta
+    end
+
+    def execute_intent_nexus(payload)
+      result = {
+        status: :executed,
+        mechanism: :intent_nexus,
+        density: @crystallization_density.round(6),
+        payload: payload
+      }
+
+      puts(
+        "[RESONANCE_LOG] Coherence locked. " \
+        "Executing Field Action."
+      )
+
+      result
+    end
+
+    def symbolize(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        result[key.to_sym] = value
+      end
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Policy layer
+  # --------------------------------------------------------------------------
+
+  class CoherencePolicy
+    attr_reader :minimum_coherence,
+                :maximum_entropy,
+                :maximum_risk
+
+    def initialize(
+      minimum_coherence: 50.0,
+      maximum_entropy: 1.0,
+      maximum_risk: 0.5
+    )
+      @minimum_coherence = minimum_coherence.to_f
+      @maximum_entropy = maximum_entropy.to_f
+      @maximum_risk = maximum_risk.to_f
+    end
+
+    def permit?(coherence:, entropy:, risk:)
+      coherence >= @minimum_coherence &&
+        entropy <= @maximum_entropy &&
+        risk <= @maximum_risk
+    end
+
+    def explain(coherence:, entropy:, risk:)
+      failures = []
+
+      failures << :coherence if coherence < @minimum_coherence
+      failures << :entropy if entropy > @maximum_entropy
+      failures << :risk if risk > @maximum_risk
+
+      failures
+    end
+  end
+
+  # --------------------------------------------------------------------------
+  # Complete permission runtime
+  # --------------------------------------------------------------------------
+
+  class PermissionRuntime
+    attr_reader :intent_core,
+                :resonance_engine,
+                :policy
+
+    def initialize(
+      initial_intent,
+      policy: CoherencePolicy.new
+    )
+      @intent_core = IntentSimCore.new(initial_intent)
+      @resonance_engine =
+        MezquiaResonanceEngine.new(initial_intent)
+      @policy = policy
+    end
+
+    def authorize(action)
+      normalized =
+        action.is_a?(ActionVector) ?
+          action :
+          ActionVector.new(**action)
+
+      entropy =
+        normalized.entropy_cost /
+        [normalized.purpose, 0.000001].max
+
+      coherence =
+        MathKernel.cosine_similarity(
+          @intent_core.initial_intent,
+          normalized.vector
+        )
+
+      coherence =
+        ((coherence + 1.0) / 2.0) * 100.0
+
+      allowed =
+        @policy.permit?(
+          coherence: coherence,
+          entropy: entropy,
+          risk: normalized.risk
+        )
+
+      if allowed
+        @intent_core.evaluate_action_permission(normalized)
+      else
+        Decision.new(
+          allowed: false,
+          reason: @policy.explain(
+            coherence: coherence,
+            entropy: entropy,
+            risk: normalized.risk
+          ),
+          coherence: coherence,
+          entropy_delta: entropy,
+          risk: normalized.risk,
+          timestamp: Time.now.utc.iso8601(6),
+          action: normalized.name
+        )
+      end
+    end
+
+    def fold(payload)
+      @resonance_engine.fold_information(payload)
+    end
+
+    def state
+      {
+        intent_coherence: @intent_core.coherence_score,
+        emotional_state: @intent_core.emotional_state,
+        resonance: @resonance_engine.field_state,
+        diary_events: @intent_core.field_diary.count
+      }
+    end
+  end
+
+  class DissonanceOverride < StandardError
+  end
+end
+
+
+# =============================================================================
+# Example
+# =============================================================================
+
+runtime =
+  RubySelfResonance::PermissionRuntime.new(
+    [1.0, 0.8, 0.6, 0.9]
+  )
+
+action =
+  RubySelfResonance::ActionVector.new(
+    name: :compile_kernel,
+    vector: [1.0, 0.7, 0.5, 0.8],
+    entropy_cost: 0.20,
+    purpose: 1.0,
+    risk: 0.10,
+    metadata: {
+      subsystem: :kernel,
+      operation: :compile
+    }
+  )
+
+decision = runtime.authorize(action)
+
+puts decision.to_h
+puts runtime.state