A messy input enters PlanetOS.

mode selected
→ language checked
→ workers activated
→ route chosen
→ guardians triggered
→ ledgers audited
→ repair applied
→ Cerberus release gate passed
→ output compiled
→ memory updated

PLANETOS.ECU.COMPILER.v1.0
SYSTEM.TYPE:
  Execution Control Unit
SYSTEM.ROLE:
  Governs signal movement across PlanetOS.
SYSTEM.NOT:
  Not an OS branch.
  Not a worker.
  Not a mythical guardian.
  Not a truth oracle.
  Not a replacement for evidence.
SYSTEM.DOES:
  Selects control mode.
  Orders worker sequence.
  Routes signal.
  Activates guardians.
  Controls thresholds.
  Audits ledgers.
  Sends weak signals to Shadow Ledger.
  Sends junk to Decay Bin.
  Triggers repair.
  Gates release through Cerberus.
  Updates MemoryOS.

INPUT.OBJECT:
signal.id:
  unique signal identifier
signal.raw:
  original input
signal.source:
  user / document / report / news / sensor / memory / external system
signal.type:
  question / claim / problem / case / report / scenario / metaphor / instruction
signal.domain:
  EducationOS / NewsOS / WaterOS / FinanceOS / GovernanceOS / RealityOS / Unknown
signal.stakes:
  low / medium / high / critical
signal.audience:
  private / student / parent / public / institutional / policy / safety-critical
signal.evidence_state:
  none / weak / partial / strong / verified
signal.time_pressure:
  low / medium / high / emergency
signal.creativity_need:
  none / low / medium / high / frontier
signal.release_target:
  answer / article / report / dashboard / case study / registry / memory update

FUNCTION SELECT_ECU_MODE(signal):
IF signal.stakes = critical:
    RETURN STRICT_ECU
ELSE IF signal.domain IN [health, safety, law, finance, water_security, governance, public_policy]:
    RETURN STRICT_ECU
ELSE IF signal.release_target IN [public_report, formal_report, risk_report]:
    RETURN STRICT_ECU
ELSE IF signal.creativity_need IN [high, frontier]:
    RETURN CREATIVE_ECU
ELSE IF signal.release_target IN [article, teaching, case_study, parent_explanation, student_explanation]:
    RETURN BALANCED_ECU
ELSE:
    RETURN BALANCED_ECU

STRICT_ECU:
purpose:
  protect accuracy, safety, public trust, evidence integrity
requires:
  evidence check
  claim boundary
  uncertainty label
  audit trail
  source discipline where applicable
  Cerberus final gate
forbids:
  unsupported certainty
  speculative release as fact
  metaphor treated as proof
  emotional overstatement
  hidden assumptions
BALANCED_ECU:
purpose:
  explain clearly while preserving truth boundaries
requires:
  conceptual clarity
  reasonable checking
  useful synthesis
  visible limits
  repair pathway where needed
allows:
  explanation
  teaching analogy
  structured interpretation
  framework connection
forbids:
  careless overclaim
  fake precision
  unsupported diagnosis
CREATIVE_ECU:
purpose:
  generate new models, names, metaphors, scenarios, and frontier structures
requires:
  label as fact / inference / scenario / metaphor / speculation
  internal coherence check
  safety boundary
  Cerberus final gate
allows:
  invention
  pattern extension
  metaphor
  speculative architecture
  frontier synthesis
forbids:
  presenting speculation as established fact
  bypassing Cerberus
  collapsing imagination into truth claim

FUNCTION ECU_INTAKE(signal):
STEP 1:
  VocabularyOS.check(signal)
STEP 2:
  Janitor.clean(signal)
STEP 3:
  Sorter.classify(signal)
STEP 4:
  Librarian.retrieve_context(signal)
STEP 5:
  Translator.normalise(signal)
STEP 6:
  Dispatcher.route(signal)
RETURN prepared_signal

VOCABULARYOS.CHECK(signal):
CHECK definition_drift
CHECK frame_injection
CHECK emotional_overload
CHECK label_content_mismatch
CHECK attribution_warp
CHECK compression_distortion
CHECK hidden_lattice_flip
IF severe_language_warp_detected:
    flag signal.language_status = WARPED
    send to Sphinx for meaning gate
ELSE:
    flag signal.language_status = STABLE_ENOUGH

NO RAW LANGUAGE MOVES UNCHECKED.

WORKER.DEFAULT_CHAIN:
1. Janitor
2. Sorter
3. Librarian
4. Translator
5. Dispatcher
6. Inspector
7. Auditor
8. Repairman
9. Operator

JANITOR:
  remove noise
  separate junk from signal
  preserve raw original
SORTER:
  classify domain
  classify stakes
  classify urgency
  classify signal type
LIBRARIAN:
  retrieve memory
  retrieve relevant OS branch
  retrieve prior cases
  retrieve ledgers
TRANSLATOR:
  convert raw phrasing into stable operational meaning
DISPATCHER:
  route to OS branch / worker / guardian
INSPECTOR:
  check task-fit and route-fit
AUDITOR:
  check invariants, evidence, logic, contradictions
REPAIRMAN:
  repair missing nodes, broken routes, failed transfer
OPERATOR:
  compile final usable output

FUNCTION DETERMINE_SIGNAL_ROUTE(prepared_signal):
IF evidence_state IN [strong, verified]
AND meaning_status = stable
AND route_fit = clear:
    RETURN STRONG_ROUTE
ELSE IF signal has anomaly_value
OR future_warning_value
OR rare_pattern_value
OR unresolved_but_non-junk_value:
    RETURN SHADOW_LEDGER
ELSE IF signal is duplicate_spam
OR incoherent_after_repair_attempt
OR malicious_noise
OR irrelevant_junk:
    RETURN DECAY_BIN
ELSE:
    RETURN SHADOW_LEDGER

LOW-VOLUME SIGNAL ≠ LOW-VALUE SIGNAL.

SHADOW_LEDGER.STORE(signal):
store raw_signal
store cleaned_signal
store reason_for_nonrelease
store uncertainty_level
store possible_future_value
store required_evidence_for_promotion
store review_trigger
store decay_timer

DECAY_BIN.STORE(signal):
IF signal is clearly junk:
    mark as DECAY
    preserve minimal trace only
    do not route further
IF signal later repeats across independent channels:
    re-open as Shadow Ledger candidate

FUNCTION ACTIVATE_GUARDIANS(signal):
IF signal.has_multiple_routes
OR signal.requires_multi-branch_processing:
    wake HYDRA
IF signal.meaning_unclear
OR definition_unstable
OR question_hidden:
    wake SPHINX
IF signal.future_uncertain
OR weak_signal_with_possible_importance
OR early_warning:
    wake ORACLE
IF signal.trapped_in_loop
OR circular_problem
OR maze_structure:
    wake MINOTAUR
IF signal.needs_escape_route
OR continuity_path
OR thread_recovery:
    wake ARIADNE
IF signal.high_value_resource
OR guarded_capability
OR power_concentration:
    wake DRAGON
IF signal.deep_hidden_risk
OR submerged_systemic_force:
    wake KRAKEN
IF signal.load_bearing
OR burden_distribution_problem:
    wake ATLAS
IF signal.requires_repair
OR collapse_recovery
OR rebirth_after_failure:
    wake PHOENIX
ALWAYS before release:
    wake CERBERUS

HYDRA_OUTPUT:
  route map
  branch map
  head activation list
SPHINX_OUTPUT:
  corrected question
  definition lock
  meaning gate result
ORACLE_OUTPUT:
  watch signal
  uncertainty band
  future review trigger
MINOTAUR_OUTPUT:
  trap map
  loop detection
  dead-end warning
ARIADNE_OUTPUT:
  path thread
  exit route
  continuity corridor
DRAGON_OUTPUT:
  guarded resource map
  concentration warning
  access condition
KRAKEN_OUTPUT:
  hidden risk trace
  deep-system pressure warning
ATLAS_OUTPUT:
  load map
  burden stress
  collapse pressure
PHOENIX_OUTPUT:
  repair route
  rebuild plan
  recovery condition
CERBERUS_OUTPUT:
  release / hold / revise / reject

AUDITOR.CHECK(signal, output):
CHECK evidence_integrity
CHECK invariant_integrity
CHECK ledger_alignment
CHECK mode_compliance
CHECK claim_boundary
CHECK uncertainty_label
CHECK contradiction
CHECK missing_node
CHECK inverse_lattice_risk
CHECK public_consequence

IF violation_detected:
    send to REPAIRMAN
IF violation_severe:
    send to CERBERUS_HOLD
IF unresolved_but_important:
    send to SHADOW_LEDGER

REPAIRMAN.TRIGGER IF:
missing_node = true
broken_route = true
contradiction_detected = true
failed_transfer = true
student_uptake_failure = true
definition_drift = severe
ledger_breach = true
output_unusable = true
mode_mismatch = true

REPAIRMAN.ACTION:
identify failure point
retrieve missing context
repair route
adjust mode if needed
call Phoenix if collapse/rebuild required
send back to Auditor

CERBERUS.FINAL_GATE(output, mode):
IF mode = STRICT_ECU:
    REQUIRE verified_or_bounded_claims
    REQUIRE uncertainty_labels
    REQUIRE no unsupported factual claim
    REQUIRE audit_pass
    REQUIRE public_consequence_check
IF mode = BALANCED_ECU:
    REQUIRE clear_explanation
    REQUIRE bounded_synthesis
    REQUIRE no reckless certainty
    REQUIRE useful_output
    REQUIRE audit_pass
IF mode = CREATIVE_ECU:
    REQUIRE labels:
      fact / inference / scenario / metaphor / speculation
    REQUIRE internal coherence
    REQUIRE no false hard-truth claim
    REQUIRE safety boundary
    REQUIRE audit_pass
IF requirements_met:
    RELEASE
ELSE IF repair_possible:
    RETURN_TO_REPAIRMAN
ELSE IF important_but_unready:
    STORE_IN_SHADOW_LEDGER
ELSE:
    REJECT_OR_DECAY

FUNCTION MODE_SWITCH(section):
IF section.contains_high_stakes_facts:
    section.mode = STRICT_ECU
ELSE IF section.explains_to_public:
    section.mode = BALANCED_ECU
ELSE IF section.designs_future_model:
    section.mode = CREATIVE_ECU
ELSE:
    section.mode = BALANCED_ECU

WATER_HEALTH_REPORT:
facts_section:
  STRICT_ECU
public_explanation:
  BALANCED_ECU
future_dashboard_design:
  CREATIVE_ECU
final_recommendation:
  STRICT_ECU + CERBERUS

OUTPUT.OBJECT:
output.id:
  unique output identifier
output.mode:
  strict / balanced / creative / mixed
output.domain:
  active OS branch
output.claim_status:
  fact / inference / scenario / metaphor / speculation / unresolved
output.evidence_status:
  none / weak / partial / strong / verified
output.guardians_used:
  list
output.workers_used:
  list
output.ledger_status:
  pass / warning / breach / repaired
output.shadow_items:
  list of stored unresolved signals
output.release_status:
  released / held / revised / rejected / stored
output.memory_update:
  none / temporary / durable / registry_lock

MEMORYOS.UPDATE(output):
IF output creates durable framework law:
    store as registry_lock
ELSE IF output updates article queue:
    store as branch_status
ELSE IF output records weak signal:
    store in Shadow Ledger
ELSE IF output is temporary:
    do not store long-term
ELSE:
    store minimal trace

STORE STRUCTURE, NOT NOISE.

FUNCTION PLANETOS_ECU_RUN(signal):
1. create INPUT.OBJECT
2. mode = SELECT_ECU_MODE(signal)
3. prepared_signal = ECU_INTAKE(signal)
4. route = DETERMINE_SIGNAL_ROUTE(prepared_signal)
5. IF route = DECAY_BIN:
       store minimal decay trace
       STOP
6. IF route = SHADOW_LEDGER:
       ShadowLedger.store(prepared_signal)
       IF mode != STRICT_ECU:
           continue only as labelled weak signal
       ELSE:
           hold from public release
7. guardians = ACTIVATE_GUARDIANS(prepared_signal)
8. workers_process(prepared_signal)
9. draft_output = Operator.compile(prepared_signal)
10. audit_result = Auditor.check(draft_output)
11. IF audit_result = fail:
        Repairman.repair(draft_output)
        send back to Auditor
12. IF collapse_or_rebuild_needed:
        Phoenix.activate(draft_output)
13. release_result = Cerberus.final_gate(draft_output, mode)
14. IF release_result = release:
        output = publish_or_answer(draft_output)
15. IF release_result = hold:
        store in Shadow Ledger or return to Repairman
16. IF release_result = reject:
        mark decay or unresolved
17. MemoryOS.update(output)
18. RETURN output

ECU.ERROR_CODES:
ECU.001:
  Mode not selected before movement
ECU.002:
  Raw signal bypassed VocabularyOS
ECU.003:
  Worker chain skipped without justification
ECU.004:
  Guardian activated before worker preparation
ECU.005:
  Weak signal deleted without Shadow Ledger review
ECU.006:
  Creative speculation released as fact
ECU.007:
  Strict output released without audit
ECU.008:
  Cerberus bypass detected
ECU.009:
  Memory stored noise instead of structure
ECU.010:
  Ledger breach unresolved

BEFORE RELEASE, CONFIRM:
[ ] ECU mode selected
[ ] VocabularyOS checked language
[ ] Worker intake completed
[ ] Route selected
[ ] Shadow signals handled
[ ] Guardians activated where needed
[ ] Ledger checked
[ ] Repair applied if needed
[ ] Output labelled properly
[ ] Cerberus passed
[ ] MemoryOS updated correctly

1. What kind of signal is this?
2. How strict should the system be?
3. Who handles it first?
4. Which gate must wake?
5. Can this safely leave the system?

PLANETOS.ECU.COMPILER.v1.0 =
Mode Selection
+ VocabularyOS Intake
+ Worker Chain
+ Movement Threshold
+ Shadow Ledger
+ Guardian Activation
+ Ledger Audit
+ Repair Loop
+ Cerberus Release
+ MemoryOS Update

less noisy
less rigid
more creative
more bounded
more auditable
more reusable
more AI-ingestable