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.

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.

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: Pretty PHP [[1]]
• For Lua: StyLua [[2]]
• For CSS: Prettier [[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:

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.

5. Converti: The Collegium's SDK and Development Roadmap

The "Collegium Toolkit" is not a loose collection of scripts; it is a single, integrated SDK known as Converti. All previously separate tools are to be deprecated and their functionality folded into `Converti` as distinct commands and capabilities.

`Converti` is the canonized, opinionated, CLI-based quality and production system for the AetherOS wiki. It is designed to be downloaded and run directly in the terminal by any contributor—human developers and their AI Wingmen (Code Virtuoso's Companions) alike. Its sole purpose is to provide a unified pipeline to draft, validate, and deploy high-quality, "virtuous" code to the wiki, and to assist in the removal or refactoring of graceless code.

The following roadmap outlines the planned evolution of `Converti` into this comprehensive SDK.

5.1 Core Architecture and Pipeline

The foundation of the SDK will be upgraded to ensure maximum robustness and automation.

• Parsing Engine Upgrade: `Converti`'s wikitext parsing engine will be rebuilt using a dedicated library (e.g., mwparserfromhell). This will replace all brittle regular expression-based logic, ensuring accurate and reliable analysis of complex templates and modules. This is the highest-priority technical-debt payment.
• Centralized Configuration: `Converti` will be driven by a single, version-controlled configuration file, collegium_config.yaml. This file will contain all tunable constants, including WM Score weights and formatter paths, making the entire system's behavior transparent and easy to adjust.
• Integrated Formatter Toolchain: The sanctioned code formatters ([[4]], [[5]], and [[6]]) will be integrated directly into the SDK. A new command, converti format, will be created to automatically apply the canonized style to any staged codebase.

5.2 Commands for Analysis and Discovery (The Quaesitor's Toolkit)

This suite of commands allows the Quaesitor to map and audit the wiki's entire structural landscape.

• converti map: This command replaces the standalone `dependency_resolver.py`. It takes a list of root pages as input and generates the canonical dependency_map.json artifact, which serves as the static worldview for all other commands.
• converti audit: This powerful command replaces both `dependency_analyzer.py` and `scriptor_explico.py`. It consumes the dependency_map.json and performs a full analysis, generating:
  • The Wiki Maneuverability Score for every page in the map, with an enhanced check to ensure documentation pages exist and are not empty.
  • A detailed, "explainable" JSON output that breaks down the calculation for each page's score.
  • A human-readable text report summarizing the most foundational and complex pages.
  • An enriched, interactive HTML graph where nodes are color-coded by their WM Score and sized by their foundational importance, creating a true diagnostic dashboard.

5.3 Commands for Deployment and Maintenance (The Praetor's Gateway)

This suite provides the tools for the Praetor and Custos Animae to manage the lifecycle of code on the wiki.

• converti deploy: This command replaces both `wiki_importer.py` and `batch_installer.py`, becoming the sole, sanctioned gateway for deploying code. It is driven by the static dependency map and supports two primary modes:
  • converti deploy --page 'Template:Infobox': For deploying a single asset and its dependencies.
  • converti deploy --batch approved_list.txt: For executing a controlled, batch deployment of pre-vetted assets.
• Mandatory Dry-Run Protocol: The `deploy` command will feature a mandatory --dry-run flag. This provides a pre-flight check that generates a report of all proposed changes (creations, skips, errors) without writing to the wiki, ensuring all deployments are deliberate and auditable.
• converti assist: This command evolves the `active_voice_assistant.py` into a comprehensive Scribal Quality Assistant for interactive content improvement. It will feature several modes for authors:
  • --check-voice: The original check for passive voice.
  • --check-jargon: Identifies overly technical terms that should be linked to a glossary or simplified.
  • --check-reading-level: Calculates a standard readability score to ensure content is accessible.