Oculus Prime (servizio unico, porta 9050)           ← ships con Vitruvyan Core (gratuito)
├── Core agents (7 media types + GDrive)
├── APIRegistry ← i connettori Frontier si registrano qui via entry points
└── Evidence Pack pipeline (universale)

vitruvyan-frontier-odoo (pacchetto premium)          ← pip install / vit install
├── fetchers/                                        ← OdooInvoiceFetcher, OdooSaleOrderFetcher, OdooPartnerFetcher
├── domains/enterprise/                              ← intent_config.py, vertical_manifest.yaml (dominio singolo, condiviso da tutti i connettori ERP)
└── pyproject.toml                                   ← entry-points: vitruvyan.oculus_connect

infrastructure/edge/oculus_prime/plugins/frontier_odoo/
├── __init__.py
├── fetchers.py          ← OdooInvoiceFetcher, OdooSaleOrderFetcher, OdooPartnerFetcher
├── auth.py              ← OdooAuthenticator (XML-RPC uid caching)
└── pyproject.toml       ← template per il pacchetto standalone

vitruvyan_core/domains/enterprise/
├── __init__.py
├── intent_config.py     ← IntentRegistry "enterprise" (condiviso da tutti i connettori Frontier)
└── vertical_manifest.yaml

[project]
name = "vitruvyan-frontier-odoo"
version = "0.1.0"
description = "Vitruvyan Frontier connector for Odoo ERP"
requires-python = ">=3.11"
 
[project.entry-points."vitruvyan.oculus_connect"]
odoo_invoices = "vitruvyan_frontier_odoo.fetchers:OdooInvoiceFetcher"
odoo_orders = "vitruvyan_frontier_odoo.fetchers:OdooSaleOrderFetcher"
odoo_partners = "vitruvyan_frontier_odoo.fetchers:OdooPartnerFetcher"

from importlib.metadata import entry_points
 
def discover_frontier_plugins(self):
    """Auto-discover Frontier connectors installed via pip/vit."""
    eps = entry_points(group="vitruvyan.oculus_connect")
    for ep in eps:
        fetcher_cls = ep.load()
        self.register(ep.name, fetcher_cls())

class OdooInvoiceFetcher(AbstractAPIFetcher):
 
    def get_config(self) -> APIConfig:
        # base_url da ODOO_URL, endpoint="/xmlrpc/2/object"
        # auth_type="basic" (Odoo XML-RPC usa uid+api_key)
        # response_format="json"
 
    def build_params(self, **kwargs) -> Dict[str, Any]:
        # model="account.move", method="search_read"
        # domain filtri: move_type, date range, payment_state
        # fields: name, partner_id, amount_total, invoice_date,
        #         invoice_date_due, payment_state, invoice_line_ids
 
    def parse_response(self, response: APIResponse) -> Dict[str, Any]:
        # Estrae records, li normalizza in formato standard
        # Calcola aggregati (totale, count, media)
        # NO semantica — solo dati letterali
 
    def create_evidence_metadata(self, parsed_data, params) -> Dict[str, Any]:
        # source_type: "erp_record"
        # source_ref JSONB con: source_system="odoo", source_model,
        #   structured_fields (importi, date, stati)
        # technical_metadata: extraction_method="odoo_xmlrpc",
        #   erp_version, fetch_timestamp, record_count

✅ "Fattura INV/2026/0847 emessa il 2026-01-15 verso Rossi SpA (ID partner: 42).
    Importo totale EUR 12.500,00. Stato pagamento: non pagato.
    Scadenza: 2026-02-28. Righe: 50x Widget Pro a EUR 250,00/unità."

❌ "La fattura di Rossi è in ritardo e potrebbe indicare problemi di liquidità."
   (violazione: "potrebbe indicare" = inferential, "problemi" = evaluative)

source_ref = {
    "source_type": "erp_record",
    "source_system": "odoo",
    "source_model": "account.move",
    "source_id": "INV/2026/0847",
    "source_uri": "odoo://demo.odoo.com/account.move/847",
    "source_hash": "sha256:<hash del record JSON>",
    "mime_type": "application/json",
    "byte_size": 1024,
    "structured_fields": {
        "partner_id": 42,
        "partner_name": "Rossi SpA",
        "amount_total": 12500.00,
        "currency": "EUR",
        "payment_state": "not_paid",
        "invoice_date": "2026-01-15",
        "invoice_date_due": "2026-02-28",
        "line_items": [
            {"product": "Widget Pro", "qty": 50, "unit_price": 250.00}
        ]
    }
}
 
technical_metadata = {
    "extraction_method": "odoo_xmlrpc",
    "erp_version": "17.0",
    "record_type": "out_invoice",
    "fetch_timestamp": "2026-03-14T10:30:00Z",
    "record_count": 1,
    "chunk_position": 0,
    "language_detected": "it"
}
 
integrity = {
    "evidence_hash": "sha256:<hash dell'intero evidence pack>",
    "immutable": True,
    "signature": None
}

# In APIRegistry.discover_frontier_plugins() — boot di Oculus Prime
from importlib.metadata import entry_points
 
eps = entry_points(group="vitruvyan.oculus_connect")
for ep in eps:
    fetcher_cls = ep.load()
    registry.register(ep.name, fetcher_cls())
# → registra automaticamente: odoo_invoices, odoo_orders, odoo_partners

# In services/api_edge_oculus_prime/main.py al lifespan
from infrastructure.edge.oculus_prime.plugins.frontier_odoo.fetchers import (
    OdooInvoiceFetcher, OdooSaleOrderFetcher, OdooPartnerFetcher
)
 
registry.register("odoo_invoices", OdooInvoiceFetcher())
registry.register("odoo_orders", OdooSaleOrderFetcher())
registry.register("odoo_partners", OdooPartnerFetcher())

Fetcher.parse_response() → normalized_text + metadata
  → OculusPrimeAdapter persiste Evidence Pack in PostgreSQL
  → OculusPrimeEventEmitter.emit_evidence_created()
  → Channel: "oculus_prime.evidence.created" (v2 canonical)

{
    "event_id": "EVT-<uuid>",
    "evidence_id": "EVD-<uuid>",
    "chunk_id": "CHK-0",
    "source_type": "erp_record",
    "source_uri": "odoo://demo.odoo.com/account.move/847",
    "source_hash": "sha256:...",
    "byte_size": 1024,
    "language_detected": "it",
    "sampling_policy_ref": "SAMPPOL-ERP-DEFAULT-V1"
}

POST /api/oculus-prime/erp
Body: { "source": "odoo", "model": "account.move", "domain": [...], "limit": 100 }
Response: { "status": "success", "evidence_ids": [...], "records_ingested": 47 }

oculus_prime.evidence.created
  ↓
Codex Hunters (listener)
  → Entity discovery: "Rossi SpA" → tipo:cliente
  → Entity binding: Rossi SpA → nodo ontologico (se esiste, lo lega; se nuovo, lo crea)
  → Emette: codex.entity.discovered, codex.entity.bound
  ↓
Babel Gardens (listener)
  → Language detection: "it"
  → Sentiment: neutral (è un dato contabile, non un'opinione)
  → Embedding: vettore 768-dim del normalized_text
  ↓
Memory Orders (listener)
  → Persiste embedding in Qdrant con metadati ontologici
  → Il vettore è arricchito: non solo il testo, ma le relazioni (partner, importo, stato)
  → Abilita RAG: "fatture di Rossi" → semantic search → trova tutti gli evidence pack correlati
  ↓
Pattern Weavers
  → Ontologia semantica: Rossi COMPRA Widget, Rossi HA fattura_scaduta
  → Anomaly detection: quantità fuori media, inattività seguita da ordine grande
  → Trend: variazione importi nel tempo
  ↓
Vault Keepers
  → Archiviazione immutabile degli evidence pack processati
  → Snapshot per audit trail

ENTERPRISE_INTENTS = [
    IntentDefinition(
        name="erp_query",
        description="Query ERP data: fatture, ordini, clienti",
        examples=[
            "Quanto abbiamo fatturato questo mese?",
            "Quali clienti hanno fatture scadute?",
            "Mostrami gli ordini aperti",
            "How much did we invoice in Q4?",
        ],
        synonyms=["fatturato", "invoices", "ordini", "orders", "scaduto", "overdue"],
        requires_entities=False,
        route_type="direct",
    ),
    IntentDefinition(
        name="erp_comparison",
        description="Confronto temporale di metriche ERP",
        examples=[
            "Confronta vendite Q3 vs Q4",
            "Come sono andate le vendite rispetto al mese scorso?",
            "Year over year revenue comparison",
        ],
        synonyms=["confronta", "compare", "vs", "trend", "variazione"],
        requires_entities=False,
        route_type="direct",
    ),
    IntentDefinition(
        name="erp_anomaly",
        description="Rilevamento anomalie nei dati ERP",
        examples=[
            "C'è qualcosa di strano negli ordini recenti?",
            "Anomalie nelle fatture di questo mese",
            "Any unusual patterns in recent orders?",
        ],
        synonyms=["anomalia", "strano", "unusual", "anomaly", "outlier"],
        requires_entities=False,
        route_type="direct",
    ),
]
 
ENTERPRISE_FILTERS = [
    ScreeningFilter(
        name="erp_model",
        description="Tipo di dato ERP",
        value_type="enum",
        enum_values=["invoices", "orders", "partners", "products"],
        keywords=["fatture", "ordini", "clienti", "prodotti", "invoices", "orders"],
    ),
    ScreeningFilter(
        name="time_range",
        description="Periodo temporale",
        value_type="enum",
        enum_values=["today", "this_week", "this_month", "this_quarter", "this_year", "custom"],
        keywords=["oggi", "settimana", "mese", "trimestre", "anno", "today", "week", "month"],
    ),
]
 
def create_enterprise_registry() -> IntentRegistry:
    registry = IntentRegistry(domain_name="enterprise")
    for intent in ENTERPRISE_INTENTS:
        registry.register_intent(intent)
    for f in ENTERPRISE_FILTERS:
        registry.register_filter(f)
    return registry

domain_name: "enterprise"
domain_version: "0.1.0"
status: "draft"
 
compatibility:
  min_core_version: "1.0.0"
  max_core_version: "1.x.x"
  contracts_major: 1
  update_channel: "stable"
  breaking_changes_allowlist: []
  smoke_tests_timeout: 300
 
ownership:
  team: "vitruvyan-core"
  tech_lead: "vitruvyan"
  contact: "info@vitruvyan.com"
 
required_components:
  intent_config: true
  readme: true
  manifest: true
 
optional_components:
  graph_plugin: false
  graph_nodes: false
  governance_rules: false
  slot_filler: false
  response_formatter: false
 
adapters:
  langgraph_plugin: false
  sacred_orders_rules: false
  neural_engine_contracts: false
 
contracts_used:
  - contracts.IIngestionPlugin

Flusso:
1. Autenticazione Odoo (XML-RPC)
2. Fetch partners (res.partner) → Evidence Pack per ciascun cliente/fornitore
3. Fetch fatture (account.move) ultimi 12 mesi → Evidence Pack per fattura
4. Fetch ordini (sale.order) ultimi 12 mesi → Evidence Pack per ordine
5. Emissione eventi → pipeline epistemico li processa
6. Report: N partners, N fatture, N ordini ingeriti

Fase 0 (env vars)               ← 5 min
  ↓
Fase 1.0 (struttura pacchetto)  ← scaffold plugin
  ↓
Fase 1.1-1.5 (fetcher + EP)     ← lavoro principale
  ↓
Fase 4.1 (ingestione bulk)      ← verifica pipeline
  ↓
Fase 2 (pipeline — zero codice) ← verifica automatica
  ↓
Fase 3 (intent config)          ← dominio enterprise condiviso
  ↓
Fase 5 (test)                   ← validazione
  ↓
Fase 4.2 (scenari demo)         ← demo pronta

infrastructure/edge/oculus_prime/plugins/frontier_odoo/

vitruvyan-frontier-odoo/
├── src/vitruvyan_frontier_odoo/
│   ├── __init__.py
│   ├── fetchers.py
│   └── auth.py
├── tests/
├── pyproject.toml        ← entry-points: vitruvyan.oculus_connect
├── LICENSE               ← licenza premium
└── README.md