ogar-from-schema: DO-arm lift → SPO emitter, proven end-to-end

Closes the lift→triples seam for the behavioral arm: the DO-arm
ActionDef (D-HIRO-DO) flows through the canonical ogar-emitter to
SPO triples — the surface the RBAC / query layers consume.

tests/do_arm_emit.rs (new integration test, ogar-emitter as dev-dep):
- KnowledgeItem TTL → into_action_def → emit_action_def: asserts the
  §4 field mapping survives as ogar:ActionDef / ogar:actionPredicate
  (execute) / ogar:actionObjectClass (ogit-automation/mars_node_template)
  / LifecycleTrigger kausal / actuator-verb decorators.
- lossless-DO holds END-TO-END: body_source is None, so the emitter
  produces NO ogar:actionBody triple — a body triple would mean bytes
  leaked into the IR. Test fails if any do.

ogar-emitter is an acyclic dev-dep (it depends on ogar-vocab/-ontology,
never on ogar-from-schema). 24 lib + 2 integration tests green, clippy-clean.

Docs: D-HIRO-DO ledger row notes the proven emit path (+ D-EMIT dep).

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

Author: claude

crates/ogar-from-schema/Cargo.toml

@@ -29,3 +29,10 @@ roxmltree = { version = "0.20", optional = true }
 # When the TTL surface grows (Wikidata-shaped TTL, full RDF/XML, OWL
 # imports), swap in `oxttl` / `oxrdf` without touching the
 # Class/Attribute target shape this crate produces.
+
+[dev-dependencies]
+# Used only by tests/do_arm_emit.rs to prove the DO-arm lift's output
+# (`ogar_vocab::ActionDef`) flows through the canonical SPO emitter
+# end-to-end. Acyclic: ogar-emitter depends on ogar-vocab/-ontology,
+# never on this crate.
+ogar-emitter = { path = "../ogar-emitter" }

crates/ogar-from-schema/tests/do_arm_emit.rs

@@ -0,0 +1,95 @@
+//! End-to-end integration: the DO-arm lift reaches the SPO emitter.
+//!
+//! Proves the full behavioral-arm path closes —
+//!
+//! ```text
+//!   OGIT Automation TTL  →  ttl::parse_file  →  EntityDecl
+//!                        →  do_arm::into_action_def  →  ogar_vocab::ActionDef
+//!                        →  ogar_emitter::TripleEmitter::emit_action_def  →  Vec<Triple>
+//! ```
+//!
+//! i.e. the `KnowledgeItem` → `ActionDef` contract template (D‑HIRO‑DO)
+//! emits as canonical `ogar:ActionDef` SPO triples carrying the §4 field
+//! mapping, with the lossless‑DO invariant preserved across the whole path
+//! (no body inlined, so no `ogar:actionBody` triple is produced at the schema
+//! level). This is the lift→triples seam the RBAC / query layers consume.
+
+use ogar_emitter::TripleEmitter;
+use ogar_from_schema::do_arm::into_action_def;
+use ogar_from_schema::ttl::parse_file;
+use ogar_from_schema::TtlDeclaration;
+
+const KNOWLEDGE_ITEM_TTL: &str =
+    include_str!("../../../vocab/imports/ogit/NTO/Automation/entities/KnowledgeItem.ttl");
+
+fn obj(triples: &[ogar_emitter::Triple], subject: &str, predicate: &str) -> Option<String> {
+    triples
+        .iter()
+        .find(|t| t.subject == subject && t.predicate == predicate)
+        .map(|t| t.object.clone())
+}
+
+#[test]
+fn knowledge_item_lifts_and_emits_as_action_def_triples() {
+    // Lift.
+    let TtlDeclaration::Entity(ki) = parse_file(KNOWLEDGE_ITEM_TTL).expect("parses") else {
+        panic!("expected entity");
+    };
+    let def = into_action_def(&ki).expect("KnowledgeItem → ActionDef");
+    let id = def.identity.clone();
+    assert_eq!(id, "ogit-automation/knowledge_item::action_def::execute");
+
+    // Emit.
+    let triples = TripleEmitter::emit_action_def(&def);
+
+    // Type triple — the def IS an ogar:ActionDef on the SPO surface.
+    assert_eq!(obj(&triples, &id, "rdf:type").as_deref(), Some("ogar:ActionDef"));
+
+    // The §4 field mapping survives the lift→emit path verbatim.
+    assert_eq!(
+        obj(&triples, &id, "ogar:actionPredicate").as_deref(),
+        Some("execute")
+    );
+    assert_eq!(
+        obj(&triples, &id, "ogar:actionObjectClass").as_deref(),
+        Some("ogit-automation/mars_node_template")
+    );
+
+    // The `contains Trigger` → LifecycleTrigger kausal emits its triple(s).
+    assert!(
+        triples
+            .iter()
+            .any(|t| t.subject == id && t.predicate.starts_with("ogar:") && t.object == "Trigger"),
+        "LifecycleTrigger event `Trigger` missing from emitted triples: {triples:?}"
+    );
+
+    // The §4 actuator verbs ride as ogar:actionDecorator provenance.
+    for verb in ["relates", "contains", "uses"] {
+        assert!(
+            triples
+                .iter()
+                .any(|t| t.subject == id
+                    && t.predicate == "ogar:actionDecorator"
+                    && t.object == verb),
+            "decorator `{verb}` missing from emitted triples"
+        );
+    }
+}
+
+#[test]
+fn lossless_do_survives_the_emit_path() {
+    // The lossless-DO invariant must hold END-TO-END, not just at the lift:
+    // since `body_source` is None (the body is pointed-to, never inlined),
+    // the emitter must NOT produce an `ogar:actionBody` triple. A body triple
+    // here would mean some bytes leaked into the IR.
+    let TtlDeclaration::Entity(ki) = parse_file(KNOWLEDGE_ITEM_TTL).expect("parses") else {
+        panic!("expected entity");
+    };
+    let def = into_action_def(&ki).expect("ActionDef");
+    let triples = TripleEmitter::emit_action_def(&def);
+
+    assert!(
+        !triples.iter().any(|t| t.predicate == "ogar:actionBody"),
+        "lossless-DO violated across emit: a body triple was produced ({triples:?})"
+    );
+}

docs/DISCOVERY-MAP.md

@@ -208,7 +208,7 @@ two halves of a cell. ADR‑026 names the cascade that ties them.
 | D‑KNOWABLE | `KnowableFromStore` + `register_class_knowable_from`; `surrealql-hint`; **`vart-backend`** | G | CODED | `ogar-knowable-from/` (#25,#33,#43) | D‑IDENT |
 | D‑HINT | `schema_ddl_hint` loop closed — self‑describing registry via emit | G | CODED | (#33) | D‑SURREALQL, D‑KNOWABLE |
 | D‑ELIXIR | Elixir/HIRO SchemaSource scaffold (`gen_statem`→Rubicon) | G | CODED (scaffold) | `ogar-from-elixir/` | D‑VOCAB |
-| D‑HIRO‑DO | OGIT Automation → DO arm: `into_action_def` lifts `KnowledgeItem`→`ActionDef` (object_class←`relates`, kausal←`contains Trigger`, body **pointed‑to** not inlined — lossless‑DO §1); schema half of `PROBE‑OGAR‑DO‑ARM‑LIFT` green | G | CODED (schema half) | `ogar-from-schema/src/do_arm.rs` | D‑VOCAB, D‑TTL, D‑ELIXIR |
+| D‑HIRO‑DO | OGIT Automation → DO arm: `into_action_def` lifts `KnowledgeItem`→`ActionDef` (object_class←`relates`, kausal←`contains Trigger`, body **pointed‑to** not inlined — lossless‑DO §1); schema half of `PROBE‑OGAR‑DO‑ARM‑LIFT` green; lift→`emit_action_def`→SPO triples proven end‑to‑end (`tests/do_arm_emit.rs`, lossless‑DO holds across emit) | G | CODED (schema half) | `ogar-from-schema/src/do_arm.rs` | D‑VOCAB, D‑TTL, D‑ELIXIR, D‑EMIT |
 | D‑OSM | `ogar-from-osm-pbf` — Node/Way/Relation; quadkey NiblePath from resolved geometry | H | IDEA | (queued) | D‑VOCAB, `[per rt]` D‑OSM‑3 |
 | D‑PATTERN | `ogar-pattern` — recognition library + confidence (FMA‑D/FIBO/SKR/PROV‑O) | H | IDEA | (queued) | D‑TTL |
 | D‑ACTION | `ogar-actionable` — lifecycle → `ActionDef`/`KausalSpec` | H | IDEA | (queued) | D‑PATTERN |