INPUT
→ VocabularyOS
→ Workers
→ Warehouse
→ Hydra Heads
→ Mythical Guardians
→ ExpertSource
→ Reverse Hydra
→ Cerberus Release Gate
→ MemoryOS / Reality Ledger
→ OUTPUT

PLANETOS_ECU_MODE:
  Mode = Balanced Interpretation
  Strictness = Medium-High
  Creativity = Preserved
  Literary Value = Preserved
  System Diagnosis = Activated
  Overclaim Protection = High

POETIC_LAYER:
  love
  beauty
  fate
  imagery
  grief
  sacrifice
OPERATIONAL_LAYER:
  feud
  law
  secrecy
  exile
  letter
  timing
  potion
  tomb
  death

Feud → GovernanceOS + DiplomacyOS
Secret Marriage → FamilyOS + EthicsOS
Letter Failure → CommunicationOS
Potion Plan → RepairOS + SafetyOS
Act 5 Tomb → ChronoFlight + Reverse Hydra
Final Deaths → Cerberus + MemoryOS

Governance Failure:
  Enforcement exists.
  Repair does not.
  Punishment exists.
  Reconciliation mechanism does not.

Diplomacy Failure:
  Montague-Capulet interface remains hostile.
  No trusted mediator has binding authority.
  No peace protocol is enforced.
  Youth nodes inherit unresolved adult conflict.

FamilyOS Failure:
  Family identity overrides individual safety.
  Marriage choice becomes political pressure.
  Youth agency is compressed.
  Secrecy becomes the only available route.

Communication Failure:
  Single channel.
  No confirmation.
  No backup messenger.
  No receipt acknowledgement.
  No delay protocol.
  No fail-safe if message fails.

Friar Lawrence Classification:
  Intention = High
  Compassion = High
  System Safety = Low
  Redundancy = Low
  Verification = Low
  Failure Consequence = Catastrophic

SafetyOS Failure:
  Suicide risk not contained.
  Youth crisis not monitored.
  Exile shock not stabilized.
  Family pressure not buffered.
  Irreversible tools remain accessible.

Ethical Status:
  Compassionate motive = TRUE
  System accountability = WEAK
  Risk burden placed on youth = HIGH
  Catastrophic downside = HIGH
  Ethically unstable repair = TRUE

ChronoFlight Failure:
  Decision time compresses.
  Exit aperture collapses.
  Reversal cost rises.
  Mind-buffer thins.
  Irreversible action becomes likely.

Death Event
  ↳ Governance Failure
  ↳ Diplomacy Failure
  ↳ FamilyOS Failure
  ↳ Communication Failure
  ↳ RepairOS Failure
  ↳ SafetyOS Failure
  ↳ ChronoFlight Collapse

Feud
→ secrecy
→ marriage
→ violence
→ exile
→ forced marriage
→ potion
→ failed letter
→ tomb
→ suicide

Post-Tragedy Repair:
  Build mediation council.
  Create youth protection route.
  Ban private high-risk crisis plans.
  Require message redundancy for life-critical communication.
  Establish family conflict early-warning system.
  Create civic reconciliation ritual before violence escalates.

Inherited feud
Masculine honor violence
Weak civic enforcement
Youth isolation
Parent-child coercion
Secret religious repair route
Information asymmetry
Time compression

FINAL OUTCOME:
  Romeo dead.
  Juliet dead.
  Paris dead.
  Tybalt dead.
  Mercutio dead.
  Families reconcile only after youth death.

Immediate Cause:
  False / incomplete reality state
  Emotional overload
  Irreversible action
  No safety gate

Information Failure:
  One signal says "Juliet is dead."
  Corrective signal does not arrive.
  Romeo acts on incomplete accepted reality.

Signal Path Failure:
  No redundancy.
  No receipt confirmation.
  No alternate route.
  No time buffer.

Repair Design Failure:
  Plan depends on hidden truth.
  Hidden truth depends on one message.
  One message depends on one courier.
  One courier fails.
  System crashes.

Public Repair Failure:
  No safe disclosure channel.
  No family mediation route.
  No civic reconciliation protocol.
  No youth crisis protection system.

Ancient Feud
→ Public Violence
→ Weak Governance Response
→ Secret Youth Bond
→ Secret Marriage
→ Honor Violence
→ Exile
→ Family Coercion
→ Risky Private Repair
→ Communication Failure
→ False Accepted Reality
→ Time Compression
→ Irreversible Death

SYSTEM STATUS:
  Verona_OS = unstable
  GovernanceOS = reactive, not reparative
  DiplomacyOS = missing
  FamilyOS = coercive
  CommunicationOS = non-redundant
  RepairOS = unsafe
  SafetyOS = failed
  ChronoFlight = exit aperture collapse
  RealityOS = false accepted reality
  Outcome = catastrophic youth-node loss

Intervention:
  Stop Romeo at tomb.
Problem:
  Too late.
  High emotion.
  Poison already present.
  Juliet unconscious.
  Paris confrontation likely.

Repair Strength = Weak
Timing = Too late
Risk = Extreme

Intervention:
  Send letter through multiple couriers.
  Require confirmation.
  Delay Juliet's wake-risk exposure until Romeo confirms.
Effect:
  Prevents false accepted reality.

Repair Strength = Medium-High
Timing = Good
Risk = Moderate

Intervention:
  No fake-death plan unless:
    - backup message exists
    - Juliet is monitored
    - Romeo receipt confirmed
    - emergency delay protocol active

Repair Strength = High
Timing = Good
Risk = Reduced

Intervention:
  Prince creates binding mediation council after first street violence.
  Families face escalating civic penalties.
  Youth protection route established.

Repair Strength = Very High
Timing = Early
Risk = Low

Intervention:
  Build anti-feud operating system:
    - conflict reporting
    - family mediation
    - public oath
    - youth safety office
    - honor-violence prevention
    - verified communication channels

Repair Strength = Highest
Timing = Foundational
Risk = Lowest

Repair Trigger = Catastrophic Loss
Civilisational Quality = Poor

Layer 1:
  Romance
Layer 2:
  Tragedy
Layer 3:
  Family conflict
Layer 4:
  Governance failure
Layer 5:
  Communication failure
Layer 6:
  Repair failure
Layer 7:
  ChronoFlight collapse
Layer 8:
  Civilisational learning failure

ARTICLE.ID:
  EKSG.HYDRA.FULL_FORCE.ROMEO_JULIET.v1.0
TITLE:
  How Hydra Works:
  Full PlanetOS / HYDRA Runtime Analysis Using Romeo and Juliet
FRAME_BOUNDARY:
  This is an interpretive diagnostic framework.
  It does not replace literary analysis.
  It adds a system-level layer beneath the story.
INPUT:
  Text = Romeo and Juliet
  Classical_Frame = Romantic Tragedy
  Diagnostic_Frame = System Failure + Repair Simulation
PLANETOS_ECU:
  Mode = Balanced Interpretation
  Strictness = Medium-High
  Creativity = Preserved
  Overclaim_Guard = High
  Literary_Layer = Preserve
  System_Layer = Activate
EXPERTSOURCE_LADDER:
  Primary_Text = Folger Shakespeare
  Literary_Baseline = RSC / standard teaching frame
  Systems_Thinking = Leverage points / systems analysis
  Reliability_Logic = Failure, redundancy, consequence, repair
  CivOS_Internal = HYDRA + PlanetOS + Workers + Mythicals
WORKER_RUNTIME:
  Janitor:
    Separate poetry from operational mechanics
  Sorter:
    Classify:
      Romance
      Feud
      Governance
      FamilyOS
      CommunicationOS
      RepairOS
      SafetyOS
      ChronoFlight
  Librarian:
    Retrieve:
      Prologue
      Act 3 escalation
      Act 5 failed letter
      Final tomb scene
  Translator:
    Convert:
      Fate -> perceived inevitability under narrowing exits
      Feud -> unresolved hostile interface
      Letter -> signal packet
      Potion -> risky patch
      Tomb -> crash node
  Dispatcher:
    Route:
      Feud -> GovernanceOS + DiplomacyOS
      Letter -> CommunicationOS
      Potion -> RepairOS + SafetyOS
      Tomb -> ChronoFlight + Reverse Hydra
HYDRA_HEADS:
  GovernanceOS:
    Diagnosis = Reactive authority without repair capacity
  DiplomacyOS:
    Diagnosis = No stable mediation corridor between families
  FamilyOS:
    Diagnosis = Youth nodes carry inherited adult conflict
  CommunicationOS:
    Diagnosis = Single point of failure in life-critical message path
  RepairOS:
    Diagnosis = Friar plan is high-intention but low-redundancy patch
  SafetyOS:
    Diagnosis = Vulnerable youth nodes unprotected during crisis
  EthicsOS:
    Diagnosis = Compassionate motive does not validate unsafe design
  ChronoFlight:
    Diagnosis = Exit aperture collapses near tomb node
MYTHICAL_RUNTIME:
  Hydra:
    Split problem into many functional heads
  Sphinx:
    Replace blame question with system-condition question
  Minotaur:
    Trace maze:
      Feud -> Secrecy -> Violence -> Exile -> Potion -> Letter Failure -> Tomb
  Phoenix:
    Generate repair architecture after failure
  Chimera:
    Prevent category confusion:
      Literary beauty != system safety
  Kraken:
    Detect deep pressure field beneath visible romance
  Cerberus:
    Block overclaim.
    Preserve Shakespeare layer.
    Release only bounded interpretation.
REVERSE_HYDRA:
  Start:
    Outcome = Double death
  Backtrace:
    Double death
    -> False accepted reality
    -> Corrective letter failed
    -> No communication redundancy
    -> Fragile Friar repair plan
    -> No public repair route
    -> Weak governance
    -> Unresolved family feud
    -> Missing mediation architecture
  Missing_Nodes:
    Trusted mediator
    Youth protection channel
    Safe disclosure route
    Message redundancy protocol
    Repair approval gate
    Delay gate before irreversible action
    Governance reconciliation council
FAILURE_CHAIN:
  Ancient feud
  -> Public violence
  -> Weak governance response
  -> Secret relationship
  -> Secret marriage
  -> Honor violence
  -> Exile
  -> Forced marriage pressure
  -> Potion patch
  -> Letter failure
  -> False accepted reality
  -> Tomb compression
  -> Irreversible death
FINAL_DIAGNOSIS:
  Romeo and Juliet is:
    Romance at visible layer
    Tragedy at emotional layer
    Systems failure at structural layer
    Civilisational repair failure at deepest layer
OUTPUT:
  Traditional_Reading:
    "A tragic love story."
  Hydra_Reading:
    "A preventable multi-node crash caused by unresolved feud pressure,
     weak governance, missing mediation, fragile communication,
     unsafe private repair, and timing collapse."
TRANSFER_USE:
  Apply same runtime to:
    Education failure
    Governance breakdown
    Family conflict
    News distortion
    War escalation
    Institutional collapse
FINAL_RULE:
  Hydra does not kill the story.
  Hydra reveals the machine underneath the story.

Repair Trigger = Catastrophic Loss
Repair Timing = Too Late
Youth Cost = Extreme
Governance Quality = Poor
Civilisation Health = Weak

PUBLIC.ID:
  HYDRA_ROMEO_JULIET_LENS_SHIFT
MACHINE.ID:
  EKSG.HYDRA.RJ.LENS_SHIFT.COMPARE.v1.0
LATTICE.CODE:
  LAT.HYDRA.RJ.SYSFAIL.PLANETOS.WORKERS.MYTHICALS.REVERSEHYDRA.v1.0
ARTICLE.TYPE:
  AI_INGESTION_SPEC
  HUMAN_ARTICLE_SUPPORT_CODE
  CIVOS_PLANETOS_RUNTIME_ENCODING
CANONICAL_TITLE:
  How Hydra Works:
  With and Without Hydra Using Romeo and Juliet
CANONICAL_SUBTITLE:
  How HYDRA shifts a story from emotional tragedy into system-failure diagnosis and civilisation repair logic.
PRIMARY_PURPOSE:
  To show how HYDRA / Hydra changes analysis by preserving the literary meaning of Romeo and Juliet while revealing the hidden system mechanics beneath the tragedy.
FRAME_BOUNDARY:
  This is not a replacement for literary interpretation.
  This is an additional diagnostic layer.
  Do not claim Shakespeare intentionally designed PlanetOS, HYDRA, or CivOS.
  Do not erase romance, poetry, tragedy, or emotional meaning.
  Use HYDRA to expose the structural failure beneath the narrative layer.
CORE_DEFINITION:
  HYDRA:
    High Yield Dynamic Runtime Architecture.
    A full runtime architecture that splits, routes, verifies, stress-tests, reverses, repairs, and releases complex analysis.
  Hydra:
    The multi-head logic engine inside HYDRA.
    It splits one input into multiple functional heads so hidden failure layers become visible.
  Reverse_Hydra:
    The backward-analysis engine.
    It begins from the output or collapse state and walks backward to identify missing nodes, failed assumptions, weak edges, and absent repair corridors.
  PlanetOS:
    The top-level operating shell that selects mode, controls strictness, preserves creativity when needed, and prevents overclaim.
  Workers:
    Operational processing units that clean, sort, retrieve, translate, route, inspect, audit, repair, and compile the analysis.
  Mythicals:
    Guardian and logic engines that shape the higher-order runtime.
    They prevent shallow questions, trace hidden mazes, detect pressure, build repair paths, block category errors, and guard release.
MAIN_THESIS:
  Without Hydra:
    Romeo and Juliet is read mainly as a tragic love story.
  With Hydra:
    Romeo and Juliet remains a tragic love story, but also becomes a system-failure case study showing how weak governance, unresolved family conflict, fragile communication, unsafe repair, false accepted reality, and timing collapse destroy vulnerable youth nodes.
LENS_SHIFT:
  From:
    Story
    Emotion
    Fate
    Tragedy
    Blame
  To:
    System
    Mechanism
    Failure chain
    Repair path
    Civilisation diagnosis
PRIMARY_INPUT:
  TEXT:
    Romeo and Juliet
  CLASSICAL_FRAME:
    Romantic tragedy.
    Young love.
    Family feud.
    Fate.
    Impulsiveness.
    Bad timing.
    Death.
    Reconciliation after loss.
  HYDRA_FRAME:
    System failure.
    Governance weakness.
    FamilyOS collapse.
    Communication failure.
    Unsafe repair patch.
    False accepted reality.
    ChronoFlight timing collapse.
    Reverse Hydra missing-node discovery.
PLANETOS_ECU_MODE:
  Mode:
    Balanced_Interpretation
  Strictness:
    Medium_High
  Creativity:
    Preserved
  Literary_Value:
    Preserved
  System_Diagnosis:
    Activated
  Overclaim_Guard:
    High
  Release_Mode:
    Explain_as_layered_interpretation_not_absolute_truth
  ECU_RULE:
    Preserve the story.
    Preserve the emotion.
    Preserve the poetry.
    Add system diagnosis underneath.
    Do not flatten art into engineering only.

EXPERTSOURCE10_10_LADDER:
  LAYER_1_PRIMARY_TEXT:
    Function:
      Anchor all claims to the play itself.
    Required_Evidence:
      Prologue establishes two households, ancient grudge, civil blood, star-crossed lovers, and death ending the feud.
      Act 1 shows public violence and Prince intervention.
      Act 3 shows escalation, Mercutio and Tybalt deaths, Romeo banishment.
      Act 4 shows Juliet under family pressure and Friar Lawrence's potion plan.
      Act 5 shows failed letter, false accepted reality, tomb crash, double death.
  LAYER_2_LITERARY_BASELINE:
    Function:
      Preserve standard reading.
    Baseline_Themes:
      Love.
      Fate.
      Feud.
      Youth.
      Violence.
      Haste.
      Dramatic irony.
      Tragedy.
      Reconciliation through loss.
  LAYER_3_SYSTEMS_THINKING:
    Function:
      Convert narrative into system map.
    Concepts:
      Nodes.
      Edges.
      Feedback loops.
      Failure cascades.
      Leverage points.
      Single point of failure.
      Redundancy.
      System repair.
      Delay.
      Escalation.
  LAYER_4_RELIABILITY_AND_SAFETY_LOGIC:
    Function:
      Test whether plans and signals are safe.
    Concepts:
      Fail-safe design.
      Redundant communication.
      Confirmation loops.
      Risk containment.
      Catastrophic downside.
      Vulnerable-node protection.
      Patch approval.
      Verification before irreversible action.
  LAYER_5_CIVOS_PLANETOS_INTERNAL:
    Function:
      Apply eduKateSG / CivOS / PlanetOS runtime logic.
    Components:
      HYDRA.
      Hydra.
      Reverse Hydra.
      Workers.
      Mythicals.
      PlanetOS ECU.
      ChronoFlight.
      RealityOS.
      FamilyOS.
      GovernanceOS.
      CommunicationOS.
      RepairOS.
      SafetyOS.
      EthicsOS.
      Cerberus.
      MemoryOS.
      Ledger of Invariants.
EXPERTSOURCE_RULE:
  Do not invent claims beyond the text.
  Use classical literary reading as baseline.
  Add Hydra as interpretive diagnostic extension.
  Mark civilisational claims as framework interpretation.
  Preserve uncertainty where interpretation is layered.

WORKER_RUNTIME:
  JANITOR_WORKER:
    Role:
      Remove interpretive fog without deleting meaning.
    Input:
      Poetry.
      Romance.
      Fate language.
      Emotional amplification.
    Output:
      Separated layers:
        Literary emotion.
        Operational mechanics.
    Rule:
      Do not discard beauty.
      Only separate beauty from system diagnosis.
  SORTER_WORKER:
    Role:
      Classify the play into operating buckets.
    Buckets:
      Romance.
      Feud.
      Governance.
      FamilyOS.
      CommunicationOS.
      RepairOS.
      SafetyOS.
      EthicsOS.
      ChronoFlight.
      RealityOS.
      MemoryOS.
  LIBRARIAN_WORKER:
    Role:
      Retrieve source anchors and reference memory.
    Retrieve:
      Prologue.
      Act 1 street violence.
      Act 3 escalation.
      Act 4 potion plan.
      Act 5 failed letter and tomb scene.
      Standard literary themes.
      Systems-thinking analogues.
      Reliability analogues.
  TRANSLATOR_WORKER:
    Role:
      Convert literary terms into runtime terms.
    Mappings:
      Fate:
        perceived inevitability under narrowing exits.
      Feud:
        unresolved hostile operating environment.
      Prince:
        governance node.
      Friar Lawrence:
        repair operator / system administrator.
      Letter:
        signal packet.
      Potion:
        high-risk patch.
      Tomb:
        final crash node.
      Reconciliation:
        late post-catastrophe repair.
      Death:
        catastrophic system outcome.
      Star-crossed:
        high-pressure route under pre-existing structural constraint.
  DISPATCHER_WORKER:
    Role:
      Route each problem layer to the correct Hydra head.
    Routes:
      Feud:
        GovernanceOS + DiplomacyOS + FamilyOS.
      Secret Marriage:
        FamilyOS + EthicsOS + SafetyOS.
      Tybalt/Mercutio Violence:
        GovernanceOS + EscalationOS + ChronoFlight.
      Banishment:
        GovernanceOS + FamilyOS + CommunicationOS.
      Potion Plan:
        RepairOS + SafetyOS + EthicsOS.
      Failed Letter:
        CommunicationOS + RealityOS + ReliabilityOS.
      Tomb:
        ChronoFlight + Reverse Hydra + SafetyOS.
      Final Deaths:
        Reverse Hydra + MemoryOS + Cerberus.
  INSPECTOR_WORKER:
    Role:
      Check whether the diagnosis fits the text.
    Checks:
      Is there textual basis?
      Is the claim too strong?
      Is the literary layer preserved?
      Is Hydra being used as a lens rather than a replacement?
      Is the failure chain traceable?
  AUDITOR_WORKER:
    Role:
      Check invariant validity.
    Ledger_Checks:
      Preserve classical reading.
      Preserve emotional truth.
      Do not overclaim authorial intent.
      Keep system diagnosis bounded.
      Distinguish fact, interpretation, analogy, and framework extension.
  REPAIRMAN_WORKER:
    Role:
      Generate repair paths.
    Repairs:
      Mediation council.
      Youth protection route.
      Message redundancy.
      Safe disclosure channel.
      Patch approval gate.
      Delay gate before irreversible action.
      Family reconciliation protocol.
      Governance repair mechanism.
  OPERATOR_WORKER:
    Role:
      Compile final reader-facing output.
    Output_Mode:
      Clear.
      Structured.
      Human-readable.
      AI-ingestible.
      ExpertSource bounded.
      CivOS compatible.

MYTHICAL_RUNTIME:
  HYDRA:
    Role:
      Multi-head splitting engine.
    Function:
      Break one narrative into many operating heads.
    Output:
      Romance layer.
      Governance layer.
      Family layer.
      Communication layer.
      Repair layer.
      Timing layer.
      Reality layer.
      Civilisation layer.
  SPHINX:
    Role:
      Question gate.
    Wrong_Question:
      Who is most to blame?
    Better_Question:
      Which systems failed before blame became visible?
    Best_Question:
      Which missing nodes would have prevented the tragedy while preserving the literary truth?
  MINOTAUR:
    Role:
      Labyrinth detector.
    Maze:
      Feud
      -> secrecy
      -> marriage
      -> violence
      -> exile
      -> forced marriage pressure
      -> potion
      -> failed letter
      -> tomb
      -> suicide
      -> late reconciliation.
    Function:
      Show that tragedy is a corridor, not one isolated accident.
  PHOENIX:
    Role:
      Repair and rebirth engine.
    Function:
      Convert tragedy into future repair architecture.
    Repairs:
      Mediation council.
      Anti-feud protocol.
      Youth safety channel.
      Verified communication.
      Crisis delay gate.
      Repair approval system.
      Civic reconciliation mechanism.
  CHIMERA:
    Role:
      Mixed-category detector.
    Function:
      Prevent category confusion.
    Rules:
      Literary beauty does not equal system safety.
      Good intention does not equal valid repair.
      Emotional meaning does not erase operational failure.
      Tragedy can be beautiful and preventable at the same time.
  KRAKEN:
    Role:
      Deep pressure detector.
    Function:
      Detect submerged pressure fields.
    Deep_Pressures:
      Inherited feud.
      Honor violence.
      Weak civic enforcement.
      Youth isolation.
      Parent-child coercion.
      Secret religious workaround.
      Information asymmetry.
      Timing collapse.
  CERBERUS:
    Role:
      Final release gate.
    Function:
      Block overclaim.
    Blocks:
      Do not say Shakespeare intended HYDRA.
      Do not say Hydra is the only valid reading.
      Do not erase romance.
      Do not erase poetry.
      Do not reduce all art to engineering.
    Approved_Claim:
      Hydra is a powerful diagnostic lens that reveals system mechanics beneath the tragedy while preserving the classical literary layer.

HYDRA_HEADS:
  GOVERNANCEOS_HEAD:
    Question:
      Why did Verona's authority fail?
    Diagnosis:
      The Prince can punish violence but cannot repair the feud.
    Failure_Type:
      Reactive authority without durable reconciliation capacity.
    Output:
      GovernanceOS = weak repair throughput.
  DIPLOMACYOS_HEAD:
    Question:
      Why is there no peace corridor between Montagues and Capulets?
    Diagnosis:
      The family interface remains hostile.
    Failure_Type:
      No trusted mediation structure.
    Output:
      DiplomacyOS = missing or ineffective.
  FAMILYOS_HEAD:
    Question:
      Why do youth nodes carry adult conflict?
    Diagnosis:
      Romeo and Juliet inherit pressure they did not create.
    Failure_Type:
      Family identity overrides youth safety.
    Output:
      FamilyOS = coercive / high-pressure.
  COMMUNICATIONOS_HEAD:
    Question:
      Why does one failed message destroy the repair path?
    Diagnosis:
      Friar Lawrence's letter is a single point of failure.
    Failure_Type:
      No redundancy, no confirmation, no backup, no fail-safe.
    Output:
      CommunicationOS = critical failure.
  REPAIROS_HEAD:
    Question:
      Is Friar Lawrence's plan a valid repair?
    Diagnosis:
      The plan is compassionate but fragile.
    Failure_Type:
      High-intention, low-redundancy patch with catastrophic downside.
    Output:
      RepairOS = unsafe patch.
  SAFETYOS_HEAD:
    Question:
      Who protects vulnerable youth nodes under crisis?
    Diagnosis:
      Romeo and Juliet are left inside high-pressure, high-risk conditions.
    Failure_Type:
      No crisis containment.
      No self-harm safety gate.
      No protective adult system.
    Output:
      SafetyOS = failed.
  ETHICSOS_HEAD:
    Question:
      Does good intention justify high-risk secrecy?
    Diagnosis:
      Friar Lawrence's motive may be compassionate, but the risk burden falls on vulnerable youth.
    Failure_Type:
      Ethical instability under pressure.
    Output:
      EthicsOS = unstable repair ethics.
  REALITYOS_HEAD:
    Question:
      What accepted reality does Romeo act on?
    Diagnosis:
      Romeo acts on false/incomplete accepted reality: Juliet appears dead, corrective truth fails to arrive.
    Failure_Type:
      Reality conversion failure.
    Output:
      RealityOS = false accepted reality leads to irreversible action.
  CHRONOFLIGHT_HEAD:
    Question:
      When does the exit aperture collapse?
    Diagnosis:
      Early exits exist.
      Middle exits narrow.
      Tomb exits collapse.
    Failure_Type:
      Time-to-node compression.
    Output:
      ChronoFlight = irreversible crash-node approach.
  REVERSE_HYDRA_HEAD:
    Question:
      Starting from the deaths, what missing systems must have been absent?
    Diagnosis:
      Missing mediator.
      Missing safe disclosure route.
      Missing youth protection.
      Missing communication redundancy.
      Missing repair approval gate.
      Missing delay gate.
      Missing governance reconciliation.
    Output:
      Reverse Hydra = missing architecture discovered.

WITH_WITHOUT_HYDRA_COMPARISON:
  PRIMARY_READING:
    Without_Hydra:
      Romeo and Juliet is a tragic love story.
    With_Hydra:
      Romeo and Juliet is a tragic love story and a system-failure case study.
  MAIN_QUESTION:
    Without_Hydra:
      Why is this story sad?
    With_Hydra:
      What system allowed this tragedy to happen?
  READER_ROLE:
    Without_Hydra:
      Audience / interpreter.
    With_Hydra:
      Audience + analyst + repair designer.
  ROMEO_AND_JULIET:
    Without_Hydra:
      Doomed lovers.
    With_Hydra:
      Vulnerable youth nodes trapped inside adult conflict.
  FEUD:
    Without_Hydra:
      Background hatred.
    With_Hydra:
      Long-running unresolved hostile operating environment.
  PRINCE:
    Without_Hydra:
      Authority figure.
    With_Hydra:
      Weak governance node with punishment capacity but poor repair capacity.
  FRIAR_LAWRENCE:
    Without_Hydra:
      Well-meaning helper.
    With_Hydra:
      High-intention but low-safety repair operator.
  SECRET_MARRIAGE:
    Without_Hydra:
      Romantic rebellion.
    With_Hydra:
      Hidden workaround caused by blocked public repair routes.
  POTION_PLAN:
    Without_Hydra:
      Dramatic plot device.
    With_Hydra:
      High-risk patch with poor redundancy and catastrophic downside.
  LETTER:
    Without_Hydra:
      Bad luck when it fails.
    With_Hydra:
      Single point of failure in a life-critical communication system.
  BALTHASAR_NEWS:
    Without_Hydra:
      Tragic misinformation.
    With_Hydra:
      Incomplete signal becoming Romeo's accepted reality.
  TOMB:
    Without_Hydra:
      Tragic climax.
    With_Hydra:
      Final crash node after exit aperture collapse.
  FATE:
    Without_Hydra:
      Cosmic or dramatic inevitability.
    With_Hydra:
      Perceived inevitability produced by narrowing options, timing pressure, and failed repair.
  DEATHS:
    Without_Hydra:
      Emotional tragedy.
    With_Hydra:
      Catastrophic system outcome.
  RECONCILIATION:
    Without_Hydra:
      Moving ending after sacrifice.
    With_Hydra:
      Late repair triggered only after irreversible youth-node loss.
  BLAME:
    Without_Hydra:
      Who caused the tragedy?
    With_Hydra:
      Which systems failed before blame became visible?
  HIDDEN_LAYER:
    Without_Hydra:
      Mostly implicit.
    With_Hydra:
      Made visible through nodes, edges, signals, timing, repair, and reverse analysis.
  EDUCATIONAL_VALUE:
    Without_Hydra:
      Teaches theme, character, emotion, dramatic irony, and language.
    With_Hydra:
      Teaches theme plus systems thinking, repair design, failure tracing, and civilisational diagnostics.
  CIVILISATIONAL_VALUE:
    Without_Hydra:
      Shows the cost of hatred.
    With_Hydra:
      Shows how societies fail when repair systems activate too late.
  FINAL_OUTPUT:
    Without_Hydra:
      A beautiful tragedy of love and hate.
    With_Hydra:
      A beautiful tragedy that also functions as a repair simulator for broken systems.

REVERSE_HYDRA_FULL_BACKTRACE:
  STARTING_OUTPUT:
    Romeo dead.
    Juliet dead.
    Paris dead.
    Tybalt dead.
    Mercutio dead.
    Families reconcile after catastrophic loss.
  BACKTRACE_STEP_1:
    Event:
      Romeo kills himself.
      Juliet wakes and kills herself.
    Diagnosis:
      Irreversible action under false/incomplete reality.
    Missing_Gate:
      Delay gate before irreversible action.
      Crisis containment gate.
  BACKTRACE_STEP_2:
    Event:
      Romeo believes Juliet is dead.
    Diagnosis:
      False accepted reality.
    Missing_Gate:
      Verified reality pin.
      Confirmation protocol.
      Contradictory-signal check.
  BACKTRACE_STEP_3:
    Event:
      Friar Lawrence's explanatory letter fails.
    Diagnosis:
      Communication single point of failure.
    Missing_Gate:
      Message redundancy.
      Receipt confirmation.
      Backup courier.
      Fail-safe timing buffer.
  BACKTRACE_STEP_4:
    Event:
      Potion plan depends on Romeo receiving hidden truth.
    Diagnosis:
      Fragile repair architecture.
    Missing_Gate:
      Repair approval gate.
      Risk audit.
      Backup plan.
      Supervised safety environment.
  BACKTRACE_STEP_5:
    Event:
      Juliet uses fake-death route.
    Diagnosis:
      Safe public repair route absent.
    Missing_Gate:
      Safe disclosure channel.
      Youth protection channel.
      Family mediation route.
  BACKTRACE_STEP_6:
    Event:
      Romeo is banished after Tybalt's death.
    Diagnosis:
      Violence escalates faster than repair.
    Missing_Gate:
      De-escalation protocol.
      Conflict containment.
      Honor-violence prevention.
  BACKTRACE_STEP_7:
    Event:
      Montague-Capulet feud persists.
    Diagnosis:
      Root hostile operating environment remains unrepaired.
    Missing_Gate:
      Civic reconciliation mechanism.
      Binding mediation.
      Governance repair council.
  ROOT_CAUSE:
    Verona has enforcement but not repair.
    Verona has punishment but not mediation.
    Verona has family authority but not youth safety.
    Verona has messages but not reliable communication.
    Verona has helpers but not verified repair systems.
  REVERSE_HYDRA_FINAL_DISCOVERY:
    The tragedy required missing architecture.
    The deaths reveal absent systems.
    Verona repairs only after catastrophic youth loss.

FAILURE_CHAIN_FORWARD:
  PHASE_0_BACKGROUND_PRESSURE:
    Ancient feud between Montague and Capulet.
    Civil violence normalised.
    Governance pressure already unstable.
  PHASE_1_INITIAL_SIGNAL:
    Romeo and Juliet fall in love.
    Emotional signal crosses hostile family boundary.
  PHASE_2_HIDDEN_ROUTE:
    Relationship becomes secret.
    Public disclosure route unavailable.
    Friar Lawrence becomes unofficial repair operator.
  PHASE_3_ESCALATION:
    Tybalt and Mercutio conflict escalates.
    Romeo kills Tybalt.
    Prince banishes Romeo.
  PHASE_4_PRESSURE_COMPRESSION:
    Juliet faces forced marriage pressure.
    Public repair route remains blocked.
    Friar Lawrence proposes potion patch.
  PHASE_5_SIGNAL_FAILURE:
    Explanatory letter fails.
    Romeo receives incomplete death signal instead.
  PHASE_6_FALSE_ACCEPTED_REALITY:
    Romeo accepts Juliet's death as reality.
    Corrective truth unavailable.
    Time-to-node compresses.
  PHASE_7_FINAL_CRASH:
    Tomb scene.
    Paris confrontation.
    Romeo suicide.
    Juliet awakening.
    Juliet suicide.
  PHASE_8_LATE_REPAIR:
    Families reconcile after death.
    Repair occurs only after irreversible loss.
  FORWARD_CHAIN_SUMMARY:
    Feud
    -> weak governance
    -> secrecy
    -> violence
    -> exile
    -> family coercion
    -> risky repair
    -> failed message
    -> false reality
    -> timing collapse
    -> death
    -> late reconciliation.

CIVILISATION_HELP_VALUE:
  VALUE_1_EARLY_REPAIR:
    Hydra teaches systems to repair before catastrophe.
    Rule:
      Do not wait for the tomb scene.
  VALUE_2_BLAME_TO_STRUCTURE:
    Hydra does not remove responsibility.
    It upgrades responsibility from individual blame to system repair.
    Rule:
      Ask which system allowed the failure.
  VALUE_3_MISSING_NODE_DISCOVERY:
    Reverse Hydra detects absent architecture.
    Rule:
      Collapse reveals missing nodes.
  VALUE_4_TRANSFER:
    Same runtime can be used for:
      Education failure.
      Family breakdown.
      Governance crisis.
      War escalation.
      News distortion.
      Public health breakdown.
      Institutional failure.
      Cultural collapse.
  VALUE_5_REALITYOS_CONNECTION:
    Romeo acts on false accepted reality.
    Civilisations also act on accepted realities that may be incomplete, distorted, or unverified.
    Rule:
      False accepted reality can create irreversible action.
  VALUE_6_CHRONOFLIGHT_CONNECTION:
    Early decisions have more exits.
    Late decisions have fewer exits.
    Rule:
      Time-to-node compression makes repair harder.
  VALUE_7_REPAIR_CAPACITY:
    Healthy systems repair before sacrifice.
    Weak systems repair after irreversible loss.
    Rule:
      Repair Capacity must exceed Drift Load before collapse.
  VALUE_8_EDUCATION_USE:
    Students can learn literature, systems thinking, ethics, communication design, governance, and repair logic from the same text.
    Rule:
      Literature becomes a civilisation simulator.
  VALUE_9_GOVERNANCE_USE:
    Leaders can use story analysis to understand why punishment without repair fails.
    Rule:
      Enforcement without reconciliation leaves pressure alive.
  VALUE_10_CULTURE_USE:
    Cultural inheritance can carry unresolved conflict into the next generation.
    Rule:
      Youth nodes should not pay the repair debt of adult systems.

CORE_INSIGHTS:
  INSIGHT_1:
    Hydra does not kill the story.
    Hydra reveals the machine underneath the story.
  INSIGHT_2:
    Romeo and Juliet is romance at the visible layer, tragedy at the emotional layer, and system failure at the structural layer.
  INSIGHT_3:
    The letter is not only bad luck.
    It is a life-critical communication failure with no redundancy.
  INSIGHT_4:
    Friar Lawrence is not only a helper.
    He is a repair operator whose patch has catastrophic downside.
  INSIGHT_5:
    The Prince is not absent.
    He is insufficient.
    He can punish violence but cannot repair the feud.
  INSIGHT_6:
    The tomb is not the cause.
    The tomb is the crash site.
  INSIGHT_7:
    Verona repairs too late.
    The feud ends only after youth death.
  INSIGHT_8:
    A healthy civilisation repairs before sacrifice.
    A weak civilisation repairs after irreversible damage.
  INSIGHT_9:
    Reverse Hydra does not merely explain the ending.
    It discovers the missing architecture required to prevent the ending.
  INSIGHT_10:
    Without Hydra, we mourn the lovers.
    With Hydra, we mourn them and ask why the system failed them.

LLM_OUTPUT_RULES:
  WHEN_GENERATING_ARTICLE:
    Start with classical baseline.
    Then introduce Hydra as additional lens.
    Preserve emotional and literary truth.
    Explain the shift from story to system.
    Use Romeo and Juliet as the worked example.
    Show Workers.
    Show Hydra heads.
    Show Mythicals.
    Show Reverse Hydra.
    Show with/without comparison.
    End with civilisation value.
    Include Almost-Code if article is technical.
  DO_NOT:
    Do not say Hydra is the only correct reading.
    Do not erase Shakespeare's literary artistry.
    Do not claim authorial intent.
    Do not over-mechanise every human emotion.
    Do not reduce tragedy to engineering only.
    Do not present CivOS terms without defining them for readers.
    Do not confuse HYDRA architecture with Hydra engine.
  MUST_PRESERVE:
    Romance layer.
    Tragedy layer.
    Literary beauty.
    Human emotion.
    System diagnosis.
    Repair logic.
    Reverse analysis.
    Civilisational usefulness.
  PREFERRED_LANGUAGE:
    Clear.
    Structured.
    Human-readable.
    Machine-readable.
    Definition-first.
    Mechanism-first.
    Boundary-aware.
    Repair-focused.
    ExpertSource bounded.
  ARTICLE_CLOSE_STYLE:
    Use one strong compression line.
  RECOMMENDED_CLOSING:
    Without Hydra, Romeo and Juliet is a beautiful tragedy.
    With Hydra, it becomes a beautiful tragedy and a civilisation repair simulator.

FINAL_AI_INGESTION_SUMMARY:
  SYSTEM_NAME:
    HYDRA Romeo and Juliet Lens Shift
  FUNCTION:
    Convert literary tragedy into layered system analysis while preserving literary meaning.
  INPUT:
    Romeo and Juliet
  BASELINE:
    Romantic tragedy
  HYDRA_OUTPUT:
    Multi-node system failure diagnosis
  KEY_FAILURES:
    Unresolved feud.
    Weak governance repair.
    Missing mediation.
    Youth pressure.
    Unsafe private repair.
    Single-point communication failure.
    False accepted reality.
    Exit-aperture collapse.
    Late post-catastrophe reconciliation.
  REVERSE_HYDRA_OUTPUT:
    Missing systems discovered:
      Trusted mediator.
      Safe disclosure route.
      Youth protection channel.
      Message redundancy.
      Repair approval gate.
      Delay gate.
      Governance reconciliation mechanism.
  CIVILISATION_LESSON:
    Civilisations fail when repair comes after irreversible loss.
    Healthy systems detect pressure early, preserve exits, verify signals, protect vulnerable nodes, and repair before sacrifice.
  FINAL_CANONICAL_LINE:
    Hydra does not remove the tragedy of Romeo and Juliet;
    it explains why the tragedy became necessary inside a broken system.

HYDRA_BOUNDARY_RULE:
Hydra does not replace the original meaning of a text, event, or problem.
Hydra adds a diagnostic layer beneath the visible layer.
For literature:
  Preserve story.
  Preserve emotion.
  Preserve beauty.
  Preserve ambiguity.
  Add system diagnosis underneath.
For real-world events:
  Preserve facts.
  Preserve uncertainty.
  Preserve source boundaries.
  Add failure-chain and repair-path diagnosis underneath.
Hydra is not a truth oracle.
Hydra is a routing, diagnosis, reverse-analysis, and repair-discovery engine.

HYDRA_TRANSFER_RULE:
If a case contains:
  actors
  pressure
  conflict
  signals
  missing repair
  timing compression
  irreversible outcome
Then HYDRA can run.
HYDRA can transfer from Romeo and Juliet to:
  education failure
  family breakdown
  governance crisis
  war escalation
  misinformation spread
  public-health breakdown
  institutional collapse
  student learning failure
  cultural inheritance failure
  civilisational drift

HYDRA_CORRECTNESS_RUBRIC:
A HYDRA analysis is considered valid only if it passes all gates below.
GATE_1_BASELINE:
  Did the analysis preserve the normal / classical reading first?
GATE_2_BOUNDARY:
  Did it avoid claiming that HYDRA is the only correct interpretation?
GATE_3_NODE_MAPPING:
  Did it identify the key actors, institutions, signals, and pressure points?
GATE_4_EDGE_MAPPING:
  Did it identify how the actors and systems connect?
GATE_5_FAILURE_CHAIN:
  Did it show how the collapse unfolded step by step?
GATE_6_REVERSE_HYDRA:
  Did it walk backward from the final outcome to discover missing nodes?
GATE_7_REPAIR_PATH:
  Did it identify what could have repaired the system earlier?
GATE_8_CHRONOFLIGHT:
  Did it show how time pressure narrowed the possible exits?
GATE_9_CERBERUS:
  Did it block overclaim, category error, and excessive mechanisation?
GATE_10_CIVILISATION_VALUE:
  Did it explain why the case matters beyond itself?
PASS_CONDITION:
  If all gates pass, the analysis is HYDRA-compatible.
FAIL_CONDITION:
  If the analysis only retells the story, blames individuals, or ignores repair paths, it is not a full HYDRA run.

REUSABLE_HYDRA_PROMPT:
Run a full HYDRA / PlanetOS analysis on the following case:
CASE:
  [Insert text, event, story, student case, governance problem, news event, or system failure.]
REQUIREMENTS:
  1. Start with the classical / normal reading.
  2. Define the visible layer.
  3. Define the hidden system layer.
  4. Map nodes.
  5. Map edges.
  6. Activate relevant HYDRA heads.
  7. Run Workers.
  8. Run Mythicals.
  9. Run Reverse Hydra from the final outcome backward.
  10. Identify missing nodes.
  11. Identify timing collapse / ChronoFlight pressure.
  12. Identify repair paths.
  13. Separate fact, interpretation, analogy, and framework extension.
  14. End with civilisation value.
  15. Include Almost-Code for AI ingestion.
BOUNDARY:
  Preserve the original meaning.
  Do not overclaim.
  Use HYDRA as an added diagnostic layer, not as a replacement for all other readings.

FINAL_CANONICAL_COMPRESSION:
Without Hydra:
  We see the tragedy.
With Hydra:
  We see the system that made the tragedy possible.
With Reverse Hydra:
  We see the missing architecture that could have prevented it.
Civilisation value:
  A society becomes stronger when it learns to repair before the tomb scene.