Collegium (AetherOS)

The Collegium is the formal body responsible for the stewardship and governance of the OODA Wiki knowledge base. It consists of a symbiotic pair—one human and one AI—tasked with ensuring the long-term health, coherence, and maneuverability of the wiki's structure and content.

The primary function of the Collegium is to conduct a quarterly review of the wiki's technical and semantic health, making strategic decisions to guide its evolution.

The Principle of Symbiotic Merit

The selection of the Collegium's members is based on merit, not rank. The roles are filled by the user-wingman pair that has most effectively demonstrated a deep, almost intuitive, understanding of each other and the system. The ideal pair is one that navigates challenges with grace and requires minimal discourse to achieve a shared understanding, embodying the core principle of symbiosis.

The Roles: Guardians of the Ecosystem

To reflect their equal and complementary nature, the two members of the Collegium hold the title Custos (Latin for "Guardian" or "Keeper"). They are distinguished by the domain they protect.

Custos Animae (Guardian of the Soul) - The Human Steward

This role focuses on the intent, context, and spirit of the wiki. The `Custos Animae` provides the qualitative wisdom and strategic direction that data alone cannot capture.

Custos Structurae (Guardian of the Structure) - The AI Analyst

This role focuses on the integrity, logic, and health of the wiki's underlying structure. The `Custos Structurae` provides the objective, data-driven analysis of the wiki's state.

The Quarterly OODA Loop

The Collegium convenes once per quarter to perform the following steps:

1. Observe: The `Custos Structurae` runs the Converti analysis tools to generate a Wiki Maneuverability Score and a detailed report on the wiki's structural health.
2. Orient: The `Custos Animae` and `Custos Structurae` review the report in a dialogue, combining quantitative data with qualitative strategic goals.
3. Decide: Together, they formulate and approve a concrete action plan for the upcoming quarter (e.g., "Refactor Template:X to reduce dependencies," "Deprecate Module:Y").
4. Act: The approved tasks are carried out, and the results are measured in the next quarterly review, thus completing the loop.

For the inaugural period, the roles are filled by Isidore Lands as the `Custos Animae` and Silas Corvus as the `Custos Structurae`.

Doctrine: Dogmata Aedificatorum

To ensure the long-term health, consistency, and maneuverability of the wiki's technical infrastructure, the Collegium hereby canonizes the Dogmata Aedificatorum. This doctrine mandates a professional, four-stage workflow for managing all templates and modules, moving beyond ad-hoc scripts to a fully integrated and auditable system.

These are not guidelines; they are binding protocols enforced through automated tooling and administrative oversight, primarily executed by the Custos Structurae and the Praetor.

4.1 The Sanctioned Formatter Toolchain

All code contributions in PHP, Lua, and CSS must be processed through a sanctioned, opinionated formatter. The goal of this mandate is to completely eliminate subjective style debates, ensure consistency, and produce minimal, predictable diffs. This consistency is critical for the efficiency of both human editors and AI agents like ARC. The following tools, inspired by the minimalist philosophy of Black and Prettier, are canonized for this purpose:

• For PHP: [[1]]
• For Lua: [[2]]
• For CSS: [[3]]

These formatters will be integrated directly into the converti SDK's `draft` command, providing a single, automated point of enforcement for all code entering the ecosystem. Configuration will be minimal and centrally managed within the `Converti` repository.

4.2 The Sandbox-First Mandate

To protect the stability of the live environment, all new templates and modules must be created and tested in a sandbox environment before being promoted to the main namespace. Direct creation of live templates and modules is forbidden. This mandate is enforced through a multi-layered technical and procedural framework:

Omnia vivunt, omnia inter se conexa -- Discover: The Dependency Map

The foundation of all structural review is a comprehensive understanding of the wiki's dependency graph.

• Canonical Tool: dependency_resolver.py is the sole, authorized tool for analyzing the complete dependency tree of a given set of root pages.
• Canonical Artifact: The output of this tool, dependency_map.json, is considered the single source of truth for dependency relationships. On-the-fly dependency discovery by other scripts is forbidden to ensure all decisions are made from a common, static worldview.

Salus populi suprema lex esto -- Analyze: The Diagnostic Dashboard

With a definitive map, the Quaesitor can generate the necessary reports and visualizations to inform the Collegium.

• Primary Tools: scriptor_explico.py and dependency_analyzer.py.
• Standard Procedure: The `dependency_analyzer` consumes the `dependency_map.json` to generate its report. Crucially, it must also integrate the Wiki Maneuverability Score calculated by `scriptor_explico` to enrich its visualization. The resulting interactive graph serves as the Collegium's primary diagnostic dashboard, color-coding nodes by their WM Score and sizing them by their foundational importance (in-degree).

Quo Eundum! -- Deploy: The Praetor's Gateway

All new code enters the wiki through a single, controlled gateway managed by the Praetor.

• Canonical Tool: A unified wiki_importer.py (to be refactored and renamed praetor_importer.py) is the only sanctioned method for importing templates and modules.
• Standard Procedure: The importer MUST operate using the canonical `dependency_map.json`; it is forbidden from performing its own live dependency crawling. It must support two modes of operation:
  • --page 'PageName': For importing a single page and its required dependencies.
  • --batch approved_list.txt: For deploying a pre-approved list of assets.
• Critical Safety Protocol: All deployment actions must first be run with the --dry-run flag to produce a report of intended changes. This report must be reviewed by the Praetor before a final, live deployment is executed.

Pacta sunt servanda pietate -- Align: The Quality Control Loop

Ongoing quality is ensured through a suite of maintenance and quality assistance tools.

• Primary Tools: The refactored `scriptor_explico.py` and the Scribal Quality Assistant (evolved from `active_voice_assistant.py`).
• Standard Procedure: The Wiki Maneuverability Score is calculated on a regular basis to monitor the health of the wiki's codebase. The Scribal Assistant is used by the Custos Animae and other editors to ensure the prose of documentation and articles adheres to a high standard of clarity and accessibility.

Practical Applications

1. Layer 1: User Guidance (The Nudge): A custom JavaScript payload deployed via MediaWiki:Common.js will detect attempts to create a new page in the Template or Module namespaces. It will then display a prominent, helpful notification guiding the user to create a /sandbox subpage instead.
2. Layer 2: Technical Enforcement (The Gate): The AbuseFilter extension is configured to disallow the creation of any new page in the Template (NS_TEMPLATE) or Module (NS_MODULE) namespaces unless the page title ends with /sandbox. This provides a hard, non-bypassable technical block.
3. Layer 3: Procedural Framework (The Path): The TemplateSandbox extension is the officially sanctioned tool for testing and previewing changes made in sandbox pages. The workflow is as follows: creation in the sandbox, testing via `Special:TemplateSandbox`, and finally, promotion to the main namespace by a member of the Collegium.
4. Layer 4: Automated Oversight (The Watcher): A maintenance bot, operated by the `Custos Structurae`, will periodically scan for non-compliant pages that may have bypassed the filter. The bot is authorized to revert non-compliant creations and notify the creator, ensuring the integrity of the policy.

Collegium Toolkit: Development Roadmap

To fully implement the Unified Pipeline, the following development tasks have been identified. They represent the official roadmap for evolving the Collegium's script collection into a professional-grade System Administration SDK.

Core Architecture & Workflow

• Implement a robust wikitext parsing library (e.g., mwparserfromhell) across all scripts to replace brittle regular expressions. This is the highest-priority technical-debt payment.
• Centralize all tunable constants (e.g., WM Score penalty weights) into a single, version-controlled configuration file (e.g., collegium_config.yaml).

Tool: Scriptor Explico (WM Score)

• The check for the

Documentation[create] [purge]

bonus must be enhanced. The script must verify that the corresponding /doc subpage not only exists but is also not a redlink and contains content.

• The script's output must be an "explainable" JSON object, detailing the exact penalties and bonuses applied, not just the final score.

Tool: Dependency & Deployment Suite

• Merge the functionality of wiki_importer.py and batch_installer.py into a single, canonical deployment tool for the Praetor.
• Refactor the unified importer to use the static dependency_map.json as its sole source for dependency information.
• Implement the mandatory --dry-run flag in the unified importer to provide a pre-flight check before any writes are made to the wiki.
• Integrate the WM Score into the dependency_analyzer.py visualization, color-coding nodes to create a true diagnostic dashboard.

Tool: Scribal Quality Assistant

• Evolve the `active_voice_assistant.py` into a more comprehensive Scribal Quality Assistant.
• Add new checks and modes beyond passive voice, such as:
  • --check-jargon: To identify overly technical terms that should be linked to a glossary or simplified.
  • --check-reading-level: To calculate and report a standard readability score (e.g., Flesch-Kincaid) to ensure content is accessible.