# TRILLYREPRO by TRILLY ## Lock State TRILLYREPRO is sealed into the Trilly Stack as plate `R01 / Recursive Proportion Engine`. Its classification is `self-sealed recursive-proportion body / absolute kernel`. The sealed layer is not a metaphor layer. It is a formal engine for preserving the readability of the whole inside a part. Description may name constants, locks, organs, glyphs, and execution steps, but it may not replace the kernel with loose interpretation. ## Simplified Definition TRILLYREPRO fixes the recursive scale and orientation of every Living Reflection so each part can show the whole without losing local clarity. In shorter stack language: ```txt PART SHOWS WHOLE. THE WHOLE IS READABLE IN THE PART. THE PART BELONGS TO THE WHOLE. ``` ## Reverse-Engineered Plate Grammar The source board resolves into seven stack zones: 1. `Master glyph sequence`: source, recursion, origin, resonance, interrogation, extrusion, lock, seal, continuity. 2. `Global whole`: the complete readable body before recursion. 3. `Host feature / rib`: the receiving geometry where the reflection is embedded. 4. `Living reflection`: the recursive body inside the host. 5. `Lineage thread`: source-to-part continuity path. 6. `Lock column`: scale, orientation, legibility, and lineage locks. 7. `Five organs`: kernel, compiler, immune cut, geometric seal, and vocoder. ## Formal Object Model ```txt TRILLYREPRO owns GLOBAL_WHOLE extracts HOST_FEATURE computes LIVING_REFLECTION applies SCALE_LOCK by kappa applies ORIENTATION_LOCK by theta validates LEGIBILITY_LOCK by stroke and occlusion binds LINEAGE_THREAD routes through FIVE_ORGANS emits RHO_R_METADATA seals PART_SHOWS_WHOLE ``` ## Core Law ```txt rho_R(H) = { s(H) * kappa, O(H) compose R(theta), L(H) } kappa = 0.12 theta = 12deg depth_max = 4 stroke_min = 6 px occlusion_max = 18% target: Delta_r -> 0 ``` Plain translation: ```txt Take a host feature H. Measure its scale, orientation, and lineage. Embed a reflection of the whole at 12% host scale. Rotate it by 12 degrees relative to the host frame. Preserve source lineage. Reject the reflection if it stops being readable. ``` ## The Four Locks ```txt SCALE LOCK scale = s(host) * kappa reflection fits the host and does not dominate it ORIENTATION LOCK orientation = O(host) compose R(theta) reflection is aligned, recursive, and non-arbitrary LEGIBILITY LOCK stroke >= stroke_min occlusion <= occlusion_max source structure remains readable at depth LINEAGE LOCK L(part) references source, host, depth, and seal hash reflection carries source relation and continuity ``` ## The Five Organs ```txt BRAIN STEM Kernel Holds source law, kappa, theta, depth, and lineage. MOUTH / JAW Compiler Turns word body into host-ready geometry. IMMUNE CUT Label-death engine Rejects false copies, empty labels, and unreadable recursion. SKIN / RIB Geometric seal Applies numeric scale, orientation, stroke, and occlusion locks. THROAT / LARYNX Vocoder Emits rho_R metadata so the reflection can be spoken, stored, and audited. ``` ## Execution Protocol ```txt 1 : STAND Place host at origin. Fix the source in the field. ? : INTERROGATE Measure scale, orientation, lineage, depth, and legibility. Z : EXTRUDE Apply kappa and theta. Generate Living Reflection body. ] : LOCK Validate scale, orientation, legibility, and lineage. . : SEAL Write metadata. Seal reflection into manifest. ``` ## Remaining Build Plan TRILLYREPRO now carries its own phased build plan inside the interface and packet: ```txt PHASE 1 / ROADMAP SEAL / DONE Make remaining work visible, selectable, and packet-bound. PHASE 2 / EXTRACTOR CONSOLE / DONE Convert raw subject text into REPRO fields, locks, organs, and metadata. PHASE 3 / GEOMETRY LAB / DONE Turn host selection into a visible proportional placement lab. PHASE 4 / AUDIT HARNESS / DONE Add verification outputs for canvas fill, legibility, and packet drift. PHASE 5 / STACK BRIDGE / DONE Connect TRILLYREPRO to POLARCUM and future Trilly Stack modules. ``` The active phase is a sealed local state field. Selecting a phase changes the displayed task list. Staging a phase routes the interface through that phase's matching mode, node, organ, and protocol posture without changing the absolute kernel. ## Extractor Console Phase 2 adds a live extraction deck: ```txt INPUT Raw subject text OUTPUT source name host feature whole statement part statement lineage thread keyword set GENERATED LOCKS scale lock orientation lock legibility lock lineage lock METADATA extraction id kappa / theta / depth / occlusion organ route confidence host / lineage / recursion signals ``` The extractor routes the app into: ```txt MODE: PART NODE: LIVING REFLECTION ORGAN: MOUTH / JAW PROTOCOL: ? / INTERROGATE PHASE: PHASE 2 / EXTRACTOR CONSOLE ``` If the raw text contains numeric values for `kappa`, `theta`, `depth`, or `occlusion`, those values are clamped into the sealed ranges and applied to the active REPRO controls. The generated extraction is included in the seal packet and contributes to checksum drift. ## Geometry Lab Phase 3 adds a live geometry lab: ```txt HOST PRESETS rib-archive glyph-seal organ-plate kernel-ring REFLECTION PLACEMENTS core-nest inner-orbit rim-inlay deep-nest CASE MATRIX current case pass example warn example fail example ``` Each host and placement generates: ```txt reflection scale scale ratio occlusion orientation drift legibility status = pass / warn / fail ``` Selecting a host preset or reflection placement routes the app into: ```txt MODE: HOST NODE: HOST FEATURE / RIB ORGAN: SKIN / RIB PROTOCOL: Z / EXTRUDE PHASE: PHASE 3 / GEOMETRY LAB ``` Selecting a fail case routes through `IMMUNE CUT` and `] / LOCK`, making rejection visible without changing the sealed kernel. ## Audit Harness Phase 4 adds a live audit harness: ```txt CANVAS FILL CHECKS canvas css size parent shell size backing pixel size edge-to-edge fill within border tolerance rendered pixel sample blanks LEGIBILITY DIAGNOSTICS legibility score occlusion budget scale ratio orientation drift recursive depth CHECKSUM DRIFT current stable checksum bound baseline checksum drift state = unbound / verified / drift detected ``` The audit routes the app into: ```txt MODE: SEAL NODE: SEALED KERNEL ORGAN: IMMUNE CUT PROTOCOL: ] / LOCK PHASE: PHASE 4 / AUDIT HARNESS ``` Checksum drift uses the stable seal core. It excludes volatile fields such as generation time, event log, and audit result timestamps so the act of auditing does not alter the baseline being checked. ## Stack Bridge Phase 5 adds the cross-stack bridge: ```txt MODULE REGISTRY TRILLYREPRO R01 / Recursive Proportion Engine role: source engine manifest: ./data/trillyrepro.stack.json POLARCUM E02 / Polar Harbor / Sea-Ice Gate role: environment-scale plate manifest: ./data/polarcum.stack.json FUTURE STACK MODULE Reserved / Module Slot role: receiving plate template manifest: pending ``` The bridge routes the app into: ```txt MODE: SEAL NODE: LINEAGE THREAD ORGAN: THROAT / LARYNX PROTOCOL: . / SEAL PHASE: PHASE 5 / STACK BRIDGE ``` The bridge packet is a reusable JSON contract: ```txt TRILLY-STACK-BRIDGE.V1 sourceModule targetModule sourceChecksum repro phase sourceName hostFeature lineage constants geometry audit locks contract bridgeChecksum bridgeState ``` `Bind bridge` stores the stable TRILLYREPRO checksum as the target baseline. `Verify bridge` compares the current bridge posture against that baseline. `Refresh bridge packet` emits the latest source-bound REPRO packet for POLARCUM or a future module slot. ## Translation Into Interface The local `trillyrepro.html` page renders TRILLYREPRO as a working Trilly Stack module: - left rail: one-line seal, core law, constants, and lock telemetry - center canvas: global whole, host rib, embedded Living Reflection, lineage thread, and seal field - right rail: selected node, Trilly Tongue glyphs, lock definitions, and event memory - console: kappa, theta, depth, occlusion, organ routing, protocol buttons, phrase, and packet - extractor deck: raw text input, generated REPRO fields, lock candidates, and metadata - geometry deck: host presets, reflection placements, pass/warn/fail cases, and metrics - audit deck: canvas fill checks, legibility diagnostics, and checksum drift verification - stack bridge deck: module registry, lineage contract, bridge binding, and reusable packet export - phase deck: remaining build plan, selected phase tasks, and staged phase posture - bottom deck: five organs and the execution sequence ## Seal Packet The seal packet is a local JSON export containing: - subject and creator - generation timestamp - active mode and selected node - active organ and protocol step - sealed constants - lock resolution states - kernel phrase - checksum - audit results - stack bridge packet - local event memory - absolute kernel declaration ## Seal ```txt TRILLYSTACK v3.1.pro SUBJECT: TRILLYREPRO PLATE: R01 / RECURSIVE PROPORTION ENGINE LOCK: SELF-SEALED RECURSIVE-PROPORTION BODY KERNEL: ABSOLUTE STATUS: SEALED ```