eduKateSG Full Classification Stack

Operator Use Manual v1.0

What to Do With the Stack Next

			
ARTICLE_ID: "EKSG.FULLCLASSSTACK.OPERATOR-USE-MANUAL.v1.0"
TITLE: "eduKateSG Full Classification Stack | Operator Use Manual"
PURPOSE:
  - "Turn the classification stack into a usable workflow."
  - "Show how to trigger it from prompts."
  - "Show how to use it for articles, diagnostics, repair, Purple Report, and future OS branches."
  - "Keep reader articles clean while preserving full AI runtime in the background."

		

1. The Stack Is a Control Panel

This stack is not only a set of article codes.

It is a control panel.

When looking at any system, the stack asks:

			
CONTROL_PANEL_QUESTIONS:
  1_WHAT_IS_IT:
    question: "What system are we looking at?"
    examples:
      - "society"
      - "culture"
      - "teamwork"
      - "news"
      - "civilisation"
      - "education"
      - "family"
      - "war"
      - "governance"
  2_IS_IT_REAL_OR_IMITATION:
    question: "Is it the real system, or only an imitation?"
    examples:
      - "crowd is not automatically society"
      - "trend is not automatically culture"
      - "group is not automatically teamwork"
      - "signal is not automatically news"
      - "monument is not automatically civilisation"
  3_WHAT_CONDITION_IS_IT_IN:
    question: "Is it functional, tilted, captured, inverted, decaying, repairing, or high-continuity?"
  4_HOW_DOES_IT_AFFECT_CIVILISATION:
    question: "Does it strengthen, weaken, neutralise, or invert civilisation continuity?"
  5_WHAT_REPAIR_IS_NEEDED:
    question: "What must be protected, corrected, restored, or rebuilt?"

		

2. The Main Prompt Trigger

Use this when you want the whole runtime active:

			
MASTER_TRIGGER:
  "Use eduKateSG Full Classification Stack with CivOS parent shell-lattice alignment. Classify the system in its native domain first, then add the CivOS overlay. Keep reader-facing output clean unless I ask for full code."

Short version:

			
SHORT_TRIGGER:
  "Use eduKateSG Full Classification Stack."

3. Article Writing Trigger

Use this for public articles:

			
READER_ARTICLE_TRIGGER:
  "Use eduKateSG Full Article Runtime and the Full Classification Stack in the background. Write for readers only. Do not expose the code, mechanics, or Phase 4 language. Make it clear, useful, and publish-ready."

This lets you write articles such as:

			
ARTICLE_EXAMPLES:
  - "What Is Society? | Why a Crowd Is Not a Society"
  - "How Culture Works | Why a Trend Is Not Yet Culture"
  - "What Is Teamwork? | Why a Group Is Not a Team"
  - "How News Works | Why Not Every Signal Is News"
  - "How Civilisation Works | Why Power Is Not the Same as Continuity"

		

4. Full Code Trigger

Use this when you want the AI-facing machinery:

			
FULL_CODE_TRIGGER:
  "Use eduKateSG Full Classification Stack. Give me the full code version with native ID, CivOS overlay ID, condition classes, failure classes, repair sequence, examples, and runtime lock."

This produces the background machinery for future AI reuse.

5. Diagnostic Trigger

Use this when analysing a real system, article, situation, team, culture, news item, or institution:

			
DIAGNOSTIC_TRIGGER:
  "Use the Full Classification Stack to diagnose this system. Give me:
Native classification
CivOS overlay
Condition class
Failure classes
Repair path
Confidence
What to watch next"

		

Example:

			
EXAMPLE_PROMPT:
  "Use the Full Classification Stack to diagnose this news article."

Output should include:

			
DIAGNOSTIC_OUTPUT:
  native_id: "NEWS..."
  civos_overlay: "CIVOS.FILTER-SHELL.NEWS..."
  condition: "NC3 Thin News / NC4 Framed News / NC11 Purple Signal"
  failure_classes:
    - "source weakness"
    - "frame overpowering fact"
  repair:
    - "check source"
    - "separate claim from interpretation"
    - "state uncertainty"
  confidence: "K2/K3/K4"

		

6. Repair Article Trigger

Use this when you want a constructive article.

			
REPAIR_ARTICLE_TRIGGER:
  "Use eduKateSG Full Classification Stack to write a repair article. Focus on what the system is supposed to do, how it breaks, and how it repairs. Reader-facing only."

Possible titles:

			
REPAIR_ARTICLES:
  society:
    - "How Society Repairs Itself"
    - "How Trust Returns to Society"
    - "Why Public Language Must Match Reality"
  culture:
    - "How Culture Revives"
    - "How Heritage Becomes Living Again"
    - "Why Culture Must Be Transmitted, Not Only Displayed"
  teamwork:
    - "How Teams Repair Trust"
    - "How to Fix an Overloaded Team"
    - "How a Team Reconfigures Without Breaking"
  news:
    - "How News Repairs Reality"
    - "Why Corrections Make News Stronger"
    - "How to Read a News Claim Before Reacting"
  civilisation:
    - "How Civilisation Repairs Itself"
    - "How Civilisation Reboots From the Floor"
    - "Why Civilisation Must Protect Its Load-Bearing Parts"

		

7. Purple Report Trigger

Use this for news/intelligence-style work:

			
PURPLE_REPORT_TRIGGER:
  "Use NewsOS, Purple Signal, and CivOS filter-shell alignment. Classify this signal as pre-news, emerging news, functional news, structural news, or Purple Signal. Separate claim, evidence, source, frame, confidence, urgency, and what to watch next."

Purple Report output should include:

			
PURPLE_REPORT_OUTPUT:
  - "Executive Read"
  - "Strategic Delta"
  - "Why It Matters"
  - "Corridor Watch"
  - "Evidence Signals"
  - "Confidence"
  - "Urgency"
  - "Risk / Opportunity"
  - "Alternative Explanation"
  - "What to Watch Next"
  - "Civilisation Implication"
  - "Closing Strategic Takeaway"

		

Key rule:

			
PURPLE_SIGNAL_RULE:
  "Purple Signal is watch-not-proof. It can be tracked, upgraded, downgraded, archived, or published with caution."

8. New Classification Branch Trigger

Use this when creating the next OS classification.

			
NEW_BRANCH_TRIGGER:
  "Use the Universal Classification Template Runtime to build [Domain]OS Shell-State Classification System v1.0. Align it to CivOS. Include native ID, CivOS overlay, axes, condition classes, failure classes, repair sequence, examples, and runtime lock."

Example:

			
EXAMPLE:
  "Use the Universal Classification Template Runtime to build EducationOS Shell-State Classification System v1.0."

This can now build:

			
NEXT_BRANCHES:
  - "EducationOS"
  - "FamilyOS"
  - "WarOS"
  - "VocabularyOS"
  - "RealityOS"
  - "GovernanceOS"
  - "FinanceOS"
  - "HealthOS"
  - "LogisticsOS"
  - "LanguageOS"
  - "EmotionOS"
  - "MindOS"

		

9. The Most Useful Next Move

The strongest next move is probably:

			
RECOMMENDED_NEXT_STACK:
  title: "EducationOS Shell-State Classification System v1.0"
  reason:
    - "Education is central to eduKateSG."
    - "Education connects Society, Culture, Teamwork, News, and Civilisation."
    - "Education is the capability-transfer shell of civilisation."
    - "This will let future tuition, learning, vocabulary, school, and adulthood articles classify education cleanly."

		

Recommended prompt:

			
NEXT_PROMPT:
  "Use the Universal Classification Template Runtime to build EducationOS Shell-State Classification System v1.0 in full code."

10. The Stack’s Practical Uses

			
PRACTICAL_USES:
  article_creation:
    use: "Generate cleaner, deeper eduKateSG articles."
    example:
      "What Is Education? | Why Schooling Is Not the Same as Education"
  diagnostics:
    use: "Classify whether a system is functional, tilted, captured, inverted, decaying, or repairing."
    example:
      "Diagnose this school culture."
  content_planning:
    use: "Build article series from one classification."
    example:
      "Turn SocietyOS into 10 reader articles."
  purple_report:
    use: "Read news through claim, source, evidence, frame, and civilisation impact."
    example:
      "Classify this geopolitical signal."
  ai_memory:
    use: "Give AI a stable runtime for future branches."
    example:
      "Use Full Classification Stack."
  repair_design:
    use: "Move from description into correction."
    example:
      "How does a captured culture repair?"
  seo_structure:
    use: "Create clear Google-readable article clusters."
    example:
      "What is not society, what is society, types of society, how society repairs."
  framework_expansion:
    use: "Add new OS branches without breaking the system."
    example:
      "Build FamilyOS classification."

		

11. The Stack in One Diagram

			
FULL_STACK_FLOW:
  INPUT:
    - "article idea"
    - "news signal"
    - "social problem"
    - "team problem"
    - "culture question"
    - "civilisation question"
    - "new OS branch"
  PROCESS:
    - "identify domain"
    - "classify native shell-state"
    - "add CivOS overlay"
    - "detect condition"
    - "detect failure class"
    - "define repair path"
    - "choose reader or code output"
  OUTPUT:
    - "reader article"
    - "full code article"
    - "diagnostic report"
    - "Purple Report"
    - "repair plan"
    - "new classification system"

		

12. Final Operator Rule

			
FINAL_OPERATOR_RULE:
  "When using the stack, never stop at naming. Always move from naming to function, from function to condition, from condition to civilisation impact, and from civilisation impact to repair."

In simple words:

The stack lets eduKateSG read any human system, name what condition it is in, see whether it strengthens or weakens civilisation, and decide what must be protected or repaired next.

Master Alignment: CivilisationOS as the Parent Shell-Lattice System

Full Code for AI Runtime

ARTICLE_ID: “EKSG.FULLCLASSSTACK.MASTER-ALIGNMENT.CIVOS-PARENT.v1.0”
ARTICLE_NUMBER: 1
STACK_TOTAL: 7

TITLE: “eduKateSG Full Classification Stack v1.0”
SUBTITLE: “Master Alignment: CivilisationOS as the Parent Shell-Lattice System”
PUBLIC_OR_INTERNAL: “Full Code for AI Runtime”
AUTHOR_CONTEXT: “eduKateSG”
PRIMARY_USE:

“AI runtime alignment”
“Article generation trigger”
“Classification system control”
“Cross-domain shell-state compatibility”
“CivilisationOS parent-child nesting”

RUNTIME_TRIGGER:
SIMPLE_TRIGGER:
– “Use eduKateSG Full Article Runtime”
– “Use eduKateSG Full Classification Stack”
– “Use CivOS parent alignment”
– “Use Society, Culture, Teamwork, News, and Civilisation classification stack”
– “Use Phase 4 research layer where relevant”
– “Use classification template for new systems”
– “Write full code for classification”
– “Align to eduKateSG CivOS shell-lattice system”

FULL_TRIGGER:
“Use eduKateSG Full Article Runtime with CivOS parent shell-lattice alignment, SocietyOS, CultureOS, TeamworkOS, NewsOS, and Classification Template Runtime. Apply Phase 4 research layer internally where relevant, but expose only the correct format for the requested article: reader-facing if asked, full-code if asked. All classifications must nest under CivilisationOS unless the user explicitly asks for a standalone experimental draft.”

SURFACE_RULE:
reader_articles:
– “Do not expose machinery.”
– “Do not overuse IDs.”
– “Use clear definitions, ordinary examples, and public-friendly structure.”
– “Mention eduKateSG only where useful.”
– “Do not mention Phase 4 mechanics unless the user explicitly asks for technical framework output.”
code_articles:
– “Expose IDs, runtime grammar, classification axes, examples, repair rules, and alignment logic.”
– “Use YAML-style blocks for AI precision.”
– “State parent-child relationship clearly.”
– “Preserve all domain-specific classification systems while aligning them under CivOS.”

CORE_DECISION:
question: “Do we need to redo Society, Culture, Teamwork, and News to align with CivilisationOS?”
answer: “No. Keep the domain systems and add CivOS overlay compatibility.”
rule: “CivilisationOS is the parent shell-lattice system. Society, Culture, Teamwork, and News are child shell-state systems nested inside it.”

CANONICAL_STACK_NAME:
full: “eduKateSG Full Classification Stack v1.0”
short: “EKSG-FULL-CLASS-STACK v1.0”

PARENT_SYSTEM:
name: “CivilisationOS”
canonical_classification: “CIVOS-SHELL-LATTICE-CLASS v1.0”
function: “Parent continuity machine”
public_explanation: “CivilisationOS reads how human systems hold, filter, repair, transfer, and regenerate life, memory, infrastructure, trust, knowledge, and capability through time.”
core_line: “Civilisation is not merely a large society. Civilisation is the parent continuity machine that carries societies, cultures, teams, news systems, institutions, infrastructures, and knowledge across time.”

CHILD_SYSTEMS:
society:
name: “SocietyOS”
canonical_classification: “SOC-SHELL-CLASS v1.0”
role_inside_civos: “Human social continuity shell”
reads:
– “trust”
– “rules”
– “memory”
– “protection”
– “repair”
– “transmission”
– “social function”

culture:
name: “CultureOS”
canonical_classification: “CULT-SHELL-CLASS v1.0”
role_inside_civos: “Meaning, memory, identity, and transmission shell”
reads:
– “symbols”
– “rituals”
– “shared memory”
– “values”
– “emotional codes”
– “participation depth”
– “cultural transmission”

teamwork:
name: “TeamworkOS”
canonical_classification: “TEAM-SHELL-CLASS v1.0”
role_inside_civos: “Coordination, mission, role-fit, and load-distribution shell”
reads:
– “mission”
– “roles”
– “trust”
– “load distribution”
– “communication”
– “repair”
– “dynamic reconfiguration”

news:
name: “NewsOS”
canonical_classification: “NEWS-SHELL-CLASS v1.0”
role_inside_civos: “Signal, filter, public-reality update, and correction shell”
reads:
– “event core”
– “claim”
– “source”
– “evidence”
– “frame”
– “timing”
– “correction”
– “public reality effect”

civilisation:
name: “CivilisationOS”
canonical_classification: “CIVOS-SHELL-LATTICE-CLASS v1.0”
role_inside_civos: “Parent shell-lattice system”
reads:
– “core systems”
– “shell types”
– “zoom levels”
– “phase states”
– “time horizons”
– “lattice direction”
– “repair capacity”
– “regenerative surplus”
– “collapse risk”

			
---
# 1. Master Hierarchy

yaml id=”master-hierarchy”
EDUKATESG_CLASSIFICATION_HIERARCHY:
ROOT:
system: “CivilisationOS”
code: “CIVOS-SHELL-LATTICE-CLASS v1.0”
role: “Parent shell-lattice classification system”
description: “Classifies civilisation-scale and sub-civilisation systems by shell type, core system, zoom level, phase, time, lattice state, repair capacity, and confidence.”

CHILDREN:
SOCIETY:
code: “SOC-SHELL-CLASS v1.0”
parent_overlay: “CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY”
role: “Classifies human social continuity systems.”

			
CULTURE:
  code: "CULT-SHELL-CLASS v1.0"
  parent_overlay: "CIVOS.MEMORY-SHELL.CULTURE"
  role: "Classifies meaning-transmission systems."
TEAMWORK:
  code: "TEAM-SHELL-CLASS v1.0"
  parent_overlay: "CIVOS.COORDINATION-SHELL.TEAMWORK"
  role: "Classifies human coordination systems."
NEWS:
  code: "NEWS-SHELL-CLASS v1.0"
  parent_overlay: "CIVOS.FILTER-SHELL.NEWS"
  role: "Classifies public-signal and reality-update systems."
FUTURE_CLASSIFICATIONS:
  code: "CLASS-TEMPLATE-RUNTIME v1.0"
  parent_overlay: "CIVOS.[SELECTED-SHELL].[NEW-CORE-SYSTEM]"
  role: "Reusable template for adding new eduKateSG classification systems."

		

			
---
# 2. The Parent CivOS Grammar
All child systems should be able to map upward into this parent CivOS format.

yaml id=”parent-civos-grammar”
CIVOS_PARENT_GRAMMAR:
canonical_name: “CivilisationOS Shell-Lattice Classification System v1.0”
canonical_format:
“CIVOS.[SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

fields:
CIVOS:
meaning: “CivilisationOS classification object”

			
SHELLTYPE:
  meaning: "The civilisation shell being read"
  examples:
    - "CORE-SHELL"
    - "BOUNDARY-SHELL"
    - "FILTER-SHELL"
    - "MEMORY-SHELL"
    - "INFRASTRUCTURE-SHELL"
    - "TRUST-SHELL"
    - "REPAIR-SHELL"
    - "FRONTIER-SHELL"
    - "CONTINUITY-REPAIR-SHELL"
    - "COORDINATION-SHELL"
CORE_SYSTEM:
  meaning: "The load-bearing system under analysis"
  examples:
    - "SOCIETY"
    - "CULTURE"
    - "TEAMWORK"
    - "NEWS"
    - "EDUCATION"
    - "LAW"
    - "LANGUAGE"
    - "TRUST"
    - "MEDIA"
    - "ECONOMY"
    - "HEALTH"
    - "INFRASTRUCTURE"
    - "GOVERNANCE"
    - "TECHNOLOGY"
    - "REPAIR"
Z:
  meaning: "Zoom level / scale"
  range: "Z0-Z6"
P:
  meaning: "Phase"
  range: "P0-P4"
T:
  meaning: "Time slice / time horizon"
  range: "T0-T25"
L:
  meaning: "Lattice state"
  range:
    - "LPOS"
    - "LNEU"
    - "LNEG"
    - "LINV"
R:
  meaning: "Repair capacity"
  range: "R0-R5"
K:
  meaning: "Confidence"
  range: "K1-K5"

		

			
---
# 3. Zoom Levels

yaml id=”civos-z-levels”
ZOOM_LEVELS:
Z0:
name: “Human / skill / role level”
reads:
– “individual competence”
– “language”
– “habits”
– “judgement”
– “courage”
– “role performance”
– “human floor”

Z1:
name: “Family / small group / local role level”
reads:
– “households”
– “friend groups”
– “small teams”
– “classroom groups”
– “local trust”
– “small-group continuity”

Z2:
name: “Institution level”
reads:
– “schools”
– “workplaces”
– “courts”
– “hospitals”
– “agencies”
– “companies”
– “organised role systems”

Z3:
name: “Network / sector level”
reads:
– “media systems”
– “supply chains”
– “education sectors”
– “health networks”
– “port systems”
– “finance systems”
– “logistics systems”

Z4:
name: “City / regional level”
reads:
– “cities”
– “regions”
– “urban systems”
– “regional corridors”
– “infrastructure clusters”
– “local governance systems”

Z5:
name: “State / nation level”
reads:
– “nation-state society”
– “national institutions”
– “national economy”
– “national education”
– “national trust”
– “national governance”

Z6:
name: “Civilisation / planetary level”
reads:
– “civilisation-scale continuity”
– “global systems”
– “planetary survival”
– “frontier shells”
– “intergenerational survival”
– “species-scale coordination”

			
---
# 4. Phase Levels

yaml id=”civos-phase-levels”
PHASE_LEVELS:
P0:
name: “Collapse / failure state”
meaning: “The shell cannot carry its function. Survival mode, blackout, or collapse valley behaviour appears.”
public_phrase: “The floor is broken.”

P1:
name: “Fragile / degraded state”
meaning: “The shell still exists but suffers recurring failures, weak buffers, high load, low trust, or weak repair.”
public_phrase: “The system is standing, but fragile.”

P2:
name: “Repair-capable / functional state”
meaning: “The system functions and can repair normal damage, but still needs active maintenance.”
public_phrase: “The system works if maintained.”

P4:
name: “Regenerative / surplus-capable state”
meaning: “The shell generates enough surplus to repair itself and support frontier expansion without consuming the base.”
public_phrase: “The system can renew itself and safely extend.”
guardrail: “P4 is valid only when the base remains protected. It is not a prestige badge.”

			
---
# 5. Lattice States

yaml id=”civos-lattice-states”
LATTICE_STATE:
LPOS:
name: “Positive lattice”
meaning: “The route strengthens continuity, trust, truth, repair, capability, welfare, and future.”
public_phrase: “The move strengthens the system.”

LNEU:
name: “Neutral lattice”
meaning: “The route is administrative, technical, observational, or low-valence; not clearly strengthening or damaging.”
public_phrase: “The move is not clearly harmful or strengthening.”

LNEG:
name: “Negative lattice”
meaning: “The route damages trust, repair, truth, capability, welfare, or continuity.”
public_phrase: “The move weakens the system.”

LINV:
name: “Inverse lattice”
meaning: “A system uses its legitimate form to produce the opposite of its intended function.”
public_phrase: “The organ is working backwards.”

			
---
# 6. Repair Scale

yaml id=”civos-repair-scale”
REPAIR_SCALE:
R0:
name: “No repair”
meaning: “Damage is not detected or cannot be corrected.”

R1:
name: “Weak repair”
meaning: “Damage is noticed but repair is slow, partial, blocked, or mostly symbolic.”

R2:
name: “Partial repair”
meaning: “Some correction exists, but drift still accumulates.”

R3:
name: “Workable repair”
meaning: “Repair can respond to normal damage and maintain function.”

R4:
name: “Strong repair”
meaning: “Repair is faster than normal drift and recurring damage.”

R5:
name: “Adaptive regenerative repair”
meaning: “The system learns from stress, improves, and builds surplus repair capacity.”

			
---
# 7. Confidence Scale

yaml id=”classification-confidence-scale”
CONFIDENCE_SCALE:
K1:
name: “Low confidence”
meaning: “Evidence is weak, early, incomplete, or speculative.”

K2:
name: “Limited confidence”
meaning: “Some evidence exists, but source, scope, or interpretation remains uncertain.”

K3:
name: “Medium confidence”
meaning: “Evidence is plausible and structured, but not yet strong enough for high confidence.”

K4:
name: “High confidence”
meaning: “Evidence is strong, multi-layered, or well-supported.”

K5:
name: “Very high confidence”
meaning: “Evidence is primary-source anchored, repeatedly verified, or structurally confirmed.”

			
---
# 8. Domain Systems and Their Native IDs
The stack keeps native domain IDs because each system needs domain-specific detail.

yaml id=”domain-native-ids”
DOMAIN_NATIVE_IDS:
SOCIETY:
system: “SOC-SHELL-CLASS v1.0”
native_id_format:
“SOC.[L0-L6].[SC0-SC5].[TR0-TR5].[FN0-FN5].[RP0-RP5].[C0-C10].[T+/T0/T-/TX].[K1-K5]”
civos_overlay:
“CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

CULTURE:
system: “CULT-SHELL-CLASS v1.0”
native_id_format:
“CULT.[L0-L6].[CSC0-CSC5].[D0-D5].[PEN0-PEN6].[V+/V0/V-/VI/VM].[CC0-CC10].[T+/T0/T-/TX].[K1-K5]”
correction:
“Use PEN0-PEN6 for penetration. Do not use P0-P6 because P0-P4 is reserved for CivOS phase.”
civos_overlay:
“CIVOS.MEMORY-SHELL.CULTURE.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

TEAMWORK:
system: “TEAM-SHELL-CLASS v1.0”
native_id_format:
“TEAM.[L0-L6].[TSC0-TSC5].[RF0-RF5].[TR0-TR5].[LD0-LD5].[TC0-TC11].[T+/T0/T-/TX].[K1-K5]”
civos_overlay:
“CIVOS.COORDINATION-SHELL.TEAMWORK.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

NEWS:
system: “NEWS-SHELL-CLASS v1.0”
native_id_format:
“NEWS.[L0-L6].[NSC0-NSC5].[CL0-CL6].[SI0-SI5].[FR0-FR5].[NC0-NC11].[T+/T0/T-/TX].[K1-K5]”
civos_overlay:
“CIVOS.FILTER-SHELL.NEWS.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

CIVILISATION:
system: “CIVOS-SHELL-LATTICE-CLASS v1.0”
native_id_format:
“CIVOS.[SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”
civos_overlay:
“N/A: CivilisationOS is the parent system.”

			
---
# 9. Parent-Child Translation Rule

yaml id=”parent-child-translation-rule”
PARENT_CHILD_TRANSLATION_RULE:
rule_1:
name: “Native first”
meaning: “Classify the system in its native domain format first because the domain ID carries specific diagnostic detail.”

rule_2:
name: “Overlay second”
meaning: “Translate the native reading upward into CivOS Z/P/T/L/R/K grammar.”

rule_3:
name: “Do not flatten”
meaning: “Do not force Society, Culture, Teamwork, and News to lose their domain-specific axes.”

rule_4:
name: “Do not fork”
meaning: “Do not create a separate Civilisation classification system outside the existing CivOS shell-lattice grammar.”

rule_5:
name: “CivOS is the parent map”
meaning: “All child systems must be able to show how they affect civilisation continuity, repair, trust, memory, coordination, and future transmission.”

			
---
# 10. Example: Society Native ID + CivOS Overlay

yaml id=”society-example-native-overlay”
EXAMPLE_SOCIETY_READING:
observed_system:
type: “nation-level society”
issue: “uneven trust and repair capacity”
domain: “SocietyOS”

native_id:
id: “SOC.L5.SC4.TR3.FN3.RP3.C3.T-.K4”
meaning: “Nation-level mature society shell, operational trust, functional but uneven organs, workable repair, tilted condition, deteriorating trajectory, high confidence.”

civos_overlay:
id: “CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z5.P2.T6.LNEU.R3.K4”
meaning: “Nation-scale civilisation continuity shell, society subsystem, repair-capable phase, medium horizon, neutral lattice, workable repair, high confidence.”

derived_civos_condition:
– “CIV.TILTED”
– “CIV.FUNCTIONAL-BUT-STRESSED”

			
---
# 11. Example: Culture Native ID + CivOS Overlay

yaml id=”culture-example-native-overlay”
EXAMPLE_CULTURE_READING:
observed_system:
type: “national heritage culture becoming commercialised”
issue: “depth weakening while visibility remains high”
domain: “CultureOS”

native_id:
id: “CULT.L5.CSC5.D2.PEN4.VM.CC5.T-.K3”
meaning: “National deep culture shell, mostly audience/appreciation depth, national penetration, mixed valence, captured culture, deteriorating, medium confidence.”

civos_overlay:
id: “CIVOS.MEMORY-SHELL.CULTURE.Z5.P2.T6.LNEU.R2.K3”
meaning: “Nation-scale civilisation memory shell, culture subsystem, repair-capable but stressed, medium horizon, neutral lattice, partial repair, medium confidence.”

derived_civos_condition:
– “CIV.TILTED”
– “CIV.CAPTURED-SHELL-RISK”

			
---
# 12. Example: Teamwork Native ID + CivOS Overlay

yaml id=”teamwork-example-native-overlay”
EXAMPLE_TEAMWORK_READING:
observed_system:
type: “project team with dynamic reconfiguration”
issue: “high-functioning adaptive team”
domain: “TeamworkOS”

native_id:
id: “TEAM.L3.TSC5.RF5.TR5.LD5.TC10.T+.K4”
meaning: “Project-level dynamic team shell, elite adaptive role fit, pressure-tested trust, dynamic load balancing, adaptive team, improving, high confidence.”

civos_overlay:
id: “CIVOS.COORDINATION-SHELL.TEAMWORK.Z2.P3.T3.LPOS.R4.K4”
meaning: “Institution/project-scale civilisation coordination shell, teamwork subsystem, stable phase, short-medium horizon, positive lattice, strong repair, high confidence.”

derived_civos_condition:
– “CIV.STABLE”
– “CIV.POSITIVE-COORDINATION”

			
---
# 13. Example: News Native ID + CivOS Overlay

yaml id=”news-example-native-overlay”
EXAMPLE_NEWS_READING:
observed_system:
type: “early logistics signal”
issue: “possible future corridor movement”
domain: “NewsOS”

native_id:
id: “NEWS.L5.NSC2.CL2.SI3.FR1.NC11.TX.K2”
meaning: “International reported-claim shell, multiple but weakly independent sources, low-frame signal, Purple Signal / early corridor news, volatile, limited confidence.”

civos_overlay:
id: “CIVOS.FILTER-SHELL.NEWS.Z5.P1.T1.LNEU.R1.K2”
meaning: “International civilisation filter shell, news subsystem, fragile phase, short horizon, neutral lattice, weak repair/checking, limited confidence.”

derived_civos_condition:
– “CIV.EARLY-SIGNAL”
– “WATCH-NOT-PROOF”

			
---
# 14. Phase 4 Research Layer
This stack may use Phase 4 internally where relevant.

yaml id=”phase-4-research-layer”
PHASE_4_RESEARCH_LAYER:
status: “Internal / technical / code-facing unless user asks for reader explanation.”
meaning: “A frontier research overlay used when a system has enough stable base capacity to explore regenerative or frontier conditions.”
guardrails:
– “P4 is not a prestige badge.”
– “P4 must sit above a protected P3 base.”
– “P4 must not consume the base system.”
– “P4 must pay rent to P3.”
– “If frontier work weakens the base, downgrade the reading.”
applies_to:
civilisation:
usage: “Frontier shell, regenerative surplus, civilisation extension.”
society:
usage: “High-continuity social systems with strong repair and surplus trust.”
culture:
usage: “Deep heritage renewal or meaning systems that regenerate across generations.”
teamwork:
usage: “Dynamic/adaptive or Pegasus teams that generate surplus creative coordination.”
news:
usage: “Purple Signal and early-corridor reading, but never as proof.”
public_rule:
– “Do not mention Phase 4 mechanics in reader-facing articles unless the user asks.”
– “Translate into simple public phrases such as advanced, regenerative, frontier, high-continuity, or early-signal.”

			
---
# 15. Article Runtime Rules for This 7-Part Stack

yaml id=”seven-article-runtime-rules”
SEVEN_ARTICLE_STACK:
article_1:
title: “Master Alignment: CivilisationOS as the Parent Shell-Lattice System”
status: “current article”
purpose:
– “Define the full stack.”
– “Set parent-child hierarchy.”
– “Lock CivOS overlay grammar.”
– “Prevent conflicting classification systems.”

article_2:
title: “SocietyOS Shell-State Classification System v1.1”
purpose:
– “Full code for Society classification.”
– “Align SocietyOS to CivOS continuity-repair shell.”
– “Preserve SOC native ID.”
– “Add CivOS overlay.”

article_3:
title: “CultureOS Shell-State Classification System v1.1”
purpose:
– “Full code for Culture classification.”
– “Align CultureOS to CivOS memory shell.”
– “Correct P to PEN for penetration.”
– “Preserve culture depth, penetration, valence, and condition classes.”

article_4:
title: “TeamworkOS Shell-State Classification System v1.1”
purpose:
– “Full code for Teamwork classification.”
– “Align TeamworkOS to CivOS coordination shell.”
– “Preserve role fit, trust, load, dynamic team, and Pegasus class.”

article_5:
title: “NewsOS Shell-State Classification System v1.1”
purpose:
– “Full code for News classification.”
– “Align NewsOS to CivOS filter shell.”
– “Preserve claim strength, source integrity, frame state, correction, and Purple Signal class.”

article_6:
title: “CivilisationOS Shell-Lattice Classification System v1.1”
purpose:
– “Full code for Civilisation classification.”
– “Use existing eduKateSG shell-lattice grammar.”
– “Preserve Z/P/T/L/R/K system.”
– “Define derived civilisation conditions.”

article_7:
title: “Universal Classification Template Runtime v1.0”
purpose:
– “Reusable template for future classification systems.”
– “Allows eduKateSG to add Education, War, Family, Vocabulary, Reality, Finance, Governance, Health, Logistics, etc.”
– “Ensures every new system nests under CivOS.”

			
---
# 16. Universal Operating Rule

yaml id=”universal-operating-rule”
UNIVERSAL_OPERATING_RULE:
statement:
“Every eduKateSG classification system must answer two questions: first, what is the system in its own domain; second, how does that system affect civilisation continuity, repair, trust, memory, coordination, reality, and future transmission?”

native_question:
“What is this system doing in its own domain?”

civos_question:
“What does this system do to civilisation’s ability to hold, filter, repair, transfer, and regenerate through time?”

output_requirement:
– “Native Domain ID”
– “CivOS Overlay ID”
– “Derived condition”
– “Confidence”
– “Repair or watch recommendation”

			
---
# 17. Full Stack Output Format
Every future classification should use this layout.

yaml id=”standard-output-format”
STANDARD_CLASSIFICATION_OUTPUT:
1_observed_system:
required:
– “system name”
– “unit of analysis”
– “scale”
– “domain”
– “reason for classification”

2_native_domain_id:
required:
– “native ID”
– “native meaning”
– “condition class”

3_civos_overlay_id:
required:
– “CivOS overlay ID”
– “CivOS meaning”
– “Z/P/T/L/R/K reading”

4_derived_condition:
required:
– “domain condition”
– “CivOS condition”
– “positive/neutral/negative/inverse direction”

5_evidence_and_confidence:
required:
– “evidence notes”
– “confidence K1-K5”
– “uncertainty”
– “what would upgrade/downgrade the classification”

6_repair_or_action:
required:
– “protect”
– “repair”
– “watch”
– “downgrade”
– “upgrade”
– “hold”
– “publish with caution”

			
---
# 18. Public Translation Table

yaml id=”public-translation-table”
PUBLIC_TRANSLATION:
shell:
public_phrase: “the structure that holds the system together”

lattice:
public_phrase: “the direction the system is moving”

positive_lattice:
public_phrase: “strengthening direction”

neutral_lattice:
public_phrase: “unclear or low-impact direction”

negative_lattice:
public_phrase: “weakening direction”

inverse_lattice:
public_phrase: “the system is working backwards”

phase:
public_phrase: “the operating condition of the system”

P0:
public_phrase: “broken or collapsed”

P1:
public_phrase: “fragile”

P2:
public_phrase: “functional but needing repair”

P3:
public_phrase: “stable”

P4:
public_phrase: “regenerative or frontier-capable”

repair_capacity:
public_phrase: “how well the system can fix damage”

confidence:
public_phrase: “how sure we are based on evidence”

			
---
# 19. Article 1 Closing Runtime Lock

yaml id=”article-1-runtime-lock”
RUNTIME_LOCK:
locked_decisions:
– “CivilisationOS is the parent classification system.”
– “Society, Culture, Teamwork, and News remain valid as child native classification systems.”
– “All child systems must carry a CivOS overlay ID.”
– “Culture penetration must use PEN, not P, to avoid conflict with CivOS phase.”
– “Phase 4 is an internal frontier/regenerative overlay and must not be casually exposed in reader articles.”
– “Future classification systems must use the Universal Classification Template in Article 7.”

next_article:
article_number: 2
title: “SocietyOS Shell-State Classification System v1.1”
prompt_to_continue:
“Next”

			
---
# 20. Short AI Memory Version

yaml id=”short-ai-memory-version”
SHORT_MEMORY:
“eduKateSG Full Classification Stack v1.0 uses CivilisationOS as the parent shell-lattice system. Keep SOC, CULT, TEAM, and NEWS native IDs, but add CivOS overlay IDs to each. Parent format: CIVOS.[SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]. Culture uses PEN0-PEN6 for penetration to avoid confusion with CivOS P0-P4 phase. The 7-article stack is: 1 Master Alignment, 2 Society, 3 Culture, 4 Teamwork, 5 News, 6 Civilisation, 7 Universal Classification Template.”
“`

Article 1 is complete.

Article 2 of 7

SocietyOS Shell-State Classification System v1.1

Full Code Aligned to CivilisationOS Parent Shell-Lattice

Full Code for AI Runtime

“`yaml id=”societyos-v1-1-header”
ARTICLE_ID: “EKSG.FULLCLASSSTACK.SOCIETYOS.SHELL-STATE-CLASS.v1.1”
ARTICLE_NUMBER: 2
STACK_TOTAL: 7

TITLE: “SocietyOS Shell-State Classification System v1.1”
SUBTITLE: “Full Code Aligned to CivilisationOS Parent Shell-Lattice”
PUBLIC_OR_INTERNAL: “Full Code for AI Runtime”
AUTHOR_CONTEXT: “eduKateSG”

PARENT_STACK:
name: “eduKateSG Full Classification Stack v1.0”
parent_article: “Article 1 — Master Alignment: CivilisationOS as the Parent Shell-Lattice System”
parent_system: “CivilisationOS”
parent_classification: “CIVOS-SHELL-LATTICE-CLASS v1.0”

RUNTIME_TRIGGER:
SIMPLE_TRIGGER:
– “Use SocietyOS classification”
– “Use Society Shell-State Classification”
– “Classify society”
– “What is not a society”
– “What type of society is this”
– “Use SOC-SHELL-CLASS”
– “Use SocietyOS with CivOS overlay”
– “Classify society by shell-state”
– “Use eduKateSG Full Classification Stack”

FULL_TRIGGER:
“Use eduKateSG SocietyOS Shell-State Classification System v1.1 aligned to CivilisationOS parent shell-lattice. First classify the social system using the native SOC ID, then translate upward into the CivOS overlay ID. Preserve reader-facing clarity if writing public article, and expose full IDs only when full-code or technical output is requested.”

SURFACE_RULE:
reader_facing:
– “Do not overuse IDs.”
– “Use words like society condition, social shell, social function, repair, trust, and continuity.”
– “Avoid saying society species.”
– “Do not expose Phase 4 unless explicitly requested.”
code_facing:
– “Expose native SOC ID.”
– “Expose CivOS overlay ID.”
– “Include classification axes, condition classes, failure classes, examples, repair sequence, and confidence.”

			
---
# 1. Canonical Name

yaml id=”societyos-canon-v1-1″
CANONICAL_NAME:
“eduKateSG SocietyOS Shell-State Classification System v1.1”

SHORT_NAME:
“SOC-SHELL-CLASS v1.1”

SYSTEM_TYPE:
“SocietyOS”

UNIT_OF_ANALYSIS:
“Human social continuity system”

PARENT_CIVOS_ROLE:
“Continuity / trust / social repair shell”

DEFAULT_CIVOS_OVERLAY:
“CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY”

CORE_LINE:
“Society is not merely people together. Society is human life carried across time by trust, rules, memory, protection, correction, repair, and transmission.”

PUBLIC_DEFINITION:
“A society is a continuing human system where people share enough rules, memory, trust, roles, protection, correction, repair, and meaning to live together across time.”

NOT_SOCIETY_DEFINITION:
“A group is not yet society when people are merely gathered, counted, connected, controlled, entertained, or exchanging value without enough shared continuity, responsibility, memory, repair, and transmission.”

			
---
# 2. Native SocietyOS ID Format

yaml id=”societyos-native-id-format”
NATIVE_SOCIETY_ID:
formula:
“SOC.[LEVEL].[SHELL_COMPLETENESS].[TRUST].[FUNCTION].[REPAIR].[CONDITION].[TRAJECTORY].[CONFIDENCE]”

full_format:
“SOC.[L0-L6].[SC0-SC5].[TR0-TR5].[FN0-FN5].[RP0-RP5].[C0-C10].[T+/T0/T-/TX].[K1-K5]”

example:
id: “SOC.L5.SC4.TR3.FN3.RP3.C3.T-.K4”
meaning: “Nation-level mature society shell, operational trust, functional but uneven organs, workable repair, tilted condition, deteriorating trajectory, high confidence.”

			
---
# 3. CivOS Overlay ID Format

yaml id=”societyos-civos-overlay-format”
CIVOS_OVERLAY_ID:
formula:
“CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

example:
id: “CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z5.P2.T6.LNEU.R3.K4”
meaning: “Nation-scale civilisation continuity shell, society subsystem, repair-capable phase, medium horizon, neutral lattice, workable repair, high confidence.”

ALIGNMENT_RULE:

“Use native SOC ID for social-system detail.”
“Use CivOS overlay ID to place the society reading inside the parent civilisation shell-lattice.”
“Do not replace SOC ID with CivOS ID.”
“Do not create a competing civilisation classification.”

			
---
# 4. SocietyOS Axes
## Axis 1 — Level

yaml id=”societyos-level-axis”
SOCIETY_LEVEL:
L0:
name: “Single interaction”
examples:
– “one conversation”
– “one queue”
– “one crowd moment”
– “one comment exchange”
note: “Usually not enough to count as society.”

L1:
name: “Family / small group”
examples:
– “family”
– “friend group”
– “small neighbourhood group”
– “small class group”

L2:
name: “Institution / school / workplace”
examples:
– “school community”
– “workplace”
– “hospital”
– “court”
– “company department”

L3:
name: “Community / town / platform community”
examples:
– “town”
– “local community”
– “online community”
– “subculture community”

L4:
name: “City / region”
examples:
– “city society”
– “regional society”
– “urban social system”

L5:
name: “Nation-level society”
examples:
– “national society”
– “state-wide social system”

L6:
name: “Civilisation-scale society”
examples:
– “civilisation-scale human society”
– “planetary society layer”
– “large-scale intergenerational society”

			
---
## Axis 2 — Society Shell Completeness

yaml id=”societyos-shell-completeness”
SOCIETY_SHELL_COMPLETENESS:
SC0:
name: “No society shell”
meaning: “People may exist, but no meaningful social shell is present.”

SC1:
name: “Contact shell only”
meaning: “People encounter one another, but there is little continuity, memory, repair, or transmission.”

SC2:
name: “Emerging society shell”
meaning: “Recognition, repeated interaction, and early memory begin to form.”

SC3:
name: “Basic society shell”
meaning: “Rules, roles, trust, and protection exist at basic level.”

SC4:
name: “Mature society shell”
meaning: “Institutions, memory, language, correction, repair, and transmission are organised.”

SC5:
name: “Advanced / complex society shell”
meaning: “Multiple social organs coordinate across time with adaptive repair and high continuity.”

### Society Shell Layers

yaml id=”societyos-shell-layers”
SOCIETY_SHELL_LAYERS:
boundary:
question: “Who belongs?”
failure: “Belonging is unclear or constantly contested.”

people:
question: “Who is inside the system?”
failure: “People are counted but not socially carried.”

rules:
question: “What is allowed or forbidden?”
failure: “Rules are absent, arbitrary, or illegitimate.”

roles:
question: “Who carries which function?”
failure: “Role confusion or role abandonment.”

memory:
question: “What is remembered?”
failure: “The system forgets harm, sacrifice, lessons, or obligations.”

trust:
question: “Can people rely on the system?”
failure: “People cannot depend on words, rules, or institutions.”

language:
question: “Can meaning be shared?”
failure: “Words no longer match lived reality.”

institutions:
question: “Are functions organised?”
failure: “Institutions remain but do not perform their purpose.”

protection:
question: “Are vulnerable parts protected?”
failure: “Children, weak groups, families, truth, or justice are sacrificed.”

correction:
question: “Can errors be corrected?”
failure: “Mistakes become permanent or protected.”

repair:
question: “Can damage be repaired?”
failure: “Damage accumulates faster than correction.”

transmission:
question: “Can society pass itself forward?”
failure: “The young inherit symbols without functioning floors.”

future:
question: “Can the young inherit a viable path?”
failure: “Future corridors close or become irrational.”

			
---
## Axis 3 — Trust

yaml id=”societyos-trust-axis”
SOCIETY_TRUST:
TR0:
name: “No trust”
meaning: “People cannot rely on the system or one another.”

TR1:
name: “Fragile trust”
meaning: “Trust exists only in small pockets or under low pressure.”

TR2:
name: “Basic trust”
meaning: “People can rely on some norms or institutions, but trust is weak or uneven.”

TR3:
name: “Operational trust”
meaning: “Enough trust exists for ordinary life, work, learning, exchange, and repair.”

TR4:
name: “Strong trust”
meaning: “Trust is broadly reliable across social functions.”

TR5:
name: “Deep / pressure-tested trust”
meaning: “Trust survives stress, disagreement, mistakes, and repair cycles.”

			
---
## Axis 4 — Function Integrity

yaml id=”societyos-function-integrity”
FUNCTION_INTEGRITY:
FN0:
name: “No functional organs”
meaning: “No meaningful society organs perform reliably.”

FN1:
name: “Severely weak function”
meaning: “Major organs exist weakly or symbolically.”

FN2:
name: “Partial function”
meaning: “Some organs function, but important parts are damaged.”

FN3:
name: “Functional but uneven”
meaning: “Society broadly works, but unevenness, overload, or drift is visible.”

FN4:
name: “Strong functional integrity”
meaning: “Most major social organs perform their intended work well.”

FN5:
name: “High-integrity adaptive function”
meaning: “Social organs perform well and adapt under pressure.”

### Main Social Organs

yaml id=”societyos-organs”
SOCIETY_ORGANS:
family:
proper_function: “Protects and forms the young.”
inversion: “Home becomes unsafe, neglectful, or fear-based.”

education:
proper_function: “Grows mind, language, reasoning, skill, character, and future capability.”
inversion: “School remains, but learning becomes fear, ranking, pressure, or branding.”

law:
proper_function: “Protects justice and restrains power.”
inversion: “Law protects injustice or powerful insiders.”

media:
proper_function: “Clarifies reality for public coordination.”
inversion: “Media increases confusion while claiming to inform.”

market:
proper_function: “Supports exchange, livelihood, and value circulation.”
inversion: “Market consumes human life and social floors.”

work:
proper_function: “Provides dignity, contribution, skill, livelihood, and future route.”
inversion: “Work consumes dignity and life without future.”

culture:
proper_function: “Transmits meaning, memory, beauty, belonging, and responsibility.”
inversion: “Culture normalises what damages life.”

governance:
proper_function: “Coordinates public responsibility.”
inversion: “Governance protects image, insiders, or control over responsibility.”

health:
proper_function: “Protects bodily and social resilience.”
inversion: “Health system becomes inaccessible, extractive, or reactive only.”

technology:
proper_function: “Extends human capability without consuming the human base.”
inversion: “Humans are reorganised to serve technology.”

language:
proper_function: “Carries meaning, trust, and shared reality.”
inversion: “Words hide the opposite of reality.”

			
---
## Axis 5 — Repair Capacity

yaml id=”societyos-repair-axis”
SOCIETY_REPAIR:
RP0:
name: “No repair capacity”
meaning: “Damage is not detected or cannot be corrected.”

RP1:
name: “Weak repair capacity”
meaning: “Damage is noticed but repair is slow, symbolic, blocked, or selective.”

RP2:
name: “Partial repair”
meaning: “Some correction exists, but drift and damage still accumulate.”

RP3:
name: “Workable repair”
meaning: “Society can respond to normal damage and maintain function.”

RP4:
name: “Strong repair”
meaning: “Society repairs faster than normal drift and recurring damage.”

RP5:
name: “Adaptive / learning repair”
meaning: “Society learns from stress, improves, and builds future repair capacity.”

			
---
## Axis 6 — Society Condition Class

yaml id=”societyos-condition-class”
SOCIETY_CONDITION_CLASS:
C0: “Pre-Society Contact”
C1: “Emerging Society”
C2: “Functional / Zero-Tilt Society”
C3: “Tilted Society”
C4: “Captured Society”
C5: “Inverted Society”
C6: “Below-Threshold Society”
C7: “Repairing Society”
C8: “Decaying Society”
C9: “Fragmented Society”
C10: “High-Continuity Society”

			
---
## Axis 7 — Trajectory

yaml id=”societyos-trajectory-axis”
TRAJECTORY:
T+:
name: “Improving / repairing”
meaning: “Trust, function, repair, protection, or continuity are improving.”

T0:
name: “Stable / no clear movement”
meaning: “No strong directional change is visible.”

T-:
name: “Deteriorating”
meaning: “Trust, function, repair, protection, or continuity are weakening.”

TX:
name: “Volatile / unclear”
meaning: “Direction is unstable, fast-changing, contested, or insufficiently evidenced.”

			
---
## Axis 8 — Confidence

yaml id=”societyos-confidence-axis”
CONFIDENCE:
K1:
name: “Low confidence”
meaning: “Evidence is weak, speculative, or incomplete.”

K2:
name: “Limited confidence”
meaning: “Some evidence exists, but the picture is uncertain.”

K3:
name: “Medium confidence”
meaning: “Evidence is plausible and structured, but not strong enough for high confidence.”

K4:
name: “High confidence”
meaning: “Evidence is strong, repeated, or multi-layered.”

K5:
name: “Very high confidence”
meaning: “Evidence is primary-source anchored, structurally confirmed, or repeatedly verified.”

			
---
# 5. Society Condition Classes
## C0 — Pre-Society Contact

yaml id=”societyos-c0″
C0_PRE_SOCIETY_CONTACT:
id: “SOC.C0.PRE_CONTACT”
status: “Not yet society”
core_signal: “People are in contact, but continuity has not formed.”
signs:
– “temporary gathering”
– “one-time interaction”
– “no durable obligation”
– “no shared repair”
– “no transmission”
– “no stable rule”
examples:
– “crowd”
– “queue”
– “audience”
– “comment thread”
– “one-time market contact”
key_question:
“Does contact become continuity?”

			
---
## C1 — Emerging Society

yaml id=”societyos-c1″
C1_EMERGING_SOCIETY:
id: “SOC.C1.EMERGING”
status: “Beginning society”
core_signal: “Repeated contact becomes memory, rules, roles, and duty.”
signs:
– “recognition appears”
– “patterns repeat”
– “roles form”
– “rules begin”
– “children or newcomers are taught”
– “conflict begins to have repair paths”
– “obligations carry across time”
key_question:
“Are repeated patterns becoming memory, rule, and duty?”

			
---
## C2 — Functional / Zero-Tilt Society

yaml id=”societyos-c2″
C2_FUNCTIONAL_ZERO_TILT:
id: “SOC.C2.ZERO_TILT”
status: “Healthy baseline society”
core_signal: “The main social organs carry life properly enough.”
note:
“Zero tilt does not mean perfect society. It means society is balanced enough to carry ordinary life and correct mistakes.”
signs:
– “law broadly protects justice”
– “education broadly forms the young”
– “families broadly protect and form children”
– “work broadly gives dignity and livelihood”
– “media broadly clarifies reality”
– “culture broadly transmits meaning”
– “mistakes can still be corrected”
– “truth can still challenge power”
key_question:
“Are the main social organs still pointing toward their proper purpose?”

			
---
## C3 — Tilted Society

yaml id=”societyos-c3″
C3_TILTED_SOCIETY:
id: “SOC.C3.TILTED”
status: “Functioning but uneven”
core_signal: “The social table leans.”
signs:
– “some groups carry more burden”
– “some groups receive more protection”
– “starting floors differ sharply”
– “trust is uneven”
– “mistakes are forgiven for some but permanent for others”
– “future routes narrow for some”
– “ordinary life feels heavier for certain groups”
key_question:
“Can the tilt still be corrected?”
repair_need:
– “name uneven burden”
– “protect overloaded groups”
– “correct rules and floors”
– “restore trust”

			
---
## C4 — Captured Society

yaml id=”societyos-c4″
C4_CAPTURED_SOCIETY:
id: “SOC.C4.CAPTURED”
status: “Society bent toward a narrower interest”
core_signal: “A part controls too much of the whole.”
capture_agents:
– “wealth”
– “political group”
– “ideology”
– “bureaucracy”
– “platform”
– “media system”
– “criminal network”
– “status class”
– “fear culture”
signs:
– “institutions protect insiders”
– “public language remains moral but function shifts”
– “rules appear neutral but serve a narrow group”
– “image is protected over reality”
– “ordinary people feel the system is rigged”
key_question:
“Who or what is the system really protecting?”

			
---
## C5 — Inverted Society

yaml id=”societyos-c5″
C5_INVERTED_SOCIETY:
id: “SOC.C5.INVERTED”
status: “Society whose functions have reversed”
core_signal: “The organs remain, but purpose reverses.”
distinction:
“Inverted society is not the same as no society. The visible shell remains, but some organs produce the opposite of their intended purpose.”
examples:
education: “Education weakens learning.”
law: “Law protects injustice.”
media: “Media clouds reality.”
work: “Work consumes dignity.”
family: “Family becomes unsafe.”
culture: “Culture normalises decay.”
leadership: “Leadership extracts loyalty without responsibility.”
technology: “Technology captures humans instead of serving them.”
key_question:
“Is the organ still doing what it is supposed to do?”

			
---
## C6 — Below-Threshold Society

yaml id=”societyos-c6″
C6_BELOW_THRESHOLD_SOCIETY:
id: “SOC.C6.BELOW_THRESHOLD”
status: “Not enough society to carry life properly”
core_signal: “The minimum floor is broken.”
distinction:
“Below-threshold society is different from inverted society. In inversion, organs remain but reverse. Below threshold means the minimum floor itself is missing or too weak.”
signs:
– “not enough trust”
– “not enough rule”
– “not enough protection”
– “not enough shared reality”
– “not enough teaching”
– “not enough repair”
– “not enough continuity”
repair_need:
– “restore safety”
– “restore trust”
– “restore basic rules”
– “restore protection”
– “restore teaching”
– “restore repair”

			
---
## C7 — Repairing Society

yaml id=”societyos-c7″
C7_REPAIRING_SOCIETY:
id: “SOC.C7.REPAIRING”
status: “Damaged but recovering”
core_signal: “Truth and repair return.”
signs:
– “damage is named”
– “weak points are protected”
– “public language reconnects with reality”
– “institutions admit mistakes”
– “children and families are protected”
– “trust is rebuilt through repeated action”
– “functions return to purpose”
key_question:
“Is repair becoming faster than damage?”

			
---
## C8 — Decaying Society

yaml id=”societyos-c8″
C8_DECAYING_SOCIETY:
id: “SOC.C8.DECAYING”
status: “Still visible, but weakening”
core_signal: “Damage outruns repair.”
signs:
– “trust thins”
– “language becomes performative”
– “families become overloaded”
– “children become anxious”
– “work consumes dignity”
– “media confuses reality”
– “institutions protect image”
– “culture becomes shallow”
– “repair slows”
key_question:
“Is the visible shell hiding inner weakening?”

			
---
## C9 — Fragmented Society

yaml id=”societyos-c9″
C9_FRAGMENTED_SOCIETY:
id: “SOC.C9.FRAGMENTED”
status: “Society split into poorly translating parts”
core_signal: “People share space but not enough meaning, trust, or reality.”
signs:
– “groups cannot understand one another”
– “public language splits”
– “media realities diverge”
– “generations cannot translate each other”
– “communities retreat into separate shells”
– “shared rituals weaken”
– “common trust declines”
warning:
“Fragmentation is not always bad. Diversity and plurality can be healthy. It becomes dangerous when translation, repair, and shared reality fail.”

			
---
## C10 — High-Continuity Society

yaml id=”societyos-c10″
C10_HIGH_CONTINUITY_SOCIETY:
id: “SOC.C10.HIGH_CONTINUITY”
status: “Strong continuity and adaptive repair”
core_signal: “Society carries memory, trust, adaptation, and future transmission strongly.”
signs:
– “high trust”
– “strong family floors”
– “good education transmission”
– “institutions remember purpose”
– “public language remains meaningful”
– “damage is repaired early”
– “children inherit viable futures”
– “society adapts without losing its core”
note:
“This is not utopia. It is deep continuity with repair.”

			
---
# 6. SocietyOS Movement Map

yaml id=”societyos-movement-map”
SOCIETY_MOVEMENT_MAP:
formation_route:
– “C0 Pre-Society Contact”
– “C1 Emerging Society”
– “C2 Functional / Zero-Tilt Society”
– “C10 High-Continuity Society”

weakening_route:
– “C2 Functional / Zero-Tilt Society”
– “C3 Tilted Society”
– “C4 Captured Society”
– “C5 Inverted Society”
– “C9 Fragmented Society”
– “C8 Decaying Society”
– “C6 Below-Threshold Society”

repair_route:
– “C3 / C4 / C5 / C8 / C9”
– “damage named”
– “weak points protected”
– “functions restored”
– “public language reconnected to reality”
– “trust rebuilt”
– “C7 Repairing Society”
– “C2 Functional Society”
– “C10 High-Continuity Society”

			
---
# 7. Society Failure Classes

yaml id=”societyos-failure-classes”
SOCIETY_FAILURE_CLASSES:
SF0:
name: “No shared boundary”
meaning: “People do not know who belongs or what system is being carried.”

SF1:
name: “No common reality”
meaning: “People cannot coordinate because reality has split.”

SF2:
name: “Trust failure”
meaning: “People cannot rely on one another, institutions, or public words.”

SF3:
name: “Rule legitimacy failure”
meaning: “Rules exist but are not trusted or accepted as legitimate.”

SF4:
name: “Protection failure”
meaning: “The vulnerable are not protected.”

SF5:
name: “Education transmission failure”
meaning: “The young are not receiving capability, judgement, or future pathways.”

SF6:
name: “Family floor failure”
meaning: “Homes or family structures cannot provide basic safety, formation, or continuity.”

SF7:
name: “Public language failure”
meaning: “Words no longer match reality.”

SF8:
name: “Institutional purpose failure”
meaning: “Institutions remain but no longer perform their proper function.”

SF9:
name: “Justice failure”
meaning: “Law, fairness, or consequence no longer restrain power properly.”

SF10:
name: “Repair failure”
meaning: “Damage cannot be corrected fast enough.”

SF11:
name: “Memory failure”
meaning: “Society forgets lessons, obligations, harm, or identity.”

SF12:
name: “Future corridor failure”
meaning: “The young cannot see or access viable future routes.”

Failure class append example:

yaml id=”societyos-failure-example”
FAILURE_APPEND_EXAMPLE:
id:
“SOC.L5.SC4.TR2.FN2.RP1.C8.T-.K4 + SF2 + SF7 + SF10”
meaning:
“Nation-level decaying society, deteriorating, with trust failure, public language failure, and repair failure.”

			
---
# 8. Society Repair Sequence

yaml id=”societyos-repair-sequence”
SOCIETY_REPAIR_SEQUENCE:
step_1_notice:
action: “Recognise that something is wrong.”
diagnostic_questions:
– “What feels wrong?”
– “Who is carrying the burden?”
– “What repeated harm is visible?”
– “What is being normalised?”

step_2_name:
action: “Classify the damage accurately.”
possible_damage:
– “tilt”
– “capture”
– “inversion”
– “fragmentation”
– “decay”
– “below-threshold floor failure”
rule:
“Bad naming creates bad repair.”

step_3_protect:
action: “Protect the load-bearing parts first.”
protected_parts:
– “children”
– “truth”
– “family floors”
– “education”
– “trust”
– “justice”
– “public language”
– “repair channels”
– “future options”

step_4_restore_function:
action: “Return organs to their proper purpose.”
examples:
– “Education returns to learning.”
– “Law returns to justice.”
– “Media returns to reality.”
– “Work returns to dignity.”
– “Family returns to protection.”
– “Culture returns to meaning.”
– “Governance returns to responsibility.”

step_5_repeat:
action: “Repeat repair long enough for trust to return.”
warning:
“One speech is not repair. One reform is not repair. Repair becomes real when lived experience changes.”

step_6_transmit:
action: “Pass repaired function to the next generation.”
success_signal:
“The young inherit stronger floors than before.”

			
---
# 9. SocietyOS Classification Sequence

yaml id=”societyos-classification-sequence”
SOCIETY_CLASSIFICATION_SEQUENCE:
step_1_define_unit:
question: “What social unit are we classifying?”
examples:
– “family”
– “school”
– “workplace”
– “community”
– “platform community”
– “city”
– “nation”
– “civilisation-scale society”

step_2_define_boundary:
question: “Who belongs, and where does the system begin and end?”

step_3_check_shell_layers:
question: “Does it have boundary, rules, roles, memory, trust, language, institutions, protection, correction, repair, transmission, and future?”

step_4_assign_level:
question: “What level is the society shell operating at?”
output: “L0-L6”

step_5_assign_shell_completeness:
question: “How complete is the society shell?”
output: “SC0-SC5”

step_6_assign_trust:
question: “Can people rely on one another and the system under normal pressure?”
output: “TR0-TR5”

step_7_assign_function_integrity:
question: “Are the main organs doing their proper work?”
output: “FN0-FN5”

step_8_assign_repair_capacity:
question: “Can the system notice damage, name it, correct it, and rebuild trust?”
output: “RP0-RP5”

step_9_assign_condition_class:
question: “Which society condition class best fits?”
output: “C0-C10”

step_10_assign_trajectory:
question: “Is it improving, stable, deteriorating, or volatile?”
output: “T+ / T0 / T- / TX”

step_11_assign_confidence:
question: “How strong is the evidence?”
output: “K1-K5”

step_12_output_native_id:
format: “SOC.[L].[SC].[TR].[FN].[RP].[C].[T].[K]”

step_13_translate_to_civos_overlay:
format: “CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

step_14_derive_condition:
output:
– “domain condition”
– “CivOS condition”
– “failure classes if any”
– “repair/watch recommendation”

			
---
# 10. Native-to-CivOS Translation Guide

yaml id=”societyos-native-to-civos-translation”
NATIVE_TO_CIVOS_TRANSLATION:
level_to_zoom:
L0: “Z0”
L1: “Z1”
L2: “Z2”
L3: “Z3”
L4: “Z4”
L5: “Z5”
L6: “Z6”

shell_to_phase_guidance:
SC0: “usually P0”
SC1: “usually P0-P1”
SC2: “usually P1-P2”
SC3: “usually P2”
SC4: “usually P2-P3”
SC5: “usually P3-P4 if repair and surplus are strong”

condition_to_lattice_guidance:
C0: “LNEU or LNEG depending on risk”
C1: “LNEU or LPOS if stabilising”
C2: “LPOS or LNEU”
C3: “LNEU or LNEG”
C4: “LNEG or LINV”
C5: “LINV”
C6: “LNEG”
C7: “LPOS”
C8: “LNEG”
C9: “LNEU or LNEG”
C10: “LPOS”

repair_translation:
RP0: “R0”
RP1: “R1”
RP2: “R2”
RP3: “R3”
RP4: “R4”
RP5: “R5”

confidence_translation:
K1: “K1”
K2: “K2”
K3: “K3”
K4: “K4”
K5: “K5”

			
---
# 11. Example Classifications
## Example 1 — Crowd

yaml id=”societyos-example-crowd”
EXAMPLE_1_CROWD:
observed_system:
type: “crowd”
level: “L0”
reason: “People gathered temporarily with no stable continuity.”

native_id:
id: “SOC.L0.SC1.TR1.FN0.RP0.C0.TX.K4”
meaning: “Single-interaction contact shell, fragile trust, no functional society organs, no repair capacity, pre-society contact, volatile direction, high confidence.”

civos_overlay:
id: “CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z0.P0.T0.LNEU.R0.K4”
meaning: “Human-scale society shell not yet formed, collapsed/non-social phase, immediate time slice, neutral lattice, no repair, high confidence.”

derived_condition:
– “SOC.C0.PRE_CONTACT”
– “CIV.CONTACT-NOT-SOCIETY”

repair_or_action:
“Do not treat crowd as society unless repeated continuity, rule, memory, and repair begin to appear.”

			
---
## Example 2 — Functioning School Community

yaml id=”societyos-example-school-functional”
EXAMPLE_2_FUNCTIONING_SCHOOL:
observed_system:
type: “school community”
level: “L2”
reason: “Institutional society shell with rules, roles, trust, education function, correction, and transmission.”

native_id:
id: “SOC.L2.SC4.TR4.FN4.RP4.C2.T0.K4”
meaning: “Institution-level mature society shell, strong trust, strong function integrity, strong repair, functional baseline society, stable, high confidence.”

civos_overlay:
id: “CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z2.P3.T6.LPOS.R4.K4”
meaning: “Institution-scale civilisation continuity shell, society subsystem, stable phase, medium horizon, positive lattice, strong repair, high confidence.”

derived_condition:
– “SOC.C2.ZERO_TILT”
– “CIV.STABLE”

			
---
## Example 3 — School Where Education Has Inverted

yaml id=”societyos-example-school-inverted”
EXAMPLE_3_INVERTED_SCHOOL:
observed_system:
type: “school community”
level: “L2”
issue: “Education shell remains but learning is replaced by fear, ranking, and performance pressure.”

native_id:
id: “SOC.L2.SC4.TR2.FN2.RP2.C5.T-.K3”
meaning: “Institution-level mature shell, basic trust, partial function, partial repair, inverted condition, deteriorating, medium confidence.”

civos_overlay:
id: “CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z2.P2.T3.LINV.R2.K3”
meaning: “Institution-scale civilisation continuity shell, repair-capable only in form, short-medium horizon, inverse lattice, partial repair, medium confidence.”

derived_condition:
– “SOC.C5.INVERTED”
– “CIV.INVERTED / education-social shell”

failure_classes:
– “SF5 Education transmission failure”
– “SF8 Institutional purpose failure”

			
---
## Example 4 — Nation-Level Tilted Society

yaml id=”societyos-example-nation-tilted”
EXAMPLE_4_NATION_TILTED:
observed_system:
type: “nation-level society”
issue: “Mature social shell with uneven trust, burden, opportunity, and repair.”

native_id:
id: “SOC.L5.SC4.TR3.FN3.RP3.C3.T0.K4”
meaning: “Nation-level mature society shell, operational trust, functional but uneven organs, workable repair, tilted condition, stable trajectory, high confidence.”

derived_condition:
– “SOC.C3.TILTED”
– “CIV.TILTED / functional-but-stressed”

			
---
## Example 5 — Repairing Society

yaml id=”societyos-example-repairing”
EXAMPLE_5_REPAIRING_SOCIETY:
observed_system:
type: “nation-level society”
issue: “Damage is named and repair capacity is improving.”

native_id:
id: “SOC.L5.SC4.TR3.FN3.RP4.C7.T+.K3”
meaning: “Nation-level mature society shell, operational trust, uneven but workable function, strong repair, repairing condition, improving, medium confidence.”

civos_overlay:
id: “CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z5.P2.T6.LPOS.R4.K3”
meaning: “Nation-scale civilisation continuity shell, society subsystem, repair-capable phase, medium horizon, positive lattice, strong repair, medium confidence.”

derived_condition:
– “SOC.C7.REPAIRING”
– “CIV.REPAIRING”

			
---
## Example 6 — Platform Community That Looks Social But Lacks Responsibility

yaml id=”societyos-example-platform”
EXAMPLE_6_PLATFORM_COMMUNITY:
observed_system:
type: “online platform community”
issue: “Connection exists, but memory, repair, accountability, and protection are weak.”

native_id:
id: “SOC.L3.SC2.TR2.FN1.RP1.C1.TX.K3”
meaning: “Community-level emerging shell, basic trust, weak function, weak repair, emerging society condition, volatile direction, medium confidence.”

civos_overlay:
id: “CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z3.P1.T1.LNEU.R1.K3”
meaning: “Network-scale civilisation continuity shell, society subsystem, fragile phase, short horizon, neutral lattice, weak repair, medium confidence.”

derived_condition:
– “SOC.C1.EMERGING”
– “CIV.EMERGING / fragile social shell”

warning:
“Connection should not be mistaken for society.”

			
---
# 12. Society vs Its Imitations

yaml id=”societyos-vs-imitations”
SOCIETY_VS_IMITATION:
crowd:
imitation: “society”
missing:
– “continuity”
– “responsibility”
– “repair”
– “transmission”

population:
imitation: “society”
missing:
– “shared meaning”
– “trust”
– “organised continuity”

market:
imitation: “society”
missing:
– “protection”
– “moral boundary”
– “human continuity”

platform:
imitation: “community”
missing:
– “responsibility”
– “memory”
– “protection”
– “repair”

audience:
imitation: “public”
missing:
– “participation”
– “obligation”

state:
imitation: “society”
missing:
– “family”
– “culture”
– “trust”
– “lived meaning”
– “everyday continuity”

order:
imitation: “healthy society”
missing:
– “truth”
– “justice”
– “correction”
– “legitimacy”

freedom:
imitation: “healthy society”
missing:
– “responsibility”
– “memory”
– “repair”

technology:
imitation: “progress”
missing:
– “human flourishing”
– “social repair”

Core rule:

yaml id=”societyos-imitations-core-rule”
CORE_RULE:
“Not every human group is a society. A society begins when human beings carry shared life across time through trust, rule, memory, protection, repair, and transmission.”

			
---
# 13. Society Contact Model

yaml id=”societyos-contact-model”
SOCIETY_CONTACT_MODEL:
SCON0:
name: “No contact”
meaning: “No social relation exists.”

SCON1:
name: “Surface contact”
meaning: “People encounter one another.”

SCON2:
name: “Recognition”
meaning: “People begin recognising one another.”

SCON3:
name: “Repeated interaction”
meaning: “Patterns begin repeating.”

SCON4:
name: “Memory forms”
meaning: “Past action begins to matter.”

SCON5:
name: “Rules appear”
meaning: “Allowed and forbidden behaviour begins to stabilise.”

SCON6:
name: “Roles and duties form”
meaning: “People carry functions and obligations.”

SCON7:
name: “Trust and protection appear”
meaning: “People can rely on basic safety and expectation.”

SCON8:
name: “Repair becomes possible”
meaning: “Damage can be corrected.”

SCON9:
name: “Transmission across time”
meaning: “The system passes itself forward.”

Public explanation:

yaml id=”societyos-contact-public”
PUBLIC_EXPLANATION:
“A society does not form the moment people meet. Society deepens when recognition, repetition, memory, rules, roles, trust, protection, repair, and transmission appear across time.”

			
---
# 14. Society Time-Slice Model

yaml id=”societyos-time-slice”
SOCIETY_TIME_SLICE_MODEL:
rule:
“One moment shows social appearance. Many moments show social direction.”

time_slices:
T0: “First contact”
T1: “Repeated recognition”
T2: “Memory appears”
T3: “Rules stabilise”
T4: “Roles and institutions form”
T5: “Protection and trust are tested”
T6: “Damage occurs”
T7: “Repair or denial”
T8: “Transmission to next generation”
T9: “Continuity, decay, or inversion becomes visible”

core_line:
“Society is not only what it looks like now. Society is what it carries forward.”

			
---
# 15. Phase 4 Internal Overlay for SocietyOS

yaml id=”societyos-phase-4-overlay”
PHASE_4_INTERNAL_OVERLAY:
status: “Internal / technical only unless user asks.”
society_equivalent:
“High-continuity or regenerative social condition where trust, institutions, education, family floors, public language, and repair capacity produce surplus social resilience without consuming the base.”

valid_when:
– “base social shell is at least C2 functional / zero-tilt”
– “many key organs are FN4-FN5”
– “repair is RP4-RP5”
– “trust is TR4-TR5”
– “trajectory is T+ or stable T0 with strong buffers”
– “young inherit viable future corridors”
– “social surplus strengthens the base instead of extracting from it”

invalid_when:
– “society is tilted but calling itself advanced”
– “frontier ambition consumes children, families, trust, or education”
– “public language hides social damage”
– “institutions protect image over function”
– “repair is weaker than drift”
– “P4 is used as prestige label”

public_translation:
– “high-continuity society”
– “regenerative society”
– “deep repair society”
– “future-carrying society”

			
---
# 16. Standard SocietyOS Output Format

yaml id=”societyos-output-format”
STANDARD_SOCIETYOS_OUTPUT:
1_observed_system:
required:
– “system name”
– “scale”
– “boundary”
– “reason for classification”

2_native_society_id:
required:
– “SOC ID”
– “meaning”
– “condition class”

3_civos_overlay_id:
required:
– “CivOS overlay”
– “Z/P/T/L/R/K reading”
– “derived civilisation condition”

4_diagnostic_reading:
required:
– “trust”
– “function integrity”
– “repair capacity”
– “trajectory”
– “failure classes if any”

5_repair_or_watch:
required:
– “protect”
– “repair”
– “watch”
– “upgrade”
– “downgrade”
– “hold”

			
---
# 17. Public Article Translation

yaml id=”societyos-public-translation”
PUBLIC_TRANSLATION:
SOC.L:
public_phrase: “scale of the society being read”

SC:
public_phrase: “how complete the social shell is”

TR:
public_phrase: “how much trust the system can carry”

FN:
public_phrase: “whether social organs are doing their proper work”

RP:
public_phrase: “how well the society repairs damage”

C:
public_phrase: “the society condition”

T:
public_phrase: “whether the society is improving, stable, weakening, or volatile”

K:
public_phrase: “how confident the reading is”

CIVOS_OVERLAY:
public_phrase: “how the society affects civilisation continuity”

			
---
# 18. Article Runtime Lock

yaml id=”societyos-runtime-lock”
RUNTIME_LOCK:
locked_decisions:
– “SocietyOS uses SOC-SHELL-CLASS v1.1.”
– “Society is classified as a human social continuity shell, not species.”
– “Native SOC ID remains detailed and domain-specific.”
– “CivOS overlay places SocietyOS inside CivilisationOS.”
– “Default CivOS overlay is CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.”
– “Do not confuse inverted society with below-threshold society.”
– “Do not confuse crowd, population, market, platform, state, or order with society.”
– “High-continuity society is the public-facing positive advanced class.”
– “Phase 4 society reading stays internal unless requested.”

next_article:
article_number: 3
title: “CultureOS Shell-State Classification System v1.1”
prompt_to_continue:
“Next”

			
---
# 19. Short AI Memory Version

yaml id=”societyos-short-memory”
SHORT_MEMORY:
“SocietyOS v1.1 classifies society as a human social continuity shell. Native format: SOC.[L0-L6].[SC0-SC5].[TR0-TR5].[FN0-FN5].[RP0-RP5].[C0-C10].[T+/T0/T-/TX].[K1-K5]. Default CivOS overlay: CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]. Condition classes: C0 Pre-Society Contact, C1 Emerging, C2 Functional/Zero-Tilt, C3 Tilted, C4 Captured, C5 Inverted, C6 Below-Threshold, C7 Repairing, C8 Decaying, C9 Fragmented, C10 High-Continuity. Inverted society means organs remain but reverse. Below-threshold means the minimum floor is broken.”
“`

Article 3 of 7

CultureOS Shell-State Classification System v1.1

Full Code Aligned to CivilisationOS Parent Shell-Lattice

Full Code for AI Runtime

“`yaml id=”cultureos-v1-1-header”
ARTICLE_ID: “EKSG.FULLCLASSSTACK.CULTUREOS.SHELL-STATE-CLASS.v1.1”
ARTICLE_NUMBER: 3
STACK_TOTAL: 7

TITLE: “CultureOS Shell-State Classification System v1.1”
SUBTITLE: “Full Code Aligned to CivilisationOS Parent Shell-Lattice”
PUBLIC_OR_INTERNAL: “Full Code for AI Runtime”
AUTHOR_CONTEXT: “eduKateSG”

RUNTIME_TRIGGER:
SIMPLE_TRIGGER:
– “Use CultureOS classification”
– “Use Culture Shell-State Classification”
– “Classify culture”
– “What is culture”
– “What type of culture is this”
– “Use CULT-SHELL-CLASS”
– “Use CultureOS with CivOS overlay”
– “Classify culture by shell-state”
– “Use eduKateSG Full Classification Stack”

FULL_TRIGGER:
“Use eduKateSG CultureOS Shell-State Classification System v1.1 aligned to CivilisationOS parent shell-lattice. First classify the cultural system using the native CULT ID, then translate upward into the CivOS overlay ID. Use PEN0-PEN6 for culture penetration, never P0-P6, because CivOS reserves P0-P4 for phase. Preserve reader-facing clarity if writing public article, and expose full IDs only when full-code or technical output is requested.”

SURFACE_RULE:
reader_facing:
– “Do not overuse IDs.”
– “Use words like culture condition, meaning shell, memory, practice, transmission, participation, and repair.”
– “Avoid saying culture species.”
– “Do not expose Phase 4 mechanics unless explicitly requested.”
code_facing:
– “Expose native CULT ID.”
– “Expose CivOS overlay ID.”
– “Use PEN for penetration.”
– “Include culture axes, condition classes, failure classes, contact model, time slices, examples, and repair sequence.”

			
---
# 1. Canonical Name

yaml id=”cultureos-canon-v1-1″
CANONICAL_NAME:
“eduKateSG CultureOS Shell-State Classification System v1.1”

SHORT_NAME:
“CULT-SHELL-CLASS v1.1”

SYSTEM_TYPE:
“CultureOS”

UNIT_OF_ANALYSIS:
“Human meaning-transmission system”

PARENT_CIVOS_ROLE:
“Memory / meaning / identity / transmission shell”

DEFAULT_CIVOS_OVERLAY:
“CIVOS.MEMORY-SHELL.CULTURE”

CORE_LINE:
“Culture is not merely what people like. Culture is what people repeat with meaning, remember with emotion, practise through life, and transmit across time.”

PUBLIC_DEFINITION:
“Culture is a continuing meaning-transmission system where people share symbols, memory, practices, habits, values, stories, rituals, aesthetics, emotional codes, and ways of interpreting life across time.”

NOT_CULTURE_DEFINITION:
“A thing is not yet culture when it is only a trend, preference, fashion, signal, meme, performance, or isolated behaviour without enough memory, repetition, meaning, participation, transmission, and social embedding.”

IMPORTANT_CORRECTION:
old_axis: “P0-P6 for penetration”
new_axis: “PEN0-PEN6 for penetration”
reason: “CivOS already reserves P0-P4 for phase.”

			
---
# 2. Native CultureOS ID Format

yaml id=”cultureos-native-id-format”
NATIVE_CULTURE_ID:
formula:
“CULT.[LEVEL].[SHELL_COMPLETENESS].[DEPTH].[PENETRATION].[VALENCE].[CONDITION].[TRAJECTORY].[CONFIDENCE]”

full_format:
“CULT.[L0-L6].[CSC0-CSC5].[D0-D5].[PEN0-PEN6].[V+/V0/V-/VI/VM].[CC0-CC10].[T+/T0/T-/TX].[K1-K5]”

example:
id: “CULT.L3.CSC4.D3.PEN2.V+.CC2.T0.K4”
meaning: “Community-level mature culture shell, practitioner depth, local/community penetration, positive valence, functional living culture, stable trajectory, high confidence.”

forbidden_format:
“CULT.[L].[CSC].[D].[P0-P6].[V].[CC].[T].[K]”

warning:
“Do not use P for culture penetration. Use PEN.”

			
---
# 3. CivOS Overlay ID Format

yaml id=”cultureos-civos-overlay-format”
CIVOS_OVERLAY_ID:
formula:
“CIVOS.MEMORY-SHELL.CULTURE.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

example:
id: “CIVOS.MEMORY-SHELL.CULTURE.Z3.P2.T6.LPOS.R3.K4”
meaning: “Network/community-scale civilisation memory shell, culture subsystem, repair-capable phase, medium horizon, positive lattice, workable repair, high confidence.”

ALIGNMENT_RULE:

“Use native CULT ID for cultural-system detail.”
“Use CivOS overlay ID to place the culture reading inside civilisation’s memory/meaning shell.”
“Do not replace CULT ID with CivOS ID.”
“Use PEN for penetration to prevent conflict with CivOS phase.”

			
---
# 4. CultureOS Axes
## Axis 1 — Level

yaml id=”cultureos-level-axis”
CULTURE_LEVEL:
L0:
name: “Object / symbol / word / gesture”
examples:
– “word”
– “symbol”
– “gesture”
– “colour”
– “song fragment”
– “food item”
– “ritual object”

L1:
name: “Individual habit / personal cultural imprint”
examples:
– “personal memory”
– “individual habit”
– “childhood imprint”
– “private cultural association”

L2:
name: “Family / small group culture”
examples:
– “family ritual”
– “household food tradition”
– “small group custom”
– “friend group language”

L3:
name: “Community / school / workplace / subculture”
examples:
– “school culture”
– “workplace culture”
– “local community culture”
– “online subculture”
– “music subculture”

L4:
name: “City / regional culture”
examples:
– “regional dialect”
– “city food culture”
– “regional festival”
– “local arts scene”

L5:
name: “National culture”
examples:
– “national holiday”
– “national language culture”
– “national memory”
– “national rituals”

L6:
name: “Civilisational / global culture”
examples:
– “civilisational heritage”
– “global language culture”
– “world religion”
– “global media culture”
– “planetary youth culture”

			
---
## Axis 2 — Culture Shell Completeness

yaml id=”cultureos-shell-completeness”
CULTURE_SHELL_COMPLETENESS:
CSC0:
name: “No culture shell”
meaning: “A signal exists but has no meaningful cultural layer.”

CSC1:
name: “Signal shell only”
meaning: “A sign, behaviour, image, phrase, or trend appears, but meaning has not stabilised.”

CSC2:
name: “Emerging culture shell”
meaning: “Repeated recognition, imitation, and emotional association begin.”

CSC3:
name: “Basic culture shell”
meaning: “Symbol, practice, story, value, and participation exist at basic level.”

CSC4:
name: “Mature culture shell”
meaning: “Memory, practice, emotion, ritual, values, participation, and transmission are organised.”

CSC5:
name: “Deep heritage / civilisational culture shell”
meaning: “Culture carries deep memory, identity, and continuity across generations.”

### Culture Shell Layers

yaml id=”cultureos-shell-layers”
CULTURE_SHELL_LAYERS:
boundary:
question: “Who recognises, belongs to, performs, or carries this culture?”
failure: “Belonging is unclear, performative, or externally imposed.”

symbol:
question: “What signs, objects, sounds, colours, words, or gestures carry meaning?”
failure: “Symbols are visible but empty or misunderstood.”

practice:
question: “What is repeated?”
failure: “The culture is named but not practised.”

memory:
question: “What past is carried?”
failure: “The culture has symbols without memory.”

emotion:
question: “What feelings are activated?”
failure: “The emotional code is missing, flattened, or replaced by performance.”

story:
question: “What narrative explains the meaning?”
failure: “People know the ritual but not the story.”

ritual:
question: “What repeated acts preserve the meaning?”
failure: “The ritual continues but becomes empty.”

aesthetics:
question: “What visual, musical, linguistic, or sensory style belongs to it?”
failure: “The aesthetic is copied without meaning.”

values:
question: “What is honoured, shameful, sacred, funny, beautiful, or wrong?”
failure: “The value code is inverted, flattened, or lost.”

participation:
question: “Who only watches, and who embodies the culture?”
failure: “Culture becomes audience consumption only.”

transmission:
question: “How is it passed to others?”
failure: “The young receive symbols but not meaning.”

repair:
question: “Can the culture correct harmful drift?”
failure: “Damaging meanings become normalised.”

continuity:
question: “Can it survive across time?”
failure: “The culture cannot transmit beyond one generation.”

			
---
## Axis 3 — Depth of Participation

yaml id=”cultureos-depth-axis”
CULTURE_DEPTH:
D0:
name: “No contact”
meaning: “The person or group has no meaningful contact with the culture.”

D1:
name: “Surface recognition”
meaning: “The culture is recognised as a symbol, name, sound, image, or marker.”

D2:
name: “Audience / appreciation”
meaning: “The culture is enjoyed, watched, consumed, or appreciated, but not deeply practised.”

D3:
name: “Participant / practitioner”
meaning: “The person or group participates in practices and understands basic meaning.”

D4:
name: “Embodied insider”
meaning: “The culture is carried as lived memory, habit, emotion, role, and identity.”

D5:
name: “Keeper / teacher / transmitter”
meaning: “The person or group can preserve, teach, adapt, and transmit the culture forward.”

Depth note:

yaml id=”cultureos-depth-note”
DEPTH_NOTE:
rule:
“Visibility is not depth.”
example:
“A festival may be globally recognised at D1/D2 by outsiders, but carried at D4/D5 by insiders.”

			
---
## Axis 4 — Penetration

yaml id=”cultureos-penetration-axis”
CULTURE_PENETRATION:
PEN0:
name: “Private / individual”
meaning: “The cultural meaning exists mainly at personal level.”

PEN1:
name: “Family / small circle”
meaning: “The culture is carried within family or small group.”

PEN2:
name: “Local / community”
meaning: “The culture is carried by a local community.”

PEN3:
name: “Regional / subculture”
meaning: “The culture has regional or subcultural spread.”

PEN4:
name: “National”
meaning: “The culture is recognised or practised at national level.”

PEN5:
name: “International”
meaning: “The culture has cross-border recognition or participation.”

PEN6:
name: “Global / civilisational”
meaning: “The culture has global or civilisation-scale reach.”

Penetration note:

yaml id=”cultureos-penetration-note”
PENETRATION_NOTE:
rule:
“Depth and penetration are not the same.”
global_shallow:
id_pattern: “D1/D2 + PEN6”
meaning: “Many people recognise it, but few embody it.”
local_deep:
id_pattern: “D4/D5 + PEN1/PEN2”
meaning: “Few people carry it, but those who do carry it deeply.”

			
---
## Axis 5 — Valence

yaml id=”cultureos-valence-axis”
CULTURE_VALENCE:
V+:
name: “Positive culture”
meaning: “Strengthens trust, meaning, care, responsibility, beauty, wisdom, courage, continuity, and repair.”

V0:
name: “Neutral / technical / low-valence culture”
meaning: “Mainly technical, aesthetic, recreational, administrative, or low moral load.”

V-:
name: “Negative culture”
meaning: “Damages trust, health, truth, responsibility, dignity, learning, or repair capacity.”

VI:
name: “Inverse culture”
meaning: “Uses cultural legitimacy to produce the opposite of healthy cultural function.”

VM:
name: “Mixed / contested culture”
meaning: “Contains strengthening and damaging elements depending on context, use, time, and interpretation.”

Valence rule:

yaml id=”cultureos-valence-rule”
VALENCE_RULE:
“Culture valence must be read relative to a named context, time, function, and affected group. Do not label culture positive or negative without defining what function is being measured.”

			
---
## Axis 6 — Culture Condition Class

yaml id=”cultureos-condition-class”
CULTURE_CONDITION_CLASS:
CC0: “Pre-Culture Signal”
CC1: “Emerging Culture”
CC2: “Functional / Living Culture”
CC3: “Thin Culture”
CC4: “Tilted Culture”
CC5: “Captured Culture”
CC6: “Inverted Culture”
CC7: “Fragmented Culture”
CC8: “Decaying Culture”
CC9: “Repairing / Reviving Culture”
CC10: “Heritage Culture”

			
---
## Axis 7 — Trajectory

yaml id=”cultureos-trajectory-axis”
TRAJECTORY:
T+:
name: “Strengthening / reviving”
meaning: “Meaning, practice, memory, participation, or transmission are improving.”

T0:
name: “Stable / no clear movement”
meaning: “No strong directional change is visible.”

T-:
name: “Weakening / thinning”
meaning: “Depth, memory, practice, transmission, or meaning are weakening.”

TX:
name: “Volatile / unclear”
meaning: “Direction is unstable, contested, fast-changing, or insufficiently evidenced.”

			
---
## Axis 8 — Confidence

yaml id=”cultureos-confidence-axis”
CONFIDENCE:
K1:
name: “Low confidence”
meaning: “Evidence is weak, speculative, or based on surface observation.”

K2:
name: “Limited confidence”
meaning: “Some evidence exists, but cultural meaning or scope is uncertain.”

K3:
name: “Medium confidence”
meaning: “Evidence is plausible and structured, but not strong enough for high confidence.”

K4:
name: “High confidence”
meaning: “Evidence is strong, repeated, and supported by participation, memory, or transmission patterns.”

K5:
name: “Very high confidence”
meaning: “Evidence is deep, multi-generational, well-documented, and validated by carriers or primary cultural sources.”

			
---
# 5. Culture Condition Classes
## CC0 — Pre-Culture Signal

yaml id=”cultureos-cc0″
CC0_PRE_CULTURE_SIGNAL:
id: “CULT.CC0.PRE_SIGNAL”
status: “Not yet culture”
core_signal: “A signal appears, but has not become repeated meaning.”
signs:
– “single meme”
– “one-off gesture”
– “unembedded trend”
– “phrase without stable meaning”
– “image without memory”
– “fashion before shared practice”
key_question:
“Does this signal become repeated, meaningful, and transmissible?”

			
---
## CC1 — Emerging Culture

yaml id=”cultureos-cc1″
CC1_EMERGING_CULTURE:
id: “CULT.CC1.EMERGING”
status: “Beginning culture”
core_signal: “Repeated meaning begins forming around a group.”
signs:
– “people repeat it”
– “people recognise it”
– “emotion attaches”
– “imitation begins”
– “insider/outsider boundary forms”
– “a story begins explaining the meaning”
key_question:
“Is repeated recognition turning into shared meaning?”

			
---
## CC2 — Functional / Living Culture

yaml id=”cultureos-cc2″
CC2_FUNCTIONAL_LIVING_CULTURE:
id: “CULT.CC2.LIVING”
status: “Healthy living culture”
core_signal: “Meaning, practice, memory, and transmission are alive.”
signs:
– “memory is carried”
– “belonging is created”
– “behaviour is shaped”
– “meaning is transmitted”
– “identity is formed”
– “values are taught”
– “the culture can adapt without losing its core”
key_question:
“Is the culture alive in practice, not only visible in symbol?”

			
---
## CC3 — Thin Culture

yaml id=”cultureos-cc3″
CC3_THIN_CULTURE:
id: “CULT.CC3.THIN”
status: “Visible but shallow”
core_signal: “Recognition exists, but depth is weak.”
signs:
– “symbol known but story forgotten”
– “ritual performed without meaning”
– “style copied without memory”
– “phrase repeated without depth”
– “culture consumed but not embodied”
note:
“Thin culture is not always bad. It can be an entry point. It becomes dangerous when all depth is lost.”
key_question:
“Is this culture becoming visible but hollow?”

			
---
## CC4 — Tilted Culture

yaml id=”cultureos-cc4″
CC4_TILTED_CULTURE:
id: “CULT.CC4.TILTED”
status: “Uneven culture”
core_signal: “Some meanings dominate while others are suppressed, ignored, or overloaded.”
signs:
– “some voices become central”
– “some memories are excluded”
– “some histories disappear”
– “some practices are valued while others are mocked”
– “some people are told they belong less”
key_question:
“Can the culture rebalance without destroying itself?”

			
---
## CC5 — Captured Culture

yaml id=”cultureos-cc5″
CC5_CAPTURED_CULTURE:
id: “CULT.CC5.CAPTURED”
status: “Culture controlled by narrower interest”
core_signal: “Culture is used to serve power, profit, ideology, status, or control.”
capture_agents:
– “money”
– “politics”
– “ideology”
– “fashion markets”
– “platforms”
– “status groups”
– “tourism”
– “entertainment industries”
– “national branding”
– “identity performance”
– “attention algorithms”
signs:
– “meaning is subordinated to profit or power”
– “culture becomes branding”
– “outsiders consume while insiders lose ownership”
– “aesthetic survives but memory weakens”
– “heritage is flattened into product”
key_question:
“Who benefits from this cultural framing?”

			
---
## CC6 — Inverted Culture

yaml id=”cultureos-cc6″
CC6_INVERTED_CULTURE:
id: “CULT.CC6.INVERTED”
status: “Culture whose function has reversed”
core_signal: “Culture uses meaning to normalise what damages life.”
signs:
– “cruelty becomes funny”
– “emptiness becomes stylish”
– “humiliation becomes entertainment”
– “addiction becomes identity”
– “irresponsibility becomes cool”
– “deception becomes clever”
– “wisdom is mocked”
– “repair is treated as weakness”
– “dignity is lowered”
distinction:
“Inverted culture is not simply bad taste. It is function reversal.”
key_question:
“Is culture strengthening life, or using meaning to normalise damage?”

			
---
## CC7 — Fragmented Culture

yaml id=”cultureos-cc7″
CC7_FRAGMENTED_CULTURE:
id: “CULT.CC7.FRAGMENTED”
status: “Culture split into weak or hostile fragments”
core_signal: “Shared meaning breaks into disconnected shells.”
signs:
– “groups no longer understand one another”
– “generations cannot translate memories”
– “subcultures become hostile”
– “words carry different meanings across groups”
– “shared rituals weaken”
– “public symbols no longer unite”
warning:
“Fragmentation can create creativity and diversity. It becomes dangerous when translation, trust, and shared meaning fail.”

			
---
## CC8 — Decaying Culture

yaml id=”cultureos-cc8″
CC8_DECAYING_CULTURE:
id: “CULT.CC8.DECAYING”
status: “Culture losing meaning faster than it is renewed”
core_signal: “Symbols remain, but memory and transmission weaken.”
signs:
– “rituals become empty”
– “language becomes shallow”
– “art becomes repetitive without meaning”
– “traditions are performed without understanding”
– “memory becomes decorative”
– “young inherit symbols but not depth”
– “elders carry memory but cannot transmit it”
– “culture becomes museum shell or entertainment product”
key_question:
“Is the cultural shell visible while its carrying power weakens?”

			
---
## CC9 — Repairing / Reviving Culture

yaml id=”cultureos-cc9″
CC9_REPAIRING_REVIVING_CULTURE:
id: “CULT.CC9.REPAIRING”
status: “Culture being restored, reinterpreted, or strengthened”
core_signal: “Meaning returns through teaching, practice, memory, and renewal.”
signs:
– “lost practices are relearned”
– “stories are retold with care”
– “rituals regain meaning”
– “elders and young reconnect”
– “language is repaired”
– “symbols are explained”
– “harmful drift is corrected”
– “old forms adapt without being emptied”
key_question:
“Is meaning returning strongly enough to transmit forward?”

			
---
## CC10 — Heritage Culture

yaml id=”cultureos-cc10″
CC10_HERITAGE_CULTURE:
id: “CULT.CC10.HERITAGE”
status: “Deep memory culture”
core_signal: “Culture has survived across generations and carries identity, memory, and continuity.”
examples:
– “living heritage”
– “ritual heritage”
– “language heritage”
– “food heritage”
– “craft heritage”
– “religious heritage”
– “family heritage”
– “national heritage”
– “civilisational heritage”
note:
“Heritage culture can be healthy, thin, captured, decaying, or repairing depending on its current state. Pair CC10 with valence and trajectory.”
key_question:
“Is this heritage living, thinning, captured, decaying, or being renewed?”

			
---
# 6. CultureOS Movement Map

yaml id=”cultureos-movement-map”
CULTURE_MOVEMENT_MAP:
upward_route:
– “CC0 Pre-Culture Signal”
– “CC1 Emerging Culture”
– “CC2 Living Culture”
– “CC10 Heritage Culture”

weakening_route:
– “CC2 Living Culture”
– “CC3 Thin Culture”
– “CC4 Tilted Culture”
– “CC5 Captured Culture”
– “CC6 Inverted Culture”
– “CC7 Fragmented Culture”
– “CC8 Decaying Culture”

repair_route:
– “CC3 / CC5 / CC6 / CC7 / CC8”
– “meaning recovered”
– “practice relearned”
– “memory reconnected”
– “elders and young re-linked”
– “transmission restored”
– “CC9 Repairing / Reviving Culture”
– “CC2 Living Culture”
– “CC10 Heritage Culture”

			
---
# 7. Culture Failure Classes

yaml id=”cultureos-failure-classes”
CULTURE_FAILURE_CLASSES:
CF0:
name: “No symbol integrity”
meaning: “The symbol no longer carries stable meaning.”

CF1:
name: “Memory loss”
meaning: “The culture forgets its stories, origins, or lived context.”

CF2:
name: “Practice loss”
meaning: “People name the culture but no longer practise it.”

CF3:
name: “Ritual hollowing”
meaning: “The ritual continues but meaning is absent.”

CF4:
name: “Transmission failure”
meaning: “The young do not receive the culture deeply.”

CF5:
name: “Audience-only culture”
meaning: “Culture becomes something watched or consumed, not embodied.”

CF6:
name: “Commercial capture”
meaning: “Culture is flattened into product, branding, or market display.”

CF7:
name: “Ideological capture”
meaning: “Culture is bent toward a political or ideological purpose.”

CF8:
name: “Translation failure”
meaning: “Groups cannot interpret one another’s cultural meanings.”

CF9:
name: “Generational fracture”
meaning: “Older and younger carriers cannot pass memory across.”

CF10:
name: “Valence inversion”
meaning: “Culture normalises what damages life.”

CF11:
name: “Heritage museumification”
meaning: “Heritage remains visible but no longer lives in practice.”

CF12:
name: “Repair failure”
meaning: “Culture cannot correct harmful drift.”

Failure class append example:

yaml id=”cultureos-failure-example”
FAILURE_APPEND_EXAMPLE:
id:
“CULT.L5.CSC5.D2.PEN4.VM.CC5.T-.K3 + CF6 + CF11”
meaning:
“National deep culture shell, mostly audience depth, national penetration, mixed valence, captured culture, deteriorating, with commercial capture and heritage museumification.”

			
---
# 8. Culture Repair Sequence

yaml id=”cultureos-repair-sequence”
CULTURE_REPAIR_SEQUENCE:
step_1_notice:
action: “Recognise cultural thinning, capture, fragmentation, inversion, or decay.”
diagnostic_questions:
– “What symbol remains but no longer carries meaning?”
– “Which memory is missing?”
– “Who still practises this culture?”
– “Who only consumes it?”
– “What is not being transmitted?”

step_2_name:
action: “Classify the cultural condition accurately.”
possible_damage:
– “thin culture”
– “tilted culture”
– “captured culture”
– “inverted culture”
– “fragmented culture”
– “decaying culture”
– “heritage shell without living practice”
rule:
“Bad naming creates bad cultural repair.”

step_3_reconnect_memory:
action: “Recover story, origin, lived experience, and emotional code.”
protected_parts:
– “elders”
– “language”
– “ritual meaning”
– “origin stories”
– “family memory”
– “community memory”
– “historical context”

step_4_restore_practice:
action: “Move culture from symbol-only to practised meaning.”
examples:
– “teach ritual steps”
– “explain stories”
– “practise songs, food, crafts, language, or ceremonies”
– “restore family participation”
– “create real occasions for use”

step_5_repair_transmission:
action: “Reconnect children, youth, newcomers, and future carriers.”
success_signal:
“The next generation can explain, practise, and adapt the culture without emptying it.”

step_6_correct_harmful_drift:
action: “Separate life-giving meaning from damaging, captured, or inverted uses.”
warning:
“Cultural repair does not mean freezing culture. It means preserving living meaning while correcting damage.”

step_7_repeat:
action: “Repeat practice long enough for culture to live again.”

			
---
# 9. CultureOS Classification Sequence

yaml id=”cultureos-classification-sequence”
CULTURE_CLASSIFICATION_SEQUENCE:
step_1_define_unit:
question: “What cultural unit are we classifying?”
examples:
– “word”
– “symbol”
– “ritual”
– “festival”
– “language”
– “family practice”
– “food tradition”
– “music genre”
– “fashion style”
– “online meme”
– “workplace culture”
– “school culture”
– “national culture”
– “civilisational heritage”

step_2_define_boundary:
question: “Who recognises, belongs to, performs, or carries this culture?”

step_3_check_shell_layers:
question: “Does it have symbol, memory, practice, emotion, story, value, participation, transmission, repair, and continuity?”

step_4_assign_level:
question: “What level is the culture shell operating at?”
output: “L0-L6”

step_5_assign_shell_completeness:
question: “How complete is the culture shell?”
output: “CSC0-CSC5”

step_6_assign_depth:
question: “Is it only recognised, appreciated, practised, embodied, or transmitted?”
output: “D0-D5”

step_7_assign_penetration:
question: “How far has it spread?”
output: “PEN0-PEN6”

step_8_assign_valence:
question: “Does it strengthen, neutralise, damage, invert, or mix meaning?”
output: “V+ / V0 / V- / VI / VM”

step_9_assign_condition_class:
question: “Which culture condition class best fits?”
output: “CC0-CC10”

step_10_assign_trajectory:
question: “Is it strengthening, stable, weakening, or volatile?”
output: “T+ / T0 / T- / TX”

step_11_assign_confidence:
question: “How strong is the evidence?”
output: “K1-K5”

step_12_output_native_id:
format: “CULT.[L].[CSC].[D].[PEN].[V].[CC].[T].[K]”

step_13_translate_to_civos_overlay:
format: “CIVOS.MEMORY-SHELL.CULTURE.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

step_14_derive_condition:
output:
– “culture condition”
– “CivOS memory-shell condition”
– “failure classes if any”
– “repair/watch recommendation”

			
---
# 10. Native-to-CivOS Translation Guide

yaml id=”cultureos-native-to-civos”
NATIVE_TO_CIVOS_TRANSLATION:
level_to_zoom:
L0: “Z0”
L1: “Z0-Z1”
L2: “Z1”
L3: “Z2-Z3”
L4: “Z4”
L5: “Z5”
L6: “Z6”

shell_to_phase_guidance:
CSC0: “usually P0”
CSC1: “usually P0-P1”
CSC2: “usually P1-P2”
CSC3: “usually P2”
CSC4: “usually P2-P3”
CSC5: “usually P3 or P4 only if regenerative transmission exists”

condition_to_lattice_guidance:
CC0: “LNEU or LNEG depending on risk”
CC1: “LNEU or LPOS if stabilising”
CC2: “LPOS”
CC3: “LNEU or LNEG”
CC4: “LNEU or LNEG”
CC5: “LNEG or LINV”
CC6: “LINV”
CC7: “LNEU or LNEG”
CC8: “LNEG”
CC9: “LPOS”
CC10: “LPOS if living, LNEU/LNEG if museumified or captured”

depth_to_repair_guidance:
D0: “R0”
D1: “R1 if no transmission”
D2: “R1-R2”
D3: “R2-R3”
D4: “R3-R4”
D5: “R4-R5”

valence_to_lattice_guidance:
V+: “LPOS”
V0: “LNEU”
V-: “LNEG”
VI: “LINV”
VM: “requires contextual reading”

confidence_translation:
K1: “K1”
K2: “K2”
K3: “K3”
K4: “K4”
K5: “K5”

			
---
# 11. Example Classifications
## Example 1 — Global Meme

yaml id=”cultureos-example-meme”
EXAMPLE_1_GLOBAL_MEME:
observed_system:
type: “global meme”
level: “L6”
reason: “A signal is globally visible but may not have deep memory or transmission.”

native_id:
id: “CULT.L6.CSC1.D1.PEN6.V0.CC0.TX.K3”
meaning: “Global signal shell, surface recognition, global penetration, neutral valence, pre-culture signal, volatile direction, medium confidence.”

civos_overlay:
id: “CIVOS.MEMORY-SHELL.CULTURE.Z6.P1.T1.LNEU.R1.K3”
meaning: “Civilisation-scale culture memory shell, fragile signal phase, short horizon, neutral lattice, weak repair/transmission, medium confidence.”

derived_condition:
– “CULT.CC0.PRE_SIGNAL”
– “CIV.SIGNAL-NOT-LIVING-CULTURE”

warning:
“Global reach should not be mistaken for cultural depth.”

			
---
## Example 2 — Family Tradition

yaml id=”cultureos-example-family-tradition”
EXAMPLE_2_FAMILY_TRADITION:
observed_system:
type: “family tradition”
level: “L2”
reason: “Repeated practice with memory, emotion, participation, and transmission.”

native_id:
id: “CULT.L2.CSC4.D4.PEN1.V+.CC2.T0.K4”
meaning: “Family-level mature culture shell, embodied insider depth, family penetration, positive living culture, stable, high confidence.”

civos_overlay:
id: “CIVOS.MEMORY-SHELL.CULTURE.Z1.P3.T6.LPOS.R4.K4”
meaning: “Family-scale civilisation memory shell, stable phase, medium horizon, positive lattice, strong repair/transmission, high confidence.”

derived_condition:
– “CULT.CC2.LIVING”
– “CIV.POSITIVE-MEMORY-SHELL”

			
---
## Example 3 — National Festival Becoming Commercialised

yaml id=”cultureos-example-festival-captured”
EXAMPLE_3_COMMERCIALISED_NATIONAL_FESTIVAL:
observed_system:
type: “national festival”
issue: “High visibility but meaning is increasingly flattened into commerce and branding.”

derived_condition:
– “CULT.CC5.CAPTURED”
– “CIV.CAPTURED-MEMORY-SHELL-RISK”

failure_classes:
– “CF6 Commercial capture”
– “CF11 Heritage museumification”

			
---
## Example 4 — Dying Language Tradition Being Revived

yaml id=”cultureos-example-language-revival”
EXAMPLE_4_LANGUAGE_REVIVAL:
observed_system:
type: “regional language tradition”
issue: “A weakening language tradition is being relearned and transmitted.”

native_id:
id: “CULT.L4.CSC4.D3.PEN2.V+.CC9.T+.K4”
meaning: “Regional mature culture shell, practitioner depth, local penetration, positive repairing culture, improving, high confidence.”

civos_overlay:
id: “CIVOS.MEMORY-SHELL.CULTURE.Z4.P2.T6.LPOS.R4.K4”
meaning: “Regional civilisation memory shell, repair-capable phase, medium horizon, positive lattice, strong repair, high confidence.”

derived_condition:
– “CULT.CC9.REPAIRING”
– “CIV.REPAIRING-MEMORY-SHELL”

			
---
## Example 5 — Destructive Subculture

yaml id=”cultureos-example-destructive-subculture”
EXAMPLE_5_DESTRUCTIVE_SUBCULTURE:
observed_system:
type: “destructive subculture”
issue: “Meaning system normalises harm, irresponsibility, humiliation, or self-destruction.”

native_id:
id: “CULT.L3.CSC3.D3.PEN3.V-.CC6.T-.K3”
meaning: “Subculture-level basic culture shell, participant depth, regional/subculture penetration, negative inverted culture, deteriorating, medium confidence.”

civos_overlay:
id: “CIVOS.MEMORY-SHELL.CULTURE.Z3.P1.T3.LINV.R1.K3”
meaning: “Network/community-scale civilisation memory shell, fragile phase, short-medium horizon, inverse lattice, weak repair, medium confidence.”

derived_condition:
– “CULT.CC6.INVERTED”
– “CIV.INVERTED-CULTURE-SHELL”

failure_classes:
– “CF10 Valence inversion”
– “CF12 Repair failure”

			
---
## Example 6 — Deep Heritage Culture With Living Transmission

yaml id=”cultureos-example-heritage-living”
EXAMPLE_6_LIVING_HERITAGE:
observed_system:
type: “deep heritage culture”
issue: “Culture remains practised, embodied, and transmitted across generations.”

native_id:
id: “CULT.L5.CSC5.D5.PEN4.V+.CC10.T0.K5”
meaning: “National deep heritage culture shell, keeper/transmitter depth, national penetration, positive valence, heritage culture, stable, very high confidence.”

civos_overlay:
id: “CIVOS.MEMORY-SHELL.CULTURE.Z5.P3.T25.LPOS.R5.K5”
meaning: “Nation-scale civilisation memory shell, stable phase, long horizon, positive lattice, adaptive regenerative repair/transmission, very high confidence.”

derived_condition:
– “CULT.CC10.HERITAGE”
– “CIV.STABLE-HIGH-CONTINUITY-MEMORY-SHELL”

			
---
# 12. Culture vs Its Imitations

yaml id=”cultureos-vs-imitations”
CULTURE_VS_IMITATION:
trend:
imitation: “culture”
missing:
– “memory”
– “transmission”
– “deep meaning”

fashion:
imitation: “identity”
missing:
– “deep meaning”
– “continuity”
– “repair”

meme:
imitation: “shared culture”
missing:
– “stable memory”
– “practice”
– “intergenerational transmission”

branding:
imitation: “heritage”
missing:
– “lived inheritance”
– “community ownership”

performance:
imitation: “belonging”
missing:
– “embodied participation”

tourism_display:
imitation: “tradition”
missing:
– “community-owned meaning”

algorithmic_feed:
imitation: “culture”
missing:
– “organic transmission”
– “responsibility”
– “repair”

nostalgia_product:
imitation: “memory”
missing:
– “living connection”
– “renewal”

Core rule:

yaml id=”cultureos-imitations-rule”
CORE_RULE:
“Not everything repeated is culture. It becomes culture only when repetition carries shared meaning, memory, participation, and transmission.”

			
---
# 13. Culture Contact Model

yaml id=”cultureos-contact-model”
CULTURE_CONTACT_MODEL:
CCON0:
name: “No contact”
meaning: “No cultural encounter exists.”

CCON1:
name: “Surface contact”
meaning: “A person or group encounters cultural signs at the surface.”

CCON2:
name: “Sensory contact”
meaning: “Smell, sound, taste, image, rhythm, or atmosphere begins to register.”

CCON3:
name: “Pattern recognition”
meaning: “Repeated forms begin to be recognised.”

CCON4:
name: “Translation begins”
meaning: “Meaning starts to be explained or interpreted.”

CCON5:
name: “Participation begins”
meaning: “The person or group begins practising or taking part.”

CCON6:
name: “Partial shell overlap”
meaning: “Shared cultural experience creates partial overlap.”

CCON7:
name: “Deep shell overlap”
meaning: “Memory, emotion, practice, and identity overlap deeply.”

CCON8:
name: “Transmission / carrying culture forward”
meaning: “The person or group can now transmit the culture.”

Public explanation:

yaml id=”cultureos-contact-public”
PUBLIC_EXPLANATION:
“When two people or groups meet, their cultures may not overlap immediately. They may only touch at the surface. Understanding grows when sensory memory, repeated pattern, translation, participation, and shared experience create deeper shell overlap.”

			
---
# 14. Culture Understanding Depth

yaml id=”cultureos-understanding-depth”
CULTURE_UNDERSTANDING_DEPTH:
U0:
name: “No understanding”
meaning: “No meaningful grasp of the culture.”

U1:
name: “Recognition”
meaning: “Can identify the culture or its symbols.”

U2:
name: “Appreciation”
meaning: “Can enjoy or respect the culture from outside.”

U3:
name: “Basic explanation”
meaning: “Can explain basic meaning, story, or practice.”

U4:
name: “Participation”
meaning: “Can participate appropriately.”

U5:
name: “Emotional memory overlap”
meaning: “Carries felt memory or shared lived association.”

U6:
name: “Embodied understanding”
meaning: “Understands culture through lived practice.”

U7:
name: “Transmission capability”
meaning: “Can teach, preserve, and pass the culture forward.”

			
---
# 15. Culture Time-Slice Model

yaml id=”cultureos-time-slice”
CULTURE_TIME_SLICE_MODEL:
rule:
“One moment shows cultural appearance. Many moments show cultural continuity, thinning, capture, decay, or repair.”

time_slices:
T0: “First contact”
T1: “Repeated recognition”
T2: “Practice forms”
T3: “Memory attaches”
T4: “Meaning stabilises”
T5: “Transmission begins”
T6: “Heritage, drift, capture, or decay appears”
T7: “Repair or hollowing becomes visible”
T8: “Next-generation carrying test”

core_line:
“Culture is not only what appears now. Culture is what meaning can survive and transmit through time.”

			
---
# 16. Phase 4 Internal Overlay for CultureOS

yaml id=”cultureos-phase-4-overlay”
PHASE_4_INTERNAL_OVERLAY:
status: “Internal / technical only unless user asks.”
culture_equivalent:
“Regenerative cultural condition where memory, practice, meaning, participation, and transmission are strong enough to renew themselves and create future cultural depth without emptying the base.”

valid_when:
– “culture shell is CSC4 or CSC5”
– “depth is D4-D5 among real carriers”
– “repair/transmission is strong”
– “valence is V+ or carefully bounded VM”
– “trajectory is T+ or stable with strong continuity”
– “young can inherit meaning, not just symbols”
– “innovation strengthens rather than hollows the culture”

invalid_when:
– “global visibility is mistaken for depth”
– “commercial capture is mistaken for cultural success”
– “heritage becomes museum shell only”
– “young inherit symbols without practice”
– “culture is used to normalise damage”
– “frontier experimentation consumes the memory base”

public_translation:
– “deep living culture”
– “regenerative culture”
– “high-continuity heritage”
– “future-carrying culture”

			
---
# 17. Standard CultureOS Output Format

yaml id=”cultureos-output-format”
STANDARD_CULTUREOS_OUTPUT:
1_observed_system:
required:
– “cultural unit”
– “scale”
– “boundary”
– “carrier group”
– “reason for classification”

2_native_culture_id:
required:
– “CULT ID”
– “meaning”
– “condition class”

3_civos_overlay_id:
required:
– “CivOS overlay”
– “Z/P/T/L/R/K reading”
– “derived civilisation memory-shell condition”

4_diagnostic_reading:
required:
– “shell completeness”
– “participation depth”
– “penetration”
– “valence”
– “trajectory”
– “failure classes if any”

5_repair_or_watch:
required:
– “protect memory”
– “restore practice”
– “repair transmission”
– “watch capture”
– “downgrade thinness”
– “upgrade living transmission”

			
---
# 18. Public Article Translation

yaml id=”cultureos-public-translation”
PUBLIC_TRANSLATION:
CULT.L:
public_phrase: “scale of the culture being read”

CSC:
public_phrase: “how complete the cultural shell is”

D:
public_phrase: “how deeply people participate”

PEN:
public_phrase: “how far the culture has spread”

V:
public_phrase: “whether the culture strengthens, neutralises, damages, inverts, or mixes effects”

CC:
public_phrase: “the culture condition”

T:
public_phrase: “whether the culture is strengthening, stable, weakening, or volatile”

K:
public_phrase: “how confident the reading is”

CIVOS_OVERLAY:
public_phrase: “how the culture affects civilisation memory and transmission”

			
---
# 19. Article Runtime Lock

yaml id=”cultureos-runtime-lock”
RUNTIME_LOCK:
locked_decisions:
– “CultureOS uses CULT-SHELL-CLASS v1.1.”
– “Culture is classified as a human meaning-transmission shell, not species.”
– “Native CULT ID remains detailed and domain-specific.”
– “CivOS overlay places CultureOS inside CivilisationOS memory shell.”
– “Default CivOS overlay is CIVOS.MEMORY-SHELL.CULTURE.”
– “Culture penetration must use PEN0-PEN6, not P0-P6.”
– “Do not confuse global visibility with depth.”
– “Do not confuse trend, fashion, meme, branding, or performance with living culture.”
– “Heritage culture must be tested for living transmission, not only age.”
– “Phase 4 culture reading stays internal unless requested.”

next_article:
article_number: 4
title: “TeamworkOS Shell-State Classification System v1.1”
prompt_to_continue:
“Next”

			
---
# 20. Short AI Memory Version

yaml id=”cultureos-short-memory”
SHORT_MEMORY:
“CultureOS v1.1 classifies culture as a meaning-transmission shell. Native format: CULT.[L0-L6].[CSC0-CSC5].[D0-D5].[PEN0-PEN6].[V+/V0/V-/VI/VM].[CC0-CC10].[T+/T0/T-/TX].[K1-K5]. Use PEN, not P, because CivOS P0-P4 means phase. Default CivOS overlay: CIVOS.MEMORY-SHELL.CULTURE.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]. Condition classes: CC0 Pre-Culture Signal, CC1 Emerging, CC2 Living, CC3 Thin, CC4 Tilted, CC5 Captured, CC6 Inverted, CC7 Fragmented, CC8 Decaying, CC9 Repairing/Reviving, CC10 Heritage. Culture is not visibility; culture is meaning, memory, practice, participation, and transmission across time.”
“`

Article 3 is complete.

Article 4 of 7

TeamworkOS Shell-State Classification System v1.1

Full Code Aligned to CivilisationOS Parent Shell-Lattice

Full Code for AI Runtime

“`yaml id=”teamworkos-v1-1-header”
ARTICLE_ID: “EKSG.FULLCLASSSTACK.TEAMWORKOS.SHELL-STATE-CLASS.v1.1”
ARTICLE_NUMBER: 4
STACK_TOTAL: 7

TITLE: “TeamworkOS Shell-State Classification System v1.1”
SUBTITLE: “Full Code Aligned to CivilisationOS Parent Shell-Lattice”
PUBLIC_OR_INTERNAL: “Full Code for AI Runtime”
AUTHOR_CONTEXT: “eduKateSG”

RUNTIME_TRIGGER:
SIMPLE_TRIGGER:
– “Use TeamworkOS classification”
– “Use Teamwork Shell-State Classification”
– “Classify teamwork”
– “What is teamwork”
– “What type of team is this”
– “Use TEAM-SHELL-CLASS”
– “Use TeamworkOS with CivOS overlay”
– “Classify team by shell-state”
– “Use eduKateSG Full Classification Stack”
– “Use Pegasus Team classification”
– “Use Dynamic Team classification”

FULL_TRIGGER:
“Use eduKateSG TeamworkOS Shell-State Classification System v1.1 aligned to CivilisationOS parent shell-lattice. First classify the team using the native TEAM ID, then translate upward into the CivOS overlay ID. Preserve role-fit, trust, load distribution, mission-shell, dynamic/adaptive team state, and Pegasus Team state. Preserve reader-facing clarity if writing public article, and expose full IDs only when full-code or technical output is requested.”

SURFACE_RULE:
reader_facing:
– “Do not overuse IDs.”
– “Use words like team condition, mission, roles, trust, load, coordination, repair, and reconfiguration.”
– “Avoid saying team species.”
– “Do not expose Phase 4 mechanics unless explicitly requested.”
code_facing:
– “Expose native TEAM ID.”
– “Expose CivOS overlay ID.”
– “Include teamwork axes, condition classes, failure classes, dynamic team model, Pegasus model, examples, and repair sequence.”

			
---
# 1. Canonical Name

yaml id=”teamworkos-canon-v1-1″
CANONICAL_NAME:
“eduKateSG TeamworkOS Shell-State Classification System v1.1”

SHORT_NAME:
“TEAM-SHELL-CLASS v1.1”

SYSTEM_TYPE:
“TeamworkOS”

UNIT_OF_ANALYSIS:
“Human coordination system”

PARENT_CIVOS_ROLE:
“Coordination / mission / role-fit / load-distribution shell”

DEFAULT_CIVOS_OVERLAY:
“CIVOS.COORDINATION-SHELL.TEAMWORK”

CORE_LINE:
“Teamwork is not merely people together. Teamwork is coordinated human capability moving through trust, roles, timing, repair, and shared mission.”

PUBLIC_DEFINITION:
“Teamwork is a continuing coordination system where two or more people combine roles, abilities, trust, communication, timing, responsibility, and repair to produce an outcome that individuals cannot produce as well alone.”

NOT_TEAMWORK_DEFINITION:
“A group is not yet a team when people are merely present together, assigned together, chatting together, competing beside one another, or moving in parallel without shared mission, role clarity, trust, coordination, and repair.”

			
---
# 2. Native TeamworkOS ID Format

yaml id=”teamworkos-native-id-format”
NATIVE_TEAMWORK_ID:
formula:
“TEAM.[LEVEL].[SHELL_COMPLETENESS].[ROLE_FIT].[TRUST].[LOAD].[CONDITION].[TRAJECTORY].[CONFIDENCE]”

full_format:
“TEAM.[L0-L6].[TSC0-TSC5].[RF0-RF5].[TR0-TR5].[LD0-LD5].[TC0-TC11].[T+/T0/T-/TX].[K1-K5]”

example:
id: “TEAM.L3.TSC5.RF5.TR5.LD5.TC10.T+.K4”
meaning: “Project-level dynamic team shell, elite adaptive role fit, pressure-tested trust, dynamic load-balancing, adaptive team, improving trajectory, high confidence.”

			
---
# 3. CivOS Overlay ID Format

yaml id=”teamworkos-civos-overlay-format”
CIVOS_OVERLAY_ID:
formula:
“CIVOS.COORDINATION-SHELL.TEAMWORK.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

example:
id: “CIVOS.COORDINATION-SHELL.TEAMWORK.Z2.P3.T3.LPOS.R4.K4”
meaning: “Institution/project-scale civilisation coordination shell, teamwork subsystem, stable phase, short-medium horizon, positive lattice, strong repair, high confidence.”

ALIGNMENT_RULE:

“Use native TEAM ID for teamwork-system detail.”
“Use CivOS overlay ID to place the teamwork reading inside civilisation’s coordination shell.”
“Do not replace TEAM ID with CivOS ID.”
“Dynamic Team and Pegasus Team are advanced teamwork conditions, not separate parent systems.”

			
---
# 4. TeamworkOS Axes
## Axis 1 — Level

yaml id=”teamworkos-level-axis”
TEAMWORK_LEVEL:
L0:
name: “Pair / dyad”
examples:
– “two-person partnership”
– “tutor-student working pair”
– “co-founder pair”
– “parent-child task pair”

L1:
name: “Small group / study group / family-task group”
examples:
– “study group”
– “family working group”
– “small project group”
– “friend group working on task”

L2:
name: “Class team / department / workplace unit”
examples:
– “class project team”
– “department”
– “sports team”
– “workplace unit”
– “school committee”

L3:
name: “Project team / mission crew”
examples:
– “product team”
– “article team”
– “research crew”
– “emergency project crew”
– “mission task force”

L4:
name: “Organisation-level teamwork”
examples:
– “company-wide team system”
– “school-wide staff coordination”
– “organisation leadership team”
– “ministry-wide coordination”

L5:
name: “Network / alliance / multi-organisation team”
examples:
– “multi-agency task force”
– “alliance network”
– “supply-chain coordination team”
– “cross-border project alliance”

L6:
name: “Civilisation-scale coordination team”
examples:
– “global scientific coordination”
– “planetary emergency response”
– “civilisation-scale infrastructure coordination”
– “multi-country survival or repair mission”

			
---
## Axis 2 — Team Shell Completeness

yaml id=”teamworkos-shell-completeness”
TEAM_SHELL_COMPLETENESS:
TSC0:
name: “No team shell”
meaning: “People are present but no team structure exists.”

TSC1:
name: “Contact group shell only”
meaning: “People have contact, but no clear mission, roles, trust, or coordination.”

TSC2:
name: “Emerging team shell”
meaning: “Mission, roles, communication, and early trust are beginning to form.”

TSC3:
name: “Basic team shell”
meaning: “Mission, roles, trust, communication, and repair exist at basic level.”

TSC4:
name: “Mature team shell”
meaning: “Role-fit, trust, communication, load distribution, authority, and repair are organised.”

TSC5:
name: “Dynamic / high-performance team shell”
meaning: “The team can reconfigure roles, membership, timing, and load across mission stages.”

### Team Shell Layers

yaml id=”teamworkos-shell-layers”
TEAM_SHELL_LAYERS:
boundary:
question: “Who is on the team?”
failure: “Membership is unclear or constantly shifting without coordination.”

mission:
question: “What are we trying to accomplish?”
failure: “People are busy but not aligned around a shared outcome.”

roles:
question: “Who does what?”
failure: “Role confusion, duplication, or abandonment.”

capability:
question: “What can each person do?”
failure: “Capabilities are unknown, misread, or unused.”

overlap:
question: “Where do abilities cover one another?”
failure: “No backup or cross-cover.”

gap:
question: “What is missing?”
failure: “Critical functions are absent or invisible.”

trust:
question: “Can members rely on one another?”
failure: “People hide problems, avoid truth, or cannot depend on one another.”

communication:
question: “Can signals move clearly?”
failure: “Messages are late, unclear, distorted, or ignored.”

timing:
question: “Can the team act in sequence?”
failure: “People act too early, too late, or out of order.”

load:
question: “Is burden distributed properly?”
failure: “Hidden overload or unfair load distribution.”

authority:
question: “Who decides when conflict appears?”
failure: “Decision deadlock, power confusion, or ego capture.”

repair:
question: “Can mistakes be corrected?”
failure: “Mistakes become blame, silence, or repeated failure.”

reconfiguration:
question: “Can the team change shape when the mission changes?”
failure: “The team uses the same shape for every stage even when the work changes.”

continuity:
question: “Can the team survive pressure across time?”
failure: “Team collapses when stress appears.”

			
---
## Axis 3 — Role Fit

yaml id=”teamworkos-role-fit-axis”
ROLE_FIT:
RF0:
name: “No role clarity”
meaning: “Members do not know who carries which function.”

RF1:
name: “Weak role fit”
meaning: “Roles exist but are mismatched to capability or mission need.”

RF2:
name: “Basic role fit”
meaning: “Roles are workable but incomplete or not well optimised.”

RF3:
name: “Good role fit”
meaning: “Most people carry suitable roles.”

RF4:
name: “Strong role fit”
meaning: “People are well-positioned according to capability, trust, and mission need.”

RF5:
name: “Elite / adaptive role fit”
meaning: “Roles can shift intelligently as mission stages change.”

Role-fit warning:

yaml id=”teamworkos-role-fit-warning”
ROLE_FIT_WARNING:
“A team can have talented people and still fail if the wrong people carry the wrong functions.”

			
---
## Axis 4 — Trust

yaml id=”teamworkos-trust-axis”
TEAM_TRUST:
TR0:
name: “No trust”
meaning: “Members cannot rely on one another.”

TR1:
name: “Fragile trust”
meaning: “Trust exists only under low pressure.”

TR2:
name: “Basic trust”
meaning: “Members can cooperate but avoid deeper conflict or risk.”

TR3:
name: “Operational trust”
meaning: “Members can rely on one another for normal work.”

TR4:
name: “Strong trust”
meaning: “Members can handle disagreement, errors, and pressure.”

TR5:
name: “Deep / pressure-tested trust”
meaning: “Trust survives high pressure, mistakes, honesty, and reconfiguration.”

Trust rule:

yaml id=”teamworkos-trust-rule”
TRUST_RULE:
“Team trust is not friendliness. Real team trust means people report problems early, tell the truth, carry their roles, and repair mistakes without destroying the mission.”

			
---
## Axis 5 — Load Distribution

yaml id=”teamworkos-load-axis”
LOAD_DISTRIBUTION:
LD0:
name: “No load awareness”
meaning: “The team does not see who is carrying what.”

LD1:
name: “Severely uneven load”
meaning: “One or a few members carry too much while others hide, drift, or extract.”

LD2:
name: “Uneven but tolerable load”
meaning: “Load is uneven but not yet breaking the team.”

LD3:
name: “Workable load distribution”
meaning: “Load is mostly manageable with some correction needed.”

LD4:
name: “Balanced load distribution”
meaning: “Burden, responsibility, and credit are distributed fairly and intelligently.”

LD5:
name: “Dynamic load-balancing”
meaning: “The team shifts load intelligently according to mission stage, energy, capability, and risk.”

Load rule:

yaml id=”teamworkos-load-rule”
LOAD_RULE:
“A team that succeeds only because one person carries everyone is not high-functioning teamwork. It is hidden overload.”

			
---
## Axis 6 — Teamwork Condition Class

yaml id=”teamworkos-condition-class”
TEAMWORK_CONDITION_CLASS:
TC0: “Pre-Team Contact”
TC1: “Emerging Team”
TC2: “Functional Team”
TC3: “Tilted Team”
TC4: “Captured Team”
TC5: “Inverted Team”
TC6: “Fragmented Team”
TC7: “Overloaded Team”
TC8: “Decaying Team”
TC9: “Repairing Team”
TC10: “Dynamic / Adaptive Team”
TC11: “Pegasus Team”

			
---
## Axis 7 — Trajectory

yaml id=”teamworkos-trajectory-axis”
TRAJECTORY:
T+:
name: “Improving / strengthening”
meaning: “Trust, role-fit, load balance, communication, repair, or mission clarity is improving.”

T0:
name: “Stable / no clear movement”
meaning: “No strong directional change is visible.”

T-:
name: “Deteriorating”
meaning: “Trust, role-fit, load balance, communication, repair, or mission clarity is weakening.”

TX:
name: “Volatile / unclear”
meaning: “Direction is unstable, fast-changing, contested, or insufficiently evidenced.”

			
---
## Axis 8 — Confidence

yaml id=”teamworkos-confidence-axis”
CONFIDENCE:
K1:
name: “Low confidence”
meaning: “Evidence is weak, speculative, or based on surface observation.”

K2:
name: “Limited confidence”
meaning: “Some evidence exists, but team function is uncertain.”

K3:
name: “Medium confidence”
meaning: “Evidence is plausible and structured, but not strong enough for high confidence.”

K4:
name: “High confidence”
meaning: “Evidence is strong, repeated, and supported by observed coordination patterns.”

K5:
name: “Very high confidence”
meaning: “Evidence is pressure-tested, repeatedly observed, and validated across mission stages.”

			
---
# 5. Teamwork Condition Classes
## TC0 — Pre-Team Contact

yaml id=”teamworkos-tc0″
TC0_PRE_TEAM_CONTACT:
id: “TEAM.TC0.PRE_TEAM_CONTACT”
status: “Not yet teamwork”
core_signal: “People are together, but not yet coordinated.”
signs:
– “people are assigned together”
– “people sit together”
– “group chat exists”
– “email chain exists”
– “committee list exists”
– “no shared mission”
– “no clear roles”
– “no repair”
key_question:
“Is there coordination, or only contact?”

			
---
## TC1 — Emerging Team

yaml id=”teamworkos-tc1″
TC1_EMERGING_TEAM:
id: “TEAM.TC1.EMERGING”
status: “Beginning teamwork”
core_signal: “People begin forming mission, roles, trust, and coordination.”
signs:
– “mission becomes clearer”
– “roles begin forming”
– “members start recognising strengths”
– “early trust appears”
– “communication improves”
– “people begin adjusting to one another”
key_question:
“Is the group becoming a team?”

			
---
## TC2 — Functional Team

yaml id=”teamworkos-tc2″
TC2_FUNCTIONAL_TEAM:
id: “TEAM.TC2.FUNCTIONAL”
status: “Healthy baseline teamwork”
core_signal: “People coordinate well enough to complete the mission.”
signs:
– “goal is understood”
– “roles are clear enough”
– “communication is workable”
– “responsibility is shared”
– “normal mistakes can be handled”
– “timing is coordinated”
– “work is delivered”
key_question:
“Can the team deliver the mission without hidden collapse?”

			
---
## TC3 — Tilted Team

yaml id=”teamworkos-tc3″
TC3_TILTED_TEAM:
id: “TEAM.TC3.TILTED”
status: “Functioning but uneven”
core_signal: “The team works, but burden, voice, credit, or responsibility is uneven.”
signs:
– “one person carries too much”
– “one person receives too much credit”
– “some people are ignored”
– “some members hide behind others”
– “some members dominate decisions”
– “invisible work is not recognised”
– “the team succeeds but feels unfair”
key_question:
“Can the team correct the tilt before resentment grows?”

			
---
## TC4 — Captured Team

yaml id=”teamworkos-tc4″
TC4_CAPTURED_TEAM:
id: “TEAM.TC4.CAPTURED”
status: “Team controlled by a narrower interest”
core_signal: “The team’s mission is bent toward one person, clique, ego, agenda, or power centre.”
capture_agents:
– “leader ego”
– “clique”
– “status competition”
– “political agenda”
– “credit capture”
– “information control”
– “personal ambition”
signs:
– “team serves politics instead of mission”
– “credit is captured”
– “information is controlled”
– “members comply instead of coordinate”
– “one person’s ego becomes the mission”
key_question:
“Is the team still serving the mission, or someone’s private agenda?”

			
---
## TC5 — Inverted Team

yaml id=”teamworkos-tc5″
TC5_INVERTED_TEAM:
id: “TEAM.TC5.INVERTED”
status: “Team whose function has reversed”
core_signal: “The team structure produces the opposite of teamwork.”
signs:
– “collaboration becomes forced compliance”
– “unity silences disagreement”
– “communication hides problems”
– “shared mission becomes leader ego”
– “team spirit becomes emotional pressure”
– “meetings create confusion”
– “roles protect weak performance”
– “strong members are drained”
– “weak members are shielded from accountability”
key_question:
“Is teamwork language being used to prevent real teamwork?”

			
---
## TC6 — Fragmented Team

yaml id=”teamworkos-tc6″
TC6_FRAGMENTED_TEAM:
id: “TEAM.TC6.FRAGMENTED”
status: “Team split into disconnected parts”
core_signal: “Members stop operating as one coordinated system.”
signs:
– “subgroups form”
– “communication breaks”
– “people withhold information”
– “members work in silos”
– “trust is local, not team-wide”
– “goals differ”
– “blame spreads”
– “talent does not combine”
key_question:
“Can the team still coordinate across its own parts?”

			
---
## TC7 — Overloaded Team

yaml id=”teamworkos-tc7″
TC7_OVERLOADED_TEAM:
id: “TEAM.TC7.OVERLOADED”
status: “Team carrying more load than its shell can support”
core_signal: “Mission demand exceeds team capacity.”
signs:
– “deadlines pile up”
– “people become reactive”
– “errors increase”
– “communication becomes rushed”
– “recovery time disappears”
– “strong members burn out”
– “weak points are hidden”
– “team becomes fragile under pressure”
key_question:
“Is the team failing because the mission load exceeds carrying capacity?”

			
---
## TC8 — Decaying Team

yaml id=”teamworkos-tc8″
TC8_DECAYING_TEAM:
id: “TEAM.TC8.DECAYING”
status: “Team weakening over time”
core_signal: “Trust, clarity, energy, and repair are declining.”
signs:
– “people stop speaking honestly”
– “meetings become performative”
– “problems repeat”
– “trust declines”
– “energy falls”
– “good members withdraw”
– “weak habits become normal”
– “mistakes are hidden”
– “team still exists but no longer improves”
key_question:
“Is the team shell still visible while team-life weakens?”

			
---
## TC9 — Repairing Team

yaml id=”teamworkos-tc9″
TC9_REPAIRING_TEAM:
id: “TEAM.TC9.REPAIRING”
status: “Damaged team recovering”
core_signal: “The team names damage and restores function.”
signs:
– “problems are named”
– “roles are clarified”
– “trust is rebuilt”
– “load is redistributed”
– “communication becomes cleaner”
– “accountability returns”
– “mission is re-centred”
– “members regain confidence”
key_question:
“Is the team correcting damage faster than it repeats?”

			
---
## TC10 — Dynamic / Adaptive Team

yaml id=”teamworkos-tc10″
TC10_DYNAMIC_ADAPTIVE_TEAM:
id: “TEAM.TC10.DYNAMIC_ADAPTIVE”
status: “High-functioning reconfigurable team”
core_signal: “The team changes shape as the mission changes.”
signs:
– “membership can shift by stage”
– “roles can change without ego collapse”
– “authority changes according to mission need”
– “specialists enter and exit at correct time”
– “load shifts intelligently”
– “review and repair are built into the pipeline”
– “mission continuity survives reconfiguration”
key_question:
“Can the team change shape without losing the mission?”

			
---
## TC11 — Pegasus Team

yaml id=”teamworkos-tc11″
TC11_PEGASUS_TEAM:
id: “TEAM.TC11.PEGASUS”
status: “High-aspiration creative alignment team”
core_signal: “The team lifts collective energy toward a noble shared vision.”
signs:
– “team has shared noble aim”
– “members feel lifted, not drained”
– “creativity increases through alignment”
– “people work in tandem without losing individuality”
– “mission feels larger than ego”
– “trust allows imagination”
– “morale stays connected to meaning”
– “people become better because they are inside the team”
key_question:
“Does the team create lift, meaning, trust, and coordinated excellence?”

			
---
# 6. TeamworkOS Movement Map

yaml id=”teamworkos-movement-map”
TEAMWORK_MOVEMENT_MAP:
upward_route:
– “TC0 Pre-Team Contact”
– “TC1 Emerging Team”
– “TC2 Functional Team”
– “TC10 Dynamic / Adaptive Team”
– “TC11 Pegasus Team”

weakening_route:
– “TC2 Functional Team”
– “TC3 Tilted Team”
– “TC4 Captured Team”
– “TC5 Inverted Team”
– “TC6 Fragmented Team”
– “TC7 Overloaded Team”
– “TC8 Decaying Team”

repair_route:
– “TC3 / TC4 / TC5 / TC6 / TC7 / TC8”
– “damage named”
– “mission re-centred”
– “roles clarified”
– “load redistributed”
– “trust rebuilt”
– “repairing team”
– “functional team”
– “dynamic / adaptive team”

			
---
# 7. Teamwork Failure Classes

yaml id=”teamworkos-failure-classes”
TEAMWORK_FAILURE_CLASSES:
TF0:
name: “No mission”
meaning: “People do not know what the team is trying to achieve.”

TF1:
name: “Role confusion”
meaning: “Members do not know who carries which function.”

TF2:
name: “Trust failure”
meaning: “Members cannot rely on one another.”

TF3:
name: “Communication breakdown”
meaning: “Signals do not move clearly.”

TF4:
name: “Load imbalance”
meaning: “Burden is unfairly or unintelligently distributed.”

TF5:
name: “Ego capture”
meaning: “A person’s ego bends the team mission.”

TF6:
name: “Invisible work exploitation”
meaning: “Unseen labour is used but not recognised.”

TF7:
name: “Coordination lag”
meaning: “The team acts out of sequence or too slowly.”

TF8:
name: “Capability gap”
meaning: “A critical skill or function is missing.”

TF9:
name: “Authority conflict”
meaning: “Decision authority is unclear or contested.”

TF10:
name: “Repair failure”
meaning: “Mistakes cannot be corrected without blame, denial, or collapse.”

TF11:
name: “Stage mismatch”
meaning: “The team shape does not match the mission stage.”

TF12:
name: “Burnout collapse”
meaning: “The team consumes its own human base.”

Failure class append example:

yaml id=”teamworkos-failure-example”
FAILURE_APPEND_EXAMPLE:
id:
“TEAM.L3.TSC4.RF3.TR2.LD1.TC3.T-.K4 + TF4 + TF6”
meaning:
“Project-level tilted team, deteriorating, with load imbalance and invisible work exploitation.”

			
---
# 8. Dynamic Team Model

yaml id=”teamworkos-dynamic-team-model”
DYNAMIC_TEAM_MODEL:
definition:
“A dynamic team is a mission-stage coordination shell that reconfigures membership, roles, authority, load, and timing as the project changes.”

core_rule:
“The best team is not always the same team at every stage.”

mission_stage_logic:
stage_1_discovery:
need: “Discovery”
required_functions:
– “scouts”
– “researchers”
– “question framers”
– “problem definers”
risk_if_missing:
“The team solves the wrong problem.”

			
stage_2_design:
  need: "Design"
  required_functions:
    - "architects"
    - "strategists"
    - "planners"
    - "constraint readers"
  risk_if_missing:
    "The team builds without coherent structure."
stage_3_build:
  need: "Build"
  required_functions:
    - "operators"
    - "specialists"
    - "engineers"
    - "producers"
  risk_if_missing:
    "The team stays conceptual and fails to produce."
stage_4_stress_test:
  need: "Stress Test"
  required_functions:
    - "auditors"
    - "critics"
    - "risk testers"
    - "quality controllers"
  risk_if_missing:
    "The team releases weak work."
stage_5_release:
  need: "Release"
  required_functions:
    - "communicators"
    - "coordinators"
    - "delivery owners"
    - "frontline operators"
  risk_if_missing:
    "The team builds but fails to land the output."
stage_6_repair_improve:
  need: "Repair / Improve"
  required_functions:
    - "feedback readers"
    - "repair workers"
    - "data reviewers"
    - "system improvers"
  risk_if_missing:
    "The team repeats mistakes and cannot improve."

		

ideal_classification_target:
native_id:
“TEAM.L3.TSC5.RF5.TR5.LD5.TC10.T+.K4”
civos_overlay:
“CIVOS.COORDINATION-SHELL.TEAMWORK.Z2.P3.T6.LPOS.R4.K4”

			
---
# 9. Pegasus Team Model

yaml id=”teamworkos-pegasus-model”
PEGASUS_TEAM_MODEL:
definition:
“A Pegasus Team is a high-aspiration coordination shell where shared mission, trust, role-fit, creativity, courage, and meaning lift the team above ordinary group performance.”

core_function:
– “elevates group energy”
– “aligns imagination with mission”
– “protects noble purpose”
– “turns individual capability into shared lift”
– “keeps morale connected to meaning”
– “prevents ego from consuming the mission”

required_conditions:
– “clear noble mission”
– “strong trust”
– “strong role-fit”
– “creative safety”
– “shared aspiration”
– “load awareness”
– “repair capacity”
– “humility”
– “coordination rhythm”

failure_modes:
– “inspiration without execution”
– “charisma without structure”
– “vision without load management”
– “creative chaos”
– “ego capture”
– “mission drift”
– “burnout hidden behind enthusiasm”

ideal_classification_target:
native_id:
“TEAM.L3.TSC5.RF4.TR5.LD4.TC11.T+.K4”
civos_overlay:
“CIVOS.COORDINATION-SHELL.TEAMWORK.Z2.P3.T6.LPOS.R4.K4”

public_line:
“A Pegasus Team is not just nice teamwork. It is elevated coordinated function.”

			
---
# 10. Teamwork Repair Sequence

yaml id=”teamworkos-repair-sequence”
TEAMWORK_REPAIR_SEQUENCE:
step_1_notice:
action: “Recognise that team function is weakening.”
diagnostic_questions:
– “Is the mission clear?”
– “Who is carrying hidden load?”
– “Where is communication breaking?”
– “Who is silent?”
– “Who is dominating?”
– “What mistake keeps repeating?”

step_2_name:
action: “Classify the team damage accurately.”
possible_damage:
– “tilt”
– “capture”
– “inversion”
– “fragmentation”
– “overload”
– “decay”
– “stage mismatch”
rule:
“Bad naming creates bad team repair.”

step_3_recentre_mission:
action: “Separate mission from ego, politics, status, and noise.”
key_question:
“What are we actually trying to accomplish?”

step_4_clarify_roles:
action: “Place the right people in the right functions.”
includes:
– “remove role confusion”
– “identify missing roles”
– “identify duplicated roles”
– “match authority to capability”

step_5_redistribute_load:
action: “Rebalance visible and invisible work.”
includes:
– “detect hidden overload”
– “protect key carriers”
– “shift work by ability and timing”
– “assign backup coverage”

step_6_rebuild_trust:
action: “Create conditions where truth can move without destroying the team.”
includes:
– “early problem reporting”
– “no punishment for useful truth”
– “clear accountability”
– “repair after conflict”

step_7_reconfigure:
action: “Change team shape if the mission stage has changed.”
warning:
“A team that refuses to reconfigure may become overloaded or stage-mismatched.”

step_8_repeat:
action: “Repeat repair until coordination improves under pressure.”

			
---
# 11. TeamworkOS Classification Sequence

yaml id=”teamworkos-classification-sequence”
TEAMWORK_CLASSIFICATION_SEQUENCE:
step_1_define_unit:
question: “What team unit are we classifying?”
examples:
– “pair”
– “study group”
– “family task group”
– “school project group”
– “class team”
– “workplace team”
– “sports team”
– “leadership team”
– “project crew”
– “company department”
– “emergency response unit”
– “alliance network”

step_2_define_mission:
question: “What is the team trying to achieve?”

step_3_define_boundary:
question: “Who is inside the team, and who is outside?”

step_4_check_shell_layers:
question: “Does the team have mission, roles, trust, communication, timing, load awareness, authority, repair, reconfiguration, and continuity?”

step_5_assign_level:
question: “What level is the team shell operating at?”
output: “L0-L6”

step_6_assign_shell_completeness:
question: “How complete is the team shell?”
output: “TSC0-TSC5”

step_7_assign_role_fit:
question: “Are the right people carrying the right functions?”
output: “RF0-RF5”

step_8_assign_trust:
question: “Can members rely on one another under pressure?”
output: “TR0-TR5”

step_9_assign_load_distribution:
question: “Is work distributed fairly and intelligently?”
output: “LD0-LD5”

step_10_assign_condition_class:
question: “Which teamwork condition class best fits?”
output: “TC0-TC11”

step_11_assign_trajectory:
question: “Is it improving, stable, deteriorating, or volatile?”
output: “T+ / T0 / T- / TX”

step_12_assign_confidence:
question: “How strong is the evidence?”
output: “K1-K5”

step_13_output_native_id:
format: “TEAM.[L].[TSC].[RF].[TR].[LD].[TC].[T].[K]”

step_14_translate_to_civos_overlay:
format: “CIVOS.COORDINATION-SHELL.TEAMWORK.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

step_15_derive_condition:
output:
– “team condition”
– “CivOS coordination-shell condition”
– “failure classes if any”
– “repair/watch recommendation”

			
---
# 12. Native-to-CivOS Translation Guide

yaml id=”teamworkos-native-to-civos”
NATIVE_TO_CIVOS_TRANSLATION:
level_to_zoom:
L0: “Z0-Z1”
L1: “Z1”
L2: “Z2”
L3: “Z2-Z3”
L4: “Z3-Z4”
L5: “Z5”
L6: “Z6”

shell_to_phase_guidance:
TSC0: “usually P0”
TSC1: “usually P0-P1”
TSC2: “usually P1-P2”
TSC3: “usually P2”
TSC4: “usually P2-P3”
TSC5: “usually P3, or P4 only if regenerative coordination strengthens the base”

condition_to_lattice_guidance:
TC0: “LNEU or LNEG depending on risk”
TC1: “LNEU or LPOS if stabilising”
TC2: “LPOS or LNEU”
TC3: “LNEU or LNEG”
TC4: “LNEG or LINV”
TC5: “LINV”
TC6: “LNEG”
TC7: “LNEG”
TC8: “LNEG”
TC9: “LPOS”
TC10: “LPOS”
TC11: “LPOS if grounded; LNEU/LNEG if inspiration lacks execution”

load_to_repair_guidance:
LD0: “R0-R1”
LD1: “R1”
LD2: “R2”
LD3: “R3”
LD4: “R4”
LD5: “R5 if sustained under pressure”

trust_to_repair_guidance:
TR0: “R0”
TR1: “R1”
TR2: “R2”
TR3: “R3”
TR4: “R4”
TR5: “R5”

confidence_translation:
K1: “K1”
K2: “K2”
K3: “K3”
K4: “K4”
K5: “K5”

			
---
# 13. Example Classifications
## Example 1 — School Group Project

yaml id=”teamworkos-example-school-group”
EXAMPLE_1_SCHOOL_GROUP_PROJECT:
observed_system:
type: “school group project”
level: “L1”
reason: “Small group beginning to coordinate around assignment.”

native_id:
id: “TEAM.L1.TSC2.RF2.TR2.LD2.TC1.T+.K3”
meaning: “Small group with emerging team shell, basic role fit, basic trust, uneven but tolerable load, emerging team condition, improving trajectory, medium confidence.”

civos_overlay:
id: “CIVOS.COORDINATION-SHELL.TEAMWORK.Z1.P2.T1.LPOS.R2.K3”
meaning: “Small-group civilisation coordination shell, repair-capable early phase, short horizon, positive lattice, partial repair, medium confidence.”

derived_condition:
– “TEAM.TC1.EMERGING”
– “CIV.EMERGING-COORDINATION”

			
---
## Example 2 — Workplace Team Where One Person Carries Everyone

yaml id=”teamworkos-example-overcarried-workplace”
EXAMPLE_2_WORKPLACE_TEAM_ONE_CARRIER:
observed_system:
type: “workplace team”
issue: “One person is carrying hidden load while others under-contribute.”

native_id:
id: “TEAM.L2.TSC3.RF2.TR2.LD1.TC3.T-.K4”
meaning: “Department-level basic team shell, basic role fit, fragile/basic trust, severely uneven load, tilted team, deteriorating, high confidence.”

civos_overlay:
id: “CIVOS.COORDINATION-SHELL.TEAMWORK.Z2.P1.T3.LNEG.R1.K4”
meaning: “Institution-scale civilisation coordination shell, fragile phase, short-medium horizon, negative lattice, weak repair, high confidence.”

derived_condition:
– “TEAM.TC3.TILTED”
– “CIV.TILTED-COORDINATION”

failure_classes:
– “TF4 Load imbalance”
– “TF6 Invisible work exploitation”
– “TF12 Burnout collapse risk”

			
---
## Example 3 — High-Performing Dynamic Project Team

yaml id=”teamworkos-example-dynamic-team”
EXAMPLE_3_DYNAMIC_PROJECT_TEAM:
observed_system:
type: “project team”
issue: “Team reconfigures membership, roles, and authority by project stage.”

native_id:
id: “TEAM.L3.TSC5.RF5.TR5.LD5.TC10.T+.K4”
meaning: “Project-level dynamic team shell, elite adaptive role fit, pressure-tested trust, dynamic load-balancing, adaptive team, improving, high confidence.”

civos_overlay:
id: “CIVOS.COORDINATION-SHELL.TEAMWORK.Z2.P3.T6.LPOS.R5.K4”
meaning: “Institution/project-scale civilisation coordination shell, stable phase, medium horizon, positive lattice, adaptive repair/load-balancing, high confidence.”

derived_condition:
– “TEAM.TC10.DYNAMIC_ADAPTIVE”
– “CIV.STABLE-POSITIVE-COORDINATION”

			
---
## Example 4 — Team Captured by Leader Ego

yaml id=”teamworkos-example-leader-ego-capture”
EXAMPLE_4_LEADER_EGO_CAPTURE:
observed_system:
type: “project team”
issue: “Mission is bent toward leader ego, credit, and control.”

native_id:
id: “TEAM.L3.TSC4.RF3.TR2.LD2.TC4.T-.K3”
meaning: “Project-level mature team shell, good role fit, fragile/basic trust, uneven load, captured team, deteriorating, medium confidence.”

civos_overlay:
id: “CIVOS.COORDINATION-SHELL.TEAMWORK.Z2.P2.T3.LNEG.R2.K3”
meaning: “Institution/project-scale civilisation coordination shell, repair-capable but stressed phase, short-medium horizon, negative lattice, partial repair, medium confidence.”

derived_condition:
– “TEAM.TC4.CAPTURED”
– “CIV.CAPTURED-COORDINATION-SHELL”

failure_classes:
– “TF5 Ego capture”
– “TF9 Authority conflict”

			
---
## Example 5 — Pegasus Team

yaml id=”teamworkos-example-pegasus”
EXAMPLE_5_PEGASUS_TEAM:
observed_system:
type: “high-aspiration creative mission team”
issue: “Shared noble aim, creative alignment, strong trust, and elevated coordination.”

native_id:
id: “TEAM.L3.TSC5.RF4.TR5.LD4.TC11.T+.K4”
meaning: “Project-level high-performance team shell, strong role fit, deep trust, balanced load, Pegasus Team condition, improving, high confidence.”

civos_overlay:
id: “CIVOS.COORDINATION-SHELL.TEAMWORK.Z2.P3.T6.LPOS.R4.K4”
meaning: “Institution/project-scale civilisation coordination shell, stable phase, medium horizon, positive lattice, strong repair, high confidence.”

derived_condition:
– “TEAM.TC11.PEGASUS”
– “CIV.POSITIVE-ELEVATED-COORDINATION”

watch_warning:
“Pegasus Team must be checked for execution, load management, humility, and ego capture risk.”

			
---
## Example 6 — Inverted Team

yaml id=”teamworkos-example-inverted-team”
EXAMPLE_6_INVERTED_TEAM:
observed_system:
type: “team using teamwork language to suppress truth”
issue: “Unity and collaboration language are used to silence disagreement and protect weak performance.”

native_id:
id: “TEAM.L2.TSC4.RF2.TR1.LD1.TC5.T-.K3”
meaning: “Institution-level mature team shell, basic/weak role fit, fragile trust, severely uneven load, inverted team, deteriorating, medium confidence.”

civos_overlay:
id: “CIVOS.COORDINATION-SHELL.TEAMWORK.Z2.P1.T3.LINV.R1.K3”
meaning: “Institution-scale civilisation coordination shell, fragile phase, short-medium horizon, inverse lattice, weak repair, medium confidence.”

derived_condition:
– “TEAM.TC5.INVERTED”
– “CIV.INVERTED-COORDINATION-SHELL”

failure_classes:
– “TF2 Trust failure”
– “TF3 Communication breakdown”
– “TF10 Repair failure”

			
---
# 14. Teamwork vs Its Imitations

yaml id=”teamworkos-vs-imitations”
TEAMWORK_VS_IMITATION:
group:
imitation: “team”
missing:
– “shared mission”
– “coordination”

committee:
imitation: “team”
missing:
– “execution responsibility”

meeting:
imitation: “teamwork”
missing:
– “actual coordinated action”

friendship:
imitation: “teamwork”
missing:
– “mission load”
– “role function”

chat_group:
imitation: “team”
missing:
– “shared output”
– “repair”

hierarchy:
imitation: “coordination”
missing:
– “trust”
– “feedback”

compliance:
imitation: “unity”
missing:
– “real contribution”
– “honest disagreement”

busyness:
imitation: “progress”
missing:
– “mission movement”

talent_collection:
imitation: “ultimate team”
missing:
– “role-fit”
– “trust”
– “timing”
– “shared mission”

hero_cluster:
imitation: “superteam”
missing:
– “coordination”
– “humility”
– “load balance”

Core rule:

yaml id=”teamworkos-imitations-rule”
CORE_RULE:
“Not every group is a team. A team begins when people coordinate roles, trust, timing, and responsibility toward a shared mission.”

			
---
# 15. Team Contact Model

yaml id=”teamworkos-contact-model”
TEAM_CONTACT_MODEL:
TCON0:
name: “No contact”
meaning: “Members have not encountered one another.”

TCON1:
name: “Surface contact”
meaning: “People are aware of one another.”

TCON2:
name: “Task awareness”
meaning: “People know a task exists.”

TCON3:
name: “Role recognition”
meaning: “People begin recognising who may do what.”

TCON4:
name: “Communication begins”
meaning: “Signals begin moving.”

TCON5:
name: “Coordination begins”
meaning: “People begin timing action together.”

TCON6:
name: “Trust overlap”
meaning: “Members begin relying on one another.”

TCON7:
name: “Capability overlap”
meaning: “Members understand strengths, backups, and gaps.”

TCON8:
name: “Shared mission embodiment”
meaning: “Members carry the mission together.”

TCON9:
name: “Adaptive reconfiguration”
meaning: “Team can change shape as mission changes.”

Public explanation:

yaml id=”teamworkos-contact-public”
PUBLIC_EXPLANATION:
“A team does not form the moment people meet. Teamwork deepens when people recognise roles, communicate clearly, trust one another, cover each other’s gaps, and adapt together as the mission changes.”

			
---
# 16. Teamwork Time-Slice Model

yaml id=”teamworkos-time-slice”
TEAMWORK_TIME_SLICE_MODEL:
rule:
“One moment shows team appearance. Many moments show team direction.”

time_slices:
T0: “First contact”
T1: “Mission defined”
T2: “Roles assigned”
T3: “First coordination”
T4: “Pressure event”
T5: “Repair or blame”
T6: “Reconfiguration”
T7: “Delivery”
T8: “Review and transfer”

pressure_test_rule:
“Many teams look good before pressure. A real team is revealed when something goes wrong.”

core_line:
“Teamwork is not only who is on the team. Teamwork is what the team can still do under pressure.”

			
---
# 17. Phase 4 Internal Overlay for TeamworkOS

yaml id=”teamworkos-phase-4-overlay”
PHASE_4_INTERNAL_OVERLAY:
status: “Internal / technical only unless user asks.”
teamwork_equivalent:
“Regenerative coordination condition where mission, roles, trust, load balance, repair, and reconfiguration create surplus capability without burning the team base.”

valid_when:
– “team shell is TSC5”
– “role-fit is RF4-RF5”
– “trust is TR4-TR5”
– “load distribution is LD4-LD5”
– “condition is TC10 or TC11”
– “trajectory is T+ or stable with strong buffers”
– “mission output strengthens the team instead of exhausting it”
– “reconfiguration preserves continuity”

invalid_when:
– “charisma is mistaken for coordination”
– “inspiration hides burnout”
– “hero cluster is mistaken for team”
– “one person carries the whole system”
– “creative energy lacks execution”
– “mission is captured by ego”
– “frontier ambition consumes the team base”

public_translation:
– “high-performance adaptive team”
– “regenerative teamwork”
– “dynamic mission team”
– “Pegasus Team”
– “future-carrying team”

			
---
# 18. Standard TeamworkOS Output Format

yaml id=”teamworkos-output-format”
STANDARD_TEAMWORKOS_OUTPUT:
1_observed_system:
required:
– “team unit”
– “scale”
– “mission”
– “boundary”
– “reason for classification”

2_native_team_id:
required:
– “TEAM ID”
– “meaning”
– “condition class”

3_civos_overlay_id:
required:
– “CivOS overlay”
– “Z/P/T/L/R/K reading”
– “derived civilisation coordination-shell condition”

4_diagnostic_reading:
required:
– “shell completeness”
– “role fit”
– “trust”
– “load distribution”
– “trajectory”
– “failure classes if any”

5_repair_or_watch:
required:
– “re-centre mission”
– “clarify roles”
– “redistribute load”
– “rebuild trust”
– “reconfigure”
– “watch capture”
– “watch overload”
– “upgrade dynamic coordination”

			
---
# 19. Public Article Translation

yaml id=”teamworkos-public-translation”
PUBLIC_TRANSLATION:
TEAM.L:
public_phrase: “scale of the team being read”

TSC:
public_phrase: “how complete the team shell is”

RF:
public_phrase: “how well roles fit people and mission”

TR:
public_phrase: “how much trust the team can carry”

LD:
public_phrase: “how intelligently load is distributed”

TC:
public_phrase: “the team condition”

T:
public_phrase: “whether the team is improving, stable, weakening, or volatile”

K:
public_phrase: “how confident the reading is”

CIVOS_OVERLAY:
public_phrase: “how the team affects civilisation coordination”

			
---
# 20. Article Runtime Lock

yaml id=”teamworkos-runtime-lock”
RUNTIME_LOCK:
locked_decisions:
– “TeamworkOS uses TEAM-SHELL-CLASS v1.1.”
– “Teamwork is classified as a human coordination shell, not species.”
– “Native TEAM ID remains detailed and domain-specific.”
– “CivOS overlay places TeamworkOS inside CivilisationOS coordination shell.”
– “Default CivOS overlay is CIVOS.COORDINATION-SHELL.TEAMWORK.”
– “Dynamic / Adaptive Team is TC10.”
– “Pegasus Team is TC11.”
– “Do not confuse a group, committee, meeting, hierarchy, busyness, talent collection, or hero cluster with teamwork.”
– “Teamwork must be tested under pressure.”
– “Phase 4 teamwork reading stays internal unless requested.”

next_article:
article_number: 5
title: “NewsOS Shell-State Classification System v1.1”
prompt_to_continue:
“Next”

			
---
# 21. Short AI Memory Version

yaml id=”teamworkos-short-memory”
SHORT_MEMORY:
“TeamworkOS v1.1 classifies teamwork as a coordination shell. Native format: TEAM.[L0-L6].[TSC0-TSC5].[RF0-RF5].[TR0-TR5].[LD0-LD5].[TC0-TC11].[T+/T0/T-/TX].[K1-K5]. Default CivOS overlay: CIVOS.COORDINATION-SHELL.TEAMWORK.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]. Condition classes: TC0 Pre-Team Contact, TC1 Emerging Team, TC2 Functional Team, TC3 Tilted Team, TC4 Captured Team, TC5 Inverted Team, TC6 Fragmented Team, TC7 Overloaded Team, TC8 Decaying Team, TC9 Repairing Team, TC10 Dynamic/Adaptive Team, TC11 Pegasus Team. Teamwork is not people together; it is coordinated capability through mission, roles, trust, load, timing, repair, and reconfiguration.”
“`

Article 4 is complete.

Article 5 of 7

NewsOS Shell-State Classification System v1.1

Full Code Aligned to CivilisationOS Parent Shell-Lattice

Full Code for AI Runtime

“`yaml id=”newsos-v1-1-header”
ARTICLE_ID: “EKSG.FULLCLASSSTACK.NEWSOS.SHELL-STATE-CLASS.v1.1”
ARTICLE_NUMBER: 5
STACK_TOTAL: 7

TITLE: “NewsOS Shell-State Classification System v1.1”
SUBTITLE: “Full Code Aligned to CivilisationOS Parent Shell-Lattice”
PUBLIC_OR_INTERNAL: “Full Code for AI Runtime”
AUTHOR_CONTEXT: “eduKateSG”

RUNTIME_TRIGGER:
SIMPLE_TRIGGER:
– “Use NewsOS classification”
– “Use News Shell-State Classification”
– “Classify news”
– “What is news”
– “What type of news is this”
– “Use NEWS-SHELL-CLASS”
– “Use NewsOS with CivOS overlay”
– “Classify news by shell-state”
– “Use Purple Signal”
– “Use Purple Report news classification”
– “Use eduKateSG Full Classification Stack”

FULL_TRIGGER:
“Use eduKateSG NewsOS Shell-State Classification System v1.1 aligned to CivilisationOS parent shell-lattice. First classify the news item using the native NEWS ID, then translate upward into the CivOS overlay ID. Separate event core, claim, source, evidence, frame, timing, uncertainty, correction, and public-reality effect. Purple Signal is allowed only as an early watch item, not proof. Preserve reader-facing clarity if writing public article, and expose full IDs only when full-code or technical output is requested.”

SURFACE_RULE:
reader_facing:
– “Do not overuse IDs.”
– “Use words like event, claim, source, evidence, frame, uncertainty, correction, and why it matters.”
– “Avoid saying news species.”
– “Do not expose Phase 4 mechanics unless explicitly requested.”
– “For Purple Report articles, use public labels such as early signal, watch item, confidence, urgency, and what to watch next.”
code_facing:
– “Expose native NEWS ID.”
– “Expose CivOS overlay ID.”
– “Include news axes, condition classes, failure classes, Purple Signal rules, examples, and repair sequence.”

			
---
# 1. Canonical Name

yaml id=”newsos-canon-v1-1″
CANONICAL_NAME:
“eduKateSG NewsOS Shell-State Classification System v1.1”

SHORT_NAME:
“NEWS-SHELL-CLASS v1.1”

SYSTEM_TYPE:
“NewsOS”

UNIT_OF_ANALYSIS:
“Public signal / event-claim package”

PARENT_CIVOS_ROLE:
“Signal / filter / public-reality update / correction shell”

DEFAULT_CIVOS_OVERLAY:
“CIVOS.FILTER-SHELL.NEWS”

CORE_LINE:
“News is not merely information. News is a public signal that asks society to update reality, and therefore must be read by event, claim, source, evidence, frame, timing, correction, and consequence.”

PUBLIC_DEFINITION:
“News is a public signal about an event, claim, change, risk, decision, conflict, discovery, harm, opportunity, or condition that may affect what people know, believe, discuss, decide, or do.”

NOT_NEWS_DEFINITION:
“A thing is not yet news when it is only noise, rumour, entertainment, opinion, speculation, advertising, propaganda, private gossip, algorithmic distraction, or isolated content without enough public relevance, verifiable claim structure, evidence pathway, timing significance, and correction capacity.”

			
---
# 2. Native NewsOS ID Format

yaml id=”newsos-native-id-format”
NATIVE_NEWS_ID:
formula:
“NEWS.[LEVEL].[SHELL_COMPLETENESS].[CLAIM_STRENGTH].[SOURCE_INTEGRITY].[FRAME_STATE].[CONDITION].[TRAJECTORY].[CONFIDENCE]”

full_format:
“NEWS.[L0-L6].[NSC0-NSC5].[CL0-CL6].[SI0-SI5].[FR0-FR5].[NC0-NC11].[T+/T0/T-/TX].[K1-K5]”

example:
id: “NEWS.L4.NSC4.CL4.SI4.FR2.NC2.T+.K4”
meaning: “National-level mature news shell, confirmed claim strength, strong source integrity, moderate framing, functional news condition, clarifying trajectory, high confidence.”

			
---
# 3. CivOS Overlay ID Format

yaml id=”newsos-civos-overlay-format”
CIVOS_OVERLAY_ID:
formula:
“CIVOS.FILTER-SHELL.NEWS.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

example:
id: “CIVOS.FILTER-SHELL.NEWS.Z5.P2.T1.LNEU.R2.K3”
meaning: “International civilisation filter shell, news subsystem, repair-capable but early phase, short horizon, neutral lattice, partial checking/repair, medium confidence.”

ALIGNMENT_RULE:

“Use native NEWS ID for event-claim detail.”
“Use CivOS overlay ID to place the news reading inside civilisation’s filter/reality-update shell.”
“Do not replace NEWS ID with CivOS ID.”
“Do not treat Purple Signal as proof.”
“Do not treat virality as claim strength.”

			
---
# 4. NewsOS Axes
## Axis 1 — Level

yaml id=”newsos-level-axis”
NEWS_LEVEL:
L0:
name: “Private signal / single witness”
examples:
– “one witness post”
– “private message”
– “single photo”
– “single video clip”
– “unverified screenshot”

L1:
name: “Local event / neighbourhood / school / workplace”
examples:
– “school closure notice”
– “workplace incident”
– “neighbourhood fire”
– “local traffic disruption”

L2:
name: “Community / institutional news”
examples:
– “school policy”
– “company announcement”
– “university update”
– “hospital notice”
– “local authority update”

L3:
name: “City / regional news”
examples:
– “city infrastructure disruption”
– “regional election”
– “regional weather emergency”
– “city-level policy”

L4:
name: “National news”
examples:
– “national law”
– “national election”
– “national budget”
– “court ruling”
– “national emergency”

L5:
name: “International / geopolitical news”
examples:
– “war”
– “trade dispute”
– “summit”
– “sanctions”
– “supply-chain shift”
– “international treaty”

L6:
name: “Civilisation-scale / planetary news”
examples:
– “global pandemic”
– “planetary climate signal”
– “major AI transition”
– “civilisation-scale war risk”
– “global food, energy, or water shock”

			
---
## Axis 2 — News Shell Completeness

yaml id=”newsos-shell-completeness”
NEWS_SHELL_COMPLETENESS:
NSC0:
name: “No news shell”
meaning: “No usable public-signal structure exists.”

NSC1:
name: “Signal shell only”
meaning: “A signal exists, but claim, source, evidence, timing, or relevance are missing.”

NSC2:
name: “Reported claim shell”
meaning: “A claim is reported, but evidence and context are incomplete.”

NSC3:
name: “Basic news shell”
meaning: “Event, claim, source, time, and public relevance are basically present.”

NSC4:
name: “Mature news shell”
meaning: “Event, claim, source, evidence, frame, uncertainty, and correction pathway are organised.”

NSC5:
name: “High-integrity / multi-source news shell”
meaning: “Primary sources, independent verification, clear uncertainty, and correction structure are strong.”

### News Shell Layers

yaml id=”newsos-shell-layers”
NEWS_SHELL_LAYERS:
event_core:
question: “What happened, or what is claimed to have happened?”
failure: “No event core.”

claim_field:
question: “What exactly is being claimed?”
failure: “Claim is vague, inflated, or shifting.”

source_field:
question: “Who is saying it?”
failure: “Source is missing, circular, anonymous, or unaccountable.”

evidence_pathway:
question: “How do we know?”
failure: “Evidence is weak, missing, manipulated, or untraceable.”

time_anchor:
question: “When did it happen, and when was it reported?”
failure: “Time is unclear, stale, recycled, or misleading.”

location_anchor:
question: “Where did it happen?”
failure: “Place is unclear or misattributed.”

actor_map:
question: “Who is involved?”
failure: “Actors are unnamed, misnamed, or flattened.”

frame_field:
question: “How is the event being interpreted?”
failure: “Frame overwhelms event core.”

incentive_field:
question: “Who benefits from this framing, timing, or omission?”
failure: “Incentives are hidden.”

uncertainty_field:
question: “What remains unknown?”
failure: “Uncertainty is concealed.”

correction_pathway:
question: “Can the report be updated, corrected, downgraded, or retracted?”
failure: “No correction pathway.”

public_relevance:
question: “Why should people know?”
failure: “Relevance is inflated, unclear, or manufactured.”

action_relevance:
question: “Does this require action, awareness, caution, or waiting?”
failure: “Reader is pushed toward reaction without evidence.”

			
---
## Axis 3 — Claim Strength

yaml id=”newsos-claim-strength”
CLAIM_STRENGTH:
CL0:
name: “Noise / unstructured signal”
meaning: “Signal exists but no clear claim is formed.”

CL1:
name: “Rumour / unverified claim”
meaning: “Claim exists but is not verified.”

CL2:
name: “Reported claim”
meaning: “Claim is reported by a source, but not yet confirmed.”

CL3:
name: “Official statement / attributed claim”
meaning: “A named authority, institution, actor, or source has made an accountable claim.”

CL4:
name: “Confirmed event”
meaning: “The event is confirmed by credible evidence or independent confirmation.”

CL5:
name: “Implementation proof / documented action”
meaning: “The claim has evidence of actual execution, document trail, filing, law, data, physical movement, or observed implementation.”

CL6:
name: “Structural change / durable reality shift”
meaning: “The event has become a durable system-level change.”

Claim-strength rule:

yaml id=”newsos-claim-strength-rule”
CLAIM_STRENGTH_RULE:

“Virality does not raise claim strength.”
“Repetition does not equal confirmation.”
“An official statement is not the same as implementation proof.”
“A forecast is not an event.”
“A weak signal is not structural change.”

			
---
## Axis 4 — Source Integrity

yaml id=”newsos-source-integrity”
SOURCE_INTEGRITY:
SI0:
name: “Unknown / anonymous / no source path”
meaning: “Source cannot be traced.”

SI1:
name: “Weak source / unclear accountability”
meaning: “Source exists but credibility or accountability is weak.”

SI2:
name: “Single attributed source”
meaning: “One named source or outlet reports it.”

SI3:
name: “Multiple sources but weak independence”
meaning: “Several sources report it, but may rely on the same origin.”

SI4:
name: “Independent credible sources / official documents”
meaning: “Sources are credible, accountable, and not merely circular.”

SI5:
name: “Primary-source anchored / verifiable record”
meaning: “Primary document, direct data, official record, court filing, transcript, image, sensor, or observable implementation supports the claim.”

Source-integrity rule:

yaml id=”newsos-source-rule”
SOURCE_RULE:
“Always distinguish multiple independent sources from multiple copies of one source.”

			
---
## Axis 5 — Frame State

yaml id=”newsos-frame-state”
FRAME_STATE:
FR0:
name: “No clear frame / raw signal”
meaning: “Signal has little interpretation attached.”

FR1:
name: “Low-frame factual report”
meaning: “Report mostly separates event from interpretation.”

FR2:
name: “Moderate framing”
meaning: “Interpretation exists but does not overwhelm the evidence.”

FR3:
name: “Strong narrative framing”
meaning: “Reader interpretation is strongly guided.”

FR4:
name: “Polarised / adversarial framing”
meaning: “Frame pushes identity, conflict, blame, fear, outrage, or factional interpretation.”

FR5:
name: “Manipulative / laundering / propaganda frame”
meaning: “Frame is designed to move belief or emotion while hiding evidence weakness, incentives, or uncertainty.”

Frame rule:

yaml id=”newsos-frame-rule”
FRAME_RULE:

“Frame is not automatically bad.”
“A frame becomes dangerous when it hides claim boundaries, source weakness, uncertainty, or alternative explanations.”

			
---
## Axis 6 — News Condition Class

yaml id=”newsos-condition-class”
NEWS_CONDITION_CLASS:
NC0: “Pre-News Signal”
NC1: “Emerging News”
NC2: “Functional News”
NC3: “Thin News”
NC4: “Framed News”
NC5: “Captured News”
NC6: “Inverted News”
NC7: “Fragmented News”
NC8: “Decaying News”
NC9: “Corrected / Repairing News”
NC10: “Structural News”
NC11: “Purple Signal / Early Corridor News”

			
---
## Axis 7 — Trajectory

yaml id=”newsos-trajectory-axis”
TRAJECTORY:
T+:
name: “Clarifying / strengthening”
meaning: “Evidence, source clarity, correction, or public understanding are improving.”

T0:
name: “Stable / no clear movement”
meaning: “No strong directional change is visible.”

T-:
name: “Degrading / confusing”
meaning: “Evidence, source clarity, correction, or public understanding are weakening.”

TX:
name: “Volatile / fast-changing / unclear”
meaning: “Facts, claims, sources, or frames are changing quickly or remain contested.”

			
---
## Axis 8 — Confidence

yaml id=”newsos-confidence-axis”
CONFIDENCE:
K1:
name: “Low confidence”
meaning: “Evidence is weak, speculative, or unverified.”

K2:
name: “Limited confidence”
meaning: “Some evidence exists, but source, scope, or interpretation is uncertain.”

K3:
name: “Medium confidence”
meaning: “Evidence is plausible and structured, but not strong enough for high confidence.”

K4:
name: “High confidence”
meaning: “Evidence is strong, credible, multi-layered, or independently supported.”

K5:
name: “Very high confidence”
meaning: “Evidence is primary-source anchored, repeatedly verified, or structurally confirmed.”

			
---
# 5. News Condition Classes
## NC0 — Pre-News Signal

yaml id=”newsos-nc0″
NC0_PRE_NEWS_SIGNAL:
id: “NEWS.NC0.PRE_SIGNAL”
status: “Not yet news”
core_signal: “A signal exists, but claim, source, evidence, or relevance is not yet formed.”
signs:
– “vague post”
– “screenshot with no context”
– “rumour”
– “single unexplained image”
– “claim with no time or place”
– “viral phrase before facts are known”
key_question:
“Is there enough event, claim, source, evidence, timing, and relevance to treat this as news?”

			
---
## NC1 — Emerging News

yaml id=”newsos-nc1″
NC1_EMERGING_NEWS:
id: “NEWS.NC1.EMERGING”
status: “Beginning news”
core_signal: “A claim is forming, but evidence and context are still incomplete.”
signs:
– “first report appears”
– “witnesses begin posting”
– “authorities may not yet confirm”
– “details are changing”
– “multiple versions exist”
– “fog-of-war is high”
reader_posture:
“Watch, verify, do not over-commit.”

			
---
## NC2 — Functional News

yaml id=”newsos-nc2″
NC2_FUNCTIONAL_NEWS:
id: “NEWS.NC2.FUNCTIONAL”
status: “Usable public news”
core_signal: “The event, claim, source, evidence, timing, and relevance are clear enough for public understanding.”
requires_separation:
– “what happened”
– “who said it”
– “what is known”
– “what is not known”
– “why it matters”
– “what may change”
key_question:
“Does this report help the public understand reality more clearly?”

			
---
## NC3 — Thin News

yaml id=”newsos-nc3″
NC3_THIN_NEWS:
id: “NEWS.NC3.THIN”
status: “Visible but shallow”
core_signal: “The report exists, but depth, context, evidence, or relevance is weak.”
signs:
– “headline without background”
– “short post without context”
– “event with no explanation”
– “numbers without comparison”
– “quote without source history”
– “claim without consequences”
– “public reaction without event core”
note:
“Thin news is not always false. It is incomplete.”

			
---
## NC4 — Framed News

yaml id=”newsos-nc4″
NC4_FRAMED_NEWS:
id: “NEWS.NC4.FRAMED”
status: “News with strong interpretation layer”
core_signal: “The report guides the reader’s interpretation strongly.”
healthy_version:
– “event is clear”
– “evidence is clear”
– “interpretation is labelled”
– “uncertainty is stated”
unhealthy_version:
– “event, claim, and interpretation are blended”
– “reader is pushed toward conclusion before evidence is established”
– “alternative explanations are excluded”
key_question:
“Is the frame helping understanding or replacing evidence?”

			
---
## NC5 — Captured News

yaml id=”newsos-nc5″
NC5_CAPTURED_NEWS:
id: “NEWS.NC5.CAPTURED”
status: “News bent toward a narrower interest”
core_signal: “The news function serves power, profit, ideology, faction, platform incentive, or emotional capture.”
capture_agents:
– “political interest”
– “advertiser interest”
– “state interest”
– “platform algorithm”
– “identity group”
– “financial incentive”
– “ideological network”
– “audience addiction”
– “institutional self-protection”
signs:
– “facts selected to serve a preferred conclusion”
– “silence is as important as speech”
– “timing supports an agenda”
– “emotion is amplified”
– “correction is minimised”
key_question:
“Who benefits if the reader accepts this frame?”

			
---
## NC6 — Inverted News

yaml id=”newsos-nc6″
NC6_INVERTED_NEWS:
id: “NEWS.NC6.INVERTED”
status: “News whose function has reversed”
core_signal: “The news shell remains, but it makes reality harder to see.”
signs:
– “information creates confusion”
– “headlines replace understanding”
– “emotion replaces evidence”
– “repetition replaces verification”
– “narrative replaces event core”
– “opinion hides as fact”
– “noise overwhelms correction”
– “reader consumes more but understands less”
distinction:
“Inverted news is not merely biased news. It is reversed-function news.”

			
---
## NC7 — Fragmented News

yaml id=”newsos-nc7″
NC7_FRAGMENTED_NEWS:
id: “NEWS.NC7.FRAGMENTED”
status: “Public reality split into incompatible news shells”
core_signal: “Different groups receive different realities.”
signs:
– “people no longer agree on what happened”
– “platforms create separate event worlds”
– “claims circulate inside separate communities”
– “correction does not cross group boundaries”
– “shared public reality weakens”
– “each group trusts only its own signal system”
key_question:
“Can correction still cross between audience worlds?”

			
---
## NC8 — Decaying News

yaml id=”newsos-nc8″
NC8_DECAYING_NEWS:
id: “NEWS.NC8.DECAYING”
status: “News system losing reliability over time”
core_signal: “Correction, context, source integrity, and public trust weaken.”
signs:
– “more outrage”
– “less context”
– “more repetition”
– “less verification”
– “more speed”
– “less correction”
– “more emotional capture”
– “less public trust”
– “more audience segmentation”
– “less shared reality”
key_question:
“Is the news system weakening society’s ability to know what is happening?”

			
---
## NC9 — Corrected / Repairing News

yaml id=”newsos-nc9″
NC9_CORRECTED_REPAIRING_NEWS:
id: “NEWS.NC9.REPAIRING”
status: “News being updated, corrected, clarified, or re-grounded”
core_signal: “The report repairs its relation to reality.”
signs:
– “correction issued”
– “new evidence added”
– “headline updated”
– “uncertainty clarified”
– “wrong claim withdrawn”
– “source error acknowledged”
– “context added”
– “claim strength downgraded or upgraded properly”
core_rule:
“Correction is not weakness. Correction is how news stays connected to reality.”

			
---
## NC10 — Structural News

yaml id=”newsos-nc10″
NC10_STRUCTURAL_NEWS:
id: “NEWS.NC10.STRUCTURAL”
status: “News that reveals durable system change”
core_signal: “The event is not just one event; it signals a structural shift.”
examples:
– “new law implemented”
– “trade route permanently changes”
– “supply chain relocates”
– “war changes borders”
– “technology changes labour structure”
– “currency regime shifts”
– “demographic pattern becomes policy-relevant”
– “recurring climate event changes planning”
key_question:
“Does this event change the structure of future choices?”

			
---
## NC11 — Purple Signal / Early Corridor News

yaml id=”newsos-nc11″
NC11_PURPLE_SIGNAL_EARLY_CORRIDOR_NEWS:
id: “NEWS.NC11.PURPLE_SIGNAL”
status: “Weak or early signal that may point toward future corridor movement”
core_signal: “A small signal may indicate a larger direction before mainstream confirmation.”
allowed_examples:
– “unusual shipping movement”
– “commodity demand shift”
– “energy load pattern”
– “job postings changing”
– “freight rate movement”
– “search trends”
– “procurement language changes”
– “military logistics hints”
– “policy language shifts”
– “factory activity changes”
– “port activity changes”
– “company filing language changes”
critical_rule:
“Purple Signal is not proof. It is an early watch item that must be tracked across time and evidence layers.”
output_status_options:
– “watch”
– “track”
– “upgrade”
– “downgrade”
– “archive”
– “publish with caution”

			
---
# 6. NewsOS Movement Map

yaml id=”newsos-movement-map”
NEWS_MOVEMENT_MAP:
healthy_route:
– “NC0 Pre-News Signal”
– “NC1 Emerging News”
– “NC2 Functional News”
– “NC10 Structural News if durable system change is proven”

weakening_route:
– “NC2 Functional News”
– “NC3 Thin News”
– “NC4 Framed News”
– “NC5 Captured News”
– “NC6 Inverted News”
– “NC7 Fragmented News”
– “NC8 Decaying News”

repair_route:
– “NC3 / NC4 / NC5 / NC6 / NC7 / NC8”
– “claim restated”
– “source rechecked”
– “evidence added”
– “uncertainty clarified”
– “frame separated”
– “correction issued”
– “NC9 Corrected / Repairing News”
– “NC2 Functional News”

purple_route:
– “NC0 Signal”
– “NC11 Purple Signal”
– “track across time”
– “upgrade if evidence hardens”
– “downgrade if signal fails”
– “NC10 Structural News only if durable system change is proven”

			
---
# 7. News Failure Classes

yaml id=”newsos-failure-classes”
NEWS_FAILURE_CLASSES:
NF0:
name: “No event core”
meaning: “The report does not clearly state what happened.”

NF1:
name: “Unclear claim”
meaning: “The exact claim is vague, shifting, or inflated.”

NF2:
name: “No source pathway”
meaning: “The source cannot be traced or held accountable.”

NF3:
name: “Weak evidence”
meaning: “Evidence does not support the claim strongly enough.”

NF4:
name: “Time/place confusion”
meaning: “The report misleads or confuses when or where something happened.”

NF5:
name: “Frame overpowers fact”
meaning: “Interpretation dominates event core and evidence.”

NF6:
name: “Omission distortion”
meaning: “Important context is missing in a way that changes understanding.”

NF7:
name: “Circular sourcing”
meaning: “Multiple reports trace back to the same weak origin.”

NF8:
name: “Opinion/fact blending”
meaning: “Commentary is presented as fact.”

NF9:
name: “Correction failure”
meaning: “Errors are not corrected, or corrections do not reach the audience.”

NF10:
name: “Algorithmic amplification failure”
meaning: “Platform spread increases visibility without increasing truth value.”

NF11:
name: “Narrative capture”
meaning: “A preferred story controls how evidence is selected or interpreted.”

NF12:
name: “Public-reality damage”
meaning: “The report weakens society’s ability to share reality and coordinate.”

Failure class append example:

yaml id=”newsos-failure-example”
FAILURE_APPEND_EXAMPLE:
id:
“NEWS.L4.NSC2.CL2.SI2.FR4.NC6.T-.K3 + NF5 + NF8 + NF11”
meaning:
“National reported-claim news shell, single-source attribution, polarised framing, inverted news, deteriorating, with frame-over-fact, opinion/fact blending, and narrative capture.”

			
---
# 8. Purple Signal Layer

yaml id=”newsos-purple-signal-layer”
PURPLE_SIGNAL_LAYER:
parent_branch:
“The Purple Intelligence Machine / Purple Report”

purpose:
“Detect early signals that may indicate future corridor movement before mainstream confirmation.”

rule:
“Purple Signal is not proof. It is a watch item.”

allowed_signal_families:
logistics:
– “shipping movement”
– “freight rates”
– “port activity”
– “air cargo”
– “AIS vessel movement”

			
energy_materials:
  - "energy demand"
  - "electricity load"
  - "commodity demand"
  - "oil storage signals"
  - "critical minerals movement"
economic:
  - "job postings"
  - "company filings"
  - "procurement language"
  - "capex language"
  - "supply-chain rerouting"
public_attention:
  - "search trends"
  - "Wikipedia page views"
  - "social media velocity"
  - "media attention shifts"
governance_security:
  - "policy language"
  - "official visits"
  - "military logistics signals"
  - "sanctions wording"
  - "export-control language"
physical_environment:
  - "satellite-visible activity"
  - "nighttime lights"
  - "factory activity"
  - "port congestion"
  - "infrastructure activity"

		

release_labels:
WATCH:
meaning: “Signal noticed but not yet strong enough for public claim.”

			
TRACK:
  meaning: "Signal should be monitored across time."
UPGRADE:
  meaning: "Evidence has strengthened."
DOWNGRADE:
  meaning: "Signal failed to survive checking."
ARCHIVE:
  meaning: "Keep for future reference but do not foreground."
PUBLISH_WITH_CAUTION:
  meaning: "Can be publicly mentioned as early signal with explicit uncertainty."

		

forbidden_moves:
– “Do not call Purple Signal confirmed news.”
– “Do not call weak signal structural change.”
– “Do not turn watch item into prediction without confidence label.”
– “Do not hide uncertainty.”
– “Do not claim intent from signal alone.”

Purple Signal ID example:

yaml id=”newsos-purple-id-example”
PURPLE_SIGNAL_ID_EXAMPLE:
native_id:
“NEWS.L5.NSC2.CL2.SI3.FR1.NC11.TX.K2”
civos_overlay:
“CIVOS.FILTER-SHELL.NEWS.Z5.P1.T1.LNEU.R1.K2”
public_label:
“Early corridor signal; not yet confirmed structural news.”

			
---
# 9. News Repair Sequence

yaml id=”newsos-repair-sequence”
NEWS_REPAIR_SEQUENCE:
step_1_pause:
action: “Do not overclaim during uncertainty.”
diagnostic_questions:
– “What is actually known?”
– “What is only claimed?”
– “What is still unknown?”
– “What is changing quickly?”

step_2_restate_claim:
action: “Separate what happened, what is claimed, and what is interpreted.”
output:
– “event core”
– “reported claim”
– “interpretation”
– “uncertainty”

step_3_source_check:
action: “Identify source path and accountability.”
checks:
– “original source”
– “primary source if available”
– “independent confirmation”
– “circular sourcing risk”

step_4_evidence_check:
action: “Attach evidence or downgrade claim strength.”
outputs:
– “upgrade claim strength”
– “hold claim strength”
– “downgrade claim strength”
– “archive as unsupported”

step_5_frame_check:
action: “Separate event core from interpretation.”
checks:
– “emotional loading”
– “identity trigger”
– “blame direction”
– “missing alternative explanation”
– “beneficiary of frame”

step_6_uncertainty_label:
action: “State what is unknown.”
rule:
“Uncertainty is not weakness; it is part of truthful news.”

step_7_correction:
action: “Correct, update, retract, or clarify.”
options:
– “correction”
– “update”
– “downgrade”
– “retraction”
– “context addition”
– “claim split”

step_8_time_audit:
action: “Check whether the claim survives later evidence.”
time_slices:
– “first report”
– “24h check”
– “7d check”
– “30d check”
– “structural effect check”

step_9_archive:
action: “Preserve corrected record for future reference.”

			
---
# 10. NewsOS Classification Sequence

yaml id=”newsos-classification-sequence”
NEWS_CLASSIFICATION_SEQUENCE:
step_1_define_unit:
question: “What news unit are we classifying?”
examples:
– “rumour”
– “social post”
– “article”
– “press release”
– “official statement”
– “court filing”
– “policy announcement”
– “investigative report”
– “battlefield update”
– “market signal”
– “scientific report”
– “weak signal”
– “Purple Report watch item”

step_2_find_event_core:
question: “What happened, or what is claimed to have happened?”

step_3_extract_claim:
question: “What exact claim is being made?”

step_4_check_source:
question: “Who says this, and can the source path be verified?”

step_5_check_evidence:
question: “What evidence supports the claim?”

step_6_check_time_and_place:
question: “When and where did this happen?”

step_7_check_frame:
question: “How is the reader being guided to interpret this?”

step_8_check_incentive:
question: “Who benefits from this framing, timing, or omission?”

step_9_check_uncertainty:
question: “What remains unknown?”

step_10_assign_level:
question: “What level is the news operating at?”
output: “L0-L6”

step_11_assign_shell_completeness:
question: “How complete is the news shell?”
output: “NSC0-NSC5”

step_12_assign_claim_strength:
question: “How strong is the claim?”
output: “CL0-CL6”

step_13_assign_source_integrity:
question: “How reliable and traceable is the source pathway?”
output: “SI0-SI5”

step_14_assign_frame_state:
question: “How strongly is the report framed?”
output: “FR0-FR5”

step_15_assign_condition_class:
question: “Which news condition class best fits?”
output: “NC0-NC11”

step_16_assign_trajectory:
question: “Is it clarifying, stable, degrading, or volatile?”
output: “T+ / T0 / T- / TX”

step_17_assign_confidence:
question: “How strong is the evidence?”
output: “K1-K5”

step_18_output_native_id:
format: “NEWS.[L].[NSC].[CL].[SI].[FR].[NC].[T].[K]”

step_19_translate_to_civos_overlay:
format: “CIVOS.FILTER-SHELL.NEWS.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

step_20_derive_condition:
output:
– “news condition”
– “CivOS filter-shell condition”
– “failure classes if any”
– “repair/watch recommendation”

			
---
# 11. Native-to-CivOS Translation Guide

yaml id=”newsos-native-to-civos”
NATIVE_TO_CIVOS_TRANSLATION:
level_to_zoom:
L0: “Z0”
L1: “Z1”
L2: “Z2”
L3: “Z3-Z4”
L4: “Z5”
L5: “Z5-Z6”
L6: “Z6”

shell_to_phase_guidance:
NSC0: “usually P0”
NSC1: “usually P1”
NSC2: “usually P1-P2”
NSC3: “usually P2”
NSC4: “usually P2-P3”
NSC5: “usually P3, or P4 only for robust structural intelligence systems with correction and learning”

claim_strength_to_phase_guidance:
CL0: “P0/P1”
CL1: “P1”
CL2: “P1-P2”
CL3: “P2”
CL4: “P2-P3”
CL5: “P3”
CL6: “P3-P4 if durable structural change is verified”

condition_to_lattice_guidance:
NC0: “LNEU or LNEG depending on risk”
NC1: “LNEU”
NC2: “LPOS or LNEU”
NC3: “LNEU or LNEG”
NC4: “LNEU or LNEG depending on transparency”
NC5: “LNEG or LINV”
NC6: “LINV”
NC7: “LNEG”
NC8: “LNEG”
NC9: “LPOS”
NC10: “LPOS, LNEU, or LNEG depending on structural effect”
NC11: “LNEU by default until evidence hardens”

source_integrity_to_repair_guidance:
SI0: “R0”
SI1: “R1”
SI2: “R2”
SI3: “R2-R3”
SI4: “R3-R4”
SI5: “R4-R5”

confidence_translation:
K1: “K1”
K2: “K2”
K3: “K3”
K4: “K4”
K5: “K5”

			
---
# 12. Example Classifications
## Example 1 — Viral Unverified Screenshot

yaml id=”newsos-example-screenshot”
EXAMPLE_1_VIRAL_UNVERIFIED_SCREENSHOT:
observed_system:
type: “viral screenshot”
level: “L1”
reason: “Signal is circulating but source, time, place, and evidence are unclear.”

native_id:
id: “NEWS.L1.NSC1.CL1.SI0.FR3.NC0.TX.K2”
meaning: “Local/low-scale signal shell, rumour-level claim, unknown source, strong framing, pre-news signal, volatile, limited confidence.”

civos_overlay:
id: “CIVOS.FILTER-SHELL.NEWS.Z1.P1.T0.LNEU.R0.K2”
meaning: “Local civilisation filter shell, fragile signal phase, immediate time slice, neutral lattice, no repair/source pathway, limited confidence.”

derived_condition:
– “NEWS.NC0.PRE_SIGNAL”
– “CIV.SIGNAL-NOT-NEWS”

failure_classes:
– “NF2 No source pathway”
– “NF3 Weak evidence”
– “NF4 Time/place confusion”

action:
“Do not treat as news until source, time, place, and evidence are established.”

			
---
## Example 2 — Official Policy Announcement

yaml id=”newsos-example-policy-announcement”
EXAMPLE_2_OFFICIAL_POLICY_ANNOUNCEMENT:
observed_system:
type: “official policy announcement”
level: “L4”
reason: “A named authority has made an accountable public claim.”

native_id:
id: “NEWS.L4.NSC3.CL3.SI4.FR2.NC2.T0.K4”
meaning: “National basic news shell, official attributed claim, strong source integrity, moderate framing, functional news, stable, high confidence.”

civos_overlay:
id: “CIVOS.FILTER-SHELL.NEWS.Z5.P2.T1.LNEU.R3.K4”
meaning: “Nation-scale civilisation filter shell, repair-capable phase, short horizon, neutral lattice, workable checking, high confidence.”

derived_condition:
– “NEWS.NC2.FUNCTIONAL”
– “CIV.FUNCTIONAL-FILTER-SHELL”

warning:
“Official announcement is not implementation proof. Watch for execution evidence.”

			
---
## Example 3 — Implemented Law With Public Effects

yaml id=”newsos-example-implemented-law”
EXAMPLE_3_IMPLEMENTED_LAW:
observed_system:
type: “implemented law”
level: “L4”
reason: “Documented legal implementation creates durable public effect.”

native_id:
id: “NEWS.L4.NSC5.CL5.SI5.FR1.NC10.T+.K5”
meaning: “National high-integrity news shell, implementation proof, primary-source anchored, low-frame report, structural news, strengthening, very high confidence.”

civos_overlay:
id: “CIVOS.FILTER-SHELL.NEWS.Z5.P3.T6.LPOS.R5.K5”
meaning: “Nation-scale civilisation filter shell, stable phase, medium horizon, positive lattice if implementation improves public reality, adaptive repair, very high confidence.”

derived_condition:
– “NEWS.NC10.STRUCTURAL”
– “CIV.STRUCTURAL-NEWS”

			
---
## Example 4 — Commentary Presented as Fact

yaml id=”newsos-example-commentary-as-fact”
EXAMPLE_4_COMMENTARY_PRESENTED_AS_FACT:
observed_system:
type: “commentary presented as fact”
level: “L4”
issue: “Opinion and interpretation are blended into public factual claim.”

native_id:
id: “NEWS.L4.NSC2.CL2.SI2.FR4.NC6.T-.K3”
meaning: “National reported-claim shell, single-source attribution, polarised framing, inverted news, degrading, medium confidence.”

civos_overlay:
id: “CIVOS.FILTER-SHELL.NEWS.Z5.P1.T1.LINV.R1.K3”
meaning: “Nation-scale civilisation filter shell, fragile phase, short horizon, inverse lattice, weak correction, medium confidence.”

derived_condition:
– “NEWS.NC6.INVERTED”
– “CIV.INVERTED-FILTER-SHELL”

failure_classes:
– “NF5 Frame overpowers fact”
– “NF8 Opinion/fact blending”
– “NF11 Narrative capture”

			
---
## Example 5 — Early Logistics Signal for Purple Report

yaml id=”newsos-example-purple-logistics”
EXAMPLE_5_EARLY_LOGISTICS_SIGNAL:
observed_system:
type: “early logistics signal”
level: “L5”
issue: “Possible corridor movement, but evidence is not yet structural.”

civos_overlay:
id: “CIVOS.FILTER-SHELL.NEWS.Z5.P1.T1.LNEU.R1.K2”
meaning: “International civilisation filter shell, fragile phase, short horizon, neutral lattice, weak repair/checking, limited confidence.”

derived_condition:
– “NEWS.NC11.PURPLE_SIGNAL”
– “CIV.EARLY-SIGNAL”
– “WATCH-NOT-PROOF”

action:
“Track across time. Upgrade only if source integrity, implementation proof, or structural change appears.”

			
---
## Example 6 — Corrected News

yaml id=”newsos-example-corrected-news”
EXAMPLE_6_CORRECTED_NEWS:
observed_system:
type: “news correction”
issue: “Initial claim was wrong or incomplete; report has been corrected.”

native_id:
id: “NEWS.L4.NSC4.CL4.SI4.FR1.NC9.T+.K4”
meaning: “National mature news shell, confirmed claim, strong source integrity, low-frame corrected news, clarifying trajectory, high confidence.”

civos_overlay:
id: “CIVOS.FILTER-SHELL.NEWS.Z5.P2.T1.LPOS.R4.K4”
meaning: “Nation-scale civilisation filter shell, repair-capable phase, short horizon, positive lattice, strong correction repair, high confidence.”

derived_condition:
– “NEWS.NC9.REPAIRING”
– “CIV.REPAIRING-FILTER-SHELL”

note:
“Correction increases integrity when handled transparently.”

			
---
# 13. News vs Its Imitations

yaml id=”newsos-vs-imitations”
NEWS_VS_IMITATION:
rumour:
imitation: “news”
missing:
– “verification”
– “source integrity”

opinion:
imitation: “news”
missing:
– “event-claim separation”

commentary:
imitation: “news”
missing:
– “clear distinction between fact and interpretation”

propaganda:
imitation: “news”
missing:
– “truth-seeking”
– “correction”

advertisement:
imitation: “public information”
missing:
– “independent public-interest function”

viral_content:
imitation: “public importance”
missing:
– “verified relevance”

algorithmic_feed:
imitation: “newsroom”
missing:
– “editorial responsibility”
– “correction pathway”

entertainment:
imitation: “news awareness”
missing:
– “public-reality update function”

screenshot:
imitation: “evidence”
missing:
– “source”
– “time”
– “place”
– “context”

headline:
imitation: “understanding”
missing:
– “event core”
– “evidence”
– “uncertainty”

Core rule:

yaml id=”newsos-imitations-rule”
CORE_RULE:
“Not every signal is news. News begins when a public signal has enough event structure, claim clarity, source pathway, evidence, timing, relevance, and correction capacity to update public reality responsibly.”

			
---
# 14. News Contact Model

yaml id=”newsos-contact-model”
NEWS_CONTACT_MODEL:
NCON0:
name: “No signal”
meaning: “No public signal exists.”

NCON1:
name: “Signal appears”
meaning: “A signal enters attention.”

NCON2:
name: “Claim forms”
meaning: “The signal becomes a claim.”

NCON3:
name: “Source appears”
meaning: “A source pathway becomes visible.”

NCON4:
name: “Evidence attaches”
meaning: “Evidence begins supporting or weakening the claim.”

NCON5:
name: “Frame forms”
meaning: “Interpretation begins shaping public understanding.”

NCON6:
name: “Public spread begins”
meaning: “Signal moves across audience or platforms.”

NCON7:
name: “Verification / contradiction appears”
meaning: “New information tests the claim.”

NCON8:
name: “Correction or confirmation”
meaning: “Claim is corrected, confirmed, downgraded, or rejected.”

NCON9:
name: “Accepted reality / policy / action effect”
meaning: “The signal affects belief, decision, action, policy, or memory.”

Public explanation:

yaml id=”newsos-contact-public”
PUBLIC_EXPLANATION:
“A signal does not become reliable news immediately. It moves from signal to claim, from claim to source, from source to evidence, from evidence to public interpretation, and then toward confirmation, correction, or rejection.”

			
---
# 15. News Time-Slice Model

yaml id=”newsos-time-slice”
NEWS_TIME_SLICE_MODEL:
rule:
“One moment shows a report. Many moments show whether the claim survives.”

time_slices:
T0: “Signal appears”
T1: “First report”
T2: “Source attribution”
T3: “Evidence added”
T4: “Frame competition”
T5: “Correction / contradiction”
T6: “Implementation proof”
T7: “Structural effect”
T8: “Memory / archive / historical record”

core_line:
“News is not only what is said first. News is what survives verification, correction, and time.”

			
---
# 16. Phase 4 Internal Overlay for NewsOS

yaml id=”newsos-phase-4-overlay”
PHASE_4_INTERNAL_OVERLAY:
status: “Internal / technical only unless user asks.”
news_equivalent:
“Advanced civilisation-sensing condition where public signals, weak signals, source systems, correction pathways, and structural watch items can detect early corridor movement without overclaiming.”

valid_when:
– “news shell is NSC4 or NSC5”
– “source integrity is SI4-SI5 for strong claims”
– “Purple Signals are clearly labelled as watch items”
– “claim strength is separated from confidence”
– “correction pathway is active”
– “time-slice audit is used”
– “structural claims require implementation proof or durable change”

invalid_when:
– “weak signal is treated as proof”
– “forecast is treated as event”
– “official statement is treated as implementation”
– “virality is treated as truth”
– “emotion outruns evidence”
– “narrative captures source selection”
– “uncertainty is hidden”

public_translation:
– “early signal reading”
– “structural watch”
– “Purple Report watch item”
– “confidence-bounded analysis”
– “not yet confirmed”

			
---
# 17. Standard NewsOS Output Format

yaml id=”newsos-output-format”
STANDARD_NEWSOS_OUTPUT:
1_observed_news_unit:
required:
– “news item”
– “event core”
– “claim”
– “source”
– “time/place”
– “reason for classification”

2_native_news_id:
required:
– “NEWS ID”
– “meaning”
– “condition class”

3_civos_overlay_id:
required:
– “CivOS overlay”
– “Z/P/T/L/R/K reading”
– “derived civilisation filter-shell condition”

4_diagnostic_reading:
required:
– “claim strength”
– “source integrity”
– “frame state”
– “uncertainty”
– “trajectory”
– “failure classes if any”

5_repair_or_watch:
required:
– “verify”
– “watch”
– “track”
– “upgrade”
– “downgrade”
– “correct”
– “publish with caution”
– “archive”

			
---
# 18. Public Article Translation

yaml id=”newsos-public-translation”
PUBLIC_TRANSLATION:
NEWS.L:
public_phrase: “scale of the news being read”

NSC:
public_phrase: “how complete the news shell is”

CL:
public_phrase: “how strong the claim is”

SI:
public_phrase: “how reliable the source path is”

FR:
public_phrase: “how strongly the news is framed”

NC:
public_phrase: “the news condition”

T:
public_phrase: “whether the report is clarifying, stable, degrading, or volatile”

K:
public_phrase: “how confident the reading is”

CIVOS_OVERLAY:
public_phrase: “how the news affects civilisation’s reality-filter”

			
---
# 19. Purple Report Public Output Bridge

yaml id=”newsos-purple-report-output-bridge”
PURPLE_REPORT_PUBLIC_OUTPUT_BRIDGE:
when_using_newsos_for_purple_report:
public_sections:
– “Executive Read”
– “Strategic Delta”
– “Why It Matters”
– “Corridor Watch”
– “Evidence Signals”
– “Confidence”
– “Urgency”
– “Risk / Opportunity”
– “Alternative Explanation”
– “What to Watch Next”
– “Civilisation Implication”
– “Closing Strategic Takeaway”

internal_to_public_translation:
NEWS_ID:
public_phrase: “signal classification”
CLAIM_STRENGTH:
public_phrase: “how hard the evidence is”
SOURCE_INTEGRITY:
public_phrase: “how reliable the source path is”
FRAME_STATE:
public_phrase: “how much interpretation surrounds the signal”
NC11:
public_phrase: “early signal / watch item”
NC10:
public_phrase: “structural change”
K:
public_phrase: “confidence”
T:
public_phrase: “direction of evidence”

			
---
# 20. Article Runtime Lock

yaml id=”newsos-runtime-lock”
RUNTIME_LOCK:
locked_decisions:
– “NewsOS uses NEWS-SHELL-CLASS v1.1.”
– “News is classified as a public signal / event-claim shell, not species.”
– “Native NEWS ID remains detailed and domain-specific.”
– “CivOS overlay places NewsOS inside CivilisationOS filter shell.”
– “Default CivOS overlay is CIVOS.FILTER-SHELL.NEWS.”
– “News must separate event, claim, source, evidence, frame, timing, uncertainty, and correction.”
– “Purple Signal is NC11 and is always watch-not-proof unless evidence hardens.”
– “Structural News is NC10 and requires durable system change.”
– “Do not confuse virality, rumour, commentary, screenshot, or algorithmic feed with news.”
– “Phase 4 news reading stays internal unless requested.”

next_article:
article_number: 6
title: “CivilisationOS Shell-Lattice Classification System v1.1”
prompt_to_continue:
“Next”

			
---
# 21. Short AI Memory Version

yaml id=”newsos-short-memory”
SHORT_MEMORY:
“NewsOS v1.1 classifies news as a public signal / event-claim shell. Native format: NEWS.[L0-L6].[NSC0-NSC5].[CL0-CL6].[SI0-SI5].[FR0-FR5].[NC0-NC11].[T+/T0/T-/TX].[K1-K5]. Default CivOS overlay: CIVOS.FILTER-SHELL.NEWS.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]. Condition classes: NC0 Pre-News Signal, NC1 Emerging News, NC2 Functional News, NC3 Thin News, NC4 Framed News, NC5 Captured News, NC6 Inverted News, NC7 Fragmented News, NC8 Decaying News, NC9 Corrected/Repairing News, NC10 Structural News, NC11 Purple Signal/Early Corridor News. Purple Signal is watch-not-proof. News must separate event, claim, source, evidence, frame, timing, uncertainty, correction, and consequence.”
“`

Article 6 of 7

CivilisationOS Shell-Lattice Classification System v1.1

Parent Classification System for eduKateSG Full Classification Stack

Full Code for AI Runtime

“`yaml id=”civos-v1-1-header”
ARTICLE_ID: “EKSG.FULLCLASSSTACK.CIVOS.SHELL-LATTICE-CLASS.v1.1”
ARTICLE_NUMBER: 6
STACK_TOTAL: 7

TITLE: “CivilisationOS Shell-Lattice Classification System v1.1”
SUBTITLE: “Parent Classification System for eduKateSG Full Classification Stack”
PUBLIC_OR_INTERNAL: “Full Code for AI Runtime”
AUTHOR_CONTEXT: “eduKateSG”

STATUS:
role: “Parent classification system”
relation_to_child_systems:
SocietyOS: “Child continuity-repair shell”
CultureOS: “Child memory/meaning shell”
TeamworkOS: “Child coordination shell”
NewsOS: “Child filter/reality-update shell”

RUNTIME_TRIGGER:
SIMPLE_TRIGGER:
– “Use CivilisationOS classification”
– “Use CivOS Shell-Lattice Classification”
– “Classify civilisation”
– “Use CivOS parent system”
– “Use Z P T L R K”
– “Use civilisation shell-lattice”
– “Use eduKateSG CivOS classification”
– “Use eduKateSG Full Classification Stack”

FULL_TRIGGER:
“Use eduKateSG CivilisationOS Shell-Lattice Classification System v1.1 as the parent classification grammar. Classify civilisation by shell type, core system, zoom level, phase, time horizon, lattice state, repair capacity, and confidence. Do not create a separate species-style civilisation taxonomy. Derive condition labels from the shell-lattice reading.”

SURFACE_RULE:
reader_facing:
– “Do not overload readers with IDs.”
– “Use simple public translations: shell = structure that holds; phase = operating condition; lattice = direction; repair = ability to fix damage.”
– “Do not mention Phase 4 mechanics unless explicitly requested.”
– “Use examples such as education, trust, food, water, energy, language, law, news, culture, and infrastructure.”
code_facing:
– “Expose full CIVOS ID.”
– “Use existing CivOS shell-lattice grammar.”
– “Use Z/P/T/L/R/K.”
– “Add derived condition labels.”
– “Align child systems upward when needed.”

			
---
# 1. Canonical Name

yaml id=”civos-canon-v1-1″
CANONICAL_NAME:
“CivilisationOS Shell-Lattice Classification System v1.1”

SHORT_NAME:
“CIVOS-SHELL-LATTICE-CLASS v1.1”

SYSTEM_TYPE:
“CivilisationOS”

UNIT_OF_ANALYSIS:
“Civilisation continuity shell / civilisation load-bearing system”

PARENT_ROLE:
“Root / parent classification system for eduKateSG Full Classification Stack”

CORE_LINE:
“Civilisation is not merely a large society. Civilisation is a continuity machine: it survives when its shells can hold, filter, repair, transfer, and regenerate life, memory, infrastructure, trust, and knowledge through time.”

PUBLIC_DEFINITION:
“Civilisation is a compounding human operating system that preserves knowledge, coordinates cooperation, builds surplus and buffers, and maintains institutions across generations under real constraints.”

SHELL_DEFINITION:
“A civilisation shell is the boundary-and-repair structure that allows civilisation to hold shape, protect its core systems, filter pressure, repair damage, and transfer life, memory, infrastructure, trust, and knowledge across time.”

NOT_CIVILISATION_DEFINITION:
“A thing is not yet civilisation when it has people, power, wealth, monuments, technology, or territory, but cannot preserve knowledge, coordinate cooperation, repair damage, maintain institutions, and transfer continuity across generations.”

ALIGNMENT_RULE:
“Do not create a competing civilisation classification family. CivilisationOS already uses shell + lattice + zoom + phase + time + repair grammar.”

			
---
# 2. Parent CivOS ID Format

yaml id=”civos-native-id-format”
CIVOS_NATIVE_ID:
formula:
“CIVOS.[SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

example:
id: “CIVOS.CONTINUITY-REPAIR-SHELL.EDUCATION.Z2.P3.T6.LPOS.R4.K4”
meaning: “Institution-scale civilisation continuity-repair shell, education core system, stable phase, medium horizon, positive lattice, strong repair, high confidence.”

FIELD_ORDER:
CIVOS:
meaning: “CivilisationOS classification object”

SHELLTYPE:
meaning: “Which civilisation shell is being read”

CORE_SYSTEM:
meaning: “Which load-bearing system is under analysis”

Z:
meaning: “Zoom level / scale”

P:
meaning: “Phase / operating condition”

T:
meaning: “Time slice or time horizon”

L:
meaning: “Lattice direction”

R:
meaning: “Repair capacity”

K:
meaning: “Confidence”

			
---
# 3. Civilisation Shell Types

yaml id=”civos-shell-types”
CIVILISATION_SHELL_TYPES:
CORE-SHELL:
function: “Holds the civilisation identity, continuity, memory, and load-bearing centre.”
public_translation: “the civilisation core”

BOUNDARY-SHELL:
function: “Defines what enters, exits, belongs, threatens, or must be filtered.”
public_translation: “the civilisation boundary”

FILTER-SHELL:
function: “Filters signals, pressure, claims, technologies, people, trade, and risks.”
public_translation: “the civilisation filter”

MEMORY-SHELL:
function: “Preserves history, knowledge, records, lessons, culture, and identity.”
public_translation: “the civilisation memory”

INFRASTRUCTURE-SHELL:
function: “Carries food, water, energy, transport, communication, housing, health, logistics, and physical continuity.”
public_translation: “the physical carrying structure”

TRUST-SHELL:
function: “Holds legitimacy, public belief, law, norms, institutions, and cooperation.”
public_translation: “the trust layer”

REPAIR-SHELL:
function: “Detects damage, routes repair, restores function, and prevents drift from compounding.”
public_translation: “the repair system”

CONTINUITY-REPAIR-SHELL:
function: “Carries social continuity while enabling correction, protection, transmission, and repair.”
public_translation: “the social continuity and repair layer”

COORDINATION-SHELL:
function: “Coordinates mission, roles, timing, authority, communication, and load across people and institutions.”
public_translation: “the coordination layer”

FRONTIER-SHELL:
function: “Projects civilisation outward only when the base shell can afford it.”
public_translation: “the frontier extension layer”

			
---
# 4. Civilisation Core Systems

yaml id=”civos-core-systems”
CIVILISATION_CORE_SYSTEMS:
FOOD:
function: “Keeps population alive.”
failure_mode: “hunger, instability, migration, conflict, collapse pressure”

WATER:
function: “Maintains life, health, agriculture, sanitation, and settlement.”
failure_mode: “disease, displacement, conflict, infrastructure breakdown”

ENERGY:
function: “Powers work, infrastructure, production, mobility, computation, and modern systems.”
failure_mode: “system slowdown, industrial failure, household stress, strategic vulnerability”

LAW:
function: “Constrains violence and stabilises justice.”
failure_mode: “power without restraint, legitimacy collapse, private force”

LANGUAGE:
function: “Carries coordination, knowledge, memory, command, and shared reality.”
failure_mode: “meaning collapse, misunderstanding, manipulation, coordination failure”

EDUCATION:
function: “Transfers capability across generations.”
failure_mode: “future capability collapse, social immobility, weak judgement, brittle workforce”

TRUST:
function: “Reduces social friction and allows cooperation.”
failure_mode: “transaction cost explosion, fragmentation, defensive society, low cooperation”

MEMORY:
function: “Prevents civilisational reset and preserves learning.”
failure_mode: “repeated mistakes, identity thinning, loss of inherited wisdom”

HEALTH:
function: “Keeps the human base functional.”
failure_mode: “labour loss, suffering, reduced resilience, social cost escalation”

ENVIRONMENT:
function: “Maintains the natural floor that civilisation depends on.”
failure_mode: “resource stress, disaster exposure, food/water/health instability”

INFRASTRUCTURE:
function: “Carries physical civilisation.”
failure_mode: “movement failure, supply failure, housing stress, communication breakdown”

GOVERNANCE:
function: “Coordinates public decisions and repair.”
failure_mode: “decision paralysis, legitimacy failure, capture, drift”

DEFENCE:
function: “Protects boundary and survival.”
failure_mode: “invasion risk, coercion, internal insecurity, boundary collapse”

ECONOMY:
function: “Circulates value, labour, production, surplus, and allocation.”
failure_mode: “poverty, inequality stress, extraction, unsustainable debt, social instability”

TECHNOLOGY:
function: “Extends capability without consuming the base.”
failure_mode: “capture, dependency, attention collapse, unequal power, uncontrolled risk”

REPAIR:
function: “Detects, corrects, and restores damaged systems.”
failure_mode: “damage compounds faster than correction”

SOCIETY:
function: “Carries human social continuity, trust, rules, protection, and transmission.”
failure_mode: “social thinning, fragmentation, inverted institutions, below-threshold society”

CULTURE:
function: “Carries meaning, memory, identity, values, and emotional transmission.”
failure_mode: “thin culture, captured culture, inverted culture, heritage hollowing”

TEAMWORK:
function: “Coordinates human capability across roles, mission, timing, load, and repair.”
failure_mode: “coordination failure, role mismatch, hidden overload, ego capture”

NEWS:
function: “Filters public signals and updates shared reality.”
failure_mode: “inverted news, fragmented reality, narrative capture, correction failure”

			
---
# 5. Zoom Levels

yaml id=”civos-zoom-levels”
ZOOM_LEVELS:
Z0:
name: “Human / skill / role level”
meaning: “Individual competence, language, habits, judgement, courage, attention, and daily role performance.”
failure_signal:
– “people cannot perform basic roles”
– “language weakens”
– “judgement weakens”
– “attention collapses”
– “courage disappears”

Z1:
name: “Family / small-group / local role level”
meaning: “Households, classrooms, teams, neighbourhoods, local trust, and small-group continuity.”
failure_signal:
– “families overloaded”
– “small groups cannot coordinate”
– “local trust weakens”
– “children lose stable floors”

Z2:
name: “Institution level”
meaning: “Schools, hospitals, courts, agencies, companies, ministries, and organised role systems.”
failure_signal:
– “institutions protect image over function”
– “role systems become inverted”
– “repair slows”
– “public trust declines”

Z3:
name: “Network / sector level”
meaning: “Supply chains, education sectors, media systems, health networks, ports, finance, logistics, and large coordination networks.”
failure_signal:
– “network fragmentation”
– “sector bottlenecks”
– “information distortion”
– “coordination lag”

Z4:
name: “City / regional level”
meaning: “Urban systems, regional corridors, infrastructure clusters, local governance, and regional social continuity.”
failure_signal:
– “regional infrastructure stress”
– “urban overload”
– “local governance failure”
– “corridor blockage”

Z5:
name: “State / nation level”
meaning: “National government, national economy, national society, national institutions, national trust, and national continuity.”
failure_signal:
– “legitimacy stress”
– “national trust decline”
– “state capture”
– “national system drift”

Z6:
name: “Civilisation / planetary level”
meaning: “Civilisation-scale continuity, global systems, planetary survival, frontier shells, and intergenerational survival.”
failure_signal:
– “planetary risk”
– “global coordination failure”
– “civilisation-scale infrastructure stress”
– “frontier expansion without base stability”

			
---
# 6. Phase Levels

yaml id=”civos-phase-levels”
PHASE_LEVELS:
P0:
name: “Collapse / failure state”
meaning: “The shell cannot carry its function. Survival mode, blackout, collapse valley, or below-threshold behaviour appears.”
public_phrase: “The floor is broken.”
repair_priority:
– “survival”
– “safety”
– “basic trust”
– “minimum rule”
– “minimum repair loop”

P1:
name: “Fragile / degraded state”
meaning: “The shell still exists but suffers recurring failures, weak buffers, high load, low trust, weak repair, or degraded continuity.”
public_phrase: “The system is standing, but fragile.”
repair_priority:
– “stabilise”
– “reduce load”
– “rebuild basic repair”
– “protect vulnerable nodes”

P2:
name: “Repair-capable / functional state”
meaning: “The system functions and can repair normal damage, but still requires active maintenance.”
public_phrase: “The system works if maintained.”
repair_priority:
– “maintain”
– “correct tilt”
– “prevent capture”
– “strengthen repair”

P3:
name: “Stable / drift-controlled state”
meaning: “The shell is stable enough to hold continuity, control drift, and support higher systems.”
public_phrase: “The system can carry life reliably.”
repair_priority:
– “preserve stability”
– “monitor drift”
– “support controlled growth”
– “protect base”

P4:
name: “Regenerative / surplus-capable state”
meaning: “The shell generates enough surplus to repair itself and support frontier expansion without consuming the base.”
public_phrase: “The system can renew itself and safely extend.”
repair_priority:
– “regenerate”
– “avoid overreach”
– “keep base protected”
– “ensure frontier pays rent to base”
guardrail:
“P4 is valid only when the base remains protected. It is not a prestige badge.”

			
---
# 7. Time Horizon

yaml id=”civos-time-horizon”
TIME_HORIZON:
T0:
name: “Immediate / now”
meaning: “Current visible state.”

T1:
name: “Fast check”
meaning: “Short-term verification window.”

T3:
name: “Short-medium check”
meaning: “Early implementation or stress window.”

T6:
name: “Medium horizon”
meaning: “Enough time for repeated behaviour, early repair, or drift to become visible.”

T12:
name: “One-year / annual horizon”
meaning: “Structural trend and institutional behaviour become clearer.”

T25:
name: “Long-horizon / generational or frontier horizon”
meaning: “Continuity, transfer, regenerative capacity, or collapse debt becomes visible.”

RULE:
“Use T0-T25 flexibly as the time-slice/horizon index. Do not overclaim long-term condition from short-term signal.”

			
---
# 8. Lattice State

yaml id=”civos-lattice-states”
LATTICE_STATE:
LPOS:
name: “Positive lattice”
meaning: “The route strengthens civilisation continuity, repair, truth, trust, capability, welfare, and future.”
public_phrase: “The move strengthens the system.”

LNEG:
name: “Negative lattice”
meaning: “The route damages trust, repair, truth, capability, welfare, or continuity.”
public_phrase: “The move weakens the system.”

LINV:
name: “Inverse lattice”
meaning: “A system uses its legitimate form to produce the opposite of its intended civilisation function.”
public_phrase: “The organ is working backwards.”

			
---
# 9. Repair Capacity

yaml id=”civos-repair-capacity”
REPAIR_CAPACITY:
R0:
name: “No repair”
meaning: “Damage is not detected or cannot be corrected.”

R1:
name: “Weak repair”
meaning: “Damage is noticed but repair is slow, partial, blocked, symbolic, or selective.”

R2:
name: “Partial repair”
meaning: “Some correction exists, but drift and damage still accumulate.”

R3:
name: “Workable repair”
meaning: “Repair can respond to normal damage and maintain function.”

R4:
name: “Strong repair”
meaning: “Repair is faster than normal drift and recurring damage.”

R5:
name: “Adaptive regenerative repair”
meaning: “The system learns from stress, improves, and builds surplus repair capacity.”

Repair formula:

yaml id=”civos-repair-formula”
REPAIR_FORMULA:
core:
“Civilisation Shell Stability = Repair Capacity – Damage Pressure – Drift Load”

interpretation:
positive:
“If repair capacity is greater than damage pressure plus drift load, the shell stabilises or strengthens.”
neutral:
“If repair roughly equals damage plus drift, the shell holds but may not improve.”
negative:
“If damage plus drift exceeds repair, the shell weakens.”
inverse:
“If repair systems themselves produce damage, the shell moves toward inversion.”

			
---
# 10. Confidence Scale

yaml id=”civos-confidence-scale”
CONFIDENCE:
K1:
name: “Low confidence”
meaning: “Evidence is weak, speculative, early, incomplete, or single-source.”

K2:
name: “Limited confidence”
meaning: “Some evidence exists, but source, scale, interpretation, or time horizon remains uncertain.”

K3:
name: “Medium confidence”
meaning: “Evidence is plausible and structured, but not strong enough for high confidence.”

K4:
name: “High confidence”
meaning: “Evidence is strong, repeated, multi-layered, or well-supported.”

K5:
name: “Very high confidence”
meaning: “Evidence is primary-source anchored, structurally confirmed, or repeatedly verified across time.”

			
---
# 11. Derived Civilisation Conditions
CivilisationOS does not need a separate “species” list.
Condition labels are derived from shell, phase, lattice, repair, and time.

yaml id=”civos-derived-conditions”
DERIVED_CIVILISATION_CONDITIONS:
CIV.CONTACT:
condition: “Pre-civilisational contact”
likely_pattern: “Z0-Z1 / P0-P1 / LNEU or LNEG / R0-R1”
meaning: “Human contact exists, but durable civilisation continuity is not yet formed.”

CIV.EMERGING:
condition: “Emerging civilisation”
likely_pattern: “Z1-Z2 / P1-P2 / LNEU-LPOS / R1-R2”
meaning: “Coordination, memory, institutions, and repair are beginning to stabilise.”

CIV.FUNCTIONAL:
condition: “Functional civilisation”
likely_pattern: “Z0-Z5 mostly P2-P3 / LPOS-LNEU / R3”
meaning: “Civilisation functions and can repair ordinary damage.”

CIV.STABLE:
condition: “Stable civilisation”
likely_pattern: “Z0-Z5 mostly P3 / LPOS-LNEU / R3-R4”
meaning: “Civilisation has stable continuity and drift control.”

CIV.REGENERATIVE:
condition: “Regenerative civilisation shell”
likely_pattern: “Selected shells P4, base shells P3+ / LPOS / R4-R5”
meaning: “Civilisation produces surplus without consuming the base.”

CIV.TILTED:
condition: “Tilted civilisation”
likely_pattern: “Mixed P2-P3 with stressed Z0/Z1 or key shell imbalance”
meaning: “Civilisation still functions, but load, repair, or benefit distribution is uneven.”

CIV.CAPTURED:
condition: “Captured civilisation shell”
likely_pattern: “Formal P2-P3 shell, but LNEG or LINV in governance/trust/law/media/economy”
meaning: “A civilisation organ is bent toward a narrower interest.”

CIV.INVERTED:
condition: “Inverted civilisation shell”
likely_pattern: “Visible shell remains, but LINV dominates the organ reading”
meaning: “A civilisation function produces the opposite of its intended purpose.”

CIV.FRAGMENTED:
condition: “Fragmented civilisation shell”
likely_pattern: “Z2-Z6 networks split, shared language/trust/reality weaken, repair does not cross shells”
meaning: “Civilisation parts cannot translate, coordinate, or repair across boundaries.”

CIV.DECAYING:
condition: “Decaying civilisation”
likely_pattern: “P2 falling toward P1; repair R0-R2; drift and load rising”
meaning: “Damage accumulates faster than repair.”

CIV.COLLAPSE:
condition: “Collapse / below-threshold civilisation”
likely_pattern: “P0 across load-bearing shells; repair R0-R1”
meaning: “Civilisation shell cannot carry continuity.”

CIV.REBOOT:
condition: “Civilisation reboot condition”
likely_pattern: “P0/P1 base with targeted repair path toward P2”
meaning: “Civilisation must rebuild from survival floor, trust, repair, and minimum continuity loops.”

			
---
# 12. CivilisationOS Classification Sequence

yaml id=”civos-classification-sequence”
CIVILISATION_CLASSIFICATION_SEQUENCE:
step_1_define_shell:
question: “Which civilisation shell is being classified?”
examples:
– “core shell”
– “boundary shell”
– “filter shell”
– “memory shell”
– “infrastructure shell”
– “trust shell”
– “repair shell”
– “continuity-repair shell”
– “coordination shell”
– “frontier shell”

step_2_define_core_system:
question: “Which load-bearing system is under analysis?”
examples:
– “food”
– “water”
– “energy”
– “law”
– “language”
– “education”
– “trust”
– “memory”
– “health”
– “environment”
– “infrastructure”
– “governance”
– “defence”
– “economy”
– “technology”
– “repair”
– “society”
– “culture”
– “teamwork”
– “news”

step_3_assign_zoom:
question: “At what scale is the shell being read?”
output: “Z0-Z6”

step_4_assign_phase:
question: “Is the shell collapsed, fragile, repair-capable, stable, or regenerative?”
output: “P0-P4”

step_5_assign_time:
question: “What time slice or horizon is being read?”
output: “T0-T25”

step_6_assign_lattice:
question: “Is the route positive, neutral, negative, or inverse?”
output: “LPOS / LNEU / LNEG / LINV”

step_7_assign_repair:
question: “Is repair absent, weak, partial, workable, strong, or adaptive-regenerative?”
output: “R0-R5”

step_8_assign_confidence:
question: “How strong is the evidence?”
output: “K1-K5”

step_9_output_civos_id:
format: “CIVOS.[SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”

step_10_derive_condition:
question: “What civilisation condition follows from the shell-lattice reading?”
output:
– “CIV.CONTACT”
– “CIV.EMERGING”
– “CIV.FUNCTIONAL”
– “CIV.STABLE”
– “CIV.REGENERATIVE”
– “CIV.TILTED”
– “CIV.CAPTURED”
– “CIV.INVERTED”
– “CIV.FRAGMENTED”
– “CIV.DECAYING”
– “CIV.COLLAPSE”
– “CIV.REBOOT”

			
---
# 13. Civilisation Failure Classes

yaml id=”civos-failure-classes”
CIVILISATION_FAILURE_CLASSES:
CFV0:
name: “Core-shell failure”
meaning: “Civilisation loses its load-bearing centre, identity, or continuity logic.”

CFV1:
name: “Boundary failure”
meaning: “Civilisation cannot filter entry, exit, risk, or threat.”

CFV2:
name: “Filter failure”
meaning: “Civilisation cannot distinguish signal from noise, truth from manipulation, or risk from opportunity.”

CFV3:
name: “Memory failure”
meaning: “Civilisation forgets lessons, knowledge, identity, records, or inherited wisdom.”

CFV4:
name: “Infrastructure failure”
meaning: “Physical carrying systems cannot support life, movement, energy, water, health, or logistics.”

CFV5:
name: “Trust failure”
meaning: “Legitimacy, law, public belief, and cooperation degrade.”

CFV6:
name: “Repair failure”
meaning: “Damage cannot be detected, routed, corrected, or repeated into trusted repair.”

CFV7:
name: “Education transfer failure”
meaning: “Capability does not pass properly to the next generation.”

CFV8:
name: “Language / meaning failure”
meaning: “Words cannot carry shared reality or coordination.”

CFV9:
name: “Governance failure”
meaning: “Public decision systems cannot coordinate responsibility or correction.”

CFV10:
name: “Resource floor failure”
meaning: “Food, water, energy, health, or environmental base cannot carry civilisation.”

CFV11:
name: “Future corridor failure”
meaning: “The next generation cannot inherit viable routes.”

CFV12:
name: “Inverse organ failure”
meaning: “A civilisation organ uses its legitimate form to produce the opposite of its function.”

CFV13:
name: “Frontier overreach”
meaning: “Civilisation extends outward faster than the base can safely support.”

CFV14:
name: “Reboot failure”
meaning: “A collapsed or below-threshold shell cannot restart minimum trustworthy loops.”

Failure append example:

yaml id=”civos-failure-example”
FAILURE_APPEND_EXAMPLE:
id:
“CIVOS.FILTER-SHELL.NEWS.Z5.P1.T1.LINV.R1.K3 + CFV2 + CFV8 + CFV12”
meaning:
“Nation-scale news filter shell in fragile inverse condition, weak repair, with filter failure, language/meaning failure, and inverse organ failure.”

			
---
# 14. CivilisationOS Movement Map

yaml id=”civos-movement-map”
CIVILISATION_MOVEMENT_MAP:
formation_route:
– “CIV.CONTACT”
– “CIV.EMERGING”
– “CIV.FUNCTIONAL”
– “CIV.STABLE”
– “CIV.REGENERATIVE”

weakening_route:
– “CIV.FUNCTIONAL”
– “CIV.TILTED”
– “CIV.CAPTURED”
– “CIV.INVERTED”
– “CIV.FRAGMENTED”
– “CIV.DECAYING”
– “CIV.COLLAPSE”

repair_route:
– “CIV.TILTED / CAPTURED / INVERTED / FRAGMENTED / DECAYING”
– “damage named”
– “load-bearing floors protected”
– “core systems stabilised”
– “repair shell restored”
– “trust rebuilt”
– “memory and language reconnected”
– “CIV.FUNCTIONAL”
– “CIV.STABLE”

reboot_route:
– “CIV.COLLAPSE”
– “survival floor”
– “safety”
– “basic trust”
– “minimum rule”
– “minimum repair loop”
– “memory recovery”
– “education transfer”
– “CIV.EMERGING”
– “CIV.FUNCTIONAL”

			
---
# 15. Civilisation Repair Sequence

yaml id=”civos-repair-sequence”
CIVILISATION_REPAIR_SEQUENCE:
step_1_detect:
action: “Detect which shell and core system are failing.”
questions:
– “Which shell is under pressure?”
– “Which core system is damaged?”
– “At which zoom level is damage appearing?”
– “Is the damage local, networked, national, or civilisation-scale?”

step_2_name:
action: “Classify the condition accurately.”
possible_conditions:
– “tilt”
– “capture”
– “inversion”
– “fragmentation”
– “decay”
– “collapse”
– “reboot requirement”
rule:
“Bad naming creates bad civilisation repair.”

step_3_protect_base:
action: “Protect load-bearing floors first.”
protected_base:
– “food”
– “water”
– “energy”
– “health”
– “children”
– “trust”
– “law”
– “education”
– “language”
– “memory”
– “repair channels”

step_4_restore_filter:
action: “Restore the ability to distinguish signal from noise, truth from manipulation, and risk from opportunity.”

step_5_restore_memory:
action: “Recover knowledge, records, history, lessons, and identity.”

step_6_restore_trust:
action: “Reconnect words, rules, institutions, and lived reality.”

step_7_restore_function:
action: “Return organs to their proper work.”
examples:
– “Education transfers capability.”
– “News clarifies reality.”
– “Law restrains power.”
– “Culture transmits meaning.”
– “Governance coordinates responsibility.”
– “Technology extends capability without consuming the base.”

step_8_repair_repeatedly:
action: “Repeat correction long enough for trust and function to return.”

step_9_regenerate_only_if_base_safe:
action: “Move toward frontier/regenerative work only if P3 base shells are protected.”
guardrail:
“No P4 claim is valid if the base is being consumed.”

			
---
# 16. Phase 4 / Frontier Guardrail

yaml id=”civos-phase-4-frontier-guardrail”
PHASE_4_FRONTIER_GUARDRAIL:
status: “Internal / technical unless requested.”
definition:
“P4 is a regenerative or frontier-capable state where a shell produces surplus repair and capability without consuming the base.”

valid_when:
– “base shells are at least P3”
– “repair capacity is R4-R5”
– “lattice is LPOS”
– “frontier work strengthens rather than drains the base”
– “future generations inherit wider floors”
– “damage pressure and drift load remain below repair capacity”

invalid_when:
– “frontier ambition burns education, children, trust, environment, or infrastructure”
– “wealth or prestige is mistaken for regeneration”
– “technology advancement hides social or material decay”
– “P4 is claimed while base shells remain P1/P2 under stress”
– “expansion is funded by unrecorded damage debt”

public_translation:
– “regenerative civilisation”
– “future-carrying civilisation”
– “frontier-capable only if the base is protected”
– “advanced only if repair is stronger than drift”

			
---
# 17. Example Classifications
## Example 1 — Stable Education Shell

yaml id=”civos-example-education-stable”
EXAMPLE_1_STABLE_EDUCATION_SHELL:
observed_system:
shell: “CONTINUITY-REPAIR-SHELL”
core_system: “EDUCATION”
scale: “institution”
issue: “Education transfers capability and repairs learning gaps.”

civos_id:
id: “CIVOS.CONTINUITY-REPAIR-SHELL.EDUCATION.Z2.P3.T6.LPOS.R4.K4”
meaning: “Institution-scale education shell, stable phase, medium time horizon, positive lattice state, strong repair, high confidence.”

derived_condition:
– “CIV.STABLE”
– “positive education continuity shell”

notes:
– “Education is not merely schooling.”
– “Education is civilisation capability transfer.”

			
---
## Example 2 — Media Filter Shell Becoming Inverted

yaml id=”civos-example-media-inverted”
EXAMPLE_2_INVERTED_MEDIA_FILTER_SHELL:
observed_system:
shell: “FILTER-SHELL”
core_system: “MEDIA / NEWS”
scale: “network / national”
issue: “Media shell remains visible but weakens public reality.”

civos_id:
id: “CIVOS.FILTER-SHELL.MEDIA.Z3.P2.T3.LINV.R1.K3”
meaning: “Network-scale media filter shell, repair-capable only in form, short-to-medium horizon, inverse lattice state, weak repair, medium confidence.”

derived_condition:
– “CIV.INVERTED”
– “inverted filter shell”

failure_classes:
– “CFV2 Filter failure”
– “CFV8 Language / meaning failure”
– “CFV12 Inverse organ failure”

			
---
## Example 3 — National Trust Shell Under Tilt

yaml id=”civos-example-national-trust-tilt”
EXAMPLE_3_NATIONAL_TRUST_TILT:
observed_system:
shell: “TRUST-SHELL”
core_system: “NATIONAL-TRUST”
scale: “nation”
issue: “Trust exists but is uneven, stressed, and partially repairable.”

civos_id:
id: “CIVOS.TRUST-SHELL.NATIONAL-TRUST.Z5.P2.T6.LNEU.R2.K3”
meaning: “Nation-scale trust shell, repair-capable but stressed phase, medium horizon, neutral lattice state, partial repair, medium confidence.”

derived_condition:
– “CIV.TILTED”
– “functional but stressed trust shell”

repair_recommendation:
– “reconnect public language to lived reality”
– “repair justice and institutional trust”
– “protect shared facts”

			
---
## Example 4 — Collapse-Risk Infrastructure Shell

yaml id=”civos-example-infra-collapse-risk”
EXAMPLE_4_COLLAPSE_RISK_INFRASTRUCTURE:
observed_system:
shell: “INFRASTRUCTURE-SHELL”
core_system: “ENERGY-WATER”
scale: “regional”
issue: “Energy-water infrastructure is fragile and negatively affecting continuity.”

civos_id:
id: “CIVOS.INFRASTRUCTURE-SHELL.ENERGY-WATER.Z4.P1.T3.LNEG.R1.K4”
meaning: “Regional infrastructure shell focused on energy-water systems, fragile phase, short-to-medium horizon, negative lattice state, weak repair, high confidence.”

derived_condition:
– “CIV.DECAYING”
– “collapse-risk infrastructure shell”

failure_classes:
– “CFV4 Infrastructure failure”
– “CFV10 Resource floor failure”
– “CFV6 Repair failure”

			
---
## Example 5 — Regenerative Frontier Shell

yaml id=”civos-example-frontier-regenerative”
EXAMPLE_5_REGENERATIVE_FRONTIER_SHELL:
observed_system:
shell: “FRONTIER-SHELL”
core_system: “SPACE-LOGISTICS”
scale: “civilisation”
issue: “Long-horizon frontier expansion under uncertainty.”

civos_id:
id: “CIVOS.FRONTIER-SHELL.SPACE-LOGISTICS.Z6.P4.T25.LPOS.R5.K2”
meaning: “Civilisation-scale frontier shell, regenerative phase, long time horizon, positive lattice state, adaptive regenerative repair, limited confidence.”

derived_condition:
– “CIV.REGENERATIVE”
– “frontier shell”

guardrail:
“Valid only if base P3 shells remain protected and frontier activity does not consume Earth/base civilisation floors.”

confidence_note:
“Limited confidence because frontier claims are long-horizon and require future validation.”

			
---
## Example 6 — Civilisation Reboot Condition

yaml id=”civos-example-reboot”
EXAMPLE_6_CIVILISATION_REBOOT:
observed_system:
shell: “REPAIR-SHELL”
core_system: “BASIC-TRUST-SURVIVAL-FLOOR”
scale: “local / regional / post-collapse”
issue: “Minimum social and material floors must be rebuilt.”

civos_id:
id: “CIVOS.REPAIR-SHELL.BASIC-TRUST-SURVIVAL-FLOOR.Z1.P0.T0.LNEG.R0.K3”
meaning: “Local small-group repair shell, collapsed phase, immediate horizon, negative lattice, no repair capacity, medium confidence.”

derived_condition:
– “CIV.REBOOT”
– “below-threshold repair start”

repair_priority:
– “safety”
– “food”
– “water”
– “basic rule”
– “trust”
– “repair loop”
– “memory”
– “education transfer”

			
---
# 18. Civilisation vs Its Imitations

yaml id=”civos-vs-imitations”
CIVILISATION_VS_IMITATION:
city:
imitation: “civilisation”
missing:
– “intergenerational continuity”
– “repair”
– “memory”
– “system transfer”

monument:
imitation: “civilisation strength”
missing:
– “living repair”
– “load-bearing function”

empire:
imitation: “civilisation”
missing:
– “may project power without sustainable repair”

technology:
imitation: “civilisation advancement”
missing:
– “trust”
– “repair”
– “wisdom”
– “continuity”

wealth:
imitation: “civilisation strength”
missing:
– “regeneration”
– “shock survival”
– “future transfer”

population:
imitation: “civilisation scale”
missing:
– “coordination”
– “memory”
– “institutions”
– “repair”

bureaucracy:
imitation: “civilisation order”
missing:
– “living legitimacy”
– “adaptive correction”

military_power:
imitation: “civilisation security”
missing:
– “civilian continuity”
– “regenerative base”

cultural_prestige:
imitation: “civilisation health”
missing:
– “load-bearing social, material, and repair systems”

Core rule:

yaml id=”civos-imitations-rule”
CORE_RULE:
“Civilisation is not proven by monuments, wealth, armies, population, technology, or prestige. Civilisation is proven by whether its shells can hold, repair, and transfer life, memory, trust, infrastructure, knowledge, and capability through time.”

			
---
# 19. Child System Overlay Registry

yaml id=”civos-child-overlay-registry”
CHILD_SYSTEM_OVERLAY_REGISTRY:
SocietyOS:
native_id:
“SOC.[L].[SC].[TR].[FN].[RP].[C].[T].[K]”
civos_overlay:
“CIVOS.CONTINUITY-REPAIR-SHELL.SOCIETY.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”
parent_shell:
“CONTINUITY-REPAIR-SHELL”

CultureOS:
native_id:
“CULT.[L].[CSC].[D].[PEN].[V].[CC].[T].[K]”
civos_overlay:
“CIVOS.MEMORY-SHELL.CULTURE.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”
parent_shell:
“MEMORY-SHELL”

TeamworkOS:
native_id:
“TEAM.[L].[TSC].[RF].[TR].[LD].[TC].[T].[K]”
civos_overlay:
“CIVOS.COORDINATION-SHELL.TEAMWORK.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”
parent_shell:
“COORDINATION-SHELL”

NewsOS:
native_id:
“NEWS.[L].[NSC].[CL].[SI].[FR].[NC].[T].[K]”
civos_overlay:
“CIVOS.FILTER-SHELL.NEWS.Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]”
parent_shell:
“FILTER-SHELL”

			
---
# 20. Public Article Translation

yaml id=”civos-public-translation”
PUBLIC_TRANSLATION:
CIVOS:
public_phrase: “the civilisation system being read”

SHELLTYPE:
public_phrase: “which structure is holding or failing”

CORE_SYSTEM:
public_phrase: “which load-bearing part is being examined”

Z:
public_phrase: “scale”

P:
public_phrase: “operating condition”

T:
public_phrase: “time horizon”

LPOS:
public_phrase: “strengthening direction”

LNEU:
public_phrase: “unclear or low-impact direction”

LNEG:
public_phrase: “weakening direction”

LINV:
public_phrase: “the system is working backwards”

R:
public_phrase: “repair capacity”

K:
public_phrase: “confidence”

P4:
public_phrase: “regenerative or frontier-capable only if the base is protected”

			
---
# 21. Standard CivilisationOS Output Format

yaml id=”civos-output-format”
STANDARD_CIVOS_OUTPUT:
1_observed_system:
required:
– “civilisation shell”
– “core system”
– “scale”
– “time horizon”
– “reason for classification”

2_civos_id:
required:
– “CivOS ID”
– “meaning”
– “Z/P/T/L/R/K reading”

3_derived_condition:
required:
– “civilisation condition”
– “lattice direction”
– “phase state”
– “repair state”

4_diagnostic_reading:
required:
– “load-bearing shell”
– “core system”
– “damage pressure”
– “drift load”
– “repair capacity”
– “failure classes if any”

5_repair_or_watch:
required:
– “protect base”
– “repair”
– “watch”
– “upgrade”
– “downgrade”
– “reboot”
– “hold frontier”
– “allow regenerative expansion only if base is safe”

			
---
# 22. Article Runtime Lock

yaml id=”civos-runtime-lock”
RUNTIME_LOCK:
locked_decisions:
– “CivilisationOS uses CIVOS-SHELL-LATTICE-CLASS v1.1.”
– “Civilisation is not classified as species.”
– “Civilisation is the parent shell-lattice system.”
– “Native CivOS format is CIVOS.[SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5].”
– “SocietyOS, CultureOS, TeamworkOS, and NewsOS remain child native systems with CivOS overlays.”
– “Derived civilisation conditions come from Z/P/T/L/R/K readings.”
– “P4 is valid only if base shells remain protected.”
– “Do not mistake monuments, wealth, armies, technology, population, bureaucracy, or prestige for civilisation health.”
– “Civilisation health depends on shells holding, filtering, repairing, transferring, and regenerating through time.”

next_article:
article_number: 7
title: “Universal Classification Template Runtime v1.0”
prompt_to_continue:
“Next”

			
---
# 23. Short AI Memory Version

yaml id=”civos-short-memory”
SHORT_MEMORY:
“CivilisationOS v1.1 is the parent shell-lattice classification system. Native format: CIVOS.[SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]. Civilisation is not species; it is a continuity machine. Shell types include CORE, BOUNDARY, FILTER, MEMORY, INFRASTRUCTURE, TRUST, REPAIR, CONTINUITY-REPAIR, COORDINATION, FRONTIER. Core systems include FOOD, WATER, ENERGY, LAW, LANGUAGE, EDUCATION, TRUST, MEMORY, HEALTH, ENVIRONMENT, INFRASTRUCTURE, GOVERNANCE, DEFENCE, ECONOMY, TECHNOLOGY, REPAIR, SOCIETY, CULTURE, TEAMWORK, NEWS. Derived conditions: CIV.CONTACT, EMERGING, FUNCTIONAL, STABLE, REGENERATIVE, TILTED, CAPTURED, INVERTED, FRAGMENTED, DECAYING, COLLAPSE, REBOOT. P4 is regenerative/frontier-capable only if base P3 shells are protected.”
“`

Article 7 of 7

Universal Classification Template Runtime v1.0

Reusable Template for New eduKateSG Classification Systems

Full Code for AI Runtime

			
ARTICLE_ID: "EKSG.FULLCLASSSTACK.UNIVERSAL-CLASSIFICATION-TEMPLATE.v1.0"
ARTICLE_NUMBER: 7
STACK_TOTAL: 7
TITLE: "Universal Classification Template Runtime v1.0"
SUBTITLE: "Reusable Template for New eduKateSG Classification Systems"
PUBLIC_OR_INTERNAL: "Full Code for AI Runtime"
AUTHOR_CONTEXT: "eduKateSG"
PARENT_STACK:
  name: "eduKateSG Full Classification Stack v1.0"
  parent_system: "CivilisationOS"
  parent_classification: "CIVOS-SHELL-LATTICE-CLASS v1.1"
PURPOSE:
  - "Provide a reusable classification template for future eduKateSG OS branches."
  - "Prevent each new classification from inventing incompatible grammar."
  - "Ensure every new domain system has both a native domain ID and a CivOS overlay ID."
  - "Allow future systems such as EducationOS, WarOS, FamilyOS, VocabularyOS, RealityOS, FinanceOS, GovernanceOS, HealthOS, LogisticsOS, EmotionOS, LanguageOS, and MindOS to plug into the same architecture."
RUNTIME_TRIGGER:
  SIMPLE_TRIGGER:
    - "Use eduKateSG classification template"
    - "Create a new shell-state classification"
    - "Classify this new OS"
    - "Make this fit into CivOS"
    - "Use Universal Classification Template"
    - "Build new classification system"
    - "Use eduKateSG Full Classification Stack"
  FULL_TRIGGER:
    "Use eduKateSG Universal Classification Template Runtime v1.0. Build a new domain-specific shell-state classification system with a native domain ID, then align it upward into CivilisationOS using the CivOS shell-lattice overlay format: CIVOS.[SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]. Preserve domain-specific detail without creating a competing civilisation classification."

		

1. Core Rule

			
UNIVERSAL_CORE_RULE:
  statement:
    "Every eduKateSG classification system must answer two questions: first, what is the system doing in its own domain; second, how does that system affect civilisation continuity, repair, trust, memory, coordination, reality, and future transmission?"
  native_question:
    "What is this system doing in its own domain?"
  civos_question:
    "What does this system do to civilisation's ability to hold, filter, repair, transfer, and regenerate through time?"
  required_outputs:
    - "Native Domain ID"
    - "CivOS Overlay ID"
    - "Derived Condition"
    - "Failure Classes"
    - "Confidence"
    - "Repair / Watch / Upgrade Recommendation"

		

2. Universal Build Sequence

			
UNIVERSAL_CLASSIFICATION_BUILD_SEQUENCE:
  step_1_define_system:
    question: "What OS or domain is being classified?"
    examples:
      - "EducationOS"
      - "WarOS"
      - "FamilyOS"
      - "VocabularyOS"
      - "RealityOS"
      - "FinanceOS"
      - "GovernanceOS"
      - "HealthOS"
      - "LogisticsOS"
      - "LanguageOS"
      - "EmotionOS"
      - "MindOS"
  step_2_define_unit_of_analysis:
    question: "What kind of system unit does this OS classify?"
    examples:
      EducationOS: "learning / capability-transfer system"
      WarOS: "force / conflict / survival pressure system"
      FamilyOS: "household / kinship / formation system"
      VocabularyOS: "word / meaning / semantic-shell system"
      RealityOS: "truth / evidence / shared-reality system"
      FinanceOS: "value / risk / allocation system"
      GovernanceOS: "decision / legitimacy / public repair system"
      HealthOS: "body / resilience / treatment / prevention system"
      LogisticsOS: "movement / supply / timing / delivery system"
  step_3_define_public_definition:
    question: "What is the simplest reader-facing definition?"
  step_4_define_not_system_boundary:
    question: "What is commonly mistaken for this system but is not enough?"
  step_5_define_native_axes:
    question: "Which domain-specific axes are needed?"
    minimum_required:
      - "Level / scale"
      - "Shell completeness"
      - "Condition class"
      - "Trajectory"
      - "Confidence"
    optional_domain_axes:
      - "trust"
      - "role fit"
      - "claim strength"
      - "source integrity"
      - "depth"
      - "penetration"
      - "valence"
      - "repair"
      - "load"
      - "risk"
      - "capability"
      - "evidence"
      - "pressure"
      - "timing"
      - "transfer"
  step_6_define_native_id_format:
    question: "What is the domain's native classification ID?"
  step_7_choose_civos_parent_shell:
    question: "Which CivOS shell does this domain map into?"
    choices:
      - "CORE-SHELL"
      - "BOUNDARY-SHELL"
      - "FILTER-SHELL"
      - "MEMORY-SHELL"
      - "INFRASTRUCTURE-SHELL"
      - "TRUST-SHELL"
      - "REPAIR-SHELL"
      - "CONTINUITY-REPAIR-SHELL"
      - "COORDINATION-SHELL"
      - "FRONTIER-SHELL"
  step_8_choose_civos_core_system:
    question: "Which core system name should appear in the CivOS overlay?"
    examples:
      - "EDUCATION"
      - "WAR"
      - "FAMILY"
      - "VOCABULARY"
      - "REALITY"
      - "FINANCE"
      - "GOVERNANCE"
      - "HEALTH"
      - "LOGISTICS"
      - "LANGUAGE"
      - "EMOTION"
      - "MIND"
  step_9_define_condition_classes:
    question: "What are the domain's condition classes?"
    pattern:
      - "pre-system signal/contact"
      - "emerging system"
      - "functional baseline"
      - "tilted / uneven"
      - "captured"
      - "inverted"
      - "fragmented / overloaded / decaying"
      - "repairing"
      - "advanced / high-continuity / regenerative"
  step_10_define_failure_classes:
    question: "What are the most important ways this system fails?"
  step_11_define_repair_sequence:
    question: "How does this system repair?"
  step_12_define_native_to_civos_translation:
    question: "How do native axes translate into Z/P/T/L/R/K?"
  step_13_create_examples:
    question: "Can we classify 3 to 6 examples using both native ID and CivOS overlay?"
  step_14_lock_runtime:
    question: "What decisions must future AI preserve?"

		

3. Universal Native ID Template

			
UNIVERSAL_NATIVE_ID_TEMPLATE:
  formula:
    "[DOMAIN].[LEVEL].[SHELL_COMPLETENESS].[DOMAIN_AXIS_1].[DOMAIN_AXIS_2].[DOMAIN_AXIS_3].[CONDITION].[TRAJECTORY].[CONFIDENCE]"
  required_fields:
    DOMAIN:
      meaning: "Short code for the domain system."
      examples:
        - "EDU"
        - "WAR"
        - "FAM"
        - "VOCAB"
        - "REAL"
        - "FIN"
        - "GOV"
        - "HEALTH"
        - "LOG"
    LEVEL:
      meaning: "Scale of the unit being classified."
      pattern: "L0-L6"
    SHELL_COMPLETENESS:
      meaning: "How complete the domain shell is."
      pattern: "[DOMAIN]SC0-[DOMAIN]SC5"
    DOMAIN_AXIS_1:
      meaning: "Most important domain-specific axis."
    DOMAIN_AXIS_2:
      meaning: "Second important domain-specific axis."
    DOMAIN_AXIS_3:
      meaning: "Third important domain-specific axis."
    CONDITION:
      meaning: "Domain condition class."
    TRAJECTORY:
      meaning: "Direction of movement."
      values:
        T+: "improving / strengthening"
        T0: "stable / no clear movement"
        T-: "deteriorating / weakening"
        TX: "volatile / unclear"
    CONFIDENCE:
      meaning: "Confidence in the classification."
      values:
        K1: "low"
        K2: "limited"
        K3: "medium"
        K4: "high"
        K5: "very high"
  example_placeholder:
    "EDU.L2.ESC4.TR4.CAP4.RP4.EC2.T0.K4"

		

4. Universal CivOS Overlay Template

			
UNIVERSAL_CIVOS_OVERLAY_TEMPLATE:
  formula:
    "CIVOS.[SELECTED-SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]"
  example:
    "CIVOS.CONTINUITY-REPAIR-SHELL.EDUCATION.Z2.P3.T6.LPOS.R4.K4"
  field_meanings:
    SELECTED-SHELLTYPE:
      meaning: "The CivOS shell that best matches the domain's function."
    CORE-SYSTEM:
      meaning: "The domain's load-bearing role inside civilisation."
    Z:
      meaning: "Scale / zoom level."
    P:
      meaning: "Phase / operating condition."
    T:
      meaning: "Time horizon."
    L:
      meaning: "Lattice direction."
    R:
      meaning: "Repair capacity."
    K:
      meaning: "Confidence."

		

5. Recommended Parent Shell Mapping for Future Systems

			
RECOMMENDED_PARENT_SHELL_MAPPING:
  EducationOS:
    civos_shell: "CONTINUITY-REPAIR-SHELL"
    core_system: "EDUCATION"
    reason: "Education transfers capability across generations."
  WarOS:
    civos_shell: "BOUNDARY-SHELL"
    secondary_shells:
      - "TRUST-SHELL"
      - "INFRASTRUCTURE-SHELL"
      - "REPAIR-SHELL"
    core_system: "WAR"
    reason: "War tests boundary, survival, force, damage, and repair capacity."
  FamilyOS:
    civos_shell: "CONTINUITY-REPAIR-SHELL"
    core_system: "FAMILY"
    reason: "Family forms the first human floor and transmits trust, language, emotion, and duty."
  VocabularyOS:
    civos_shell: "MEMORY-SHELL"
    secondary_shells:
      - "FILTER-SHELL"
      - "TRUST-SHELL"
    core_system: "VOCABULARY"
    reason: "Vocabulary carries meaning, classification, language precision, and reality routing."
  RealityOS:
    civos_shell: "FILTER-SHELL"
    core_system: "REALITY"
    reason: "RealityOS filters truth, evidence, claims, illusions, and shared reality."
  FinanceOS:
    civos_shell: "INFRASTRUCTURE-SHELL"
    secondary_shells:
      - "TRUST-SHELL"
      - "REPAIR-SHELL"
    core_system: "FINANCE"
    reason: "Finance allocates value, risk, time, credit, and trust."
  GovernanceOS:
    civos_shell: "TRUST-SHELL"
    secondary_shells:
      - "REPAIR-SHELL"
      - "BOUNDARY-SHELL"
    core_system: "GOVERNANCE"
    reason: "Governance coordinates decisions, legitimacy, authority, correction, and public responsibility."
  HealthOS:
    civos_shell: "INFRASTRUCTURE-SHELL"
    secondary_shells:
      - "REPAIR-SHELL"
    core_system: "HEALTH"
    reason: "Health keeps the human base functional and repairable."
  LogisticsOS:
    civos_shell: "INFRASTRUCTURE-SHELL"
    core_system: "LOGISTICS"
    reason: "Logistics moves goods, people, resources, timing, and continuity."
  LanguageOS:
    civos_shell: "MEMORY-SHELL"
    secondary_shells:
      - "FILTER-SHELL"
      - "COORDINATION-SHELL"
    core_system: "LANGUAGE"
    reason: "Language carries meaning, command, memory, coordination, and shared reality."
  EmotionOS:
    civos_shell: "CONTINUITY-REPAIR-SHELL"
    secondary_shells:
      - "TRUST-SHELL"
    core_system: "EMOTION"
    reason: "Emotion carries signal, energy, courage, fear, repair, and relational stability."
  MindOS:
    civos_shell: "CORE-SHELL"
    secondary_shells:
      - "FILTER-SHELL"
      - "MEMORY-SHELL"
    core_system: "MIND"
    reason: "MindOS governs attention, meaning, memory, judgement, reasoning, and repair."

		

6. Universal Condition Class Pattern

Every new OS should adapt this pattern.

			
UNIVERSAL_CONDITION_CLASS_PATTERN:
  C0:
    name: "Pre-System Signal / Contact"
    meaning: "The system has not yet formed. Only signal, contact, or raw material exists."
  C1:
    name: "Emerging System"
    meaning: "Repeated pattern and early structure begin to form."
  C2:
    name: "Functional Baseline System"
    meaning: "The system performs its proper function well enough."
  C3:
    name: "Tilted / Uneven System"
    meaning: "The system functions but burden, access, output, or protection is uneven."
  C4:
    name: "Captured System"
    meaning: "The system is bent toward a narrower interest."
  C5:
    name: "Inverted System"
    meaning: "The system uses its legitimate form to produce the opposite of its intended purpose."
  C6:
    name: "Fragmented / Below-Threshold / Overloaded System"
    meaning: "The system cannot coordinate, hold, or carry its load properly."
  C7:
    name: "Decaying System"
    meaning: "Damage accumulates faster than repair."
  C8:
    name: "Repairing System"
    meaning: "Damage is named and function is being restored."
  C9:
    name: "High-Continuity / Advanced System"
    meaning: "The system carries function with strong repair and stable transmission."
  C10:
    name: "Regenerative / Frontier-Capable System"
    meaning: "The system produces surplus repair and future capability without consuming its base."
    guardrail: "Use only if the base is protected."

		

7. Universal Failure Class Pattern

			
UNIVERSAL_FAILURE_CLASS_PATTERN:
  F0:
    name: "Boundary failure"
    meaning: "The system cannot define what belongs or what is being classified."
  F1:
    name: "Function failure"
    meaning: "The system does not perform its proper work."
  F2:
    name: "Trust failure"
    meaning: "Participants cannot rely on the system."
  F3:
    name: "Language / meaning failure"
    meaning: "Words, signals, or categories no longer route to reality."
  F4:
    name: "Memory failure"
    meaning: "The system cannot preserve lessons, identity, or prior corrections."
  F5:
    name: "Transmission failure"
    meaning: "The system cannot pass itself forward."
  F6:
    name: "Repair failure"
    meaning: "Damage cannot be corrected fast enough."
  F7:
    name: "Capture failure"
    meaning: "The system is bent toward a narrow actor, incentive, ideology, or ego."
  F8:
    name: "Inversion failure"
    meaning: "The system uses its legitimate shell to produce the opposite of its purpose."
  F9:
    name: "Load failure"
    meaning: "The system carries more pressure than its shell can support."
  F10:
    name: "Fragmentation failure"
    meaning: "The system splits into parts that cannot translate or coordinate."
  F11:
    name: "Future corridor failure"
    meaning: "The system cannot provide viable forward routes."
  F12:
    name: "Base consumption failure"
    meaning: "The system appears advanced but consumes the base that supports it."

		

8. Universal Repair Sequence

			
UNIVERSAL_REPAIR_SEQUENCE:
  step_1_detect:
    action: "Detect which part of the system is failing."
    questions:
      - "What is the system supposed to do?"
      - "What is it actually producing?"
      - "Where is the mismatch?"
      - "Who or what is carrying hidden cost?"
  step_2_name:
    action: "Classify the damage accurately."
    possible_damage:
      - "tilt"
      - "capture"
      - "inversion"
      - "fragmentation"
      - "overload"
      - "decay"
      - "below-threshold failure"
    rule:
      "Bad naming creates bad repair."
  step_3_protect_base:
    action: "Protect the load-bearing floor first."
    examples:
      - "children"
      - "truth"
      - "trust"
      - "language"
      - "memory"
      - "health"
      - "food"
      - "water"
      - "education"
      - "repair channels"
      - "future options"
  step_4_restore_function:
    action: "Return the system to its proper work."
    examples:
      - "Education returns to learning."
      - "News returns to reality."
      - "Culture returns to meaning."
      - "Teamwork returns to coordination."
      - "Governance returns to responsibility."
      - "Finance returns to value allocation with trust."
      - "Health returns to resilience and care."
  step_5_rebuild_trust:
    action: "Reconnect words, actions, rules, and lived experience."
  step_6_repair_repeatedly:
    action: "Repeat correction long enough for trust to return."
  step_7_transmit:
    action: "Pass the repaired function forward."
  step_8_regenerate_only_if_safe:
    action: "Move toward advanced or frontier state only if base shells are protected."

		

9. Universal Native-to-CivOS Translation Guide

			
UNIVERSAL_NATIVE_TO_CIVOS_TRANSLATION:
  level_to_zoom:
    L0: "Z0"
    L1: "Z1"
    L2: "Z2"
    L3: "Z3"
    L4: "Z4"
    L5: "Z5"
    L6: "Z6"
  shell_completeness_to_phase:
    SC0: "usually P0"
    SC1: "usually P0-P1"
    SC2: "usually P1-P2"
    SC3: "usually P2"
    SC4: "usually P2-P3"
    SC5: "usually P3-P4 if repair and base protection are strong"
  condition_to_lattice:
    PRE_SYSTEM:
      default: "LNEU"
      risk_case: "LNEG"
    EMERGING:
      default: "LNEU"
      improving_case: "LPOS"
    FUNCTIONAL:
      default: "LPOS or LNEU"
    TILTED:
      default: "LNEU or LNEG"
    CAPTURED:
      default: "LNEG or LINV"
    INVERTED:
      default: "LINV"
    FRAGMENTED:
      default: "LNEG"
    OVERLOADED:
      default: "LNEG"
    DECAYING:
      default: "LNEG"
    REPAIRING:
      default: "LPOS"
    HIGH_CONTINUITY:
      default: "LPOS"
    REGENERATIVE:
      default: "LPOS only if base protected"
  repair_to_R:
    none: "R0"
    weak: "R1"
    partial: "R2"
    workable: "R3"
    strong: "R4"
    regenerative: "R5"
  confidence_to_K:
    low: "K1"
    limited: "K2"
    medium: "K3"
    high: "K4"
    very_high: "K5"

		

10. New Classification Creation Template

Use this block when building any new system.

			
NEW_CLASSIFICATION_TEMPLATE:
  HEADER:
    ARTICLE_ID: "EKSG.FULLCLASSSTACK.[DOMAIN].SHELL-STATE-CLASS.v1.0"
    TITLE: "[Domain] Shell-State Classification System v1.0"
    SUBTITLE: "Full Code Aligned to CivilisationOS Parent Shell-Lattice"
    PUBLIC_OR_INTERNAL: "Full Code for AI Runtime"
  CANONICAL_NAME:
    full: "eduKateSG [Domain] Shell-State Classification System v1.0"
    short: "[DOMAIN]-SHELL-CLASS v1.0"
  SYSTEM_TYPE:
    "[Domain]OS"
  UNIT_OF_ANALYSIS:
    "[Define what this system classifies]"
  PARENT_CIVOS_ROLE:
    "[Define role inside CivilisationOS]"
  DEFAULT_CIVOS_OVERLAY:
    "CIVOS.[SELECTED-SHELLTYPE].[CORE-SYSTEM]"
  CORE_LINE:
    "[One sentence: this system is not merely X; it is Y.]"
  PUBLIC_DEFINITION:
    "[Simple reader-facing definition]"
  NOT_SYSTEM_DEFINITION:
    "[What is commonly mistaken for the system but is not enough]"
  NATIVE_ID_FORMAT:
    formula:
      "[DOMAIN].[L0-L6].[DOMAINSC0-DOMAINSC5].[AXIS1].[AXIS2].[AXIS3].[CONDITION].[T+/T0/T-/TX].[K1-K5]"
  CIVOS_OVERLAY_FORMAT:
    formula:
      "CIVOS.[SELECTED-SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]"
  AXES:
    axis_1_level:
      code: "L0-L6"
      meaning: "Scale of system"
    axis_2_shell_completeness:
      code: "[DOMAINSC0-DOMAINSC5]"
      meaning: "Completeness of domain shell"
    axis_3_domain_axis_1:
      code: "[Define]"
      meaning: "[Define]"
    axis_4_domain_axis_2:
      code: "[Define]"
      meaning: "[Define]"
    axis_5_domain_axis_3:
      code: "[Define]"
      meaning: "[Define]"
    axis_6_condition:
      code: "[Define condition classes]"
    axis_7_trajectory:
      code: "T+ / T0 / T- / TX"
    axis_8_confidence:
      code: "K1-K5"
  CONDITION_CLASSES:
    - "C0 Pre-System"
    - "C1 Emerging"
    - "C2 Functional"
    - "C3 Tilted"
    - "C4 Captured"
    - "C5 Inverted"
    - "C6 Fragmented / Overloaded / Below-Threshold"
    - "C7 Decaying"
    - "C8 Repairing"
    - "C9 High-Continuity"
    - "C10 Regenerative / Frontier-Capable if valid"
  FAILURE_CLASSES:
    - "F0 Boundary failure"
    - "F1 Function failure"
    - "F2 Trust failure"
    - "F3 Language / meaning failure"
    - "F4 Memory failure"
    - "F5 Transmission failure"
    - "F6 Repair failure"
    - "F7 Capture failure"
    - "F8 Inversion failure"
    - "F9 Load failure"
    - "F10 Fragmentation failure"
    - "F11 Future corridor failure"
    - "F12 Base consumption failure"
  REPAIR_SEQUENCE:
    - "Detect"
    - "Name"
    - "Protect base"
    - "Restore function"
    - "Rebuild trust"
    - "Repeat repair"
    - "Transmit"
    - "Regenerate only if safe"
  EXAMPLES_REQUIRED:
    minimum: 3
    preferred: 6
    each_example_must_include:
      - "observed system"
      - "native ID"
      - "CivOS overlay ID"
      - "derived condition"
      - "failure classes if any"
      - "repair/watch recommendation"
  RUNTIME_LOCK:
    must_include:
      - "[Domain] uses [DOMAIN]-SHELL-CLASS v1.0."
      - "[Domain] is classified as a shell-state system, not species."
      - "Native ID remains domain-specific."
      - "CivOS overlay places [Domain] inside CivilisationOS."
      - "Do not create competing civilisation grammar."
      - "P4/regenerative state is valid only if base is protected."

		

11. Example Future System: EducationOS

This is a sample showing how to use the template.

			
EXAMPLE_EDUCATIONOS_CLASSIFICATION:
  CANONICAL_NAME:
    "eduKateSG EducationOS Shell-State Classification System v1.0"
  SHORT_NAME:
    "EDU-SHELL-CLASS v1.0"
  SYSTEM_TYPE:
    "EducationOS"
  UNIT_OF_ANALYSIS:
    "Learning / capability-transfer system"
  PARENT_CIVOS_ROLE:
    "Continuity / capability-transfer / repair shell"
  DEFAULT_CIVOS_OVERLAY:
    "CIVOS.CONTINUITY-REPAIR-SHELL.EDUCATION"
  CORE_LINE:
    "Education is not merely schooling. Education is the transfer of capability, judgement, language, memory, discipline, courage, and future-readiness across time."
  PUBLIC_DEFINITION:
    "Education is the system that helps a human being grow the capability to understand, act, repair, and carry a future."
  NOT_EDUCATION_DEFINITION:
    "A thing is not yet education when it is only schooling, instruction, testing, ranking, memorisation, or certification without real capability transfer."
  NATIVE_ID_FORMAT:
    "EDU.[L0-L6].[ESC0-ESC5].[CAP0-CAP5].[TR0-TR5].[RP0-RP5].[EC0-EC10].[T+/T0/T-/TX].[K1-K5]"
  AXES:
    L:
      meaning: "Level / scale"
    ESC:
      meaning: "Education shell completeness"
    CAP:
      meaning: "Capability transfer strength"
    TR:
      meaning: "Trust / learning safety"
    RP:
      meaning: "Repair capacity"
    EC:
      meaning: "Education condition"
    T:
      meaning: "Trajectory"
    K:
      meaning: "Confidence"
  CONDITION_CLASSES:
    EC0: "Pre-Education Contact"
    EC1: "Emerging Learning"
    EC2: "Functional Education"
    EC3: "Tilted Education"
    EC4: "Captured Education"
    EC5: "Inverted Education"
    EC6: "Below-Threshold Education"
    EC7: "Decaying Education"
    EC8: "Repairing Education"
    EC9: "High-Continuity Education"
    EC10: "Regenerative / Future-Capability Education"
  EXAMPLE_NATIVE_ID:
    id: "EDU.L2.ESC4.CAP4.TR4.RP4.EC2.T0.K4"
    meaning: "Institution-level mature education shell, strong capability transfer, strong trust, strong repair, functional education, stable, high confidence."
  EXAMPLE_CIVOS_OVERLAY:
    id: "CIVOS.CONTINUITY-REPAIR-SHELL.EDUCATION.Z2.P3.T6.LPOS.R4.K4"
    meaning: "Institution-scale education shell, stable phase, medium horizon, positive lattice, strong repair, high confidence."

		

12. Example Future System: WarOS

			
EXAMPLE_WAROS_CLASSIFICATION:
  CANONICAL_NAME:
    "eduKateSG WarOS Shell-State Classification System v1.0"
  SHORT_NAME:
    "WAR-SHELL-CLASS v1.0"
  SYSTEM_TYPE:
    "WarOS"
  UNIT_OF_ANALYSIS:
    "Force / conflict / survival pressure system"
  PARENT_CIVOS_ROLE:
    "Boundary / damage / survival / repair shell"
  DEFAULT_CIVOS_OVERLAY:
    "CIVOS.BOUNDARY-SHELL.WAR"
  CORE_LINE:
    "War is not merely fighting. War is organised force applied to change, defend, break, or survive a political, social, territorial, or civilisational condition."
  PUBLIC_DEFINITION:
    "War is a condition where organised force is used to compel, defend, seize, survive, punish, deter, or reshape a human system."
  NOT_WAR_DEFINITION:
    "A thing is not yet war when there is anger, rivalry, argument, protest, threat, crime, or competition without organised force crossing the threshold of sustained coercive conflict."
  NATIVE_ID_FORMAT:
    "WAR.[L0-L6].[WSC0-WSC5].[FORCE0-FORCE5].[AIM0-AIM5].[DAMAGE0-DAMAGE5].[WC0-WC10].[T+/T0/T-/TX].[K1-K5]"
  AXES:
    L:
      meaning: "Level / scale"
    WSC:
      meaning: "War shell completeness"
    FORCE:
      meaning: "Force organisation level"
    AIM:
      meaning: "War aim clarity"
    DAMAGE:
      meaning: "Damage / pressure level"
    WC:
      meaning: "War condition"
    T:
      meaning: "Trajectory"
    K:
      meaning: "Confidence"
  CONDITION_CLASSES:
    WC0: "Pre-War Tension"
    WC1: "Emerging Conflict"
    WC2: "Limited War"
    WC3: "Tilted War"
    WC4: "Captured War"
    WC5: "Inverted War"
    WC6: "Fragmented / Multi-Actor War"
    WC7: "Decaying / Exhaustion War"
    WC8: "Repair / Ceasefire Corridor"
    WC9: "Post-War Stabilisation"
    WC10: "Civilisation Reboot / Reconstruction War Aftermath"
  EXAMPLE_NATIVE_ID:
    id: "WAR.L5.WSC4.FORCE4.AIM3.DAMAGE4.WC2.TX.K3"
    meaning: "Nation-level mature war shell, strong force organisation, moderate aim clarity, high damage, limited war, volatile trajectory, medium confidence."
  EXAMPLE_CIVOS_OVERLAY:
    id: "CIVOS.BOUNDARY-SHELL.WAR.Z5.P1.T3.LNEG.R1.K3"
    meaning: "Nation-scale boundary shell under war pressure, fragile phase, short-medium horizon, negative lattice, weak repair, medium confidence."

		

13. Example Future System: VocabularyOS

			
EXAMPLE_VOCABULARYOS_CLASSIFICATION:
  CANONICAL_NAME:
    "eduKateSG VocabularyOS Shell-State Classification System v1.0"
  SHORT_NAME:
    "VOCAB-SHELL-CLASS v1.0"
  SYSTEM_TYPE:
    "VocabularyOS"
  UNIT_OF_ANALYSIS:
    "Word / semantic shell / meaning-routing system"
  PARENT_CIVOS_ROLE:
    "Memory / language / filter shell"
  DEFAULT_CIVOS_OVERLAY:
    "CIVOS.MEMORY-SHELL.VOCABULARY"
  CORE_LINE:
    "A word is not merely a dictionary packet. A word is a semantic shell that routes meaning across sentence, context, memory, and reality."
  PUBLIC_DEFINITION:
    "Vocabulary is the system of words and meanings that lets a person classify, understand, explain, and act in the world."
  NOT_VOCABULARY_DEFINITION:
    "A thing is not full vocabulary knowledge when a person only memorises a thin dictionary definition without knowing the word’s live target area, context, valence, and usage."
  NATIVE_ID_FORMAT:
    "VOCAB.[L0-L6].[VSC0-VSC5].[DEPTH0-DEPTH5].[CONTEXT0-CONTEXT5].[VALENCE].[VC0-VC10].[T+/T0/T-/TX].[K1-K5]"
  AXES:
    L:
      meaning: "Text / context level"
    VSC:
      meaning: "Vocabulary shell completeness"
    DEPTH:
      meaning: "Meaning depth"
    CONTEXT:
      meaning: "Context fit"
    VALENCE:
      meaning: "Positive / neutral / negative / inverse meaning direction"
    VC:
      meaning: "Vocabulary condition"
    T:
      meaning: "Trajectory"
    K:
      meaning: "Confidence"
  CONDITION_CLASSES:
    VC0: "Unknown Word"
    VC1: "Surface Definition"
    VC2: "Functional Word Knowledge"
    VC3: "Thin Vocabulary"
    VC4: "Tilted Meaning"
    VC5: "Captured Word"
    VC6: "Inverted Word"
    VC7: "Context Failure"
    VC8: "Meaning Drift"
    VC9: "Repairing Word Knowledge"
    VC10: "Deep Semantic Shell"
  EXAMPLE_NATIVE_ID:
    id: "VOCAB.L1.VSC2.DEPTH1.CONTEXT1.V0.VC1.T0.K3"
    meaning: "Sentence-level thin word shell, shallow depth, weak context fit, neutral valence, surface definition condition, stable, medium confidence."
  EXAMPLE_CIVOS_OVERLAY:
    id: "CIVOS.MEMORY-SHELL.VOCABULARY.Z0.P1.T0.LNEU.R1.K3"
    meaning: "Human-level vocabulary memory shell, fragile phase, immediate horizon, neutral lattice, weak repair, medium confidence."

		

14. Standard Output Format for Any New Classification

			
STANDARD_OUTPUT_FOR_NEW_CLASSIFICATION:
  1_observed_system:
    required:
      - "system/domain"
      - "unit of analysis"
      - "scale"
      - "boundary"
      - "reason for classification"
  2_native_domain_id:
    required:
      - "native ID"
      - "native meaning"
      - "condition class"
  3_civos_overlay_id:
    required:
      - "CivOS overlay ID"
      - "Z/P/T/L/R/K reading"
      - "derived civilisation condition"
  4_diagnostic_reading:
    required:
      - "shell completeness"
      - "main domain axes"
      - "trajectory"
      - "failure classes if any"
      - "confidence"
  5_repair_or_watch:
    required:
      - "protect"
      - "repair"
      - "watch"
      - "upgrade"
      - "downgrade"
      - "hold"
      - "reboot"
      - "publish with caution if relevant"

		

15. Public Translation Rules

			
PUBLIC_TRANSLATION_RULES:
  hide_in_reader_articles:
    - "full ID strings unless useful"
    - "Phase 4 mechanics"
    - "internal runtime machinery"
    - "too many acronyms"
    - "classification scaffolding unless article is about classification"
  show_in_reader_articles:
    - "simple definition"
    - "what it is not"
    - "why it matters"
    - "how to recognise healthy version"
    - "how it breaks"
    - "how it repairs"
    - "ordinary examples"
    - "short reader-friendly tables"
  translate_terms:
    shell:
      public_phrase: "the structure that holds the system together"
    lattice:
      public_phrase: "the direction the system is moving"
    phase:
      public_phrase: "the operating condition"
    repair:
      public_phrase: "how well it can fix damage"
    confidence:
      public_phrase: "how sure we are"
    inverted:
      public_phrase: "the system is working backwards"
    captured:
      public_phrase: "the system is bent toward a narrower interest"
    tilted:
      public_phrase: "the system still works but pressure is uneven"
    below_threshold:
      public_phrase: "the basic floor is broken"
    regenerative:
      public_phrase: "the system can renew itself without burning its base"

		

16. Versioning Rules

			
VERSIONING_RULES:
  v1_0:
    meaning: "First stable classification release."
  v1_1:
    meaning: "Alignment correction or parent-overlay update."
  v1_2:
    meaning: "Minor axis improvement or condition-class refinement."
  v2_0:
    meaning: "Major architecture upgrade, new shell grammar, or deep integration with new parent system."
  patch_rules:
    when_to_patch:
      - "axis name conflicts with parent grammar"
      - "condition classes need clearer distinction"
      - "new failure class becomes necessary"
      - "CivOS overlay must be improved"
      - "public article revealed too much machinery"
      - "domain-specific logic needs stronger scientific framing"
  archive_rule:
    "Do not delete old classification systems. Mark them as superseded, nested, upgraded, or aligned."

		

17. Naming Rules

			
NAMING_RULES:
  avoid_public_terms:
    - "species of society"
    - "species of culture"
    - "species of teamwork"
    - "species of news"
    - "biological classification"
    - "civilisation species"
  preferred_public_terms:
    - "classification"
    - "condition"
    - "state"
    - "shell-state"
    - "system condition"
    - "operating condition"
    - "classification ID"
  preferred_internal_terms:
    - "shell-state classification"
    - "shell-lattice classification"
    - "native domain ID"
    - "CivOS overlay ID"
    - "Z/P/T/L/R/K grammar"
    - "derived condition"
    - "failure class"
    - "repair sequence"
  canon_rule:
    "Use species only as a private metaphor if ever needed, never as the formal public term for these systems."

		

18. Full Stack Index

			
FULL_STACK_INDEX:
  Article_1:
    title: "eduKateSG Full Classification Stack v1.0"
    subtitle: "Master Alignment: CivilisationOS as the Parent Shell-Lattice System"
    role: "Parent-child alignment and full stack control"
  Article_2:
    title: "SocietyOS Shell-State Classification System v1.1"
    role: "Classifies society as human social continuity shell"
  Article_3:
    title: "CultureOS Shell-State Classification System v1.1"
    role: "Classifies culture as meaning-transmission shell"
  Article_4:
    title: "TeamworkOS Shell-State Classification System v1.1"
    role: "Classifies teamwork as coordination shell"
  Article_5:
    title: "NewsOS Shell-State Classification System v1.1"
    role: "Classifies news as public-signal / reality-update shell"
  Article_6:
    title: "CivilisationOS Shell-Lattice Classification System v1.1"
    role: "Parent classification system using Z/P/T/L/R/K"
  Article_7:
    title: "Universal Classification Template Runtime v1.0"
    role: "Reusable template for all future eduKateSG classification systems"

		

19. Master Runtime Lock

			
MASTER_RUNTIME_LOCK:
  locked_decisions:
    - "CivilisationOS is the parent shell-lattice system."
    - "All new eduKateSG classification systems must have a native domain ID and a CivOS overlay ID."
    - "Do not classify systems as biological species."
    - "Use shell-state classification for domain systems."
    - "Use shell-lattice classification for CivilisationOS."
    - "Use Z/P/T/L/R/K grammar for CivOS overlay."
    - "Keep domain-specific axes when needed."
    - "Do not flatten Society, Culture, Teamwork, News, or future systems into generic CivOS only."
    - "Do not create competing civilisation grammar."
    - "P4/regenerative/frontier status is valid only if the base shell is protected."
    - "Reader-facing articles should hide machinery unless classification itself is the topic."
    - "Full-code articles should expose runtime grammar clearly."
  completed_stack:
    - "Article 1: Master Alignment"
    - "Article 2: SocietyOS"
    - "Article 3: CultureOS"
    - "Article 4: TeamworkOS"
    - "Article 5: NewsOS"
    - "Article 6: CivilisationOS"
    - "Article 7: Universal Template"

		

20. Short AI Memory Version

			
SHORT_MEMORY:
  "Universal Classification Template Runtime v1.0 is Article 7 of the eduKateSG Full Classification Stack. Every new eduKateSG OS classification must have: native domain ID + CivOS overlay ID + derived condition + failure classes + repair/watch recommendation. Parent overlay format: CIVOS.[SHELLTYPE].[CORE-SYSTEM].Z[0-6].P[0-4].T[0-25].L[POS|NEU|NEG|INV].R[0-5].K[1-5]. Domain systems use shell-state classification; CivilisationOS uses shell-lattice classification. Avoid 'species' as formal term. Use condition, shell-state, system state, classification ID. P4/regenerative only valid if base shell remains protected. Template can build EducationOS, WarOS, FamilyOS, VocabularyOS, RealityOS, FinanceOS, GovernanceOS, HealthOS, LogisticsOS, LanguageOS, EmotionOS, MindOS, and future branches."

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