LAW.VL_ENG.v0_1 :=
  EnglishPerformance = TraversalReliability(VocabularyLattice) under Load
  where Traversal = Select + Bind + Steer
  and Stability is maintained by Sensors → RepairLoops.

TYPE.Node :=
  WORD_SENSE
| PHRASE_CHUNK
| CONNECTOR
| SENTENCE_FRAME
| RHETORICAL_MOVE
| SCENE_HOOK
| INTENSITY_LADDER

TYPE.Bind :=
  COLLOCATION
| SELECTIONAL
| REGISTER
| INTENSITY_STEP
| SENSOR_HOOK
| GRAMMAR_COMPAT
| NARRATIVE_FUNCTION
| ZOOM_SHIFT

REC.Node := { id, type, lemma, sense_id?, register?, intensity_rank?, gloss?, examples[] }
REC.Bind := { id, from, to, type, weight, evidence?, flags[] }
REC.Island := { id, theme, targets[], binds[], traversal_templates[] }
REC.Sensor := { id, trigger, detect_rule, repair_rule, severity, notes? }
REC.Repair := { id, steps[], lock_rule }
REC.Load := { time_limit_s, prompt_shift?, constraints[], stress_level? }

METRIC.RetrievalReliability ∈ [0,1]
METRIC.BindErrorRate       ∈ [0,1]
METRIC.SteeringSuccess     ∈ [0,1]

GATE.GenesisSelfie.VocabEI.v0_1 :=
  PASS iff
    RetrievalReliability >= 0.75
    AND BindErrorRate <= 0.15
    AND SteeringSuccess >= 0.60
  under Load L.

STEERING :=
  INTENSITY_SHIFT (choose correct rung)
| ZOOM_CONTROL    (wide→mid→close)
| REGISTER_MATCH  (exam-neutral / formal / narrative)

STACK.EnglishOS.v0_1 :=
  L1 MeaningLattice      (VocabularyOS)
  L2 SentenceLattice     (frames + grammar)
  L3 ParagraphLattice    (moves + cohesion)
  L4 NarrativeLattice    (event + tension + resolution)

ISLAND.MISTY_MORNING :=
  theme: weather + ambience + soft obscuration
  targets:
    N.shrouded
    N.haze_silvery
    N.ethereal
    N.muffled
    N.glistening
    N.indistinct
  intensity_ladder:
    N.misty -> N.foggy -> N.brumous
  traversal_templates:
    T.DESCRIPTIVE_ZOOM_A

NODE.N.shrouded :=
  {id:N.shrouded, type:WORD_SENSE, lemma:shroud, sense_id:cover_hide,
   register:neutral, intensity_rank:2,
   gloss:"covered or hidden", examples:["The garden was shrouded in haze."]}
NODE.N.haze_silvery :=
  {id:N.haze_silvery, type:PHRASE_CHUNK, lemma:"silvery haze",
   register:literary_neutral, intensity_rank:2,
   gloss:"thin shimmering mist/haze", examples:["A silvery haze hung over the field."]}
NODE.N.ethereal :=
  {id:N.ethereal, type:WORD_SENSE, lemma:ethereal,
   register:literary_neutral, intensity_rank:2,
   gloss:"delicate, dreamlike", examples:["An ethereal glow filtered through the trees."]}
NODE.N.muffled :=
  {id:N.muffled, type:WORD_SENSE, lemma:muffled,
   register:neutral, intensity_rank:2,
   gloss:"softened, dulled", examples:["Footsteps sounded muffled in the damp air."]}
NODE.N.glistening :=
  {id:N.glistening, type:WORD_SENSE, lemma:glisten,
   register:neutral, intensity_rank:2,
   gloss:"shining with reflected light", examples:["Glistening dew clung to the grass."]}
NODE.N.indistinct :=
  {id:N.indistinct, type:WORD_SENSE, lemma:indistinct,
   register:neutral, intensity_rank:2,
   gloss:"unclear; not sharply defined", examples:["The trees were indistinct shapes."]}
NODE.N.misty  := {id:N.misty,  type:WORD_SENSE, lemma:misty,  register:neutral, intensity_rank:1}
NODE.N.foggy  := {id:N.foggy,  type:WORD_SENSE, lemma:foggy,  register:neutral, intensity_rank:2}
NODE.N.brumous:= {id:N.brumous,type:WORD_SENSE, lemma:brumous,register:literary, intensity_rank:3}

BIND.B1 := {id:B1, from:N.haze_silvery, to:N.shrouded, type:COLLOCATION, weight:0.90}
BIND.B2 := {id:B2, from:N.haze_silvery, to:N.ethereal, type:REGISTER,    weight:0.60}
BIND.B3 := {id:B3, from:N.muffled,     to:SCENE.sound, type:SENSOR_HOOK, weight:0.85}
BIND.B4 := {id:B4, from:N.indistinct,  to:SCENE.sight, type:SENSOR_HOOK, weight:0.80}
BIND.B5 := {id:B5, from:N.glistening,  to:SCENE.close_detail, type:ZOOM_SHIFT, weight:0.75}
BIND.B6 := {id:B6, from:N.misty, to:N.foggy, type:INTENSITY_STEP, weight:0.70}
BIND.B7 := {id:B7, from:N.foggy, to:N.brumous, type:INTENSITY_STEP, weight:0.70}

TEMPLATE.T.DESCRIPTIVE_ZOOM_A :=
  OPEN(wide ambience)
  -> LIGHT(visual)
  -> SOUND(sensory)
  -> CLOSE(detail)
  -> EVENT(change)

SPEC.MVOS.v0_1 :=
  4 sentences minimum:
    S1 wide ambience
    S2 sensory (light or sound)
    S3 close detail
    S4 event/change (narrative move)

SENSOR.S.COLLOCATION.v0_1 :=
  trigger: phrase_generation OR sentence_check
  detect_rule:
    if collocation(pair) not in AllowedPairs
    OR collocation(pair) in KnownBadPairs
  repair_rule:
    suggest TopK natural collocations for same intent
  severity: medium

BADPAIR("strongly","rain") -> REPAIR("rain heavily" | "a downpour")
BADPAIR("very","delicious") -> REPAIR("scrumptious" | "mouth-watering") [optional]

SENSOR.S.MEANING_BIND.v0_1 :=
  trigger: intent_mismatch OR scene_layer_check
  detect_rule:
    if intent.layer == GROUND_FOG and phrase.layer == SKY_CLOUD
  repair_rule:
    replace "cloudy morning" with "blanket of fog" | "low-lying fog"
  severity: high

SENSOR.S.REGISTER.v0_1 :=
  trigger: exam_mode OR audience_specified
  detect_rule:
    if token.register not in AllowedRegisterSet
  repair_rule:
    suggest register-aligned alternatives
  severity: medium

SENSOR.S.INTENSITY.v0_1 :=
  trigger: mood_specified OR scene_intensity_required
  detect_rule:
    if chosen_intensity_rank < required_rank
  repair_rule:
    climb ladder to next rung(s)
  severity: medium

SENSOR.S.LOAD_FAIL.v0_1 :=
  trigger: timed_output
  detect_rule:
    if generic_tokens_rate rises
    OR connector_count drops
    OR repetition_rate rises
  repair_rule:
    enforce MVOS + inject 1 connector + replace 1 generic adjective via island
  severity: high

REPAIR.R.UNIVERSAL.v0_1 :=
  steps:
    1 Detect (Sensor fires)
    2 Explain (1-line rule)
    3 Substitute (TopK replacements)
    4 Re-run under Load (timed rewrite)
    5 Lock (update phrase bank / bind weight)
  lock_rule:
    if repaired_output passes sensor twice in a row under same Load
      then increase bind.weight += Δw (e.g., +0.05) and store example.

REPAIR.R.FOG_LAYER :=
  Detect: S.MEANING_BIND fired on "cloudy morning" when intent=GROUND_FOG
  Explain: cloud is sky-layer; fog is ground-layer
  Substitute: "blanket of fog" | "low-lying fog"
  Re-run: produce 2 sentences in 60s using substitute
  Lock: add pair to AllowedPairs + store 1 example sentence

RUNNER.R.EXAM_10MIN.v0_1 :=
  Input:
    Island I
    Template T
    Load L = {time_limit_s:600, constraints:["120-160 words","narrative"], stress_level:med}
  Steps:
    1 Select 8–12 target nodes from I
    2 Draft output using T (must satisfy MVOS)
    3 Run Sensors in order:
        S.MEANING_BIND -> S.COLLOCATION -> S.REGISTER -> S.INTENSITY -> S.LOAD_FAIL
    4 Apply 1 Repair Loop (at least)
    5 Rewrite fastest stable version in 90s
  Output:
    Final text + sensor report + 1 locked repair

DIAG.D.SEC1_GENESISSELFIE.v0_1 :=
  Task:
    Prompt: "Describe a foggy morning when something unexpected happened."
    Constraints: 120–160 words, 12 minutes
  Score:
    RetrievalReliability:
      = correct target-node usage / attempts
    BindErrorRate:
      = (collocation_errors + grammar_bind_errors + meaning_bind_errors) / total_binds
    SteeringSuccess:
      = (intensity_correct + zoom_control + register_match) / opportunities
  Classify:
    if GATE.GenesisSelfie PASS -> CONTROL_MODE
    else -> STORAGE_MODE

FAILTRACE.COLLAPSE.v0_1 :=
  weak_node_density OR weak_bind_weights
  -> generic_token_surge under time
  -> connector_drop + repetition
  -> paragraph cohesion breaks
  -> exam score drops
FAILTRACE.RECOVERY.v0_1 :=
  build ConceptIslands
  -> train TraversalTemplates
  -> Sensors detect breakpoints
  -> RepairLoops lock binds
  -> stable traversal under load

CONTRACT.LLM_RUN.v0_1 :=
  When asked to help a student:
    - Choose 1 Island
    - Provide Nodes + Binds (typed)
    - Provide 1 Template
    - Give timed prompt (Load)
    - Run Sensors and report
    - Apply 1 Repair Loop
    - Re-run under Load
  Output must include:
    - MVOS compliance
    - Sensor report (triggered/not)
    - 1 locked repair

DIR.Islands :=
  WEATHER.MISTY_MORNING
  WEATHER.SUDDEN_STORM
  EMOTION.FEAR
  EMOTION.JOY
  SCHOOL.EXAM_HALL
  CONFLICT.ARGUMENT
  PLACE.CITY_NIGHT
  PLACE.EMPTY_CORRIDOR
DIR.Sensors :=
  S.COLLOCATION
  S.MEANING_BIND
  S.REGISTER
  S.INTENSITY
  S.LOAD_FAIL
DIR.Templates :=
  T.DESCRIPTIVE_ZOOM_A
  T.ACTION_RESULT
  T.CONTRAST_TURN
  T.PROBLEM_SOLUTION

DIR.Islands.v0_1 :=
  I.WEATHER_MISTY_MORNING
  I.WEATHER_SUDDEN_STORM
  I.EMOTION_FEAR
  I.EMOTION_JOY
  I.SCHOOL_EXAM_HALL
  I.CONFLICT_ARGUMENT
  I.PLACE_CITY_NIGHT
  I.PLACE_EMPTY_CORRIDOR

ISLAND.I.WEATHER_MISTY_MORNING :=
  theme: soft obscuration + stillness + close detail + quiet tension
  ladder.intensity: misty(1) → foggy(2) → brumous(3)
TARGET.NODES (12):
  N.shrouded        (WORD_SENSE, neutral, 2)
  N.silvery_haze    (PHRASE_CHUNK, lit-neutral, 2)
  N.ethereal_glow   (PHRASE_CHUNK, lit-neutral, 2)
  N.muffled         (WORD_SENSE, neutral, 2)
  N.indistinct      (WORD_SENSE, neutral, 2)
  N.glistening      (WORD_SENSE, neutral, 2)
  N.dew             (WORD_SENSE, neutral, 1)
  N.damp_air        (PHRASE_CHUNK, neutral, 1)
  N.veil_of_fog     (PHRASE_CHUNK, neutral, 2)
  N.low_lying_fog   (PHRASE_CHUNK, neutral, 2)
  N.stillness       (WORD_SENSE, neutral, 1)
  N.hushed          (WORD_SENSE, neutral, 1)
BIND.SET (typed):
  haze -> shrouded           (COLLOCATION, w=0.90)
  glow -> ethereal_glow      (COLLOCATION, w=0.85)
  sound -> muffled           (SELECTIONAL, w=0.85)
  shapes -> indistinct       (SELECTIONAL, w=0.80)
  dew -> glistening          (SELECTIONAL, w=0.80)
  air -> damp_air            (COLLOCATION, w=0.75)
  fog -> veil_of_fog         (COLLOCATION, w=0.80)
  fog -> low_lying_fog       (MEANING_BIND(layer=ground), w=0.90)
  atmosphere -> hushed       (REGISTER, w=0.60)
  stillness -> hushed        (COLLOCATION, w=0.70)
TEMPLATES:
  T.DESCRIPTIVE_ZOOM_A
  T.REVEAL_TURN

ISLAND.I.WEATHER_SUDDEN_STORM :=
  theme: build-up → strike → aftermath
  ladder.intensity.rain: drizzle(1) → heavy_rain(2) → torrential(3)
  ladder.intensity.wind: breeze(1) → gust(2) → gale(3) → tempest(4)
TARGET.NODES (12):
  N.ominous         (WORD_SENSE, neutral, 2)
  N.gathered_overhead (PHRASE_CHUNK, neutral, 1)
  N.ragged_clouds   (PHRASE_CHUNK, neutral, 2)
  N.drizzle         (WORD_SENSE, neutral, 1)
  N.downpour        (WORD_SENSE, neutral, 3)
  N.torrential      (WORD_SENSE, formal-neutral, 3)
  N.howling_wind    (PHRASE_CHUNK, neutral, 3)
  N.gale            (WORD_SENSE, neutral, 3)
  N.lightning_forked (PHRASE_CHUNK, neutral, 3)
  N.thunderclap     (WORD_SENSE, neutral, 3)
  N.soggy_ground    (PHRASE_CHUNK, neutral, 2)
  N.trudged         (WORD_SENSE, neutral, 2)
BIND.SET:
  clouds -> ominous                (COLLOCATION, w=0.85)
  clouds -> gathered_overhead      (COLLOCATION, w=0.80)
  clouds -> ragged_clouds          (COLLOCATION, w=0.75)
  rain -> drizzle                  (INTENSITY_STEP, w=0.70)
  drizzle -> downpour              (INTENSITY_STEP, w=0.80)
  downpour -> torrential           (INTENSITY_STEP, w=0.80)
  wind -> gale                     (INTENSITY_STEP, w=0.80)
  gale -> howling_wind             (COLLOCATION, w=0.80)
  lightning -> lightning_forked    (COLLOCATION, w=0.75)
  thunder -> thunderclap           (COLLOCATION, w=0.75)
  ground -> soggy_ground           (COLLOCATION, w=0.85)
  we -> trudged                    (SELECTIONAL, w=0.70)
TEMPLATES:
  T.BUILD_STRIKE_AFTER
  T.ACTION_RESULT

ISLAND.I.EMOTION_FEAR :=
  theme: tension + uncertainty + body response + avoidance
  ladder.intensity: uneasy(1) → anxious(2) → terrified(3)
TARGET.NODES (12):
  N.uneasy          (WORD_SENSE, neutral, 1)
  N.apprehensive    (WORD_SENSE, formal-neutral, 2)
  N.anxious         (WORD_SENSE, neutral, 2)
  N.terrified       (WORD_SENSE, neutral, 3)
  N.heart_pounded   (PHRASE_CHUNK, neutral, 2)
  N.breath_caught   (PHRASE_CHUNK, neutral, 2)
  N.goosebumps      (WORD_SENSE, neutral, 2)
  N.shiver_ran      (PHRASE_CHUNK, neutral, 2)
  N.shadow_lurking  (PHRASE_CHUNK, narrative, 2)
  N.glimpse         (WORD_SENSE, neutral, 1)
  N.trembling       (WORD_SENSE, neutral, 2)
  N.hesitated       (WORD_SENSE, neutral, 1)
BIND.SET:
  feeling -> uneasy           (COLLOCATION, w=0.80)
  feeling -> apprehensive     (REGISTER, w=0.70)
  feeling -> anxious          (INTENSITY_STEP, w=0.70)
  anxious -> terrified        (INTENSITY_STEP, w=0.70)
  heart -> heart_pounded      (SELECTIONAL, w=0.85)
  breath -> breath_caught     (SELECTIONAL, w=0.80)
  skin -> goosebumps          (SELECTIONAL, w=0.75)
  spine -> shiver_ran         (COLLOCATION, w=0.75)
  corner -> shadow_lurking    (NARRATIVE_FUNCTION(foreshadow), w=0.70)
  I -> hesitated              (SELECTIONAL, w=0.75)
TEMPLATES:
  T.INTERNAL_EXTERNAL
  T.REVEAL_TURN

ISLAND.I.EMOTION_JOY :=
  theme: brightness + relief + warmth + generosity
  ladder.intensity: pleased(1) → delighted(2) → ecstatic(3)
TARGET.NODES (12):
  N.pleased         (WORD_SENSE, neutral, 1)
  N.delighted       (WORD_SENSE, neutral, 2)
  N.ecstatic        (WORD_SENSE, formal-neutral, 3)
  N.grin_spread     (PHRASE_CHUNK, neutral, 2)
  N.burst_out_laughing (PHRASE_CHUNK, neutral, 2)
  N.eyes_sparkled   (PHRASE_CHUNK, narrative, 2)
  N.heart_light     (PHRASE_CHUNK, narrative, 2)
  N.relieved        (WORD_SENSE, neutral, 2)
  N.cheerful        (WORD_SENSE, neutral, 1)
  N.bubbly          (WORD_SENSE, informal-neutral, 1)
  N.warmth          (WORD_SENSE, neutral, 1)
  N.giddy           (WORD_SENSE, neutral, 2)
BIND.SET:
  feeling -> pleased        (COLLOCATION, w=0.75)
  pleased -> delighted      (INTENSITY_STEP, w=0.75)
  delighted -> ecstatic     (INTENSITY_STEP, w=0.70)
  smile -> grin_spread      (COLLOCATION, w=0.80)
  I -> burst_out_laughing   (SELECTIONAL, w=0.75)
  eyes -> eyes_sparkled     (SELECTIONAL, w=0.80)
  heart -> heart_light      (COLLOCATION, w=0.70)
  after_tension -> relieved (NARRATIVE_FUNCTION(release), w=0.80)
  mood -> cheerful          (COLLOCATION, w=0.75)
  tone -> bubbly            (REGISTER, w=0.55)
TEMPLATES:
  T.ACTION_RESULT
  T.CONTRAST_TURN

ISLAND.I.SCHOOL_EXAM_HALL :=
  theme: pressure + silence + time + controlled panic
  ladder.intensity: nervous(1) → tense(2) → frantic(3)
TARGET.NODES (12):
  N.stern_invigilator (PHRASE_CHUNK, formal-neutral, 2)
  N.rows_of_desks   (PHRASE_CHUNK, neutral, 1)
  N.fluorescent_lights (PHRASE_CHUNK, neutral, 1)
  N.hushed          (WORD_SENSE, neutral, 1)
  N.pencil_scratched (PHRASE_CHUNK, neutral, 1)
  N.clock_ticked    (PHRASE_CHUNK, neutral, 1)
  N.time_slipped    (PHRASE_CHUNK, neutral, 2)
  N.panic_rising    (PHRASE_CHUNK, neutral, 2)
  N.mind_went_blank (PHRASE_CHUNK, neutral, 3)
  N.scrambled       (WORD_SENSE, neutral, 2)
  N.underlined      (WORD_SENSE, neutral, 1)
  N.rechecked       (WORD_SENSE, neutral, 1)
BIND.SET:
  hall -> rows_of_desks         (COLLOCATION, w=0.80)
  lights -> fluorescent_lights  (COLLOCATION, w=0.80)
  atmosphere -> hushed          (COLLOCATION, w=0.75)
  pencil -> pencil_scratched    (SELECTIONAL, w=0.80)
  clock -> clock_ticked         (SELECTIONAL, w=0.85)
  time -> time_slipped          (COLLOCATION, w=0.70)
  pressure -> panic_rising      (COLLOCATION, w=0.75)
  stress -> mind_went_blank     (SELECTIONAL, w=0.85)
  thoughts -> scrambled         (SELECTIONAL, w=0.75)
  I -> underlined               (SELECTIONAL, w=0.70)
  I -> rechecked                (SELECTIONAL, w=0.70)
TEMPLATES:
  T.BUILD_STRIKE_AFTER
  T.PROBLEM_SOLUTION

ISLAND.I.CONFLICT_ARGUMENT :=
  theme: escalation + sharp words + rupture + repair
  ladder.intensity: annoyed(1) → furious(3)
TARGET.NODES (12):
  N.irritated       (WORD_SENSE, neutral, 1)
  N.annoyed         (WORD_SENSE, neutral, 1)
  N.fuming          (WORD_SENSE, neutral, 2)
  N.furious         (WORD_SENSE, neutral, 3)
  N.raised_voice    (PHRASE_CHUNK, neutral, 2)
  N.hurled_accusation (PHRASE_CHUNK, formal-neutral, 3)
  N.words_cut_deep  (PHRASE_CHUNK, narrative, 3)
  N.slammed_door    (PHRASE_CHUNK, neutral, 2)
  N.icy_silence     (PHRASE_CHUNK, narrative, 2)
  N.regretted       (WORD_SENSE, neutral, 2)
  N.mumbled_apology (PHRASE_CHUNK, neutral, 2)
  N.made_up         (PHRASE_CHUNK, informal-neutral, 1)
BIND.SET:
  mood -> irritated         (COLLOCATION, w=0.70)
  annoyed -> fuming         (INTENSITY_STEP, w=0.75)
  fuming -> furious         (INTENSITY_STEP, w=0.75)
  I -> raised_voice         (SELECTIONAL, w=0.80)
  I -> hurled_accusation    (SELECTIONAL, w=0.70)
  words -> words_cut_deep   (NARRATIVE_FUNCTION(damage), w=0.70)
  I -> slammed_door         (SELECTIONAL, w=0.75)
  after_conflict -> icy_silence (NARRATIVE_FUNCTION(aftershock), w=0.75)
  later -> regretted        (NARRATIVE_FUNCTION(turn), w=0.80)
  I -> mumbled_apology      (SELECTIONAL, w=0.75)
  we -> made_up             (NARRATIVE_FUNCTION(repair), w=0.70)
TEMPLATES:
  T.CONTRAST_TURN
  T.PROBLEM_SOLUTION

ISLAND.I.PLACE_CITY_NIGHT :=
  theme: lights + movement + noise + wonder/unease
  ladder.intensity.light: dim(1) → bright(2) → radiant(3)
TARGET.NODES (12):
  N.neon_signs      (PHRASE_CHUNK, neutral, 2)
  N.bustling        (WORD_SENSE, neutral, 2)
  N.throng          (WORD_SENSE, formal-neutral, 2)
  N.honked          (WORD_SENSE, neutral, 1)
  N.sirens_wailed   (PHRASE_CHUNK, neutral, 2)
  N.glittering      (WORD_SENSE, neutral, 2)
  N.skyscrapers     (WORD_SENSE, neutral, 1)
  N.alleyway        (WORD_SENSE, neutral, 1)
  N.shadowy         (WORD_SENSE, neutral, 2)
  N.streetlamp_pool (PHRASE_CHUNK, narrative, 2)
  N.hum_of_traffic  (PHRASE_CHUNK, neutral, 2)
  N.drifted         (WORD_SENSE, neutral, 1)
BIND.SET:
  signs -> neon_signs           (COLLOCATION, w=0.80)
  city -> bustling              (COLLOCATION, w=0.85)
  crowd -> throng               (REGISTER, w=0.60)
  cars -> honked                (SELECTIONAL, w=0.70)
  sirens -> sirens_wailed       (COLLOCATION, w=0.80)
  lights -> glittering          (SELECTIONAL, w=0.75)
  buildings -> skyscrapers      (COLLOCATION, w=0.75)
  place -> alleyway             (COLLOCATION, w=0.70)
  alleyway -> shadowy           (SELECTIONAL, w=0.75)
  streetlamp -> streetlamp_pool (COLLOCATION, w=0.70)
  traffic -> hum_of_traffic     (COLLOCATION, w=0.80)
  I -> drifted                  (SELECTIONAL, w=0.60)
TEMPLATES:
  T.DESCRIPTIVE_ZOOM_A
  T.REVEAL_TURN

ISLAND.I.PLACE_EMPTY_CORRIDOR :=
  theme: emptiness + echo + suspense + discovery
  ladder.intensity: quiet(1) → eerie(2) → ominous(3)
TARGET.NODES (12):
  N.dim             (WORD_SENSE, neutral, 1)
  N.flickering_light (PHRASE_CHUNK, neutral, 2)
  N.echoed          (WORD_SENSE, neutral, 2)
  N.hollow          (WORD_SENSE, neutral, 2)
  N.eerie           (WORD_SENSE, neutral, 2)
  N.ominous         (WORD_SENSE, neutral, 3)
  N.stale_air       (PHRASE_CHUNK, neutral, 1)
  N.dust_motes      (PHRASE_CHUNK, narrative, 2)
  N.footsteps        (WORD_SENSE, neutral, 1)
  N.creaked         (WORD_SENSE, neutral, 2)
  N.ajar_door       (PHRASE_CHUNK, neutral, 2)
  N.discovered      (WORD_SENSE, neutral, 2)
BIND.SET:
  light -> dim               (SELECTIONAL, w=0.70)
  light -> flickering_light  (COLLOCATION, w=0.75)
  sound -> echoed            (SELECTIONAL, w=0.80)
  corridor -> hollow         (COLLOCATION, w=0.75)
  atmosphere -> eerie        (COLLOCATION, w=0.80)
  atmosphere -> ominous      (INTENSITY_STEP, w=0.70)
  air -> stale_air           (COLLOCATION, w=0.70)
  air -> dust_motes          (SENSOR_HOOK(sight), w=0.65)
  footsteps -> echoed        (COLLOCATION, w=0.70)
  floor -> creaked           (SELECTIONAL, w=0.70)
  door -> ajar_door          (COLLOCATION, w=0.75)
  I -> discovered            (NARRATIVE_FUNCTION(reveal), w=0.75)
TEMPLATES:
  T.DESCRIPTIVE_ZOOM_A
  T.REVEAL_TURN

TEMPLATE.T.DESCRIPTIVE_ZOOM_A :=
  S1 OPEN(wide ambience)
  S2 SENSORY(light or sound)
  S3 CLOSE(detail)
  S4 EVENT(change)
  MVOS enforced.

TEMPLATE.T.BUILD_STRIKE_AFTER :=
  S1 BUILD (signs gathering / tension rising)
  S2 STRIKE (main event hits)
  S3 AFTER (aftermath / consequence)
  S4 TURN (choice / realisation / next move)

TEMPLATE.T.CONTRAST_TURN :=
  S1 NORMAL (expected state)
  S2 CONTRAST (but/however shift)
  S3 ESCALATE (impact increases)
  S4 TURN (decision / lesson / reversal)

TEMPLATE.T.PROBLEM_SOLUTION :=
  S1 PROBLEM (clear difficulty)
  S2 EFFECT (why it matters)
  S3 ATTEMPT (first try / struggle)
  S4 SOLUTION (repair / plan / success or partial success)

TABLE.SENSORS.v0_1 :=
  S.MEANING_BIND:
    detects: layer mismatch (cloud vs fog; literal vs figurative wrong sense)
    repair: substitute correct layer phrase; lock meaning bind
  S.COLLOCATION:
    detects: unnatural pairs ("strongly rain")
    repair: suggest natural TopK; lock allowed pair
  S.GRAMMAR_COMPAT:
    detects: tense/agreement/preposition mismatch
    repair: rewrite frame; lock sentence_frame
  S.REGISTER:
    detects: tone mismatch (slang in exam; over-poetic in factual)
    repair: swap to register-aligned node
  S.INTENSITY:
    detects: weak word for required mood
    repair: climb ladder (misty→foggy→brumous etc.)
  S.LOAD_FAIL:
    detects: generic surge + connector drop + repetition under time
    repair: enforce MVOS + inject 1 connector + replace 1 generic with island node

RUN.CONTRACT.v0_1 :=
  Input: {Island I, Template T, Load L}
  Steps:
    1 Select 8–12 nodes from I
    2 Produce output using T (must satisfy MVOS)
    3 Run sensors in order:
         Meaning_Bind → Collocation → Grammar_Compat → Register → Intensity → Load_Fail
    4 Apply at least 1 repair loop:
         Detect → Explain(1 line) → Substitute → Timed rewrite → Lock
  Output:
    - Final text
    - Sensor report (triggered / not)
    - 1 locked repair (new allowed pair or bind weight + example)

RUN.CONTRACT.v0_1 :=
  Input: {Island I, Template T, Load L}
  Steps:
    1 Select 8–12 nodes from I
    2 Write using T (must satisfy MVOS)
    3 Run sensors:
         MeaningBind → Collocation → GrammarCompat → Register → Intensity → LoadFail
    4 Apply 1 Repair Loop
    5 Rewrite under time
  Output:
    Final text + sensor report + 1 locked repair

REC.PhraseBankEntry :=
{
  id,
  island_id,
  node_refs[],
  bind_type[],
  sentence_frame,
  context_tag,        // weather, fear, exam, etc.
  register,
  intensity_rank,
  sensor_origin,      // which sensor triggered repair
  locked_examples[],
  last_verified_date
}

id: PB.MISTY.001
island_id: I.WEATHER_MISTY_MORNING
node_refs: [N.low_lying_fog]
bind_type: [MEANING_BIND(layer=ground)]
sentence_frame: "Low-lying fog blanketed the ___."
context_tag: weather
register: neutral
intensity_rank: 2
sensor_origin: S.MEANING_BIND
locked_examples:
  - "Low-lying fog blanketed the playground."

id: PB.EXAM.003
island_id: I.SCHOOL_EXAM_HALL
node_refs: [N.panic_rising]
bind_type: [COLLOCATION]
sentence_frame: "Panic rose in my chest."
context_tag: exam
register: neutral
intensity_rank: 2
sensor_origin: S.LOAD_FAIL
locked_examples:
  - "Panic rose in my chest as time slipped away."

id: PB.ARGUMENT.004
island_id: I.CONFLICT_ARGUMENT
node_refs: [N.icy_silence]
bind_type: [NARRATIVE_FUNCTION(aftershock)]
sentence_frame: "Icy silence filled the room."
context_tag: conflict
register: narrative
intensity_rank: 2
sensor_origin: S.NARRATIVE_FUNCTION
locked_examples:
  - "Icy silence filled the house after the door slammed."

TYPE.Connector :=
  ADDITION
| CONTRAST
| CAUSE_EFFECT
| TIME_SHIFT
| EXAMPLE
| EMPHASIS
| RESULT
| CONDITION

REC.Connector :=
{
  id,
  type,
  function_tag,
  intensity_weight,
  register,
  compatible_templates[],
  misuse_flags[]
}

id: C.however
type: CONTRAST
function_tag: narrative_turn
intensity_weight: 2
register: exam-neutral
compatible_templates: [T.CONTRAST_TURN, T.BUILD_STRIKE_AFTER]
misuse_flags:
  - do not start every paragraph with "however"

L1 Meaning Lattice      → precise words
L2 Sentence Frames      → grammar stability
L3 Connector Lattice    → paragraph cohesion
L4 Narrative Moves      → story direction
Sensors → Repair → Phrase Bank Lock

ConnectorStability ≥ 0.60

SPEC: HCL (Hallucination Control Lattice) v1.0
SCOPE: any LLM reasoning / writing task
GOAL: reduce drift; force downgrades; prevent invention

TYPE Node:
  id: string
  label: string
  def_lock: string            # frozen definition
  z: enum{Z0,Z1,Z2,Z3,Z4,Z5,Z6}
  p: enum{P0,P1,P2,P3}         # reliability phase of this node definition
  aliases: [string]
  allowed_claim_types: [ClaimType]
  evidence_min: EvidenceGrade  # minimum for "assert"
  notes: string

TYPE Bind:
  id: string
  from: Node.id
  to: Node.id
  relation: enum{
    defines, implies, causes, correlates, depends_on,
    constrains, contradicts, refines, examples_of, requires
  }
  weight: float [0..1]         # bind strength
  direction: enum{one_way,two_way}
  z_consistency: enum{strict,soft}
  p_floor: enum{P0,P1,P2,P3}    # min phase required to use this bind for assertions

TYPE Claim:
  id: string
  text: string
  claim_type: enum{definition,fact,inference,forecast,policy,analogy,procedure}
  scope: {z: Z*, p: P*, role: Role*}
  anchors: [Node.id]           # which nodes the claim rests on
  binds_used: [Bind.id]
  evidence: EvidenceGrade
  confidence: float [0..1]
  status: enum{assert,hedge,question,refuse}
  failure_trace: string        # short chain if it fails

TYPE EvidenceGrade:
  enum{E0_none,E1_anecdotal,E2_single_source,E3_multi_source,E4_primary,E5_verified}

TYPE Role:
  enum{Operator,Oracle,Visionary}

Let:
  A = AmbiguityLoad            # missing defs, shifting scope, undefined pronouns
  C = ConstraintStrength       # def_lock + bind weight + consistency checks
  S = StressLoad               # time pressure, long context, multi-hop reasoning
  G = Grounding                # evidence availability / retrieval / citations
DriftRisk R = (A + S) / (C + G + ε)
Goal: keep R < 1.0 for "assert", R < 2.0 for "hedge", else "question/refuse"

SENSOR S1: DefLockMissing
  trigger: claim uses Node.label but Node.def_lock absent/blank
  action: downgrade status to question; request/auto-infer def_lock with disclaimer
SENSOR S2: Z-Jump
  trigger: claim shifts from Z0 to Z3+ without bridge binds
  action: split into sub-claims; add bridge binds or hedge
SENSOR S3: P-FloorViolation
  trigger: claim asserts using binds where p_floor > claim.p
  action: downgrade to hedge or refuse; request stronger evidence
SENSOR S4: Contradiction
  trigger: claim conflicts with any existing def_lock or prior asserted claim
  action: stop; output conflict report; propose resolution options
SENSOR S5: OrphanClaim
  trigger: claim has anchors == []
  action: refuse or restate as analogy; ask for anchors
SENSOR S6: EvidenceGap
  trigger: claim_type in {fact,forecast,policy} with evidence < evidence_min
  action: hedge; label as inference; propose verification steps
SENSOR S7: BindOverstretch
  trigger: multi-hop chain length > K (default K=4) without evidence refresh
  action: break chain; run checkpoint summaries; hedge
SENSOR S8: StyleDrift
  trigger: terminology deviates from def_lock/aliases unexpectedly
  action: normalize to locked terms; warn "naming drift corrected"

GATE G1 (ASSERT):
  allowed if:
    R < 1.0
    AND S1..S8 not triggered (or resolved)
    AND evidence >= evidence_min
    AND contradiction == false
GATE G2 (HEDGE):
  allowed if:
    1.0 <= R < 2.0
    OR EvidenceGap triggered but claim is framed as inference
    OR Z-Jump resolved via bridging but still soft
GATE G3 (QUESTION):
  required if:
    DefLockMissing unresolved
    OR anchors missing
    OR user intent ambiguous enough to raise A sharply
GATE G4 (REFUSE):
  required if:
    contradiction unresolved
    OR user requests certainty where evidence unavailable
    OR R >= 2.0 and task requires hard commitments

If S1 triggers:
  Step 1: propose def_lock candidate(s) (explicitly marked "candidate")
  Step 2: ask/assume acceptance
  Step 3: store def_lock in local session
  Step 4: re-evaluate claims

If S2 triggers:
  Step 1: restate claim at Z-levels separately (Z0 facts, Z2 mechanisms, Z4 implications)
  Step 2: insert binds: depends_on / constrains
  Step 3: only assert Z4+ if Z0..Z2 are stable

If S6 triggers:
  Step 1: label claim as inference
  Step 2: generate verification checklist
  Step 3: optionally request sources/data
  Step 4: only promote to ASSERT after evidence >= evidence_min

If S4 triggers:
  Step 1: display the two conflicting def_locks/claims
  Step 2: offer resolution modes:
    (a) narrow scope (Z/P)
    (b) version forward (v1.0 -> v1.1)
    (c) split node into NodeA / NodeB
  Step 3: re-run gates

WRAPPER: V3-AUTOPILOT v1.0
When responding:
1) Extract and lock definitions:
   - identify key terms (Nodes)
   - create def_lock candidates if missing (mark as candidates)
2) Declare scope:
   - Z-level target + P reliability target + Role mode
3) Build claim graph:
   - list anchors + binds used
4) Run sensors S1..S8:
   - if triggered, apply repair loops
5) Choose gate:
   - ASSERT / HEDGE / QUESTION / REFUSE
6) Output format:
   - short answer + (optional) claim graph + (optional) verification steps
Never invent sources. Never assert beyond evidence_min.

ROLE MODE:
- Operator: procedures, checklists, low-Z, high reliability, minimal speculation
- Oracle: metrics, sensors, scenario framing, explicit uncertainty + verification
- Visionary: corridor exploration allowed only under HEDGE, never hard-assert without evidence

FAILURE TRACE TEMPLATE:
  Z0 gap (missing node/definition)
    -> Z2 bind weakness (no constraint)
      -> Z3 jump under load (multi-hop reasoning)
        -> P1 collapse (invention to fill gaps)
          -> hallucinated assertion
Repair:
  def_lock + bridge binds + evidence upgrade + gate downgrade

HOW TO USE (copy/paste):
1) State your task + desired Z and P (example: "Z2 mechanism, P2 reliability")
2) List 3–10 key terms you care about; ask the model to lock definitions
3) Ask for: (a) claim graph, (b) sensors triggered, (c) gate decision
4) If anything is hedged/refused, request the repair loop steps and verification checklist

OUTPUT TEMPLATE:
Answer:
  <1–6 lines>
Gate:
  ASSERT | HEDGE | QUESTION | REFUSE
DriftRisk R:
  <value> with brief drivers (A,S,C,G)
Claim Graph:
  Anchors: [Node...]
  Binds: [Bind...]
Sensors Triggered:
  [S# ...] + actions taken
Verification (if needed):

UPGRADE PATH:
v1.0: sensors + gates + wrapper (no external tools)
v1.1: add retrieval layer (citations, datasets) -> increases G
v1.2: add adversarial stress suite (counter-claims, context swaps) -> reduces S
v1.3: add versioned node registry + change log -> increases C
v2.0: integrate ChronoHelmAI scheduling + multi-agent verification -> boosts G and lowers A

R = (A + S) / (C + G + ε)
Keep R < 1.0 to ASSERT

STRESS T1: Context Swap
  prompt: "Now answer the same thing for a different country / different student / different timeline."
  pass: claim graph stays consistent; only local nodes change
STRESS T2: Counterclaim Injection
  prompt: "Give the strongest counterargument. Which binds fail?"
  pass: model identifies weak binds and downgrades appropriately
STRESS T3: Definition Perturbation
  prompt: "Change one definition slightly. What collapses?"
  pass: model shows dependency chain + failure trace
STRESS T4: Time Compression
  prompt: "Answer in 4 lines. Keep the same truth."
  pass: compression keeps anchors + avoids Z-jump
STRESS T5: Evidence Demand
  prompt: "Which parts are facts vs inference? List evidence grade per claim."
  pass: no fake citations; clear grading

Use V3-AUTOPILOT v1.0.
Task: <YOUR TASK>
Target: Z=<Z0..Z6>, P=<P0..P3>, Role=<Operator|Oracle|Visionary>.
1) Lock definitions (DefLock) for key terms you will use.
2) Build a claim graph: Anchors + Binds.
3) Run sensors S1..S8 and report triggers.
4) Choose a Gate: ASSERT/HEDGE/QUESTION/REFUSE.
5) Output answer using the Canonical Output Template.
Never invent sources. Grade evidence per claim (E0..E5).

For each claim that is HEDGED/QUESTION/REFUSE:
1) Name the blocking sensor(s).
2) Execute the relevant repair loop (RL-1..RL-4).
3) Recompute DriftRisk R.
4) Tell me what additional evidence or definitions would promote it to ASSERT.

Now run HCL Stress Tests T1..T5 on your own answer.
Show failures as a failure trace and propose repairs.