activate odoo plug-and-play profile (W11 D-RACTOR-SUPERVISOR consumer slot 50)

The seven-component plug-and-play stack the operator named — ontology /
callcenter / contract / rbac / surrealdb-on-kvs-lance / OGAR / ractor —
was already wired; the W11 plan (compile-time-consumer-binding-v1.md §2.2)
shipped the manifest-codegen build-script + CallcenterSupervisor +
GenericBridge surface. The precise gap was odoo's activation profile:
`modules/odoo/manifest.yaml` registered ODOO_V1 = (50, 1) in `MODULE_TABLE`
as INERT, with `rbac_policy: ~`, `stack_profile: ~`, `action_capabilities:
{}`, `actor: ~`.

This commit makes odoo "drop the odoo-rs crate and go" through three
additive surfaces:

1. modules/odoo/manifest.yaml — flip inert→active, declare rbac_policy:
   odoo_policy, populate stack_profile with GoBD-derived defaults
   (audit_retention_days: 3650 for §147 AO 10-year retention,
   requires_fail_closed: true, escalation: llm), enumerate 15
   action_capabilities (post_journal_entry/validate_invoice/
   reconcile_payment/delete_partner/export_xml_invoice as escalate;
   partner+journal+PDF+email writes as permit_with_audit; read paths
   as permit), wire actor: {crate: odoo-rs, type: OdooActor, message_type:
   OdooMessage}. inherits_from: fibofnd unchanged.

2. crates/lance-graph-supervisor/src/actors/odoo_actor.rs — OdooConsumerActor
   skeleton (~140 LOC, 1:1 sibling of medcare_actor.rs). ODOO_G = 50,
   ODOO_VERSION = 1. Reads ODOO_AUDIT_SALT env var, handles all 8
   ConsumerEnvelope arms with TODO markers awaiting odoo-rs to land its
   impl Consumer body. Re-exported via actors/mod.rs + lib.rs under the
   supervisor feature gate.

3. crates/lance-graph-ontology/src/bridges/odoo_bridge.rs — OdooBridge:
   NamespaceBridge (~50 LOC). bridge_id = "odoo", locks to namespace "Odoo"
   (matches the existing test seed at registry.rs:826 + the convention
   across WoaBridge/MedcareBridge/SpearBridge/SharePointBridge). impl
   BridgeFromRegistry so make_bridge::<OdooBridge>(registry) works.

Per E-OGAR-AR-SHAPE-REHOME (2026-06-19), lance-graph does NOT mint
canonical-concept ids — OGAR's ogar-vocab is the canonical AR registry.
This activation creates the resolution surface (manifest-codegen → bridge
→ actor) through which odoo-rs fans out its DO arm to OGAR's 0xDDCC-encoded
codebook. Per hydrators/odoo.rs Seam decision 1 / Option B, odoo classes
inherit existing FIBO/SKR family slots via owl:equivalentClass-routing —
no new CAM codebook family minted. Foundry-family resolution lives in
lance_graph_callcenter::odoo_alignment; OdooBridge is the public-name →
OGIT URI translator the consumer crate dispatches through.

Acceptance:
- cargo check -p lance-graph-contract: clean (rebuilds OUT_DIR
  ogit_namespace.rs + manifest_metadata.rs with ODOO_V1 non-inert).
- cargo test -p lance-graph-contract --test manifest_codegen: 8/8 pass
  (incl. test_non_inert_no_actor_rejected — proves the activated manifest
  survives the strict validator).
- cargo check -p lance-graph-supervisor: clean.
- cargo test -p lance-graph-supervisor --lib: 3/3 pass.
- cargo check -p lance-graph-ontology: clean.
- cargo test -p lance-graph-ontology --lib bridges: 1/1 filtered test pass.

Board hygiene: prepended EPIPHANIES E-ODOO-ACTIVATION-PROFILE +
LATEST_STATE Current Contract Inventory ACTIVATED entry.

Out of scope (future, lab follow-up): UnifiedBridge<OdooBridge> with
AuditChain under HSM-rooted salt — same TODO as MedcareConsumerActor;
lands with the odoo-rs consumer crate. supervisor.rs's spawn path still
uses StubConsumerActor generically; both medcare + odoo actors are
exported skeletons for future routing (W11 Tier-3 lane).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Xzyc27Nx3f8WC5KzwfWfjx

Author: claude

.claude/board/EPIPHANIES.md

@@ -260,6 +260,30 @@ Cross-ref: TECH_DEBT `TD-SURREALDB-KVLANCE-LANCE7` (now PAID); `E-LANCE7-OBJECTS
 | LEAF | 8 | 0.592 | 0.512 | 1.16 | leaks |
 
 IT **replicates and slightly extends** the ES result: the crisp band is hop-local at HEEL **and HIP** (ES was HEEL only), LEAF leaks — same shape (crisp tiers localize, finest tier leaks), on an independent grid. So the family-basin Weyl-multi-hop hop-locality is **not an ES artifact** — it holds where the bisection is stable, across grids. The tier at which leakage sets in is grid-specific (the marginal-DK / out-of-family-tie-growth boundary), as expected. Cross-ref: `E-FAMILY-BASIN-WEYL-HOP-LOCAL-AT-CRISP-TIER` (the ES finding this confirms).
+## 2026-06-20 — E-ODOO-ACTIVATION-PROFILE — odoo manifest flipped from inert to active; `OdooConsumerActor` + `OdooBridge` skeletons land; activation parity with medcare achieved — `odoo-rs` is now "drop the crate and go"
+
+**Status:** FINDING (activation completed; the plug-and-play seven-component request landed additively).
+
+**Operator goal recap.** "Make plug-and-play so whenever OGAR finds a consumer like odoo-rs it activates OGAR classes, adapters, etc. for odoo and pulls in the rest" with seven named components: lance-graph-ontology / lance-graph-callcenter / lance-graph-contract / lance-graph-rbac / surrealdb-on-kvs-lance / OGAR / ractor (compile-time mailbox-as-owner — NOT runtime mutation authority). The audit confirmed all seven already exist in workspace and that the active plan `compile-time-consumer-binding-v1.md` (W11) shipped the contract crate's manifest-codegen build-script + the `lance-graph-supervisor::CallcenterSupervisor`. The precise gap was odoo's activation profile: `modules/odoo/manifest.yaml` had `inert_when_consumer_absent: true`, `rbac_policy: ~`, `stack_profile: ~`, `action_capabilities: {}`, `actor: ~` — meaning the build-script registered ODOO_V1 in `MODULE_TABLE` as INERT, no supervisor spawn, no bridge gate, no policy hook.
+
+**What landed (3 additive surfaces, ~210 LOC total, zero edits to existing tests).**
+
+1. **`modules/odoo/manifest.yaml`** — flipped `inert_when_consumer_absent: true → false`, declared `rbac_policy: odoo_policy`, populated `stack_profile` with GoBD-derived defaults (`audit_retention_days: 3650` for §147 AO 10-year accounting retention; `requires_fail_closed: true`; `escalation: llm`), enumerated 15 `action_capabilities` (the odoo DO arm — `post_journal_entry`/`validate_invoice`/`reconcile_payment`/`delete_partner`/`export_xml_invoice` as `escalate`; partner/journal-entry/PDF/email writes as `permit_with_audit`; read paths as `permit`), wired `actor: {crate: odoo-rs, type: OdooActor, message_type: OdooMessage}`. Build-script's strict validators pass: `non_inert_no_actor` gate satisfied, `domain_name` matches dir, `entity_count = 17`, `inherits_from: fibofnd` resolves (DOLCE chain reachable).
+
+2. **`crates/lance-graph-supervisor/src/actors/odoo_actor.rs`** (~140 LOC, sibling of `medcare_actor.rs`) — `OdooConsumerActor: ractor::Actor` with `Msg = ConsumerEnvelope`, `State = OdooState`, `ODOO_G = 50` + `ODOO_VERSION = 1`. `pre_start` reads `ODOO_AUDIT_SALT` env var (default `0`); `handle` dispatches the 8 ConsumerEnvelope arms (Health/Dispatch/Ingest/Qualia/Styles + the 3 lab-only Tensors/Calibrate/Probe). All non-Health arms are stubs with `TODO` markers awaiting the `odoo-rs` consumer crate to land — exactly the medcare pattern (1:1 mirror so the actual consumer's only diff is the handler body content). Re-exported from `actors/mod.rs` + `lib.rs` under the `supervisor` feature gate.
+
+3. **`crates/lance-graph-ontology/src/bridges/odoo_bridge.rs`** (~50 LOC) — `OdooBridge: NamespaceBridge` with `bridge_id = "odoo"`, locks to namespace `"Odoo"` (matches the existing test seed at `registry.rs:826` `proposal_from("ogit.Person:Person", "odoo", "Odoo")` + the convention across `WoaBridge`/`MedcareBridge`/`SpearBridge`/`SharePointBridge`). Constructor returns `Error::UnknownNamespace` if no mapping has been registered under `"Odoo"` yet — same shape as the four sibling bridges. `impl BridgeFromRegistry` so the generic `make_bridge::<OdooBridge>(registry)` helper works.
+
+**The architectural invariant preserved.** The 2026-06-19 supersession of `E-OGAR-AR-SHAPE-REHOME` still holds: lance-graph does NOT mint canonical-concept ids; OGAR's `ogar-vocab` is the canonical AR registry; this activation creates the *resolution surface* (manifest-codegen → bridge → actor) through which an `odoo-rs` consumer fans out its DO arm to the existing OGAR `0xDDCC`-encoded codebook. Per the four-way alignment seam (Seam decision 1 / Option B, `hydrators/odoo.rs`), odoo classes inherit existing FIBO/SKR family slots via `owl:equivalentClass`-routing — no new CAM codebook family is minted. The `OdooBridge` is the public-name → OGIT URI translator the consumer crate dispatches through; the foundry-family resolution lives in `lance_graph_callcenter::odoo_alignment` (`resolve_odoo`/`resolve_odoo_to_family`) per the single-source rule documented there.
+
+**Acceptance evidence.** `cargo check -p lance-graph-contract` rebuilds `${OUT_DIR}/ogit_namespace.rs` + `${OUT_DIR}/manifest_metadata.rs` with the new ODOO_V1 row marked non-inert + actor wired. `cargo test -p lance-graph-contract --test manifest_codegen` 8/8 passing (incl. `test_non_inert_no_actor_rejected` — confirms the activated manifest survives the strict validator). `cargo check -p lance-graph-supervisor` clean (only pre-existing unused-import warning in callcenter). `cargo check -p lance-graph-ontology` clean (only pre-existing oxrdf deprecation warnings). 3 supervisor lib tests + 1 bridges-filtered ontology test pass. Branch `claude/hydrate-dolce-dul-owl-Ce9Oa`.
+
+**What remains gated (out of scope here, lab follow-up).** Wiring `UnifiedBridge<OdooBridge>` with an `AuditChain` under HSM-rooted salt — this is the same TODO that lives on `MedcareConsumerActor::pre_start`; it lands when the consumer-side `odoo-rs` crate ships its `impl Consumer` block, not before. `supervisor.rs`'s spawn path still uses `StubConsumerActor` generically — both medcare and odoo actors are skeletons exported for future routing, and that routing is the W11 plan's Tier-3 lane.
+
+**Cross-refs:** `.claude/plans/compile-time-consumer-binding-v1.md` §2.2 D-RACTOR-SUPERVISOR (W11 spec); `modules/odoo/manifest.yaml` (activated); `crates/lance-graph-supervisor/src/actors/medcare_actor.rs` (the 1:1 template); `crates/lance-graph-ontology/src/bridges/medcare_bridge.rs` (the bridge template); `crates/lance-graph-callcenter/src/odoo_alignment.rs` (the four-way alignment seam that the OdooBridge translates THROUGH); `crates/lance-graph-ontology/src/hydrators/odoo.rs` (ODOO_V1 hydration entry point, `inherits_from: fibofnd`); `E-OGAR-AR-SHAPE-REHOME` (the construction-error guard — this activation consumes OGAR's registry, does not duplicate it).
+
+---
+
 ## 2026-06-19 — E-OGAR-AR-SHAPE-REHOME — the `ar_shape` module was a PARALLEL AR registry in the wrong repo (the od-ontology construction error, repeated); OGAR's `ogar-vocab` already IS the canonical registry — lance-graph does Odoo EXTRACTION that resolves to OGAR's codebook, it does not RE-DERIVE the registry
 
 **Status:** FINDING (construction-error correction; operator-flagged 2026-06-19; #552 closed, module reverted from lance-graph). **Supersedes the CODE-HOME claim of `E-OGAR-AR-SHAPE-SMOKE-1..6` below** — their *findings* (cross-curator node/vocabulary/edge/mixin convergence) hold and are real, but the *code that proved them belongs in `AdaWorldAPI/OGAR`, not `lance-graph-ontology`*. The module was reverted; this entry records why so a future session does not rebuild it here.

.claude/board/LATEST_STATE.md

@@ -117,6 +117,8 @@
 
 ## Current Contract Inventory (lance-graph-contract)
 
+> **2026-06-20 — ACTIVATED (odoo plug-and-play profile, W11 D-RACTOR-SUPERVISOR consumer slot 50)**: `modules/odoo/manifest.yaml` flipped from inert to active, registering `OGIT::ODOO_V1 = (50, 1)` with: `rbac_policy: odoo_policy`, `stack_profile {audit_retention_days: 3650 (§147 AO 10-year accounting retention), requires_fail_closed: true, escalation: llm}`, 15 `action_capabilities` (the odoo DO arm — `post_journal_entry`/`validate_invoice`/`reconcile_payment`/`delete_partner`/`export_xml_invoice` as `escalate`; partner+journal+PDF+email writes as `permit_with_audit`; read paths as `permit`), `actor: {crate: odoo-rs, type: OdooActor, message_type: OdooMessage}`, `inherits_from: fibofnd`. The build-script's `non_inert_no_actor` strict validator passes; `MANIFEST_METADATA[ODOO_V1]` now carries `inert: false, rbac_policy: Some("odoo_policy"), actor_crate: Some("odoo-rs"), actor_type: Some("OdooActor")`. Companion skeletons land additively in two crates: (1) `lance_graph_supervisor::actors::OdooConsumerActor` (~140 LOC, 1:1 sibling of `MedcareConsumerActor`, `ODOO_G = 50` / `ODOO_VERSION = 1`, reads `ODOO_AUDIT_SALT` env var, handles all 8 `ConsumerEnvelope` arms with TODO markers awaiting `odoo-rs`); (2) `lance_graph_ontology::bridges::OdooBridge` (~50 LOC, `bridge_id = "odoo"`, locks to namespace `"Odoo"`, sibling of `MedcareBridge`/`WoaBridge`). Per `hydrators/odoo.rs` Seam decision 1 / Option B, odoo classes inherit existing FIBO/SKR family slots via `owl:equivalentClass`-routing — no new CAM codebook family minted. Foundry-family resolution stays in `lance_graph_callcenter::odoo_alignment`; `OdooBridge` is the public-name → OGIT URI translator the consumer crate dispatches through. Build clean, 8/8 `manifest_codegen` tests pass (incl. `test_non_inert_no_actor_rejected` regression-proves the activated manifest), supervisor + ontology lib tests pass. Closes the precise gap in the plug-and-play seven-component request (ontology / callcenter / contract / rbac / surrealdb-on-kvs-lance / OGAR / ractor) — odoo is now "drop the odoo-rs crate and go" through the existing CallcenterSupervisor + GenericBridge surface. EPIPHANIES `E-ODOO-ACTIVATION-PROFILE`. Branch `claude/hydrate-dolce-dul-owl-Ce9Oa`.
+
 > **2026-06-18 — ADDED (probe-excel-compute-dag-v1 Inc 0, the `compute_dag` Core gap)**: `lance_graph_contract::class_view::{ComputeEdge, compute_dag_is_acyclic}` + `ClassView::compute_dag(class) -> &[ComputeEdge]` (default `&[]`, zero-fallback). `ComputeEdge {target: u8, inputs: &'static [u8]}` is the harvest-sourced recompute edge (`emitted_by` target ← `depends_on` inputs; field positions index the class `FieldMask`), `const`-constructible like `MethodSig`/`ActionDef` (the harvest IS the manifest). `compute_dag_is_acyclic` is the **registry-build gate** — a cyclic recompute DAG (formula loop / `@api.depends` cycle / self-loop) is rejected at build (Kahn over ≤64 positions, allocation-free; out-of-range positions ignored, no panic, mirrors `FieldMask::from_positions`). This is the Core home for computed-field recompute *dispatch* that EVERY computed-field AR consumer needs (Odoo `@api.depends`, Excel formulas, medcare lab-trends, woa calc, q2 cells — they reduce to a sheet; `E-EXCEL-SHADER-PROJECTION`) and the NNUE-incremental existence-proof shape (`E-CHESS-TENSOR-PROVEN`). **Layout-preserving**: a default trait method + a free fn, resolution metadata ABOVE the SoA, stores nothing on the row, zero `NODE_ROW_STRIDE`/`ENVELOPE_LAYOUT_VERSION` impact (core-gap-auditor's EXTEND-CORE, never an adapter-state hack). The instance recompute that consumes it is gated per-cell by the cycle-aware `write_row` (`E-SOA-CYCLE-OWNERSHIP`). Additive, zero-dep; +4 tests (default-empty, acyclic-chain, cycle/self-loop/3-cycle rejected, out-of-range ignored); 10/10 class_view, clippy/fmt clean. Sibling `ClassView::constraints` (`validation_kind`-sourced) deferred to Inc-follow-up. Plan: `.claude/plans/probe-excel-compute-dag-v1.md`. Branch `claude/particle-wave-click-epiphany`.
 
 > **2026-06-18 — ADDED (D-DO-ARM-1, the OGAR DO arm)**: `lance_graph_contract::action::{ActionState, StateGuard, ActionDef, ClassActions, actions_for, effective_actions, ActionInvocation}` — the Perdurant DO arm completing the OGAR IR (the action-axis sibling of `codegen_manifest`'s `MethodSig`/THINK). Both the 4-agent `sale_order` AR→DO probe (runtime-archaeologist) AND the merged cross-repo PR survey (ruff/OGAR/lance-graph/openproject/tesseract) agreed this was the ONE missing wire: the THINK arm (`classid → ClassView`, `has_function → MethodSig`) is converged + merged; the DO-arm `ActionInvocation`/`ActionDef` type was ABSENT. **`ActionDef`** (static, `const`-constructible, all `&'static`/`Copy`): `predicate` (= harvested `has_function` method), `object_class` (classid), `exec` (`ExecTarget` incl `SurrealQl`), `guard` (`StateGuard` = KausalSpec field==value), `required_role` (RBAC), `overrides` (OGAR `classid→ClassView` inheritance). **`ClassActions`+`actions_for`** (zero-fallback) mirror `ClassMethods`/`methods_for`. **`effective_actions(parent, child)`** = OGAR inheritance on the action axis (child overrides parent by predicate). **`ActionInvocation`** (dynamic, `Copy`): lifecycle `ActionState{Pending→Committed|Failed|Cancelled}` (sticky terminals), S2.5 `cycle` stamp, idempotency/trace keys, HLC `emitted_at_millis`. **`ActionInvocation::commit(def, actor, impact, now)`** is the gated egress — RBAC FIRST (`auth::ActorContext` must hold `required_role` or be admin → else `Failed`), THEN MUL impact (`mul::GateDecision`: `Flow→Committed`+stamped, `Hold→`Pending/escalate, `Block→Cancelled`). This IS "commit to the external consumer (odoo/openproject/woa/tesseract) after the cycle decides sound." Dispatched via `UnifiedStep`/`ExecTarget`, NOT a per-crate endpoint. Additive, zero-dep. +5 tests green. Consumer reference: `docs/OGAR_CONSUMER_API.md`. Branch `claude/soa-write-deinterlace-inc2`.

crates/lance-graph-ontology/src/bridges/mod.rs

@@ -9,6 +9,11 @@
 //!   `Customer`, `WorkOrder`, `Position` are translated via the registry
 //!   to the corresponding `ogit.WorkOrder:*` URIs.
 //! - [`MedcareBridge`]: locks to the `Healthcare` namespace.
+//! - [`OdooBridge`]: locks to the `Odoo` namespace. Companion to the
+//!   `OdooConsumerActor` skeleton in `lance-graph-supervisor` and the
+//!   four-way alignment seam in `lance_graph_callcenter::odoo_alignment`
+//!   (Seam decision 1 / Option B — odoo inherits FIBO families, no own
+//!   CAM codebook).
 //! - [`SpearBridge`]: locks to the `EmailCorrespondance` namespace. Used
 //!   by the spear columnar mail server with stalwart (IMAP/JMAP) and
 //!   SharePoint as upstream mail-orchestration producers — both feed the
@@ -29,13 +34,15 @@
 //! own auth + per-customer scoping concerns that need a separate design pass.
 
 mod medcare_bridge;
+mod odoo_bridge;
 mod ogit_bridge;
 mod openproject_bridge;
 mod sharepoint_bridge;
 mod spear_bridge;
 mod woa_bridge;
 
 pub use medcare_bridge::MedcareBridge;
+pub use odoo_bridge::OdooBridge;
 pub use ogit_bridge::OgitBridge;
 pub use openproject_bridge::OpenProjectBridge;
 pub use sharepoint_bridge::SharePointBridge;

crates/lance-graph-ontology/src/bridges/odoo_bridge.rs

@@ -0,0 +1,52 @@
+//! Odoo (ERP) tenant bridge — locks to the `Odoo` namespace.
+//!
+//! Odoo lands in OGIT at G=50, inheriting from FIBO-FND (financial
+//! foundations) per `modules/odoo/manifest.yaml`. Per `hydrators/odoo.rs`
+//! (Seam decision 1 / Option B), odoo does NOT get its own CAM codebook
+//! family — every odoo class with an alignment axiom is
+//! `owl:equivalentClass`-routed into an existing FIBO/SKR slot. This bridge
+//! is the public-name → OGIT URI translator for the odoo extraction
+//! surface; the heavy lifting (foundry-family resolution, Layer-2
+//! alignment pivot lookup) lives in
+//! `lance_graph_callcenter::odoo_alignment` and is consumed via the
+//! single-source rule documented there.
+
+use crate::bridge::{BridgeFromRegistry, NamespaceBridge};
+use crate::error::{Error, Result};
+use crate::namespace::NamespaceId;
+use crate::registry::OntologyRegistry;
+use std::sync::Arc;
+
+pub const NAMESPACE: &str = "Odoo";
+
+pub struct OdooBridge {
+    registry: Arc<OntologyRegistry>,
+    g_lock: NamespaceId,
+}
+
+impl OdooBridge {
+    pub fn new(registry: Arc<OntologyRegistry>) -> Result<Self> {
+        let g_lock = registry
+            .namespace_id(NAMESPACE)
+            .ok_or_else(|| Error::UnknownNamespace(NAMESPACE.to_string()))?;
+        Ok(Self { registry, g_lock })
+    }
+}
+
+impl NamespaceBridge for OdooBridge {
+    fn bridge_id(&self) -> &'static str {
+        "odoo"
+    }
+    fn registry(&self) -> &OntologyRegistry {
+        &self.registry
+    }
+    fn g_lock(&self) -> NamespaceId {
+        self.g_lock
+    }
+}
+
+impl BridgeFromRegistry for OdooBridge {
+    fn from_registry(registry: Arc<OntologyRegistry>) -> Result<Self> {
+        Self::new(registry)
+    }
+}

crates/lance-graph-supervisor/src/actors/mod.rs

@@ -3,7 +3,8 @@
 //! Each active G slot has one actor. The `StubConsumerActor` (in `supervisor.rs`)
 //! serves as the skeleton. Concrete implementations live here:
 //!
-//! - `medcare_actor.rs` — `MedcareConsumerActor` (G=2, HEALTHCARE_V1, proof-of-concept)
+//! - `medcare_actor.rs` — `MedcareConsumerActor` (G=2,  HEALTHCARE_V1, proof-of-concept)
+//! - `odoo_actor.rs`    — `OdooConsumerActor`    (G=50, ODOO_V1,       proof-of-concept)
 //!
 //! Future:
 //! - `ogit_actor.rs`  — OgitBridge actor (G=4, SMB_V1)
@@ -16,5 +17,7 @@
 //! Arrow scalars) never cross the actor mailbox boundary.
 
 pub mod medcare_actor;
+pub mod odoo_actor;
 
 pub use medcare_actor::MedcareConsumerActor;
+pub use odoo_actor::OdooConsumerActor;