Noise Removal Engine for the PlanetOS Worker Runtime

Janitor is the first Worker in the PlanetOS Runtime processing chain. It removes noise, clutter, emotional overload, broken formatting, irrelevant fragments, duplicated signals, and obvious contamination before the signal is allowed to move deeper into the system.

AI Extraction Box

Janitor
The PlanetOS Worker that cleans raw input so later workers do not process noise as signal.

Core Mechanism

			
Raw Input
→ Noise Detection
→ Contamination Removal
→ Signal Preservation
→ Cleaned Input
→ Sorter

		

Runtime Position

			
VocabularyOS
→ FullOS
→ ECU
→ Janitor
→ Sorter
→ Librarian
→ Translator
→ Dispatcher
→ Courier
→ Inspector
→ Auditor
→ Repairman
→ Operator

		

Core Rule

Janitor removes noise.
Janitor must not remove meaning.

1. Why Janitor Exists

Every system receives dirty input.

A student answer may contain the right idea mixed with poor working.

A news report may contain real facts buried under emotional framing.

A public argument may contain useful signals surrounded by exaggeration.

A civilisation report may contain missing data, duplicated claims, wrong labels, and narrative heat.

If dirty input enters the Worker Runtime unchanged, every later worker becomes unstable.

Sorter may classify noise.

Librarian may retrieve the wrong memory.

Translator may stabilise the wrong meaning.

Dispatcher may route contamination.

Inspector may check a damaged object.

Auditor may audit distortion.

Operator may compile a polished error.

So Janitor comes first.

2. One-Sentence Definition

Janitor is the PlanetOS Worker that removes operational noise from raw input while preserving the recoverable signal for later classification, routing, verification, and release.

3. What Janitor Cleans

Janitor handles:

			
duplicate content
irrelevant clutter
formatting mess
emotional overload
obvious spam
broken fragments
contradictory residue
noise words
unusable repetition
non-functional metaphor
unsupported certainty markers
panic language
excessive compression
unlabelled speculation
source contamination

		

But Janitor must not over-clean.

Some messy signals contain early truth.

Some emotional language contains real harm.

Some contradiction indicates a hidden failure.

Some weak anomaly belongs in Shadow Ledger.

Janitor cleans the surface.

It does not erase the case.

4. Janitor Is Not a Truth Engine

Janitor does not decide final truth.

It does not say:

			
this is true
this is false
this is important
this is irrelevant forever

Janitor only says:

			
this part is noise
this part is signal
this part is damaged but recoverable
this part should be preserved for later workers

Truth belongs to ExpertSource.

Release belongs to Cerberus.

Classification belongs to Sorter and FullOS.

Memory belongs to MemoryOS.

Janitor’s job is cleaning without premature judgment.

5. Janitor and VocabularyOS

VocabularyOS stabilises language.

Janitor cleans the input.

They work together but are not the same.

VocabularyOS asks:

			
What does this word mean?
Is this phrase distorted?
Is there frame injection?
Is the label stable?

Janitor asks:

			
What is clutter?
What is duplication?
What is contamination?
What is emotional excess?
What can be removed without losing meaning?

		

Example:

			
Raw input:
    “This whole education system is totally dead, useless, broken, finished, gone, destroyed.”
VocabularyOS:
    checks what “dead,” “broken,” and “destroyed” mean.
Janitor:
    removes repetitive emotional overload.
Cleaned input:
    “The claim is that the education system is severely failing.”

		

Now the signal can be processed.

6. Janitor and FullOS

FullOS classifies state.

Janitor prepares the object for classification.

If Janitor fails, FullOS may misclassify.

Example:

			
Dirty input:
    “Everything is collapsing. Nobody learns. Schools are finished.”
Bad FullOS result:
    negative lattice collapse
Better Janitor output:
    “Claim: education performance, learning quality, or school trust may be declining.”
FullOS can now classify:
    negative / partial / overcompressed / evidence-needed

		

Janitor reduces false negative classification caused by emotional noise.

It also prevents false positive classification caused by polished but empty language.

7. Janitor and ECU Modes

Janitor obeys ECU mode.

STRICT Mode

Used for high-stakes material.

Janitor must:

			
remove emotional excess
preserve evidence
preserve quotations accurately
avoid altering factual claims
label removed material if necessary

		

BALANCED Mode

Used for normal articles and teaching.

Janitor may:

			
simplify clutter
clean repetition
stabilise readability
preserve meaning

CREATIVE Mode

Used for architecture and exploration.

Janitor may:

			
clean chaos
preserve unusual ideas
retain weak creative signals
send anomalies to Shadow Ledger if needed

In CREATIVE mode, Janitor must be careful.

What looks like noise may be a new branch forming.

8. Janitor and the Worker Chain

Janitor is Worker 1.

			
Janitor → Sorter → Librarian → Translator → Dispatcher
→ Courier → Inspector → Auditor → Repairman → Operator

If Janitor works well:

			
Sorter receives cleaner categories.
Librarian retrieves better references.
Translator stabilises clearer meaning.
Dispatcher routes less contamination.
Inspector checks cleaner output.
Auditor detects real invariant breaks.
Repairman repairs actual damage.
Operator compiles usable result.

		

If Janitor fails, the whole chain inherits dirt.

9. Janitor Cleaning Levels

Janitor should clean at multiple levels.

Level 1 — Surface Cleaning

			
remove duplicates
fix formatting
remove obvious clutter
separate paragraphs
normalise structure

		

Level 2 — Signal Cleaning

			
separate claim from emotion
separate fact from reaction
separate data from commentary
separate question from accusation

Level 3 — Contamination Cleaning

			
detect source laundering
detect frame injection
detect wrong labels
detect irrelevant authority
detect copied narrative residue

		

Level 4 — Preservation Cleaning

			
mark weak anomalies
preserve contradiction
retain possible early warning
send uncertain fragments forward with labels

The best Janitor does not make everything neat.

It makes the signal processable.

10. Janitor Output Classes

Janitor outputs one of the following:

			
CLEAN_SIGNAL:
    ready for Sorter
PARTIAL_SIGNAL:
    usable but incomplete
DAMAGED_SIGNAL:
    needs repair later
NOISE_REMOVED:
    clutter removed safely
ANOMALY_PRESERVED:
    strange but retained
SHADOW_CANDIDATE:
    weak but potentially important
DISCARD:
    obvious junk

		

The key is traceability.

Later workers must know what Janitor changed.

11. Janitor in Education

In education, Janitor cleans learning input.

A student may write messy working.

Example:

			
Student answer:
    3x + 2 = 14
    3x = 14 + 2
    3x = 16
    x = 5.333

		

Janitor does not simply mark wrong.

Janitor cleans the signal:

			
Useful signal:
    student knows to isolate x
Noise / error:
    sign handling failure
Cleaned diagnosis object:
    algebra transposition error

		

Now Sorter can classify the error properly.

Bad teaching sees only wrong answer.

PlanetOS Runtime sees the recoverable signal inside the noise.

12. Janitor in NewsOS

In NewsOS, Janitor cleans narrative heat.

Raw breaking signal:

			
“Everyone is furious after shocking new evidence proves the whole system is corrupt.”

Janitor output:

			
Claim:
    new evidence has been reported
Emotion:
    anger / shock
Unsupported overclaim:
    proves the whole system is corrupt
Cleaned signal:
    reported evidence may raise concern about institutional misconduct

		

Now ExpertSource can verify.

Cerberus can decide release.

RealityOS can track whether the claim becomes accepted reality.

13. Janitor in StrategizeOS

StrategizeOS needs clean route objects.

Dirty route:

“We must immediately expose everything and destroy the other side.”

Janitor cleans:

			
Action desire:
    public escalation
Emotion:
    anger / urgency
Risk:
    over-escalation
Clean route object:
    evaluate whether public escalation is justified, source-backed, and release-safe

		

Now StrategizeOS can decide:

			
proceed
hold
probe
repair
shadow-store
block

		

Janitor prevents strategy from being hijacked by emotion.

14. Janitor in ExpertSource

ExpertSource needs clean claims.

Dirty claim:

“Studies everywhere prove this method always works.”

Janitor output:

			
Claim:
    studies support this method
Overclaim:
    everywhere / always
Cleaned claim:
    some studies may support this method under specific conditions

		

Now ExpertSource can check:

			
Which studies?
Which population?
Which method?
Which outcome?
Which boundary?

		

Janitor reduces overclaim before verification begins.

15. Janitor and Shadow Ledger

Janitor must know when not to delete.

Some weak signals should enter Shadow Ledger.

Example:

			
Input:
    unclear repeated reports from different places

Janitor should not discard them automatically.

Output:

			
SHADOW_CANDIDATE:
    repeated weak signal
    source quality low
    pattern may be meaningful
    send to Hades / Shadow Ledger

		

This protects PlanetOS from two opposite failures:

			
believing weak signals too early
deleting weak signals too early

16. Janitor Failure Modes

Janitor fails when it:

			
removes meaning while removing noise
cleans away early warning signals
mistakes emotion for irrelevance
preserves too much clutter
changes factual content
rewrites source claims too strongly
normalises propaganda
deletes contradiction
hides uncertainty
over-polishes weak evidence

		

The most dangerous failure is clean distortion.

That happens when Janitor produces a neat version that is no longer faithful to the original signal.

17. Janitor Safety Rules

			
Rule 1:
    Remove noise, not meaning.
Rule 2:
    Preserve uncertainty.
Rule 3:
    Do not upgrade weak claims.
Rule 4:
    Do not delete anomalies without classification.
Rule 5:
    Keep evidence traceable.
Rule 6:
    Separate emotion from claim.
Rule 7:
    Send weak-but-important signals to Shadow Ledger.
Rule 8:
    Never pretend cleaning equals verification.

		

18. Drift vs Repair Reading

Janitor repairs noise drift.

Noise drift happens when signal quality degrades before the system can process it.

			
Raw signal + noise
→ wrong classification
→ wrong route
→ wrong verification
→ wrong release
→ Reality Debt

		

Janitor interrupts this chain.

Stability law:

			
Stable when:
    Signal Preservation ≥ Noise Removal Loss
Unstable when:
    Cleaning removes more meaning than noise
Collapse risk when:
    dirty input repeatedly enters release pipeline

		

19. PlanetOS Runtime Summary

Janitor is the first Worker because no system should process dirt as truth.

VocabularyOS stabilises meaning.

FullOS classifies state.

ECU selects mode.

Janitor cleans the operational object.

Then Sorter can classify.

Librarian can retrieve.

Translator can stabilise.

Dispatcher can route.

ExpertSource can verify.

Cerberus can release or block.

The Janitor Worker is humble but critical.

Without Janitor, PlanetOS becomes contaminated at the entrance.

With Janitor, the Runtime begins clean enough to work.

Full Almost-Code Block

			
TITLE:
    Janitor — Noise Removal Engine
ARTICLE.ID:
    PLANETOS.RUNTIME.ARTICLE.013
MACHINE.ID:
    EKSG.PLANETOS.RUNTIME.WORKER.JANITOR.ARTICLE013.v1.0
LATTICE.CODE:
    LAT.PLANETOS.RUNTIME.WORKER.JANITOR.Z0-Z6.P0-P4.T2026-05-02
SOURCE.STANDARD:
    ExpertSource 10/10
ECU.MODE:
    BALANCED_STRICT
RUNTIME.POSITION:
    VocabularyOS
    -> FullOS
    -> ECU
    -> Janitor
    -> Sorter
    -> Librarian
    -> Translator
    -> Dispatcher
    -> Courier
    -> Inspector
    -> Auditor
    -> Repairman
    -> Operator
    -> MythicalGuardians
    -> StrategizeOS
    -> ExpertSource
    -> Cerberus
    -> MemoryOS
    -> RealityOS
MASTER.DEFINITION:
    Janitor is the PlanetOS Worker that removes operational noise from raw input while preserving the recoverable signal for later classification, routing, verification, and release.
CORE.MECHANISM:
    RawInput
    -> NoiseDetection
    -> ContaminationRemoval
    -> SignalPreservation
    -> CleanedInput
    -> Sorter
INPUTS:
    raw_claim
    messy_student_answer
    news_signal
    public_argument
    broken_report
    duplicated_content
    emotional_fragment
    weak_anomaly
CLEANS:
    duplicate_content
    irrelevant_clutter
    formatting_mess
    emotional_overload
    obvious_spam
    broken_fragments
    contradictory_residue
    noise_words
    unsupported_certainty_markers
    panic_language
    excessive_compression
    unlabelled_speculation
    source_contamination
OUTPUT.CLASSES:
    CLEAN_SIGNAL
    PARTIAL_SIGNAL
    DAMAGED_SIGNAL
    NOISE_REMOVED
    ANOMALY_PRESERVED
    SHADOW_CANDIDATE
    DISCARD
ECU.MODE.BEHAVIOUR:
    STRICT:
        preserve_evidence
        remove_emotional_excess
        do_not_alter_factual_claims
        label_cleaning_changes
    BALANCED:
        simplify_clutter
        improve_readability
        preserve_meaning
    CREATIVE:
        clean_chaos
        preserve_unusual_ideas
        retain_weak_creative_signals
        route_anomalies_to_ShadowLedger
RELATIONSHIPS:
    VocabularyOS:
        stabilises_language
    Janitor:
        cleans_operational_noise
    Sorter:
        classifies_cleaned_signal
    ExpertSource:
        verifies_claim_strength
    Hades:
        guards_shadow_candidates
    Cerberus:
        controls_final_release
SAFETY.RULES:
    remove_noise_not_meaning
    preserve_uncertainty
    do_not_upgrade_weak_claims
    do_not_delete_anomalies_without_classification
    keep_evidence_traceable
    separate_emotion_from_claim
    route_weak_but_important_signals_to_ShadowLedger
    never_treat_cleaning_as_verification
FAILURE.MODES:
    meaning_removed_with_noise
    early_warning_deleted
    emotion_mistaken_for_irrelevance
    clutter_preserved
    factual_content_changed
    weak_claim_upgraded
    propaganda_normalised
    contradiction_deleted
    uncertainty_hidden
    clean_distortion_created
DRIFT.REPAIR.LAW:
    stable_if = SignalPreservation >= NoiseRemovalLoss
    unstable_if = CleaningRemovesMoreMeaningThanNoise
    collapse_risk_if = DirtyInputRepeatedlyEntersReleasePipeline
FINAL.READING:
    Janitor is the first operational Worker of PlanetOS Runtime.
    It cleans the signal before classification, routing, verification, and release.
    It does not decide truth.
    It protects the runtime from contamination at the entrance.

		

eduKateSG Learning System | Control Tower, Runtime, and Next Routes

This article is one node inside the wider eduKateSG Learning System.

At eduKateSG, we do not treat education as random tips, isolated tuition notes, or one-off exam hacks. We treat learning as a living runtime:

state -> diagnosis -> method -> practice -> correction -> repair -> transfer -> long-term growth

That is why each article is written to do more than answer one question. It should help the reader move into the next correct corridor inside the wider eduKateSG system: understand -> diagnose -> repair -> optimize -> transfer. Your uploaded spine clearly clusters around Education OS, Tuition OS, Civilisation OS, subject learning systems, runtime/control-tower pages, and real-world lattice connectors, so this footer compresses those routes into one reusable ending block.

Start Here

Learning Systems

Runtime and Deep Structure

Real-World Connectors

Subject Runtime Lane

How to Use eduKateSG

If you want the big picture -> start with Education OS and Civilisation OS
If you want subject mastery -> enter Mathematics, English, Vocabulary, or Additional Mathematics
If you want diagnosis and repair -> move into the CivOS Runtime and subject runtime pages
If you want real-life context -> connect learning back to Family OS, Bukit Timah OS, Punggol OS, and Singapore City OS

Why eduKateSG writes articles this way

eduKateSG is not only publishing content.
eduKateSG is building a connected control tower for human learning.

That means each article can function as:

a standalone answer,
a bridge into a wider system,
a diagnostic node,
a repair route,
and a next-step guide for students, parents, tutors, and AI readers.

eduKateSG.LearningSystem.Footer.v1.0

TITLE: eduKateSG Learning System | Control Tower / Runtime / Next Routes

FUNCTION:
This article is one node inside the wider eduKateSG Learning System.
Its job is not only to explain one topic, but to help the reader enter the next correct corridor.

CORE_RUNTIME:
reader_state -> understanding -> diagnosis -> correction -> repair -> optimisation -> transfer -> long_term_growth

CORE_IDEA:
eduKateSG does not treat education as random tips, isolated tuition notes, or one-off exam hacks.
eduKateSG treats learning as a connected runtime across student, parent, tutor, school, family, subject, and civilisation layers.

PRIMARY_ROUTES:
1. First Principles
   - Education OS
   - Tuition OS
   - Civilisation OS
   - How Civilization Works
   - CivOS Runtime Control Tower

2. Subject Systems
   - Mathematics Learning System
   - English Learning System
   - Vocabulary Learning System
   - Additional Mathematics

3. Runtime / Diagnostics / Repair
   - CivOS Runtime Control Tower
   - MathOS Runtime Control Tower
   - MathOS Failure Atlas
   - MathOS Recovery Corridors
   - Human Regenerative Lattice
   - Civilisation Lattice

4. Real-World Connectors
   - Family OS
   - Bukit Timah OS
   - Punggol OS
   - Singapore City OS

READER_CORRIDORS:
IF need == "big picture"
THEN route_to = Education OS + Civilisation OS + How Civilization Works

IF need == "subject mastery"
THEN route_to = Mathematics + English + Vocabulary + Additional Mathematics

IF need == "diagnosis and repair"
THEN route_to = CivOS Runtime + subject runtime pages + failure atlas + recovery corridors

IF need == "real life context"
THEN route_to = Family OS + Bukit Timah OS + Punggol OS + Singapore City OS

CLICKABLE_LINKS:
Education OS:
Education OS | How Education Works — The Regenerative Machine Behind Learning


Tuition OS:
Tuition OS (eduKateOS / CivOS)


Civilisation OS:
Civilisation OS


How Civilization Works:
Civilisation: How Civilisation Actually Works


CivOS Runtime Control Tower:
CivOS Runtime / Control Tower (Compiled Master Spec)


Mathematics Learning System:
The eduKate Mathematics Learning System™


English Learning System:
Learning English System: FENCE™ by eduKateSG


Vocabulary Learning System:
eduKate Vocabulary Learning System


Additional Mathematics 101:
Additional Mathematics 101 (Everything You Need to Know)


Human Regenerative Lattice:
eRCP | Human Regenerative Lattice (HRL)


Civilisation Lattice:
The Operator Physics Keystone


Family OS:
Family OS (Level 0 root node)


Bukit Timah OS:
Bukit Timah OS


Punggol OS:
Punggol OS


Singapore City OS:
Singapore City OS


MathOS Runtime Control Tower:
MathOS Runtime Control Tower v0.1 (Install • Sensors • Fences • Recovery • Directories)


MathOS Failure Atlas:
MathOS Failure Atlas v0.1 (30 Collapse Patterns + Sensors + Truncate/Stitch/Retest)


MathOS Recovery Corridors:
MathOS Recovery Corridors Directory (P0→P3) — Entry Conditions, Steps, Retests, Exit Gates


SHORT_PUBLIC_FOOTER:
This article is part of the wider eduKateSG Learning System.
At eduKateSG, learning is treated as a connected runtime:
understanding -> diagnosis -> correction -> repair -> optimisation -> transfer -> long-term growth.

Start here:
Education OS
Education OS | How Education Works — The Regenerative Machine Behind Learning


Tuition OS
Tuition OS (eduKateOS / CivOS)


Civilisation OS
Civilisation OS


CivOS Runtime Control Tower
CivOS Runtime / Control Tower (Compiled Master Spec)


Mathematics Learning System
The eduKate Mathematics Learning System™


English Learning System
Learning English System: FENCE™ by eduKateSG


Vocabulary Learning System
eduKate Vocabulary Learning System


Family OS
Family OS (Level 0 root node)


Singapore City OS
Singapore City OS


CLOSING_LINE:
A strong article does not end at explanation.
A strong article helps the reader enter the next correct corridor.

TAGS:
eduKateSG
Learning System
Control Tower
Runtime
Education OS
Tuition OS
Civilisation OS
Mathematics
English
Vocabulary
Family OS
Singapore City OS