Ship bundle-native Open Structure runtime in public release

README.md

@@ -208,7 +208,7 @@ Aethon generalizes by reusing learned structure across:
 The intended public experience is model-like:
 
 - load the bundle
-- create a runtime object
+- create a runtime object from the shipped release
 - call `ask(...)`
 - get natural text back
 
@@ -229,10 +229,12 @@ finally:
 Portable runtime included in the release:
 
 - `examples/aethon_open_structure_python.py`
+- `run_aethon.py`
+- `runtime/aethon/...`
 
-That runtime is intentionally portable and model-facing.
+This release now ships a portable bundle-native runtime pack.
 
-It should be treated as a real runnable Open Structure entry point, not as a storage demo.
+It should be treated as a real runnable Open Structure entry point, not as a storage demo or thin adapter.
 
 ## Prompt Examples
 
@@ -393,6 +395,8 @@ Additional docs in this release:
 - `docs/aethon_n1_bundle_schema.json`
 - `docs/AETHON_OPEN_STRUCTURE_RUNTIME.md`
 
-Starter runtime example:
+Portable runtime entry points:
 
 - `examples/aethon_open_structure_python.py`
+- `run_aethon.py`
+- `runtime/aethon/...`

docs/AETHON_OPEN_STRUCTURE_HF_MODEL_CARD.md

@@ -208,7 +208,7 @@ Aethon generalizes by reusing learned structure across:
 The intended public experience is model-like:
 
 - load the bundle
-- create a runtime object
+- create a runtime object from the shipped release
 - call `ask(...)`
 - get natural text back
 
@@ -229,10 +229,12 @@ finally:
 Portable runtime included in the release:
 
 - `examples/aethon_open_structure_python.py`
+- `run_aethon.py`
+- `runtime/aethon/...`
 
-That runtime is intentionally portable and model-facing.
+This release now ships a portable bundle-native runtime pack.
 
-It should be treated as a real runnable Open Structure entry point, not as a storage demo.
+It should be treated as a real runnable Open Structure entry point, not as a storage demo or thin adapter.
 
 ## Prompt Examples
 

docs/AETHON_OPEN_STRUCTURE_RUNTIME.md

@@ -51,15 +51,19 @@ Then load the persistent bundle memory from `graph.sqlite3`.
 The recommended public shape is:
 
 1. pull the bundle
-2. construct a runtime object
+2. construct a runtime object from the shipped release
 3. call `ask(...)`
 4. receive natural text back
 
 Starter example in this repo:
 
 - `examples/aethon_open_structure_python.py`
+- `run_aethon.py`
+- `runtime/aethon/...`
 
-That runtime hides storage details behind a model-facing class so developers interact with Aethon as a model rather than as a data store.
+The release now ships a portable bundle-native runtime pack.
+
+That runtime hides storage details behind a model-facing interface so developers interact with Aethon as a model rather than as a data store.
 
 ## Minimum Read Path
 

examples/aethon_open_structure_python.py

@@ -1,532 +1,92 @@
 from __future__ import annotations
 
-import json
-import re
-import sqlite3
-from collections import deque
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 
-from huggingface_hub import hf_hub_download
+from huggingface_hub import snapshot_download
 
 
 @dataclass(frozen=True)
 class AethonOpenStructureResponse:
     answer: str
     text: str
+    explanation: str
+    proof: tuple[str, ...]
+    reasoning: tuple[str, ...]
     mode: str
 
 
 class AethonOpenStructureModel:
-    """Portable model-facing Open Structure runner."""
+    """Portable bundle-native Aethon runtime wrapper.
 
-    _RELATION_WORDS = {
-        "live": "lives_in",
-        "lives": "lives_in",
-        "stay": "lives_in",
-        "sleep": "lives_in",
-        "located": "located_in",
-        "depend": "depend_on",
-        "depends": "depend_on",
-        "return": "return",
-        "returns": "return",
-        "watch": "watch",
-        "watches": "watch",
-        "buy": "bought",
-        "bought": "bought",
-        "prefer": "prefer",
-        "prefers": "prefer",
-        "like": "like",
-        "likes": "like",
-        "chase": "chase",
-        "chases": "chase",
-        "keep": "keeps",
-        "keeps": "keeps",
-        "carry": "carrying",
-        "carries": "carrying",
-        "carrying": "carrying",
-        "study": "study",
-        "studies": "study",
-        "use": "use",
-        "uses": "use",
-        "call": "call",
-        "calls": "call",
-        "import": "import",
-        "imports": "import",
-    }
+    This wrapper downloads the public Open Structure release, loads the bundled
+    native runtime, and exposes a simple model-facing API:
 
-    def __init__(self, bundle_dir: str | Path) -> None:
-        root = Path(bundle_dir)
-        self.bundle_dir = root
-        self.metadata = json.loads((root / "metadata.json").read_text(encoding="utf-8"))
-        self.conn = sqlite3.connect(root / self.metadata["graph_file"])
-        self.conn.row_factory = sqlite3.Row
-        self.semantic_lexicon = self.metadata.get("semantic_lexicon", [])
-        self.surface_lexicon = self.metadata.get("surface_lexicon", {})
-        self.query_forms = list(self.metadata.get("query_forms", []))
-        self.reasoning_rules = self.metadata.get("reasoning_rules", {})
+    - `from_hub(...)`
+    - `ask(...)`
+    - `learn(...)`
+    """
+
+    def __init__(self, release_dir: str | Path) -> None:
+        self.release_dir = Path(release_dir)
+        runtime_root = self.release_dir / "runtime"
+        if str(runtime_root) not in sys.path:
+            sys.path.insert(0, str(runtime_root))
+
+        from aethon.rfi_bundle import NativeBundleManager  # type: ignore
+
+        self._runtime = NativeBundleManager.load(self.release_dir / "bundle")
+        self.metadata = getattr(self._runtime, "metadata", None)
 
     @classmethod
     def from_hub(
         cls,
         repo_id: str,
         *,
-        local_dir: str | Path = "aethon_open_structure_bundle",
+        local_dir: str | Path = "aethon_open_structure_release",
     ) -> "AethonOpenStructureModel":
-        local_root = Path(local_dir)
-        local_root.mkdir(parents=True, exist_ok=True)
-        metadata_path = hf_hub_download(
-            repo_id=repo_id,
-            filename="bundle/metadata.json",
-            local_dir=local_root,
-            local_dir_use_symlinks=False,
-        )
-        hf_hub_download(
+        release_dir = snapshot_download(
             repo_id=repo_id,
-            filename="bundle/graph.sqlite3",
-            local_dir=local_root,
+            local_dir=str(local_dir),
             local_dir_use_symlinks=False,
         )
-        return cls(Path(metadata_path).parent)
+        return cls(release_dir)
 
     def ask(self, question: str) -> AethonOpenStructureResponse:
-        parts = self._split_prompt(question)
-        if len(parts) > 1:
-            replies = [self._ask_one(part) for part in parts]
-            text = " ".join(reply.text for reply in replies if reply.text)
-            answer = " | ".join(reply.answer for reply in replies)
-            return AethonOpenStructureResponse(answer=answer, text=text, mode="multi")
-        return self._ask_one(question)
-
-    def close(self) -> None:
-        self.conn.close()
-
-    def _ask_one(self, question: str) -> AethonOpenStructureResponse:
-        normalized = self._normalize(question)
-        tokens = normalized.split()
-        match = self._match_query_form(tokens)
-        if match is not None:
-            response = self._answer_query_form(question, normalized, tokens, match)
-            if response is not None:
-                return response
-        return self._unknown(question, normalized)
-
-    def _split_prompt(self, question: str) -> list[str]:
-        chunks = re.split(r"\?\s+|\?\s*$|\.\s+(?=[A-Z])|\bthen\b|;", question)
-        return [chunk.strip(" ?.") for chunk in chunks if chunk.strip(" ?.")]
-
-    def _match_query_form(self, tokens: list[str]) -> dict | None:
-        best: dict | None = None
-        best_score = -1
-        for form in self.query_forms:
-            prefix = [str(token).lower() for token in form.get("prefix", [])]
-            requires = [str(token).lower() for token in form.get("requires", [])]
-            if len(tokens) < len(prefix):
-                continue
-            if tokens[: len(prefix)] != prefix:
-                continue
-            if any(req not in tokens for req in requires):
-                continue
-            score = len(prefix) * 10 + len(requires)
-            if score > best_score:
-                best = form
-                best_score = score
-        return best
-
-    def _answer_query_form(
-        self,
-        question: str,
-        normalized: str,
-        tokens: list[str],
-        form: dict,
-    ) -> AethonOpenStructureResponse | None:
-        intent = str(form.get("intent", ""))
-        if intent == "where_entity":
-            subject = self._extract_subject(tokens, form)
-            if subject:
-                answer = self._latest_object(subject, ("located_in", "lives_in"))
-                if answer:
-                    return AethonOpenStructureResponse(
-                        answer=self._display(answer),
-                        text=f"{self._display(subject)} is currently in {self._display(answer)}.",
-                        mode="direct",
-                    )
-            return self._unknown(question, normalized)
-
-        if intent == "what_changed":
-            subject = self._extract_subject(tokens, form)
-            if subject:
-                row = self.conn.execute(
-                    """
-                    SELECT relation, previous_object, new_object
-                    FROM contradictions
-                    WHERE subject = ?
-                    ORDER BY contradiction_id DESC
-                    LIMIT 1
-                    """,
-                    (subject,),
-                ).fetchone()
-                if row is not None:
-                    relation = self._display_relation(str(row["relation"]))
-                    previous_value = self._display(str(row["previous_object"]))
-                    new_value = self._display(str(row["new_object"]))
-                    text = f"{self._display(subject)} changed in {relation} from {previous_value} to {new_value}."
-                    return AethonOpenStructureResponse(
-                        answer=f"{previous_value} -> {new_value}",
-                        text=text,
-                        mode="revision",
-                    )
-            return self._unknown(question, normalized)
-
-        if intent == "has_contradiction":
-            subject = self._extract_subject(tokens, form)
-            if subject:
-                row = self.conn.execute(
-                    """
-                    SELECT 1
-                    FROM contradictions
-                    WHERE subject = ?
-                    LIMIT 1
-                    """,
-                    (subject,),
-                ).fetchone()
-                if row is not None:
-                    return AethonOpenStructureResponse(
-                        answer="yes",
-                        text=f"Yes, I know conflicting or revised information about {self._display(subject)}.",
-                        mode="contradiction",
-                    )
-                return AethonOpenStructureResponse(
-                    answer="no",
-                    text=f"I do not currently see a contradiction about {self._display(subject)}.",
-                    mode="contradiction",
-                )
-
-        if intent == "relation_path":
-            subject = self._extract_subject(tokens, form)
-            object_value = self._extract_object(tokens, form)
-            if subject and object_value:
-                path = self._find_relation_path(subject, object_value)
-                if path:
-                    path_text = " -> ".join(self._display_relation(step) for step in path)
-                    text = f"{self._display(subject)} connects to {self._display(object_value)} through {path_text}."
-                    return AethonOpenStructureResponse(answer=path_text, text=text, mode="path")
-            return self._unknown(question, normalized)
-
-        if intent in {"relation_object", "keep_location_lookup"}:
-            subject = self._extract_subject(tokens, form)
-            relation = self._relation_from_form(tokens, form)
-            if subject and relation:
-                if relation == "keeps":
-                    kept = self._latest_object(subject, ("keeps",))
-                    if kept:
-                        answer = self._latest_object(kept, ("located_in", "lives_in"))
-                        if answer:
-                            text = f"{self._display(subject)} keeps it in {self._display(answer)}."
-                            return AethonOpenStructureResponse(answer=self._display(answer), text=text, mode="derived")
-                else:
-                    answer = self._latest_object(subject, (relation,))
-                    if answer:
-                        text = self._compose_relation_answer(subject, relation, answer)
-                        return AethonOpenStructureResponse(answer=self._display(answer), text=text, mode="direct")
-            return self._unknown(question, normalized)
-
-        if intent == "relation_subject":
-            relation = self._relation_from_form(tokens, form)
-            object_value = self._extract_object(tokens, form)
-            if relation and object_value:
-                answer = self._latest_subject(object_value, relation)
-                if answer:
-                    text = self._compose_reverse_relation_answer(answer, relation, object_value)
-                    return AethonOpenStructureResponse(answer=self._display(answer), text=text, mode="direct")
-            return self._unknown(question, normalized)
-
-        if intent == "classify":
-            subject = self._extract_subject(tokens, form)
-            if subject:
-                answer = self._classify(subject)
-                if answer:
-                    text = f"{self._display(subject)} is {self._article_for(self._display(answer))} {self._display(answer)}."
-                    return AethonOpenStructureResponse(answer=self._display(answer), text=text, mode="classification")
-            return self._unknown(question, normalized)
-
-        if intent in {"plan_first", "plan_next", "plan_previous"}:
-            target = self._extract_subject(tokens, form)
-            if target:
-                relation = {
-                    "plan_first": "plan_first",
-                    "plan_next": "plan_next",
-                    "plan_previous": "plan_previous",
-                }[intent]
-                answer = self._latest_object(target, (relation,))
-                if answer:
-                    text = self._plan_text(intent, target, answer)
-                    return AethonOpenStructureResponse(answer=self._display(answer), text=text, mode="plan")
-            return self._unknown(question, normalized)
-
-        if intent == "story_query":
-            subject = self._extract_subject(tokens, form)
-            anchor = self._extract_object(tokens, form)
-            story = self._story_for(subject, anchor)
-            if story:
-                return AethonOpenStructureResponse(answer=story, text=story, mode="story")
-            return self._unknown(question, normalized)
-
-        return None
-
-    def _normalize(self, text: str) -> str:
-        lowered = text.lower()
-        lowered = re.sub(r"[^\w\s]", " ", lowered)
-        lowered = re.sub(r"\s+", " ", lowered).strip()
-        for entry in self.semantic_lexicon:
-            symbol = str(entry.get("symbol", "")).strip().lower()
-            meaning = str(entry.get("meaning", "")).strip().lower()
-            if symbol and meaning:
-                lowered = re.sub(rf"\b{re.escape(symbol)}\b", meaning, lowered)
-        return lowered
-
-    def _extract_subject(self, tokens: list[str], form: dict) -> str | None:
-        mode = str(form.get("subject_mode", ""))
-        prefix_len = len(form.get("prefix", []))
-        end_anchor = str(form.get("subject_end_anchor", "")).lower()
-        if mode == "tail":
-            return self._join_tokens(tokens[prefix_len:])
-        if mode == "tail_without_last":
-            return self._join_tokens(tokens[prefix_len:-1])
-        if mode == "single_after_prefix":
-            return tokens[prefix_len] if len(tokens) > prefix_len else None
-        if mode == "between_indexes":
-            subject_start = int(form.get("subject_start", prefix_len))
-            if subject_start < prefix_len:
-                subject_start = prefix_len
-            end_index = len(tokens)
-            if end_anchor and end_anchor in tokens[subject_start:]:
-                end_index = tokens.index(end_anchor, subject_start)
-            return self._join_tokens(tokens[subject_start:end_index])
-        if mode == "between_anchors":
-            subject_start = int(form.get("subject_start", prefix_len))
-            end_index = len(tokens)
-            if end_anchor and end_anchor in tokens[subject_start:]:
-                end_index = tokens.index(end_anchor, subject_start)
-            return self._join_tokens(tokens[subject_start:end_index])
-        return self._join_tokens(tokens[prefix_len:])
-
-    def _extract_object(self, tokens: list[str], form: dict) -> str | None:
-        object_mode = str(form.get("object_mode", ""))
-        prefix_len = len(form.get("prefix", []))
-        anchor = str(form.get("object_start_anchor", "")).lower()
-        if object_mode == "after_anchor" and anchor:
-            if anchor in tokens:
-                start = tokens.index(anchor) + 1
-                return self._join_tokens(tokens[start:])
-        if object_mode == "tail_after_prefix":
-            return self._join_tokens(tokens[prefix_len:])
-        if object_mode == "from_relation_words":
-            relation = self._relation_from_form(tokens, form)
-            if relation is None:
-                return None
-            for index, token in enumerate(tokens):
-                if self._RELATION_WORDS.get(token) == relation:
-                    return self._join_tokens(tokens[index + 1 :])
-        return None
-
-    def _relation_from_form(self, tokens: list[str], form: dict) -> str | None:
-        relation_mode = str(form.get("relation_mode", "fixed"))
-        if relation_mode == "fixed":
-            relation = str(form.get("relation", "")).strip()
-            return relation or None
-        if relation_mode == "from_words":
-            for token in tokens:
-                relation = self._RELATION_WORDS.get(token)
-                if relation is not None:
-                    return relation
-        return None
-
-    def _latest_object(self, subject: str, relations: tuple[str, ...]) -> str | None:
-        if not relations:
-            return None
-        placeholders = ", ".join("?" for _ in relations)
-        row = self.conn.execute(
-            f"""
-            SELECT object
-            FROM edges
-            WHERE subject = ?
-              AND relation IN ({placeholders})
-              AND is_active = 1
-            ORDER BY edge_id DESC
-            LIMIT 1
-            """,
-            (subject, *relations),
-        ).fetchone()
-        return None if row is None else str(row["object"])
-
-    def _latest_subject(self, object_value: str, relation: str) -> str | None:
-        row = self.conn.execute(
-            """
-            SELECT subject
-            FROM edges
-            WHERE object = ?
-              AND relation = ?
-              AND is_active = 1
-            ORDER BY edge_id DESC
-            LIMIT 1
-            """,
-            (object_value, relation),
-        ).fetchone()
-        return None if row is None else str(row["subject"])
-
-    def _classify(self, subject: str) -> str | None:
-        direct = self._latest_object(subject, ("is_a", "equals"))
-        if direct is None:
-            return None
-        promoted = self._latest_object(direct, ("is_a",))
-        return promoted or direct
-
-    def _find_relation_path(self, start: str, goal: str, max_depth: int = 4) -> list[str] | None:
-        queue: deque[tuple[str, list[str], int]] = deque([(start, [], 0)])
-        seen = {start}
-        while queue:
-            node, path, depth = queue.popleft()
-            if depth >= max_depth:
-                continue
-            rows = self.conn.execute(
-                """
-                SELECT relation, object
-                FROM edges
-                WHERE subject = ?
-                  AND is_active = 1
-                ORDER BY edge_id DESC
-                """,
-                (node,),
-            ).fetchall()
-            for row in rows:
-                relation = str(row["relation"])
-                nxt = str(row["object"])
-                new_path = path + [relation]
-                if nxt == goal:
-                    return new_path
-                if nxt not in seen:
-                    seen.add(nxt)
-                    queue.append((nxt, new_path, depth + 1))
-        return None
-
-    def _story_for(self, subject: str | None, anchor: str | None) -> str | None:
-        if not subject:
-            return None
-        rows = self.conn.execute(
-            """
-            SELECT relation, object
-            FROM edges
-            WHERE subject = ?
-              AND is_active = 1
-            ORDER BY edge_id ASC
-            LIMIT 6
-            """,
-            (subject,),
-        ).fetchall()
-        if not rows:
-            return None
-        sentences = [self._compose_relation_answer(subject, str(row["relation"]), str(row["object"])) for row in rows]
-        if anchor:
-            return " ".join(sentences) + f" After {self._display(anchor)}, the story keeps moving through what Aethon already knows."
-        return " ".join(sentences)
-
-    def _compose_relation_answer(self, subject: str, relation: str, answer: str) -> str:
-        relation_text = self._display_relation(relation)
-        templates = self.surface_lexicon.get("relation_templates", {})
-        if relation in templates:
-            template = str(templates[relation])
-            return template.format(subject=self._display(subject), object=self._display(answer))
-        return f"{self._display(subject)} {relation_text} {self._display(answer)}."
-
-    def _compose_reverse_relation_answer(self, subject: str, relation: str, object_value: str) -> str:
-        if relation == "chase":
-            return f"{self._display(subject)} chases {self._display(object_value)}."
-        relation_text = self._display_relation(relation)
-        return f"{self._display(subject)} {relation_text} {self._display(object_value)}."
-
-    def _plan_text(self, intent: str, target: str, answer: str) -> str:
-        target_display = self._display(target)
-        answer_display = self._display(answer)
-        if intent == "plan_first":
-            return f"For {target_display}, the grounded first step is {answer_display}."
-        if intent == "plan_next":
-            return f"After that point, the next grounded step is {answer_display}."
-        return f"Before that point, the grounded earlier step is {answer_display}."
-
-    def _unknown(self, question: str, normalized: str) -> AethonOpenStructureResponse:
-        subject = self._salient_subject(normalized)
-        subject_text = self._display(subject) if subject else "that"
-        if normalized.startswith("where "):
-            variants = [
-                f"I cannot ground a reliable location for {subject_text}, and I would rather not invent one.",
-                f"{subject_text.capitalize()} is not something I can place confidently from what this bundle can currently support.",
-                f"I do not have enough grounded structure to place {subject_text} anywhere without guessing.",
-            ]
-        elif normalized.startswith(("who ", "what ")):
-            variants = [
-                f"I cannot ground a reliable answer about {subject_text} strongly enough yet.",
-                f"I would rather stay careful than pretend I know more about {subject_text} than I can support.",
-                f"{subject_text.capitalize()} goes beyond what I can answer faithfully from the current structure.",
-            ]
-        else:
-            variants = [
-                f"I cannot support a reliable answer for {subject_text} right now.",
-                f"I would rather stay careful than guess about {subject_text}.",
-                f"I do not have enough grounded structure to answer that faithfully about {subject_text}.",
-            ]
-        index = len(normalized) % len(variants) if normalized else 0
-        return AethonOpenStructureResponse(answer="<unknown>", text=variants[index], mode="unknown")
-
-    def _display(self, concept: str) -> str:
-        row = self.conn.execute(
-            """
-            SELECT display_name
-            FROM concepts
-            WHERE concept_id = ?
-            """,
-            (concept,),
-        ).fetchone()
-        if row is None:
-            return concept.replace("_", " ")
-        display = str(row["display_name"]).strip()
-        return display or concept.replace("_", " ")
-
-    @staticmethod
-    def _display_relation(relation: str) -> str:
-        return relation.replace("_", " ")
-
-    @staticmethod
-    def _join_tokens(tokens: list[str]) -> str | None:
-        cleaned = " ".join(token for token in tokens if token).strip()
-        return cleaned or None
+        response = self._runtime.ask(question)
+        return AethonOpenStructureResponse(
+            answer=response.answer,
+            text=response.text,
+            explanation=response.explanation,
+            proof=tuple(response.proof),
+            reasoning=tuple(response.reasoning),
+            mode=response.mode,
+        )
 
-    @staticmethod
-    def _article_for(text: str) -> str:
-        return "an" if text[:1].lower() in {"a", "e", "i", "o", "u"} else "a"
+    def learn(self, text: str) -> dict[str, object]:
+        return self._runtime.learn(text)
 
-    @staticmethod
-    def _salient_subject(normalized: str) -> str | None:
-        tokens = normalized.split()
-        for stopword in ("what", "where", "who", "how", "is", "does", "did", "the", "a", "an", "about", "to", "after", "before"):
-            tokens = [token for token in tokens if token != stopword]
-        if not tokens:
-            return None
-        return " ".join(tokens[:3])
+    def close(self) -> None:
+        self._runtime.close()
 
 
 if __name__ == "__main__":
     model = AethonOpenStructureModel.from_hub("OkeyMetaLtd/Aethon-N1-Base-Open-Structure")
     try:
         prompts = [
-            "Where does Amina live now, and what changed from before?",
-            "How is Amina related to Nigeria?",
-            "Tunde has a client call at 2 PM and lunch at 2 PM. What should happen first, and what should be rescheduled?",
+            "Amina used to live in Lagos, but now she lives in Accra. What changed about her location?",
+            "Tell me the story of Zainab after she misses the last train and discovers the map was outdated.",
+            "If the meeting conflicts with lunch and the report must finish before the client call, what should happen first and what should be rescheduled?",
         ]
         for prompt in prompts:
             reply = model.ask(prompt)
             print(f"Q: {prompt}")
             print(f"A: {reply.text}")
+            if reply.reasoning:
+                print("reasoning:")
+                for step in reply.reasoning:
+                    print(f"  - {step}")
             print()
     finally:
         model.close()

run_aethon.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT / "runtime"))
+
+from aethon.rfi_bundle import NativeBundleManager
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run Aethon Open Structure bundle.")
+    parser.add_argument("--ask", action="append", default=[])
+    parser.add_argument("--learn", action="append", default=[])
+    args = parser.parse_args()
+
+    runtime = NativeBundleManager.load(ROOT / "bundle")
+    try:
+        for fact in args.learn:
+            runtime.learn(fact)
+        for query in args.ask:
+            response = runtime.ask(query)
+            print(f"Q: {query}")
+            print(f"A: {response.text}")
+            if response.reasoning:
+                print("reasoning:")
+                for step in response.reasoning:
+                    print(f"  - {step}")
+    finally:
+        runtime.close()
+
+
+if __name__ == "__main__":
+    main()

runtime/aethon/__init__.py

@@ -0,0 +1 @@
+"""Portable Aethon Open Structure runtime package."""

runtime/aethon/rfi_abstraction.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from collections import Counter
+
+from .rfi_graph import RelationalGraphStore
+from .rfi_ontology import ConceptOntology
+
+
+@dataclass(frozen=True)
+class AbstractionRule:
+    subject_class: str
+    relation: str
+    object_class: str
+    support: int
+
+
+class AbstractionEngine:
+    """Lifts repeated graph motifs into class-level rules."""
+
+    _IGNORED_RELATIONS = {
+        "is_a",
+        "has_instance",
+        "contains",
+        "home_of",
+        "liked_by",
+        "preferred_by",
+        "chased_by",
+        "attacked_by",
+        "watched_by",
+        "purchase_site_of",
+        "kept_by",
+        "carried_by",
+    }
+
+    def __init__(self, graph: RelationalGraphStore, ontology: ConceptOntology | None = None) -> None:
+        self.graph = graph
+        self.ontology = ontology or ConceptOntology()
+
+    def derive_rules(self, min_support: int = 2) -> list[AbstractionRule]:
+        counts: Counter[tuple[str, str, str]] = Counter()
+        for edge in self.graph.iter_active_edges():
+            if edge.source_kind == "derived":
+                continue
+            if edge.relation in self._IGNORED_RELATIONS:
+                continue
+            subject_parents = self.ontology.lift(edge.subject)
+            object_parents = self.ontology.lift(edge.object)
+            for subject_parent in subject_parents:
+                for object_parent in object_parents:
+                    counts[(subject_parent, edge.relation, object_parent)] += 1
+
+        rules: list[AbstractionRule] = []
+        for (subject_class, relation, object_class), support in sorted(counts.items()):
+            if support >= min_support:
+                rules.append(
+                    AbstractionRule(
+                        subject_class=subject_class,
+                        relation=relation,
+                        object_class=object_class,
+                        support=support,
+                    )
+                )
+        return rules
+
+    def materialize_rules(self, min_support: int = 2) -> list[AbstractionRule]:
+        rules = self.derive_rules(min_support=min_support)
+        for rule in rules:
+            self.graph.add_derived_fact(
+                subject=rule.subject_class,
+                relation=rule.relation,
+                object=rule.object_class,
+                source_text=f"abstraction:{rule.subject_class}:{rule.relation}:{rule.object_class}:{rule.support}",
+                commit=False,
+            )
+        if rules:
+            self.graph.commit()
+        return rules

runtime/aethon/rfi_bundle.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import shutil
+import sqlite3
+from typing import TYPE_CHECKING
+
+from .rfi_metrics import StructuralCapacityMeter
+
+if TYPE_CHECKING:
+    from .rfi_runtime import AethonNativeBase
+
+
+class NativeBundleManager:
+    """Persists and reloads Aethon N1 as a portable native base bundle."""
+
+    METADATA_FILE = "metadata.json"
+    GRAPH_FILE = "graph.sqlite3"
+    BUNDLE_FORMAT = 2
+    PUBLIC_CONTRACT = "aethon.n1.bundle.v1"
+    ASSETS_DIR = "assets"
+    SEMANTIC_FILE = "semantic_lexicon.jsonl"
+    SURFACE_FILE = "surface_lexicon.json"
+    REASONING_RULES_FILE = "reasoning_rules.json"
+
+    @classmethod
+    def save(cls, runtime: "AethonNativeBase", bundle_dir: str | Path) -> Path:
+        target = Path(bundle_dir)
+        target.mkdir(parents=True, exist_ok=True)
+        graph_path = target / cls.GRAPH_FILE
+        metadata_path = target / cls.METADATA_FILE
+
+        cls._write_graph(runtime, graph_path)
+        capacity = StructuralCapacityMeter.from_sqlite(graph_path)
+        metadata = {
+            "bundle_format": cls.BUNDLE_FORMAT,
+            "public_contract": cls.PUBLIC_CONTRACT,
+            "release_class": "open-structure",
+            "name": runtime.NAME,
+            "family": runtime.FAMILY,
+            "tokenizer": runtime.TOKENIZER,
+            "size_unit": "Structural Capacity (SC)",
+            "capacity": capacity.to_metadata(),
+            "bundle_files": [cls.METADATA_FILE, cls.GRAPH_FILE],
+            "graph_file": cls.GRAPH_FILE,
+            "graph_dialect": "sqlite3",
+            "sqlite_schema": {
+                "required_tables": ["concepts", "edges", "contradictions"],
+                "optional_tables": ["raw_units"],
+                "edge_active_flag": "is_active",
+                "edge_support_pointer": "supports_edge_id",
+            },
+            "semantic_lexicon": runtime.ontology.semantic_lexicon.to_payload(),
+            "surface_lexicon": runtime.surface.lexicon.to_payload(),
+            "query_forms": runtime.query_forms.to_payload(),
+            "reasoning_rules": runtime.reasoner.rule_set.to_payload(),
+        }
+        metadata_path.write_text(json.dumps(metadata, indent=2), encoding="utf-8")
+        return target
+
+    @classmethod
+    def load(cls, bundle_dir: str | Path) -> "AethonNativeBase":
+        from .rfi_runtime import AethonNativeBase
+
+        source = Path(bundle_dir)
+        graph_path = source / cls.GRAPH_FILE
+        metadata_path = source / cls.METADATA_FILE
+        if not graph_path.exists():
+            raise FileNotFoundError(f"Missing bundle graph: {graph_path}")
+        metadata = json.loads(metadata_path.read_text(encoding="utf-8")) if metadata_path.exists() else {}
+        if metadata.get("bundle_format", 1) >= cls.BUNDLE_FORMAT:
+            return AethonNativeBase(
+                db_path=str(graph_path),
+                semantic_lexicon_payload=metadata.get("semantic_lexicon"),
+                surface_lexicon_payload=metadata.get("surface_lexicon"),
+                query_form_payload=metadata.get("query_forms"),
+                reasoning_rules_payload=metadata.get("reasoning_rules"),
+            )
+        assets_dir = source / cls.ASSETS_DIR
+        return AethonNativeBase(
+            db_path=str(graph_path),
+            semantic_lexicon_path=str(assets_dir / cls.SEMANTIC_FILE),
+            surface_lexicon_path=str(assets_dir / cls.SURFACE_FILE),
+            reasoning_rules_path=str(assets_dir / cls.REASONING_RULES_FILE),
+        )
+
+    @staticmethod
+    def _write_graph(runtime: "AethonNativeBase", graph_path: Path) -> None:
+        runtime.graph.conn.commit()
+        if runtime.graph.db_path != ":memory:":
+            source = Path(runtime.graph.db_path)
+            if source.resolve() != graph_path.resolve():
+                shutil.copy2(source, graph_path)
+            return
+
+        destination = sqlite3.connect(str(graph_path))
+        try:
+            runtime.graph.conn.backup(destination)
+        finally:
+            destination.close()

runtime/aethon/rfi_document_filter.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class DocumentSelection:
+    accepted: bool
+    reason: str
+    units: tuple[str, ...]
+
+
+class DocumentQualityGate:
+    """Filters low-value corpus documents and extracts higher-value learning units."""
+
+    _BLOCKLIST = (
+        "cookie policy",
+        "privacy policy",
+        "terms of service",
+        "all rights reserved",
+        "sign up",
+        "subscribe",
+        "javascript",
+        "enable cookies",
+    )
+
+    def select(self, title: str, text: str) -> DocumentSelection:
+        title = title.strip()
+        text = text.strip()
+        merged = "\n".join(part for part in (title, text) if part)
+        if not merged:
+            return DocumentSelection(False, "empty", ())
+        lowered = merged.lower()
+        if any(marker in lowered for marker in self._BLOCKLIST):
+            return DocumentSelection(False, "boilerplate", ())
+        if lowered.count("http") > 3:
+            return DocumentSelection(False, "too_many_urls", ())
+        alpha_chars = sum(1 for char in merged if char.isalpha())
+        if alpha_chars < 24:
+            return DocumentSelection(False, "too_little_language", ())
+        units = self._extract_units(title, text)
+        if not units:
+            return DocumentSelection(False, "no_viable_units", ())
+        return DocumentSelection(True, "accepted", tuple(units))
+
+    def _extract_units(self, title: str, text: str) -> list[str]:
+        units: list[str] = []
+        if title and self._is_viable_sentence(title):
+            units.append(title.strip())
+
+        for raw_line in text.splitlines():
+            line = raw_line.strip().strip("`")
+            if not line:
+                continue
+            if self._looks_like_assignment(line) or self._looks_like_return(line) or self._looks_like_equation(line):
+                units.append(line)
+
+        prose = text.replace("\r", "\n")
+        for sentence in self._split_prose_units(prose):
+            cleaned = sentence.strip(" -:;,\t")
+            if self._is_viable_sentence(cleaned):
+                units.append(cleaned)
+            if len(units) >= 64:
+                break
+        return list(dict.fromkeys(units))
+
+    def _is_viable_sentence(self, sentence: str) -> bool:
+        if not sentence:
+            return False
+        lowered = sentence.lower()
+        if any(marker in lowered for marker in self._BLOCKLIST):
+            return False
+        tokens = sentence.split()
+        if len(tokens) < 3 or len(tokens) > 24:
+            return False
+        if sentence.count("http") or sentence.count("@") > 1:
+            return False
+        if sum(1 for token in tokens if token.isupper() and len(token) > 3) > max(3, len(tokens) // 3):
+            return False
+        return True
+
+    def _looks_like_assignment(self, line: str) -> bool:
+        if sum(line.count(mark) for mark in ".!?") > 0:
+            return False
+        if "=" not in line or "==" in line:
+            return False
+        left, right = (part.strip() for part in line.split("=", 1))
+        return self._is_identifier(left) and bool(right) and not right.startswith("=")
+
+    def _looks_like_return(self, line: str) -> bool:
+        if sum(line.count(mark) for mark in ".!?") > 0:
+            return False
+        tokens = line.split()
+        if len(tokens) < 3:
+            return False
+        start = 0
+        if tokens[0] in {"def", "function"}:
+            if len(tokens) < 4:
+                return False
+            start = 1
+        name = tokens[start]
+        verb = tokens[start + 1]
+        value = " ".join(tokens[start + 2 :]).strip()
+        return self._is_identifier(name) and verb in {"return", "returns"} and bool(value)
+
+    def _looks_like_equation(self, line: str) -> bool:
+        if sum(line.count(mark) for mark in ".!?") > 0:
+            return False
+        if "=" not in line or "==" in line:
+            return False
+        left, right = (part.strip() for part in line.split("=", 1))
+        if not left or not right:
+            return False
+        allowed = set("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_+-*/() ")
+        if any(char not in allowed for char in left + right):
+            return False
+        return any(op in line for op in "+-*/")
+
+    @staticmethod
+    def _split_prose_units(prose: str) -> list[str]:
+        units: list[str] = []
+        current: list[str] = []
+        length = len(prose)
+        for index, char in enumerate(prose):
+            if char in "\n":
+                if current:
+                    units.append("".join(current).strip())
+                    current = []
+                continue
+            current.append(char)
+            if char not in ".!?":
+                continue
+            next_char = prose[index + 1] if index + 1 < length else ""
+            if not next_char or next_char.isspace():
+                units.append("".join(current).strip())
+                current = []
+        if current:
+            units.append("".join(current).strip())
+        return [unit for unit in units if unit]
+
+    @staticmethod
+    def _is_identifier(value: str) -> bool:
+        if not value:
+            return False
+        if value[0] != "_" and not value[0].isalpha():
+            return False
+        return all(char == "_" or char.isalnum() for char in value)

runtime/aethon/rfi_graph.py

@@ -0,0 +1,769 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from collections import deque
+import sqlite3
+from pathlib import Path
+import shutil
+
+from .rfi_ingest import Triple
+
+
+@dataclass(frozen=True)
+class EdgeRecord:
+    edge_id: int
+    subject: str
+    relation: str
+    object: str
+    source_kind: str
+    source_text: str
+    is_active: bool
+    supports_edge_id: int | None = None
+
+
+@dataclass(frozen=True)
+class ContradictionRecord:
+    contradiction_id: int
+    subject: str
+    relation: str
+    previous_object: str
+    new_object: str
+    previous_edge_id: int
+    new_edge_id: int
+    source_text: str
+
+
+class RelationalGraphStore:
+    """SQLite-backed sparse graph for one-shot structural learning."""
+
+    INVERSE_RELATIONS = {
+        "located_in": "contains",
+        "contains": "located_in",
+        "chase": "chased_by",
+        "chased_by": "chase",
+        "attack": "attacked_by",
+        "attacked_by": "attack",
+        "watch": "watched_by",
+        "watched_by": "watch",
+        "lives_in": "home_of",
+        "home_of": "lives_in",
+        "like": "liked_by",
+        "liked_by": "like",
+        "prefer": "preferred_by",
+        "preferred_by": "prefer",
+        "bought_in": "purchase_site_of",
+        "purchase_site_of": "bought_in",
+        "is_a": "has_instance",
+        "has_instance": "is_a",
+        "keeps": "kept_by",
+        "kept_by": "keeps",
+        "carrying": "carried_by",
+        "carried_by": "carrying",
+    }
+
+    def __init__(self, db_path: str | Path = ":memory:") -> None:
+        self.db_path = str(db_path)
+        self.conn = sqlite3.connect(self.db_path)
+        self.conn.row_factory = sqlite3.Row
+        self.mutation_version = 0
+        self._configure_connection()
+        self._init_schema()
+
+    def _configure_connection(self) -> None:
+        self.conn.execute("PRAGMA journal_mode=WAL")
+        self.conn.execute("PRAGMA synchronous=NORMAL")
+        self.conn.execute("PRAGMA temp_store=MEMORY")
+        self.conn.execute("PRAGMA foreign_keys=OFF")
+        self.conn.execute("PRAGMA cache_size=-200000")
+
+    def _init_schema(self) -> None:
+        self.conn.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS concepts (
+                concept_id TEXT PRIMARY KEY,
+                display_name TEXT NOT NULL DEFAULT ''
+            );
+
+            CREATE TABLE IF NOT EXISTS edges (
+                edge_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                subject TEXT NOT NULL,
+                relation TEXT NOT NULL,
+                object TEXT NOT NULL,
+                source_kind TEXT NOT NULL,
+                source_text TEXT NOT NULL,
+                is_active INTEGER NOT NULL DEFAULT 1,
+                supports_edge_id INTEGER,
+                created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_edges_subject_relation_active
+            ON edges(subject, relation, is_active);
+
+            CREATE INDEX IF NOT EXISTS idx_edges_object_relation_active
+            ON edges(object, relation, is_active);
+
+            CREATE TABLE IF NOT EXISTS contradictions (
+                contradiction_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                subject TEXT NOT NULL,
+                relation TEXT NOT NULL,
+                previous_object TEXT NOT NULL,
+                new_object TEXT NOT NULL,
+                previous_edge_id INTEGER NOT NULL,
+                new_edge_id INTEGER NOT NULL,
+                source_text TEXT NOT NULL,
+                created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+            );
+
+            CREATE TABLE IF NOT EXISTS raw_units (
+                unit_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                lane TEXT NOT NULL,
+                source TEXT NOT NULL,
+                text TEXT NOT NULL,
+                normalized_text TEXT NOT NULL,
+                is_digested INTEGER NOT NULL DEFAULT 0,
+                created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_raw_units_lane
+            ON raw_units(lane);
+            """
+        )
+        columns = {
+            str(row["name"])
+            for row in self.conn.execute("PRAGMA table_info(concepts)").fetchall()
+        }
+        if "display_name" not in columns:
+            self.conn.execute("ALTER TABLE concepts ADD COLUMN display_name TEXT NOT NULL DEFAULT ''")
+            self.conn.execute("UPDATE concepts SET display_name = concept_id WHERE display_name = ''")
+        raw_unit_columns = {
+            str(row["name"])
+            for row in self.conn.execute("PRAGMA table_info(raw_units)").fetchall()
+        }
+        if "is_digested" not in raw_unit_columns:
+            self.conn.execute("ALTER TABLE raw_units ADD COLUMN is_digested INTEGER NOT NULL DEFAULT 0")
+        self.conn.commit()
+
+    def ingest_triples(self, triples: list[Triple], *, commit: bool = True) -> list[int]:
+        edge_ids: list[int] = []
+        for triple in triples:
+            edge_ids.append(self.add_fact(triple, commit=False))
+        if commit and edge_ids:
+            self.conn.commit()
+        return edge_ids
+
+    def ingest_triples_fast(self, triples: list[Triple], *, commit: bool = True) -> int:
+        if not triples:
+            return 0
+
+        concepts: dict[str, str] = {}
+        edge_rows: list[tuple[str, str, str, str, str, int, int | None]] = []
+        for triple in triples:
+            if triple.subject not in concepts:
+                concepts[triple.subject] = triple.subject_surface.strip() or triple.subject
+            if triple.object not in concepts:
+                concepts[triple.object] = triple.object_surface.strip() or triple.object
+            edge_rows.append(
+                (
+                    triple.subject,
+                    triple.relation,
+                    triple.object,
+                    triple.source_kind,
+                    triple.source_text,
+                    1,
+                    None,
+                )
+            )
+            inverse_relation = self.INVERSE_RELATIONS.get(triple.relation)
+            if inverse_relation is not None:
+                edge_rows.append(
+                    (
+                        triple.object,
+                        inverse_relation,
+                        triple.subject,
+                        triple.source_kind,
+                        triple.source_text,
+                        1,
+                        None,
+                    )
+                )
+
+        self.conn.executemany(
+            """
+            INSERT OR IGNORE INTO concepts(concept_id, display_name)
+            VALUES (?, ?)
+            """,
+            tuple(concepts.items()),
+        )
+        self.conn.executemany(
+            """
+            INSERT INTO edges(subject, relation, object, source_kind, source_text, is_active, supports_edge_id)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            edge_rows,
+        )
+        self._touch()
+        if commit:
+            self.conn.commit()
+        return len(edge_rows)
+
+    def ingest_raw_units(
+        self,
+        units: list[tuple[str, str, str]],
+        *,
+        commit: bool = True,
+    ) -> int:
+        if not units:
+            return 0
+        rows = [
+            (
+                lane,
+                source,
+                text,
+                " ".join(text.lower().split()),
+            )
+            for lane, source, text in units
+            if text.strip()
+        ]
+        if not rows:
+            return 0
+        self.conn.executemany(
+            """
+            INSERT INTO raw_units(lane, source, text, normalized_text, is_digested)
+            VALUES (?, ?, ?, ?, 0)
+            """,
+            rows,
+        )
+        self._touch()
+        if commit:
+            self.conn.commit()
+        return len(rows)
+
+    def fetch_undigested_raw_units(
+        self,
+        *,
+        limit: int,
+    ) -> list[dict[str, object]]:
+        rows = self.conn.execute(
+            """
+            SELECT unit_id, lane, source, text
+            FROM raw_units
+            WHERE is_digested = 0
+            ORDER BY unit_id ASC
+            LIMIT ?
+            """,
+            (limit,),
+        ).fetchall()
+        return [
+            {
+                "unit_id": int(row["unit_id"]),
+                "lane": str(row["lane"]),
+                "source": str(row["source"]),
+                "text": str(row["text"]),
+            }
+            for row in rows
+        ]
+
+    def mark_raw_units_digested(self, unit_ids: list[int], *, commit: bool = True) -> int:
+        if not unit_ids:
+            return 0
+        placeholders = ",".join("?" for _ in unit_ids)
+        self.conn.execute(
+            f"UPDATE raw_units SET is_digested = 1 WHERE unit_id IN ({placeholders})",
+            tuple(unit_ids),
+        )
+        self._touch()
+        if commit:
+            self.conn.commit()
+        return len(unit_ids)
+
+    def count_undigested_raw_units(self) -> int:
+        row = self.conn.execute(
+            "SELECT COUNT(*) AS count FROM raw_units WHERE is_digested = 0"
+        ).fetchone()
+        return int(row["count"]) if row else 0
+
+    def purge_digested_raw_units(self, *, commit: bool = True) -> int:
+        before = self.conn.total_changes
+        self.conn.execute("DELETE FROM raw_units WHERE is_digested = 1")
+        removed = self.conn.total_changes - before
+        if removed:
+            self._touch()
+        if commit:
+            self.conn.commit()
+        return int(removed)
+
+    def restore_from_db(self, source_db_path: str | Path) -> None:
+        source_path = Path(source_db_path)
+        self.conn.close()
+        if self.db_path == ":memory:":
+            source = sqlite3.connect(str(source_path))
+            source.row_factory = sqlite3.Row
+            try:
+                self.conn = sqlite3.connect(":memory:")
+                self.conn.row_factory = sqlite3.Row
+                self._configure_connection()
+                source.backup(self.conn)
+            finally:
+                source.close()
+            return
+
+        target_path = Path(self.db_path)
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source_path, target_path)
+        self.conn = sqlite3.connect(self.db_path)
+        self.conn.row_factory = sqlite3.Row
+        self._configure_connection()
+        self._touch()
+
+    def add_fact(self, triple: Triple, *, commit: bool = True) -> int:
+        self._ensure_concept(triple.subject, triple.subject_surface)
+        self._ensure_concept(triple.object, triple.object_surface)
+        prior_edge = self.get_active_edge(triple.subject, triple.relation)
+        self._deactivate_conflicting_edges(triple.subject, triple.relation)
+        cursor = self.conn.execute(
+            """
+            INSERT INTO edges(subject, relation, object, source_kind, source_text, is_active)
+            VALUES (?, ?, ?, ?, ?, 1)
+            """,
+            (triple.subject, triple.relation, triple.object, triple.source_kind, triple.source_text),
+        )
+        edge_id = int(cursor.lastrowid)
+        if prior_edge is not None and prior_edge.object != triple.object:
+            self.conn.execute(
+                """
+                INSERT INTO contradictions(
+                    subject, relation, previous_object, new_object, previous_edge_id, new_edge_id, source_text
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    triple.subject,
+                    triple.relation,
+                    prior_edge.object,
+                    triple.object,
+                    prior_edge.edge_id,
+                    edge_id,
+                    triple.source_text,
+                ),
+            )
+        self._upsert_inverse_edge(
+            subject=triple.subject,
+            relation=triple.relation,
+            object_value=triple.object,
+            source_kind=triple.source_kind,
+            source_text=triple.source_text,
+            supports_edge_id=edge_id,
+        )
+        self._touch()
+        if commit:
+            self.conn.commit()
+        return edge_id
+
+    def add_derived_fact(
+        self,
+        *,
+        subject: str,
+        relation: str,
+        object: str,
+        source_text: str,
+        supports_edge_id: int | None = None,
+        commit: bool = True,
+    ) -> int:
+        self._ensure_concept(subject)
+        self._ensure_concept(object)
+        existing = self.get_active_edge(subject, relation)
+        if existing is not None and existing.object == object and existing.source_kind == "derived":
+            return existing.edge_id
+        cursor = self.conn.execute(
+            """
+            INSERT INTO edges(subject, relation, object, source_kind, source_text, is_active, supports_edge_id)
+            VALUES (?, ?, ?, 'derived', ?, 1, ?)
+            """,
+            (subject, relation, object, source_text, supports_edge_id),
+        )
+        edge_id = int(cursor.lastrowid)
+        self._upsert_inverse_edge(
+            subject=subject,
+            relation=relation,
+            object_value=object,
+            source_kind="derived",
+            source_text=source_text,
+            supports_edge_id=edge_id,
+        )
+        self._touch()
+        if commit:
+            self.conn.commit()
+        return edge_id
+
+    def get_active_edge(self, subject: str, relation: str) -> EdgeRecord | None:
+        row = self.conn.execute(
+            """
+            SELECT * FROM edges
+            WHERE subject = ? AND relation = ? AND is_active = 1
+            ORDER BY edge_id DESC
+            LIMIT 1
+            """,
+            (subject, relation),
+        ).fetchone()
+        return self._row_to_edge(row) if row else None
+
+    def get_objects(self, subject: str, relation: str) -> list[EdgeRecord]:
+        rows = self.conn.execute(
+            """
+            SELECT * FROM edges
+            WHERE subject = ? AND relation = ? AND is_active = 1
+            ORDER BY edge_id DESC
+            """,
+            (subject, relation),
+        ).fetchall()
+        return [self._row_to_edge(row) for row in rows]
+
+    def get_subjects(self, relation: str, object_value: str) -> list[EdgeRecord]:
+        rows = self.conn.execute(
+            """
+            SELECT * FROM edges
+            WHERE relation = ? AND object = ? AND is_active = 1
+            ORDER BY edge_id DESC
+            """,
+            (relation, object_value),
+        ).fetchall()
+        return [self._row_to_edge(row) for row in rows]
+
+    def iter_active_edges(self) -> list[EdgeRecord]:
+        rows = self.conn.execute(
+            """
+            SELECT * FROM edges
+            WHERE is_active = 1
+            ORDER BY edge_id ASC
+            """
+        ).fetchall()
+        return [self._row_to_edge(row) for row in rows]
+
+    def list_concepts(self) -> list[str]:
+        rows = self.conn.execute(
+            """
+            SELECT concept_id FROM concepts
+            ORDER BY concept_id ASC
+            """
+        ).fetchall()
+        return [str(row["concept_id"]) for row in rows]
+
+    def iter_outgoing_edges(self, subject: str) -> list[EdgeRecord]:
+        rows = self.conn.execute(
+            """
+            SELECT * FROM edges
+            WHERE subject = ? AND is_active = 1
+            ORDER BY edge_id ASC
+            """,
+            (subject,),
+        ).fetchall()
+        return [self._row_to_edge(row) for row in rows]
+
+    def find_path(
+        self,
+        start: str,
+        goal: str,
+        max_hops: int = 4,
+        *,
+        include_derived: bool = True,
+    ) -> list[EdgeRecord] | None:
+        if start == goal:
+            return []
+        queue: deque[tuple[str, list[EdgeRecord]]] = deque([(start, [])])
+        visited = {start}
+        while queue:
+            node, path = queue.popleft()
+            if len(path) >= max_hops:
+                continue
+            for edge in self.iter_outgoing_edges(node):
+                if not include_derived and edge.source_kind == "derived":
+                    continue
+                if edge.object == goal:
+                    return path + [edge]
+                if edge.object not in visited:
+                    visited.add(edge.object)
+                    queue.append((edge.object, path + [edge]))
+        return None
+
+    def get_contradictions(self, subject: str | None = None, relation: str | None = None) -> list[ContradictionRecord]:
+        where_parts: list[str] = []
+        params: list[str] = []
+        if subject is not None:
+            where_parts.append("subject = ?")
+            params.append(subject)
+        if relation is not None:
+            where_parts.append("relation = ?")
+            params.append(relation)
+        where_sql = f"WHERE {' AND '.join(where_parts)}" if where_parts else ""
+        rows = self.conn.execute(
+            f"""
+            SELECT * FROM contradictions
+            {where_sql}
+            ORDER BY contradiction_id DESC
+            """,
+            params,
+        ).fetchall()
+        return [self._row_to_contradiction(row) for row in rows]
+
+    def close(self) -> None:
+        self.conn.close()
+
+    def commit(self) -> None:
+        self.conn.commit()
+
+    def merge_from_db(self, source_db_path: str | Path, *, fast: bool = False) -> dict[str, int]:
+        source = sqlite3.connect(str(source_db_path))
+        source.row_factory = sqlite3.Row
+        edge_id_map: dict[int, int] = {}
+        merged_edges = 0
+        merged_concepts = 0
+        merged_contradictions = 0
+        merged_raw_units = 0
+        try:
+            for row in source.execute("SELECT concept_id FROM concepts ORDER BY concept_id ASC"):
+                before = self.conn.total_changes
+                display_name = str(row["display_name"]) if "display_name" in row.keys() else ""
+                self._ensure_concept(str(row["concept_id"]), display_name)
+                if self.conn.total_changes > before:
+                    merged_concepts += 1
+
+            for row in source.execute("SELECT * FROM edges ORDER BY edge_id ASC"):
+                original_edge_id = int(row["edge_id"])
+                if not fast:
+                    existing_edge_id = self._find_matching_edge(
+                        subject=str(row["subject"]),
+                        relation=str(row["relation"]),
+                        object_value=str(row["object"]),
+                        source_kind=str(row["source_kind"]),
+                        source_text=str(row["source_text"]),
+                        is_active=bool(row["is_active"]),
+                    )
+                    if existing_edge_id is not None:
+                        edge_id_map[original_edge_id] = existing_edge_id
+                        continue
+
+                self._ensure_concept(str(row["subject"]))
+                self._ensure_concept(str(row["object"]))
+                supports_edge_id = row["supports_edge_id"]
+                mapped_support = edge_id_map.get(int(supports_edge_id)) if supports_edge_id is not None else None
+                cursor = self.conn.execute(
+                    """
+                    INSERT INTO edges(subject, relation, object, source_kind, source_text, is_active, supports_edge_id)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        str(row["subject"]),
+                        str(row["relation"]),
+                        str(row["object"]),
+                        str(row["source_kind"]),
+                        str(row["source_text"]),
+                        int(row["is_active"]),
+                        mapped_support,
+                    ),
+                )
+                edge_id = int(cursor.lastrowid)
+                edge_id_map[original_edge_id] = edge_id
+                merged_edges += 1
+
+            for row in source.execute("SELECT * FROM contradictions ORDER BY contradiction_id ASC"):
+                previous_edge_id = edge_id_map.get(int(row["previous_edge_id"]))
+                new_edge_id = edge_id_map.get(int(row["new_edge_id"]))
+                if previous_edge_id is None or new_edge_id is None:
+                    continue
+                if not fast:
+                    if self._contradiction_exists(
+                        subject=str(row["subject"]),
+                        relation=str(row["relation"]),
+                        previous_object=str(row["previous_object"]),
+                        new_object=str(row["new_object"]),
+                        previous_edge_id=previous_edge_id,
+                        new_edge_id=new_edge_id,
+                    ):
+                        continue
+                self.conn.execute(
+                    """
+                    INSERT INTO contradictions(
+                        subject, relation, previous_object, new_object, previous_edge_id, new_edge_id, source_text
+                    )
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        str(row["subject"]),
+                        str(row["relation"]),
+                        str(row["previous_object"]),
+                        str(row["new_object"]),
+                        previous_edge_id,
+                        new_edge_id,
+                        str(row["source_text"]),
+                    ),
+                )
+                merged_contradictions += 1
+            for row in source.execute("SELECT * FROM raw_units ORDER BY unit_id ASC"):
+                self.conn.execute(
+                    """
+                    INSERT INTO raw_units(lane, source, text, normalized_text, is_digested)
+                    VALUES (?, ?, ?, ?, ?)
+                    """,
+                    (
+                        str(row["lane"]),
+                        str(row["source"]),
+                        str(row["text"]),
+                        str(row["normalized_text"]),
+                        int(row["is_digested"]) if "is_digested" in row.keys() else 0,
+                    ),
+                )
+                merged_raw_units += 1
+            self.conn.commit()
+            if merged_concepts or merged_edges or merged_contradictions or merged_raw_units:
+                self._touch()
+        finally:
+            source.close()
+        return {
+            "concepts": merged_concepts,
+            "edges": merged_edges,
+            "contradictions": merged_contradictions,
+            "raw_units": merged_raw_units,
+        }
+
+    def _ensure_concept(self, concept_id: str, display_name: str = "") -> None:
+        cleaned_display = display_name.strip()
+        self.conn.execute(
+            "INSERT OR IGNORE INTO concepts(concept_id, display_name) VALUES (?, ?)",
+            (concept_id, cleaned_display or concept_id),
+        )
+        if cleaned_display:
+            current = self.conn.execute(
+                "SELECT display_name FROM concepts WHERE concept_id = ? LIMIT 1",
+                (concept_id,),
+            ).fetchone()
+            current_name = str(current["display_name"]).strip() if current else ""
+            if self._prefer_display_name(cleaned_display, current_name):
+                self.conn.execute(
+                    "UPDATE concepts SET display_name = ? WHERE concept_id = ?",
+                    (cleaned_display, concept_id),
+                )
+
+    def _touch(self) -> None:
+        self.mutation_version += 1
+
+    def _deactivate_conflicting_edges(self, subject: str, relation: str) -> None:
+        if relation in {"is_a"}:
+            return
+        self.conn.execute(
+            """
+            UPDATE edges
+            SET is_active = 0
+            WHERE subject = ? AND relation = ? AND is_active = 1
+            """,
+            (subject, relation),
+        )
+
+    def _upsert_inverse_edge(
+        self,
+        *,
+        subject: str,
+        relation: str,
+        object_value: str,
+        source_kind: str,
+        source_text: str,
+        supports_edge_id: int | None,
+    ) -> None:
+        inverse_relation = self.INVERSE_RELATIONS.get(relation)
+        if inverse_relation is None:
+            return
+        self._ensure_concept(object_value)
+        self._ensure_concept(subject)
+        if inverse_relation not in {"has_instance", "is_a"}:
+            self._deactivate_conflicting_edges(object_value, inverse_relation)
+        self.conn.execute(
+            """
+            INSERT INTO edges(subject, relation, object, source_kind, source_text, is_active, supports_edge_id)
+            VALUES (?, ?, ?, ?, ?, 1, ?)
+            """,
+            (object_value, inverse_relation, subject, source_kind, source_text, supports_edge_id),
+        )
+
+    def _find_matching_edge(
+        self,
+        *,
+        subject: str,
+        relation: str,
+        object_value: str,
+        source_kind: str,
+        source_text: str,
+        is_active: bool,
+    ) -> int | None:
+        row = self.conn.execute(
+            """
+            SELECT edge_id FROM edges
+            WHERE subject = ? AND relation = ? AND object = ? AND source_kind = ? AND source_text = ? AND is_active = ?
+            ORDER BY edge_id DESC
+            LIMIT 1
+            """,
+            (subject, relation, object_value, source_kind, source_text, int(is_active)),
+        ).fetchone()
+        return int(row["edge_id"]) if row else None
+
+    def _contradiction_exists(
+        self,
+        *,
+        subject: str,
+        relation: str,
+        previous_object: str,
+        new_object: str,
+        previous_edge_id: int,
+        new_edge_id: int,
+    ) -> bool:
+        row = self.conn.execute(
+            """
+            SELECT contradiction_id FROM contradictions
+            WHERE subject = ? AND relation = ? AND previous_object = ? AND new_object = ?
+              AND previous_edge_id = ? AND new_edge_id = ?
+            LIMIT 1
+            """,
+            (subject, relation, previous_object, new_object, previous_edge_id, new_edge_id),
+        ).fetchone()
+        return row is not None
+
+    def get_display_name(self, concept_id: str) -> str:
+        row = self.conn.execute(
+            "SELECT display_name FROM concepts WHERE concept_id = ? LIMIT 1",
+            (concept_id,),
+        ).fetchone()
+        if row and str(row["display_name"]).strip():
+            return str(row["display_name"]).strip()
+        return concept_id.replace("_", " ")
+
+    @staticmethod
+    def _prefer_display_name(candidate: str, current: str) -> bool:
+        if not current:
+            return True
+        candidate_score = (sum(1 for char in candidate if char.isupper()), len(candidate))
+        current_score = (sum(1 for char in current if char.isupper()), len(current))
+        return candidate_score > current_score
+
+    @staticmethod
+    def _row_to_edge(row: sqlite3.Row) -> EdgeRecord:
+        return EdgeRecord(
+            edge_id=int(row["edge_id"]),
+            subject=str(row["subject"]),
+            relation=str(row["relation"]),
+            object=str(row["object"]),
+            source_kind=str(row["source_kind"]),
+            source_text=str(row["source_text"]),
+            is_active=bool(row["is_active"]),
+            supports_edge_id=int(row["supports_edge_id"]) if row["supports_edge_id"] is not None else None,
+        )
+
+    @staticmethod
+    def _row_to_contradiction(row: sqlite3.Row) -> ContradictionRecord:
+        return ContradictionRecord(
+            contradiction_id=int(row["contradiction_id"]),
+            subject=str(row["subject"]),
+            relation=str(row["relation"]),
+            previous_object=str(row["previous_object"]),
+            new_object=str(row["new_object"]),
+            previous_edge_id=int(row["previous_edge_id"]),
+            new_edge_id=int(row["new_edge_id"]),
+            source_text=str(row["source_text"]),
+        )

runtime/aethon/rfi_ingest.py

@@ -0,0 +1,445 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .rfi_ontology import ConceptOntology
+
+
+@dataclass(frozen=True)
+class Triple:
+    subject: str
+    relation: str
+    object: str
+    source_text: str
+    source_kind: str = "direct_assertion"
+    subject_surface: str = ""
+    object_surface: str = ""
+
+
+class DeterministicTripleExtractor:
+    """Controlled no-weight ingestion for declarative fact sentences."""
+
+    _GENERIC_BLOCKLIST = {
+        "is",
+        "are",
+        "was",
+        "were",
+        "be",
+        "been",
+        "being",
+        "do",
+        "does",
+        "did",
+        "have",
+        "has",
+        "had",
+        "say",
+        "says",
+        "said",
+    }
+
+    def __init__(self, ontology: ConceptOntology | None = None) -> None:
+        self.ontology = ontology or ConceptOntology()
+        self._patterns: tuple[tuple[str, str, bool], ...] = (
+            (" is located in ", "located_in", False),
+            (" is in ", "located_in", False),
+            (" lives in ", "lives_in", False),
+            (" stays in ", "lives_in", False),
+            (" resides in ", "lives_in", False),
+            (" works in ", "work_in", False),
+            (" studies ", "study", False),
+            (" now likes ", "like", False),
+            (" likes ", "like", False),
+            (" now prefers ", "prefer", False),
+            (" prefers ", "prefer", False),
+            (" chases ", "chase", False),
+            (" attacks ", "attack", False),
+            (" hunts ", "hunt", False),
+            (" uses ", "use", False),
+            (" calls ", "call", False),
+            (" imports ", "import", False),
+            (" depends on ", "depend_on", False),
+            (" is used by ", "use", True),
+            (" inherits from ", "is_a", False),
+            (" extends ", "is_a", False),
+            (" solves ", "solve", False),
+            (" bought ", "bought", False),
+            (" carries ", "carrying", False),
+            (" is carrying ", "carrying", False),
+            (" visited ", "visited", False),
+            (" reached ", "reached", False),
+            (" saw ", "saw", False),
+            (" returns ", "return", False),
+            (" equals ", "equals", False),
+            (" is a ", "is_a", False),
+            (" is an ", "is_a", False),
+        )
+
+    def extract(self, text: str) -> list[Triple]:
+        triples: list[Triple] = []
+        for sentence in self._split_sentences(text):
+            try:
+                triples.extend(self._extract_sentence(sentence))
+            except ValueError:
+                continue
+        return triples
+
+    def extract_ultra(self, text: str) -> list[Triple]:
+        triples: list[Triple] = []
+        for sentence in self._split_sentences(text):
+            normalized_sentence = self._cleanup(sentence)
+            if not normalized_sentence:
+                continue
+            try:
+                triples.extend(self._extract_sentence_ultra(sentence, normalized_sentence))
+            except ValueError:
+                continue
+        return triples
+
+    def _extract_sentence(self, sentence: str) -> list[Triple]:
+        normalized_sentence = self._cleanup(sentence)
+        if not normalized_sentence:
+            return []
+
+        triples: list[Triple] = []
+
+        keep_parts = self._split_multi(normalized_sentence, (" keeps ", " in "))
+        if keep_parts is not None:
+            subject, obj, loc = keep_parts
+            obj = self._strip_leading_articles(obj)
+            triples.append(self._make_triple(subject, "keeps", obj, sentence))
+            triples.append(self._make_triple(subject, "located_in", loc, sentence))
+            return triples
+
+        watch_parts = self._split_once(normalized_sentence, " was asked to watch ")
+        if watch_parts is not None:
+            subject, obj = watch_parts
+            triples.append(self._make_triple(subject, "watch", self._strip_leading_articles(obj), sentence))
+            return triples
+
+        negative_preference_parts = self._split_once(normalized_sentence, " does not like ")
+        if negative_preference_parts is not None and normalized_sentence.endswith(" anymore"):
+            subject, obj = negative_preference_parts
+            obj = obj[: -len(" anymore")].strip()
+            triples.append(
+                self._make_triple(
+                    subject,
+                    "not_like_anymore",
+                    obj,
+                    sentence,
+                )
+            )
+            return triples
+
+        carry_parts = self._split_multi(normalized_sentence, (" reached ", " carrying "))
+        if carry_parts is not None:
+            subject, loc, obj = carry_parts
+            triples.append(self._make_triple(subject, "reached", loc, sentence))
+            triples.append(self._make_triple(subject, "carrying", self._strip_leading_articles(obj), sentence))
+            return triples
+
+        buy_location_parts = self._split_multi(normalized_sentence, (" bought ", " in "))
+        if buy_location_parts is None:
+            buy_location_parts = self._split_multi(normalized_sentence, (" bought ", " at "))
+        if buy_location_parts is not None:
+            subject, obj, loc = buy_location_parts
+            triples.append(self._make_triple(subject, "bought", obj, sentence))
+            triples.append(self._make_triple(subject, "bought_in", loc, sentence))
+            return triples
+
+        later_buy_parts = self._split_multi(normalized_sentence, (" later bought ", " before leaving "))
+        if later_buy_parts is not None:
+            subject, obj, loc = later_buy_parts
+            triples.append(self._make_triple(subject, "bought", obj, sentence))
+            triples.append(self._make_triple(subject, "bought_in", loc, sentence))
+            return triples
+
+        for phrase, relation, reverse in self._iter_patterns():
+            parts = self._split_once(normalized_sentence, phrase)
+            if parts is None:
+                continue
+            left, right = parts
+            subject = right if reverse else left
+            obj = left if reverse else right
+            if subject and obj:
+                triples.append(self._make_triple(subject, relation, obj, sentence))
+                return triples
+
+        generic_locative = self._parse_generic_locative(normalized_sentence)
+        if generic_locative is not None and self._is_simple_clause(normalized_sentence):
+            subject, verb, obj = generic_locative
+            relation = self.ontology.normalize_relation(f"{verb}_in")
+            if relation not in self._GENERIC_BLOCKLIST:
+                triples.append(self._make_triple(subject, relation, obj, sentence))
+                return triples
+
+        generic_transitive = self._parse_generic_transitive(normalized_sentence)
+        if generic_transitive is not None and self._is_simple_clause(normalized_sentence):
+            subject, verb, object_value = generic_transitive
+            if verb not in self._GENERIC_BLOCKLIST and subject and object_value:
+                relation = self.ontology.normalize_relation(verb)
+                triples.append(self._make_triple(subject, relation, object_value, sentence))
+                return triples
+
+        assignment = self._parse_assignment(normalized_sentence)
+        if assignment is not None:
+            left, right = assignment
+            triples.append(self._make_triple(left, "equals", right, sentence))
+            return triples
+
+        return_match = self._parse_return_statement(normalized_sentence)
+        if return_match is not None:
+            name, value = return_match
+            triples.append(self._make_triple(name, "return", value, sentence))
+            return triples
+
+        passive_by_match = self._parse_passive_by(normalized_sentence)
+        if passive_by_match is not None and self._is_simple_clause(normalized_sentence):
+            obj, verb, subject = passive_by_match
+            relation = self.ontology.normalize_relation(verb)
+            if relation not in self._GENERIC_BLOCKLIST:
+                triples.append(self._make_triple(subject, relation, obj, sentence))
+                return triples
+
+        return triples
+
+    def _extract_sentence_ultra(self, sentence: str, normalized_sentence: str) -> list[Triple]:
+        triples: list[Triple] = []
+
+        for phrase, relation, reverse in self._iter_patterns():
+            parts = self._split_once(normalized_sentence, phrase)
+            if parts is None:
+                continue
+            left, right = parts
+            subject = right if reverse else left
+            obj = left if reverse else right
+            if subject and obj:
+                triples.append(self._make_triple(subject, relation, obj, sentence))
+                return triples
+
+        assignment = self._parse_assignment(normalized_sentence)
+        if assignment is not None:
+            left, right = assignment
+            triples.append(self._make_triple(left, "equals", right, sentence))
+            return triples
+
+        return_match = self._parse_return_statement(normalized_sentence)
+        if return_match is not None:
+            name, value = return_match
+            triples.append(self._make_triple(name, "return", value, sentence))
+            return triples
+
+        if self._is_simple_clause(normalized_sentence):
+            generic_locative = self._parse_generic_locative(normalized_sentence)
+            if generic_locative is not None:
+                subject, verb, obj = generic_locative
+                relation = self.ontology.normalize_relation(f"{verb}_in")
+                if relation not in self._GENERIC_BLOCKLIST:
+                    triples.append(self._make_triple(subject, relation, obj, sentence))
+                    return triples
+
+            generic_transitive = self._parse_generic_transitive(normalized_sentence)
+            if generic_transitive is not None:
+                subject, verb, object_value = generic_transitive
+                if verb not in self._GENERIC_BLOCKLIST and subject and object_value:
+                    relation = self.ontology.normalize_relation(verb)
+                    triples.append(self._make_triple(subject, relation, object_value, sentence))
+                    return triples
+
+        return triples
+
+    def _iter_patterns(self) -> tuple[tuple[str, str, bool], ...]:
+        learned: list[tuple[str, str, bool]] = []
+        for phrase, meaning in self.ontology.semantic_lexicon.phrase_alias_map.items():
+            if "_" not in meaning:
+                continue
+            learned.append((f" {phrase} ", self.ontology.normalize_relation(meaning), False))
+        return tuple(dict.fromkeys((*self._patterns, *learned)))
+
+    def _make_triple(self, subject: str, relation: str, obj: str, source_text: str) -> Triple:
+        subject_surface = self._recover_surface(subject, source_text)
+        object_surface = self._recover_surface(obj, source_text)
+        return Triple(
+            subject=self.ontology.resolve(subject).concept_id,
+            relation=self.ontology.normalize_relation(relation),
+            object=self.ontology.resolve(obj).concept_id,
+            source_text=source_text.strip(),
+            subject_surface=subject_surface,
+            object_surface=object_surface,
+        )
+
+    @staticmethod
+    def _recover_surface(fragment: str, source_text: str) -> str:
+        cleaned = fragment.strip()
+        if not cleaned:
+            return cleaned
+        source_lower = source_text.lower()
+        fragment_lower = cleaned.lower()
+        index = source_lower.find(fragment_lower)
+        if index >= 0:
+            return source_text[index : index + len(cleaned)].strip()
+        return cleaned
+
+    @staticmethod
+    def _split_sentences(text: str) -> list[str]:
+        clean = text.replace("\r", "\n")
+        parts: list[str] = []
+        current: list[str] = []
+        for char in clean:
+            if char in "\n.!?":
+                chunk = "".join(current).strip(" -:;,\t")
+                if chunk:
+                    parts.append(chunk)
+                current = []
+                continue
+            current.append(char)
+        chunk = "".join(current).strip(" -:;,\t")
+        if chunk:
+            parts.append(chunk)
+        return parts
+
+    @staticmethod
+    def _cleanup(sentence: str) -> str:
+        sentence = sentence.strip()
+        lowered = sentence.lower()
+        prefixes = (
+            "record:",
+            "latest record:",
+            "correction:",
+            "update:",
+            "first note:",
+            "distractor:",
+            "delay note:",
+            "target record:",
+            "briefing:",
+        )
+        for prefix in prefixes:
+            if lowered.startswith(prefix):
+                sentence = sentence[len(prefix) :].strip()
+                break
+        return " ".join(sentence.split()).lower()
+
+    @staticmethod
+    def _is_simple_clause(sentence: str) -> bool:
+        tokens = sentence.split()
+        if len(tokens) < 3 or len(tokens) > 12:
+            return False
+        if any(marker in sentence for marker in (",", ";", " that ", " which ", " because ", " while ", " although ")):
+            return False
+        return True
+
+    @staticmethod
+    def _split_once(text: str, phrase: str) -> tuple[str, str] | None:
+        if phrase not in text:
+            return None
+        left, right = text.split(phrase, 1)
+        left = left.strip()
+        right = right.strip()
+        if not left or not right:
+            return None
+        return left, right
+
+    @classmethod
+    def _split_multi(cls, text: str, phrases: tuple[str, ...]) -> tuple[str, ...] | None:
+        parts: list[str] = []
+        remainder = text
+        for phrase in phrases:
+            split = cls._split_once(remainder, phrase)
+            if split is None:
+                return None
+            left, remainder = split
+            parts.append(left)
+        remainder = remainder.strip()
+        if not remainder:
+            return None
+        parts.append(remainder)
+        return tuple(parts)
+
+    @staticmethod
+    def _strip_leading_articles(text: str) -> str:
+        for article in ("the ", "a ", "an "):
+            if text.startswith(article):
+                return text[len(article) :].strip()
+        return text.strip()
+
+    def _parse_generic_locative(self, sentence: str) -> tuple[str, str, str] | None:
+        tokens = sentence.split()
+        prepositions = {"in", "at", "inside", "within"}
+        for index, token in enumerate(tokens):
+            if token not in prepositions or index < 2 or index == len(tokens) - 1:
+                continue
+            verb = tokens[index - 1]
+            if not verb.isalpha():
+                continue
+            subject = " ".join(tokens[: index - 1]).strip()
+            obj = " ".join(tokens[index + 1 :]).strip()
+            if subject and obj:
+                return subject, verb, obj
+        return None
+
+    def _parse_generic_transitive(self, sentence: str) -> tuple[str, str, str] | None:
+        tokens = sentence.split()
+        if len(tokens) < 3:
+            return None
+        for index, token in enumerate(tokens):
+            if not token.isalpha():
+                continue
+            subject = " ".join(tokens[:index]).strip()
+            obj_tokens = tokens[index + 1 :]
+            if not subject or not obj_tokens:
+                continue
+            object_value = " ".join(obj_tokens).strip()
+            object_value = self._strip_leading_articles(object_value)
+            if object_value:
+                return subject, token, object_value
+        return None
+
+    @staticmethod
+    def _is_identifier(value: str) -> bool:
+        if not value:
+            return False
+        if value[0] != "_" and not value[0].isalpha():
+            return False
+        return all(char == "_" or char.isalnum() for char in value)
+
+    def _parse_assignment(self, sentence: str) -> tuple[str, str] | None:
+        if "=" not in sentence or "==" in sentence:
+            return None
+        left, right = (part.strip() for part in sentence.split("=", 1))
+        if not self._is_identifier(left) or not right or right.startswith("="):
+            return None
+        return left, right
+
+    def _parse_return_statement(self, sentence: str) -> tuple[str, str] | None:
+        tokens = sentence.split()
+        if len(tokens) < 3:
+            return None
+        start = 0
+        if tokens[0] in {"def", "function"}:
+            if len(tokens) < 4:
+                return None
+            start = 1
+        name = tokens[start]
+        verb = tokens[start + 1]
+        value = " ".join(tokens[start + 2 :]).strip()
+        if not self._is_identifier(name) or verb not in {"return", "returns"} or not value:
+            return None
+        return name, value
+
+    def _parse_passive_by(self, sentence: str) -> tuple[str, str, str] | None:
+        tokens = sentence.split()
+        if len(tokens) < 5:
+            return None
+        if " is " not in f" {sentence} " or " by " not in f" {sentence} ":
+            return None
+        left_right = self._split_once(sentence, " is ")
+        if left_right is None:
+            return None
+        obj, tail = left_right
+        verb_subject = self._split_once(tail, " by ")
+        if verb_subject is None:
+            return None
+        verb, subject = verb_subject
+        if not verb.isalpha() or not subject:
+            return None
+        return obj, verb, subject

runtime/aethon/rfi_interpreter.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .rfi_lexicon import AethonNativeConceptCodec
+from .rfi_math import ExactMathReasoner
+from .rfi_query_forms import NativeQueryFormSet
+
+
+@dataclass(frozen=True)
+class ParsedQuery:
+    intent: str
+    subject: str | None = None
+    relation: str | None = None
+    object_value: str | None = None
+    expression: str | None = None
+    attribute: str | None = None
+    raw: str = ""
+
+
+class NativeQueryInterpreter:
+    """Interprets queries through Aethon's native lexical codec and token structure."""
+
+    def __init__(
+        self,
+        codec: AethonNativeConceptCodec,
+        query_form_path: str | None = None,
+        query_form_payload: list[dict[str, object]] | None = None,
+    ) -> None:
+        self.codec = codec
+        self.math = ExactMathReasoner()
+        self.query_forms = NativeQueryFormSet(query_form_path, query_form_payload)
+
+    def parse(self, query: str) -> ParsedQuery | None:
+        math_expression = self.math.extract_expression(query)
+        if math_expression is not None:
+            return ParsedQuery(intent="math_eval", expression=math_expression, raw=query)
+
+        raw_words = self._clean_query_words(self.codec.ontology.normalize(query).split())
+        if not raw_words:
+            return None
+
+        form_parsed = self._parse_from_forms(raw_words, raw=query)
+        if form_parsed is not None:
+            return form_parsed
+
+        return None
+
+    def _clean_query_words(self, words: list[str]) -> list[str]:
+        cleaned = list(words)
+        filler_words = self.codec.ontology.semantic_lexicon.query_fillers
+        while cleaned and cleaned[-1] in filler_words:
+            cleaned.pop()
+        return cleaned
+
+    def _parse_from_forms(self, words: list[str], *, raw: str) -> ParsedQuery | None:
+        for form in self.query_forms.forms:
+            prefix = list(form.prefix)
+            if len(words) < len(prefix) or words[: len(prefix)] != prefix:
+                continue
+            if form.requires and not all(token in words for token in form.requires):
+                continue
+            subject = self._resolve_form_subject(words, form)
+            object_value = self._resolve_form_object(words, form)
+            relation = self._resolve_form_relation(words, form)
+            if form.intent == "used_emoji":
+                return ParsedQuery(intent=form.intent, raw=raw)
+            if form.intent in {"what_changed", "has_contradiction", "where_entity", "classify", "plan_first", "plan_next", "plan_previous"} and subject:
+                return ParsedQuery(intent=form.intent, subject=subject, raw=raw)
+            if form.intent == "story_query" and subject:
+                return ParsedQuery(intent=form.intent, subject=subject, object_value=object_value, raw=raw)
+            if form.intent == "relation_path" and subject and object_value:
+                return ParsedQuery(intent=form.intent, subject=subject, object_value=object_value, raw=raw)
+            if form.intent == "keep_location_lookup" and subject and object_value:
+                return ParsedQuery(intent=form.intent, subject=subject, object_value=object_value, raw=raw)
+            if form.intent == "relation_object" and subject and relation:
+                return ParsedQuery(intent=form.intent, subject=subject, relation=relation, raw=raw)
+            if form.intent == "relation_subject" and object_value and relation:
+                return ParsedQuery(intent=form.intent, relation=relation, object_value=object_value, raw=raw)
+        return None
+
+    def _resolve_form_subject(self, words: list[str], form) -> str | None:
+        subject_words: list[str] = []
+        if form.subject_mode == "tail":
+            subject_words = words[len(form.prefix) :]
+        elif form.subject_mode == "tail_without_last":
+            subject_words = words[len(form.prefix) : -1]
+        elif form.subject_mode == "single_after_prefix":
+            if len(words) > len(form.prefix):
+                subject_words = [words[len(form.prefix)]]
+        elif form.subject_mode == "between_indexes":
+            if form.subject_end_anchor and form.subject_end_anchor in words:
+                end_index = words.index(form.subject_end_anchor)
+                subject_words = words[form.subject_start : end_index]
+        elif form.subject_mode == "between_anchors":
+            if form.subject_end_anchor and form.subject_end_anchor in words:
+                end_index = words.index(form.subject_end_anchor)
+                subject_words = words[form.subject_start : end_index]
+        if not subject_words:
+            return None
+        return self.codec.ontology.resolve(" ".join(subject_words)).concept_id
+
+    def _resolve_form_object(self, words: list[str], form) -> str | None:
+        object_words: list[str] = []
+        if form.object_mode == "after_anchor":
+            if form.object_start_anchor and form.object_start_anchor in words:
+                anchor_index = words.index(form.object_start_anchor)
+                start_index = anchor_index + 1
+                if start_index < len(words) and words[start_index] in self._relation_prepositions():
+                    start_index += 1
+                object_words = words[start_index:]
+        elif form.object_mode == "tail_after_prefix":
+            object_words = words[len(form.prefix) :]
+        elif form.object_mode == "from_relation_words":
+            start_index = len(form.prefix) + 1
+            if start_index < len(words) and words[start_index] in self._relation_prepositions():
+                start_index += 1
+            object_words = words[start_index:]
+        if not object_words:
+            return None
+        return self.codec.ontology.resolve(" ".join(object_words)).concept_id
+
+    def _relation_prepositions(self) -> set[str]:
+        return self.codec.ontology.semantic_lexicon.relation_prepositions
+
+    def _resolve_form_relation(self, words: list[str], form) -> str | None:
+        if form.relation_mode == "fixed":
+            return form.relation or None
+        if form.relation_mode == "from_words":
+            start_index = len(form.prefix)
+            if form.subject_mode == "single_after_prefix":
+                start_index += 1
+            return self._relation_from_words(words, start_index=start_index)
+        return None
+
+    def _relation_from_words(self, words: list[str], *, start_index: int) -> str | None:
+        if start_index >= len(words):
+            return None
+        relation = words[start_index]
+        if relation in {"is", "are"}:
+            return None
+        if start_index + 1 < len(words) and words[start_index + 1] in self._relation_prepositions():
+            relation = f"{relation}_{words[start_index + 1]}"
+        return self.codec.ontology.normalize_relation(relation)

runtime/aethon/rfi_lexicon.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+import json
+
+from .rfi_ontology import ConceptOntology
+
+
+@dataclass(frozen=True)
+class LexicalUnit:
+    surface: str
+    normalized: str
+    role: str
+    features: tuple[str, ...] = ()
+
+
+class AethonNativeConceptCodec:
+    """Aethon's graph-native tokenizer/codec for post-weight intelligence."""
+
+    NAME = "Aethon Native Concept Codec"
+    SHORT_NAME = "ANCC"
+
+    _RELATION_PHRASES = (
+        "is located in",
+        "does not like anymore",
+        "was asked to watch",
+        "later bought",
+        "bought in",
+        "bought at",
+        "lives in",
+        "stays in",
+        "located in",
+        "keeps",
+        "prefers",
+        "likes",
+        "chases",
+        "attacks",
+        "hunts",
+        "bought",
+        "carries",
+        "carrying",
+        "visited",
+        "reached",
+        "saw",
+        "returns",
+        "equals",
+        "is a",
+        "is an",
+        "is in",
+    )
+
+    _QUERY_WORDS = {"what", "where", "who", "which", "how", "is", "does", "did", "there", "about", "after"}
+    _STRUCTURE_WORDS = {"the", "a", "an", "in", "at", "to", "of", "now", "later", "before", "and"}
+    _SUFFIX_MAP = {
+        "ing": "progressive",
+        "ed": "past",
+        "er": "agentive",
+        "or": "agentive",
+        "ous": "property",
+        "ly": "adverbial",
+        "tion": "abstract_noun",
+        "s": "plural_or_third_person",
+    }
+
+    def __init__(self, ontology: ConceptOntology | None = None) -> None:
+        self.ontology = ontology or ConceptOntology()
+
+    def encode(self, text: str) -> list[LexicalUnit]:
+        normalized = self.ontology.normalize(text)
+        if not normalized:
+            return []
+        words = normalized.split()
+        relation_match = self._extract_relation_chunk(words)
+        if relation_match is None:
+            return self._encode_segment(normalized, allow_empty=False)
+        start, end, phrase = relation_match
+        units: list[LexicalUnit] = []
+        before = " ".join(words[:start])
+        after = " ".join(words[end:])
+        units.extend(self._encode_segment(before, allow_empty=True))
+        relation = self.ontology.normalize_relation(phrase)
+        units.append(LexicalUnit(surface=phrase, normalized=relation, role="relation", features=("typed_edge",)))
+        if after:
+            units.extend(self.encode(after))
+        return units
+
+    def concept_signature(self, text: str) -> tuple[str, ...]:
+        normalized = self.ontology.resolve(text).concept_id
+        parts = normalized.split("_")
+        features: list[str] = [f"concept:{normalized}"]
+        if len(parts) > 1:
+            for part in parts:
+                features.append(f"compound_part:{part}")
+        for suffix, tag in self._SUFFIX_MAP.items():
+            if suffix == "s" and normalized.endswith(("os", "is", "us", "ss")):
+                continue
+            if normalized.endswith(suffix) and len(normalized) > len(suffix) + 1:
+                root = normalized[: -len(suffix)]
+                features.append(f"root:{root}")
+                features.append(f"suffix:{tag}")
+                break
+        for parent in self.ontology.lift(normalized):
+            features.append(f"parent:{parent}")
+        return tuple(dict.fromkeys(features))
+
+    def export_tokens(self, text: str) -> list[dict[str, object]]:
+        return [
+            {
+                "surface": unit.surface,
+                "normalized": unit.normalized,
+                "role": unit.role,
+                "features": list(unit.features),
+            }
+            for unit in self.encode(text)
+        ]
+
+    def _encode_segment(self, text: str, *, allow_empty: bool) -> list[LexicalUnit]:
+        normalized = self.ontology.normalize(text)
+        if not normalized:
+            return [] if allow_empty else []
+        units: list[LexicalUnit] = []
+        for token in normalized.split():
+            if token in self._STRUCTURE_WORDS:
+                units.append(LexicalUnit(surface=token, normalized=token, role="structure", features=("grammar",)))
+                continue
+            if token in self._QUERY_WORDS:
+                units.append(LexicalUnit(surface=token, normalized=token, role="query", features=("control",)))
+                continue
+            if token.isdigit():
+                units.append(LexicalUnit(surface=token, normalized=token, role="number", features=("scalar",)))
+                continue
+            concept = self.ontology.resolve(token)
+            units.append(
+                LexicalUnit(
+                    surface=token,
+                    normalized=concept.concept_id,
+                    role="concept",
+                    features=self.concept_signature(token),
+                )
+            )
+        return units
+
+    def _extract_relation_chunk(self, words: list[str]) -> tuple[int, int, str] | None:
+        best: tuple[int, int, str] | None = None
+        for phrase in self._relation_phrases():
+            phrase_words = phrase.split()
+            phrase_len = len(phrase_words)
+            if phrase_len == 0 or phrase_len > len(words):
+                continue
+            for start in range(0, len(words) - phrase_len + 1):
+                if words[start : start + phrase_len] == phrase_words:
+                    candidate = (start, start + phrase_len, phrase)
+                    if best is None or candidate[0] < best[0] or (candidate[0] == best[0] and phrase_len > (best[1] - best[0])):
+                        best = candidate
+                    break
+        return best
+
+    def _relation_phrases(self) -> tuple[str, ...]:
+        learned: list[str] = []
+        for phrase, meaning in self.ontology.semantic_lexicon.phrase_alias_map.items():
+            if "_" not in meaning:
+                continue
+            learned.append(phrase)
+            learned.append(meaning)
+        return tuple(dict.fromkeys((*self._RELATION_PHRASES, *learned)))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Inspect Aethon's native no-weight lexical codec.")
+    parser.add_argument("--text", type=str, required=True)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    codec = AethonNativeConceptCodec()
+    print(json.dumps(codec.export_tokens(args.text), indent=2))
+
+
+if __name__ == "__main__":
+    main()

runtime/aethon/rfi_math.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from fractions import Fraction
+
+
+@dataclass(frozen=True)
+class MathResult:
+    expression: str
+    value: str
+    proof: tuple[str, ...]
+    reasoning: tuple[str, ...]
+
+
+class ExactMathReasoner:
+    """Exact arithmetic evaluator for the native no-weight Aethon core."""
+
+    _NUMBER_WORDS = {
+        "zero": 0,
+        "one": 1,
+        "two": 2,
+        "three": 3,
+        "four": 4,
+        "five": 5,
+        "six": 6,
+        "seven": 7,
+        "eight": 8,
+        "nine": 9,
+        "ten": 10,
+        "eleven": 11,
+        "twelve": 12,
+        "thirteen": 13,
+        "fourteen": 14,
+        "fifteen": 15,
+        "sixteen": 16,
+        "seventeen": 17,
+        "eighteen": 18,
+        "nineteen": 19,
+        "twenty": 20,
+        "thirty": 30,
+        "forty": 40,
+        "fifty": 50,
+        "sixty": 60,
+        "seventy": 70,
+        "eighty": 80,
+        "ninety": 90,
+        "hundred": 100,
+    }
+    _NUMBER_CONNECTORS = {"and"}
+    _OPERATOR_PHRASES = (
+        ("multiplied by", "*"),
+        ("divided by", "/"),
+        ("plus", "+"),
+        ("minus", "-"),
+        ("times", "*"),
+        ("over", "/"),
+        ("modulo", "%"),
+        ("mod", "%"),
+    )
+    _TRAILING_CHATTER = (
+        "please",
+        "thanks",
+        "thank you",
+        "laughing",
+        "happy",
+        "thinking",
+        "by the way",
+    )
+
+    _ALLOWED_BINARY = {
+        ast.Add: ("add", lambda left, right: left + right),
+        ast.Sub: ("subtract", lambda left, right: left - right),
+        ast.Mult: ("multiply", lambda left, right: left * right),
+        ast.Div: ("divide", lambda left, right: left / right),
+        ast.FloorDiv: ("floor divide", lambda left, right: left // right),
+        ast.Mod: ("modulo", lambda left, right: left % right),
+        ast.Pow: ("power", lambda left, right: left**right),
+    }
+    _ALLOWED_UNARY = {
+        ast.UAdd: ("keep", lambda value: value),
+        ast.USub: ("negate", lambda value: -value),
+    }
+
+    def can_evaluate(self, text: str) -> bool:
+        expression = self.extract_expression(text)
+        return expression is not None
+
+    def extract_expression(self, text: str) -> str | None:
+        normalized = text.strip()
+        lowered = normalized.lower().strip(" ?")
+        prefixes = ("what is ", "solve ", "compute ", "evaluate ")
+        expression = lowered
+        for prefix in prefixes:
+            if lowered.startswith(prefix):
+                expression = lowered[len(prefix) :]
+                break
+        expression = expression.strip()
+        changed = True
+        while changed:
+            changed = False
+            for suffix in self._TRAILING_CHATTER:
+                if expression.endswith(f" {suffix}"):
+                    expression = expression[: -len(suffix)].strip()
+                    changed = True
+        if not expression:
+            return None
+        if self._is_symbolic_expression(expression):
+            return expression if any(symbol in expression for symbol in "+-*/%") else None
+        textual = self._textual_to_expression(expression)
+        if textual is None or not any(symbol in textual for symbol in "+-*/%"):
+            return None
+        return textual
+
+    def evaluate(self, text: str) -> MathResult | None:
+        expression = self.extract_expression(text)
+        if expression is None:
+            return None
+        tree = ast.parse(expression, mode="eval")
+        steps: list[str] = []
+        value = self._eval_node(tree.body, steps)
+        rendered = self._render_value(value)
+        proof = (f"math:{expression}={rendered}",)
+        reasoning = tuple(f"Step {index}: {step}" for index, step in enumerate(steps, start=1))
+        if not reasoning:
+            reasoning = (f"Step 1: evaluate {expression} = {rendered}.",)
+        return MathResult(expression=expression, value=rendered, proof=proof, reasoning=reasoning)
+
+    def _eval_node(self, node: ast.AST, steps: list[str]) -> Fraction:
+        if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
+            return Fraction(str(node.value))
+        if isinstance(node, ast.Num):
+            return Fraction(str(node.n))
+        if isinstance(node, ast.BinOp):
+            operator = type(node.op)
+            if operator not in self._ALLOWED_BINARY:
+                raise ValueError(f"Unsupported math operator: {operator.__name__}")
+            label, operation = self._ALLOWED_BINARY[operator]
+            left = self._eval_node(node.left, steps)
+            right = self._eval_node(node.right, steps)
+            result = operation(left, right)
+            steps.append(
+                f"{label} {self._render_value(left)} and {self._render_value(right)} to get {self._render_value(result)}."
+            )
+            return result
+        if isinstance(node, ast.UnaryOp):
+            operator = type(node.op)
+            if operator not in self._ALLOWED_UNARY:
+                raise ValueError(f"Unsupported unary operator: {operator.__name__}")
+            label, operation = self._ALLOWED_UNARY[operator]
+            value = self._eval_node(node.operand, steps)
+            result = operation(value)
+            steps.append(f"{label} {self._render_value(value)} to get {self._render_value(result)}.")
+            return result
+        raise ValueError(f"Unsupported math syntax: {type(node).__name__}")
+
+    def _textual_to_expression(self, expression: str) -> str | None:
+        normalized = f" {expression} "
+        for phrase, symbol in self._OPERATOR_PHRASES:
+            normalized = normalized.replace(f" {phrase} ", f" {symbol} ")
+        tokens = normalized.split()
+        converted: list[str] = []
+        index = 0
+        while index < len(tokens):
+            token = tokens[index]
+            if token in "+-*/%()":
+                converted.append(token)
+                index += 1
+                continue
+            if token in self._NUMBER_WORDS or token in self._NUMBER_CONNECTORS:
+                number_tokens: list[str] = []
+                while index < len(tokens) and (tokens[index] in self._NUMBER_WORDS or tokens[index] in self._NUMBER_CONNECTORS):
+                    number_tokens.append(tokens[index])
+                    index += 1
+                value = self._parse_number_words(number_tokens)
+                if value is None:
+                    return None
+                converted.append(str(value))
+                continue
+            if self._is_number_token(token):
+                converted.append(token)
+                index += 1
+                continue
+            return None
+        return " ".join(converted) if converted else None
+
+    def _parse_number_words(self, tokens: list[str]) -> int | None:
+        cleaned = [token for token in tokens if token not in self._NUMBER_CONNECTORS]
+        if not cleaned:
+            return None
+        total = 0
+        current = 0
+        for token in cleaned:
+            value = self._NUMBER_WORDS.get(token)
+            if value is None:
+                return None
+            if token == "hundred":
+                current = max(current, 1) * 100
+            else:
+                current += value
+        total += current
+        return total
+
+    @staticmethod
+    def _render_value(value: Fraction) -> str:
+        if value.denominator == 1:
+            return str(value.numerator)
+        return str(float(value))
+
+    @staticmethod
+    def _is_symbolic_expression(expression: str) -> bool:
+        allowed = set("0123456789.+-*/%() ")
+        return all(char in allowed for char in expression)
+
+    @staticmethod
+    def _is_number_token(token: str) -> bool:
+        if not token:
+            return False
+        dot_seen = False
+        for char in token:
+            if char == ".":
+                if dot_seen:
+                    return False
+                dot_seen = True
+                continue
+            if not char.isdigit():
+                return False
+        return any(char.isdigit() for char in token)

runtime/aethon/rfi_metrics.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import argparse
+from dataclasses import asdict, dataclass
+import json
+from pathlib import Path
+import sqlite3
+
+
+@dataclass(frozen=True)
+class StructuralCapacityReport:
+    structural_capacity: int
+    concept_count: int
+    explicit_edge_count: int
+    abstraction_count: int
+    revision_count: int
+    raw_unit_count: int
+
+    def to_metadata(self) -> dict[str, int]:
+        return {
+            "sc": self.structural_capacity,
+            "concept_count": self.concept_count,
+            "explicit_edge_count": self.explicit_edge_count,
+            "abstraction_count": self.abstraction_count,
+            "revision_count": self.revision_count,
+            "raw_unit_count": self.raw_unit_count,
+        }
+
+
+class StructuralCapacityMeter:
+    """Measures Aethon's live structural size instead of frozen parameter count."""
+
+    @staticmethod
+    def from_sqlite(db_path: str | Path) -> StructuralCapacityReport:
+        conn = sqlite3.connect(str(db_path))
+        try:
+            concept_count = StructuralCapacityMeter._count(conn, "SELECT COUNT(*) FROM concepts")
+            explicit_edge_count = StructuralCapacityMeter._count(
+                conn,
+                "SELECT COUNT(*) FROM edges WHERE is_active = 1 AND source_kind != 'derived'",
+            )
+            abstraction_count = StructuralCapacityMeter._count(
+                conn,
+                "SELECT COUNT(*) FROM edges WHERE is_active = 1 AND source_kind = 'derived'",
+            )
+            revision_count = StructuralCapacityMeter._count(conn, "SELECT COUNT(*) FROM contradictions")
+            raw_unit_count = StructuralCapacityMeter._count(conn, "SELECT COUNT(*) FROM raw_units")
+        finally:
+            conn.close()
+        return StructuralCapacityReport(
+            structural_capacity=concept_count + explicit_edge_count + abstraction_count + revision_count + raw_unit_count,
+            concept_count=concept_count,
+            explicit_edge_count=explicit_edge_count,
+            abstraction_count=abstraction_count,
+            revision_count=revision_count,
+            raw_unit_count=raw_unit_count,
+        )
+
+    @staticmethod
+    def _count(conn: sqlite3.Connection, sql: str) -> int:
+        row = conn.execute(sql).fetchone()
+        return int(row[0]) if row else 0
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Report Aethon Structural Capacity from a native graph store.")
+    parser.add_argument("--graph", type=str, required=True)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    report = StructuralCapacityMeter.from_sqlite(args.graph)
+    print(json.dumps(asdict(report), indent=2))
+
+
+if __name__ == "__main__":
+    main()

runtime/aethon/rfi_ontology.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+from .rfi_semantics import NativeSemanticLexicon
+
+
+def _safe_wordnet():
+    try:
+        from nltk.corpus import wordnet as wn  # type: ignore
+
+        wn.ensure_loaded()
+        return wn
+    except Exception:
+        return None
+
+
+@dataclass(frozen=True)
+class ConceptRecord:
+    concept_id: str
+    lemma: str
+    parents: tuple[str, ...]
+    aliases: tuple[str, ...] = ()
+
+
+class ConceptOntology:
+    """Ontology-backed concept resolver for the post-weight Aethon core."""
+
+    _FALLBACK_PARENT_MAP = {
+        "bobcat": ("feline", "predator"),
+        "cat": ("feline", "animal"),
+        "dog": ("canine", "animal"),
+        "wolf": ("canine", "predator"),
+        "fox": ("canine", "predator"),
+        "lion": ("feline", "predator"),
+        "zebra": ("prey", "animal"),
+        "rabbit": ("prey", "animal"),
+        "mouse": ("prey", "animal"),
+        "hen": ("prey", "animal"),
+        "lagos": ("city", "location"),
+        "accra": ("city", "location"),
+        "nigeria": ("country", "location"),
+        "ghana": ("country", "location"),
+        "professor": ("person",),
+        "developer": ("person",),
+        "teacher": ("person",),
+        "student": ("person",),
+        "predator": ("animal",),
+        "prey": ("animal",),
+        "feline": ("animal",),
+        "canine": ("animal",),
+    }
+
+    _ALIASES = {
+        "likes": "like",
+        "liked": "like",
+        "does_not_like_anymore": "not_like_anymore",
+        "prefers": "prefer",
+        "preferred": "prefer",
+        "chases": "chase",
+        "chased": "chase",
+        "attacks": "attack",
+        "attacked": "attack",
+        "hunts": "hunt",
+        "works_in": "work_in",
+        "studies": "study",
+        "uses": "use",
+        "calls": "call",
+        "imports": "import",
+        "depends_on": "depend_on",
+        "solves": "solve",
+        "bought": "bought",
+        "bought_in": "bought_in",
+        "lives_in": "lives_in",
+        "visited": "visited",
+        "reached": "reached",
+        "saw": "saw",
+        "carries": "carrying",
+        "returns": "return",
+        "equals": "equals",
+        "located": "locate",
+        "located_in": "located_in",
+        "is_in": "located_in",
+        "is_located_in": "located_in",
+        "is": "be",
+        "are": "be",
+    }
+
+    def __init__(
+        self,
+        semantic_lexicon_path: str | Path | None = None,
+        semantic_lexicon_payload: list[dict[str, str]] | None = None,
+    ) -> None:
+        self._wn = _safe_wordnet()
+        self.semantic_lexicon = NativeSemanticLexicon(semantic_lexicon_path, semantic_lexicon_payload)
+
+    def expand_semantics(self, text: str) -> str:
+        expanded = text
+        for emoji, meaning in self.semantic_lexicon.emoji_map.items():
+            expanded = expanded.replace(emoji, f" {meaning} ")
+        return expanded
+
+    def extract_emojis(self, text: str) -> list[tuple[str, str]]:
+        return self.semantic_lexicon.describe_emojis(text)
+
+    def normalize(self, text: str) -> str:
+        text = self.expand_semantics(text)
+        lowered = text.strip().lower()
+        chars: list[str] = []
+        previous_space = False
+        for char in lowered:
+            allowed = char.isalnum() or char in {"_", "-", " "}
+            next_char = char if allowed else " "
+            if next_char == " ":
+                if previous_space:
+                    continue
+                previous_space = True
+                chars.append(" ")
+                continue
+            previous_space = False
+            chars.append(next_char)
+        normalized = "".join(chars).strip()
+        normalized = self._apply_aliases(normalized)
+        return normalized
+
+    def normalize_relation(self, relation: str) -> str:
+        key = self.normalize(relation).replace(" ", "_")
+        aliased = self._ALIASES.get(key)
+        if aliased is not None:
+            return aliased
+        if "_" in key:
+            head, tail = key.split("_", 1)
+            return f"{self._canonicalize_relation_head(head)}_{tail}"
+        return self._canonicalize_relation_head(key)
+
+    @staticmethod
+    def _canonicalize_relation_head(head: str) -> str:
+        if head.endswith("ies") and len(head) > 3:
+            return head[:-3] + "y"
+        if head.endswith("s") and len(head) > 3 and not head.endswith(("ss", "us", "is")):
+            return head[:-1]
+        return head
+
+    def resolve(self, text: str) -> ConceptRecord:
+        lemma = self.normalize(text)
+        lemma = self._drop_leading_article(lemma)
+        if not lemma:
+            raise ValueError("Cannot resolve an empty concept.")
+
+        parents = list(dict.fromkeys(self._parents_from_wordnet(lemma) + list(self._FALLBACK_PARENT_MAP.get(lemma, ()))))
+        return ConceptRecord(
+            concept_id=lemma.replace(" ", "_"),
+            lemma=lemma,
+            parents=tuple(parents),
+            aliases=(lemma,),
+        )
+
+    def lift(self, text: str) -> tuple[str, ...]:
+        return self.resolve(text).parents
+
+    def nearest_shared_parent(self, left: str, right: str) -> str | None:
+        left_parents = set(self.lift(left))
+        for candidate in self.lift(right):
+            if candidate in left_parents:
+                return candidate
+        return None
+
+    def _parents_from_wordnet(self, lemma: str) -> list[str]:
+        if self._wn is None:
+            return []
+        synsets = self._wn.synsets(lemma)
+        parents: list[str] = []
+        for synset in synsets[:3]:
+            for hypernym in synset.hypernyms()[:3]:
+                name = hypernym.lemmas()[0].name().replace("_", " ").lower()
+                if name != lemma:
+                    parents.append(self.normalize(name).replace(" ", "_"))
+        return list(dict.fromkeys(parents))
+
+    def expand_with_parents(self, concepts: Iterable[str]) -> set[str]:
+        expanded: set[str] = set()
+        for concept in concepts:
+            normalized = self.normalize(concept)
+            normalized = self._drop_leading_article(normalized)
+            if not normalized:
+                continue
+            expanded.add(normalized.replace(" ", "_"))
+            expanded.update(self.lift(normalized))
+        return expanded
+
+    @staticmethod
+    def _drop_leading_article(text: str) -> str:
+        words = text.strip().split()
+        if words and words[0] in {"the", "a", "an"}:
+            return " ".join(words[1:]).strip()
+        return text.strip()
+
+    @staticmethod
+    def _replace_word_ci(text: str, target: str, replacement: str) -> str:
+        words = text.split()
+        replaced: list[str] = []
+        target_lower = target.lower()
+        for word in words:
+            if word.lower() == target_lower:
+                replaced.append(replacement)
+            else:
+                replaced.append(word)
+        return " ".join(replaced)
+
+    def _apply_aliases(self, text: str) -> str:
+        words = text.split()
+        if not words:
+            return text
+
+        lower_words = [word.lower().strip(" ?!.,;:") for word in words]
+        replaced_words: list[str] = []
+        index = 0
+        phrase_items = sorted(
+            self.semantic_lexicon.phrase_alias_map.items(),
+            key=lambda item: len(item[0].split()),
+            reverse=True,
+        )
+        while index < len(words):
+            matched = False
+            for phrase, meaning in phrase_items:
+                phrase_words = phrase.split()
+                end_index = index + len(phrase_words)
+                if end_index > len(words):
+                    continue
+                if lower_words[index:end_index] == phrase_words:
+                    replaced_words.extend(meaning.split())
+                    index = end_index
+                    matched = True
+                    break
+            if matched:
+                continue
+            token = lower_words[index]
+            replaced_words.extend(self.semantic_lexicon.alias_map.get(token, token).split())
+            index += 1
+        return " ".join(replaced_words)

runtime/aethon/rfi_query.py

@@ -0,0 +1,1079 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import difflib
+from collections import deque
+
+from .rfi_abstraction import AbstractionEngine
+from .rfi_graph import EdgeRecord, RelationalGraphStore
+from .rfi_interpreter import NativeQueryInterpreter, ParsedQuery
+from .rfi_lexicon import AethonNativeConceptCodec
+from .rfi_math import ExactMathReasoner
+from .rfi_ontology import ConceptOntology
+from .rfi_query_forms import NativeQueryFormSet
+from .rfi_reasoner import StructuralReasoner
+
+
+@dataclass(frozen=True)
+class QueryResult:
+    answer: str
+    proof: tuple[str, ...]
+    confidence: float
+    mode: str
+    reasoning: tuple[str, ...] = ()
+
+
+class ProofQueryEngine:
+    """Proof-backed query engine over the explicit Aethon relation graph."""
+
+    _SALIENT_CLASSES = {
+        "predator",
+        "prey",
+        "person",
+        "city",
+        "country",
+        "teacher",
+        "student",
+        "developer",
+        "professor",
+    }
+
+    _PROTECTED_QUERY_TOKENS = {
+        "a",
+        "about",
+        "after",
+        "and",
+        "animal",
+        "are",
+        "asked",
+        "at",
+        "bought",
+        "buy",
+        "carrying",
+        "changed",
+        "chases",
+        "color",
+        "come",
+        "comes",
+        "contradiction",
+        "continue",
+        "did",
+        "does",
+        "emoji",
+        "first",
+        "happen",
+        "happens",
+        "how",
+        "i",
+        "in",
+        "is",
+        "keep",
+        "like",
+        "live",
+        "now",
+        "next",
+        "object",
+        "plan",
+        "prefer",
+        "related",
+        "return",
+        "schedule",
+        "should",
+        "story",
+        "there",
+        "tell",
+        "to",
+        "use",
+        "watch",
+        "what",
+        "where",
+        "which",
+        "who",
+        "your",
+        "you",
+    }
+
+    def __init__(
+        self,
+        graph: RelationalGraphStore,
+        ontology: ConceptOntology | None = None,
+        abstraction: AbstractionEngine | None = None,
+        reasoner: StructuralReasoner | None = None,
+        query_forms: NativeQueryFormSet | None = None,
+    ) -> None:
+        self.graph = graph
+        self.ontology = ontology or ConceptOntology()
+        self.abstraction = abstraction or AbstractionEngine(graph, self.ontology)
+        self.reasoner = reasoner or StructuralReasoner(graph)
+        self.interpreter = NativeQueryInterpreter(
+            AethonNativeConceptCodec(self.ontology),
+            query_form_payload=query_forms.to_payload() if query_forms is not None else None,
+        )
+        self.math = ExactMathReasoner()
+        self._reasoned_version = self.graph.mutation_version
+        self._query_vocabulary_cache: list[str] | None = None
+        self._query_vocabulary_version = self.graph.mutation_version
+
+    def answer(self, query: str) -> QueryResult | None:
+        original_query = query
+        query = self.ontology.expand_semantics(query)
+        query, corrections = self._soft_correct_query(query)
+        query = self._normalize_self_reference(query)
+        query, later_corrections = self._soft_correct_query(query)
+        corrections.extend(later_corrections)
+        surface_normalized = " ".join(query.lower().replace("?", " ").replace("!", " ").replace(".", " ").split())
+        metadata = self._answer_metadata_value(surface_normalized)
+        if metadata is not None:
+            return self._with_query_awareness(metadata, original_query, corrections)
+        normalized = self.ontology.normalize(query)
+        if not normalized:
+            return None
+        if self._reasoned_version != self.graph.mutation_version:
+            self._reasoned_version = self.graph.mutation_version
+        metadata = self._answer_metadata_value(normalized)
+        if metadata is not None:
+            return self._with_query_awareness(metadata, original_query, corrections)
+        keep_lookup = self._answer_keep_location_from_query(normalized)
+        if keep_lookup is not None:
+            return self._with_query_awareness(keep_lookup, original_query, corrections)
+        parsed = self.interpreter.parse(query)
+        if parsed is not None:
+            interpreted = self._answer_interpreted(parsed)
+            if interpreted is not None:
+                return self._with_query_awareness(interpreted, original_query, corrections)
+        return None
+
+    def _answer_used_emoji(self, raw_query: str) -> QueryResult | None:
+        emojis = self.ontology.extract_emojis(raw_query)
+        if not emojis:
+            return QueryResult(
+                answer="none",
+                proof=("emoji:none",),
+                confidence=1.0,
+                mode="direct",
+                reasoning=("I do not find any emoji in your message.",),
+            )
+        parts = [f"{emoji} ({meaning})" for emoji, meaning in emojis]
+        return QueryResult(
+            answer=", ".join(parts),
+            proof=tuple(f"emoji:{emoji}->{meaning}" for emoji, meaning in emojis),
+            confidence=1.0,
+            mode="direct",
+            reasoning=tuple(f"I find {emoji} and interpret it as {meaning}." for emoji, meaning in emojis),
+        )
+
+    def _answer_metadata_value(self, query: str) -> QueryResult | None:
+        subject = None
+        if "tokenizer" in query and ("aethon" in query or "your" in query):
+            subject = "aethon_tokenizer"
+        elif "size unit" in query and ("aethon" in query or "your" in query):
+            subject = "aethon_size_unit"
+        if subject is not None:
+            equals = self._best_edge(subject, "equals")
+            if equals is None:
+                return None
+            return QueryResult(
+                answer=self.graph.get_display_name(equals.object).replace("_", " ").lower(),
+                proof=(self._edge_to_proof(equals),),
+                confidence=1.0,
+                mode="direct",
+                reasoning=self._reasoning_from_proof((self._edge_to_proof(equals),)),
+            )
+        return None
+
+    def _answer_interpreted(self, parsed: ParsedQuery) -> QueryResult | None:
+        if parsed.intent == "used_emoji":
+            return self._answer_used_emoji(parsed.raw)
+        if parsed.intent == "what_changed" and parsed.subject:
+            return self._answer_what_changed_subject(parsed.subject)
+        if parsed.intent == "has_contradiction" and parsed.subject:
+            return self._answer_has_contradiction_subject(parsed.subject)
+        if parsed.intent == "math_eval" and parsed.expression:
+            result = self.math.evaluate(parsed.expression)
+            if result is None:
+                return None
+            return QueryResult(
+                answer=result.value,
+                proof=result.proof,
+                confidence=1.0,
+                mode="derived",
+                reasoning=result.reasoning,
+            )
+        if parsed.intent == "plan_first" and parsed.subject:
+            return self._answer_plan_first_subject(parsed.subject)
+        if parsed.intent == "plan_next" and parsed.subject:
+            return self._answer_plan_next_anchor(parsed.subject)
+        if parsed.intent == "plan_previous" and parsed.subject:
+            return self._answer_plan_previous_target(parsed.subject)
+        if parsed.intent == "story_query" and parsed.subject:
+            return self._answer_story_subject(parsed.subject, anchor=parsed.object_value or "")
+        if parsed.intent == "where_entity" and parsed.subject:
+            location = self._direct_or_abstract(parsed.subject, "located_in")
+            if location is not None:
+                return location
+            carried = self._infer_carried_object_location(parsed.subject)
+            if carried is not None:
+                return carried
+            return None
+        if parsed.intent == "classify" and parsed.subject:
+            equals = self._best_edge(parsed.subject, "equals")
+            if equals is not None:
+                return QueryResult(
+                    answer=equals.object,
+                    proof=(self._edge_to_proof(equals),),
+                    confidence=1.0,
+                    mode="derived" if equals.source_kind == "derived" else "direct",
+                    reasoning=self._reasoning_from_proof((self._edge_to_proof(equals),)),
+                )
+            direct = self.graph.get_active_edge(parsed.subject, "is_a")
+            if direct is not None:
+                return QueryResult(
+                    answer=direct.object,
+                    proof=(self._edge_to_proof(direct),),
+                    confidence=1.0,
+                    mode="direct",
+                    reasoning=self._reasoning_from_proof((self._edge_to_proof(direct),)),
+                )
+            parents = self.ontology.lift(parsed.subject)
+            if parents:
+                chosen_parent = self._select_ontology_parent(tuple(parents))
+                return QueryResult(
+                    answer=chosen_parent,
+                    proof=(f"ontology:{parsed.subject}->is_a->{chosen_parent}",),
+                    confidence=0.7,
+                    mode="ontology",
+                    reasoning=self._reasoning_from_proof((f"ontology:{parsed.subject}->is_a->{chosen_parent}",)),
+                )
+        if parsed.intent == "relation_object" and parsed.subject and parsed.relation:
+            if parsed.raw.lower().startswith("where does ") and " keep " in parsed.raw.lower():
+                keep_object = self._object_after_phrase(parsed.raw, " keep ")
+                if keep_object is not None:
+                    keep_location = self._answer_keep_location_lookup(parsed.subject, keep_object)
+                    if keep_location is not None:
+                        return keep_location
+            if parsed.relation == "return":
+                value = self._direct_or_abstract(parsed.subject, "return_value")
+                if value is not None:
+                    return value
+            return self._direct_or_abstract(parsed.subject, parsed.relation)
+        if parsed.intent == "keep_location_lookup" and parsed.subject and parsed.object_value:
+            return self._answer_keep_location_lookup(parsed.subject, parsed.object_value)
+        if parsed.intent == "relation_subject" and parsed.object_value and parsed.relation:
+            direct_subjects = self.graph.get_subjects(parsed.relation, parsed.object_value)
+            if direct_subjects:
+                edge = direct_subjects[0]
+                return QueryResult(
+                    answer=edge.subject,
+                    proof=(self._edge_to_proof(edge),),
+                    confidence=1.0,
+                    mode="direct",
+                    reasoning=self._reasoning_from_proof((self._edge_to_proof(edge),)),
+                )
+            hierarchical_subject = self._subject_from_object_hierarchy(parsed.relation, parsed.object_value)
+            if hierarchical_subject is not None:
+                return hierarchical_subject
+        if parsed.intent == "relation_path" and parsed.subject and parsed.object_value:
+            resolved_path = self._resolve_relation_path(parsed.subject, parsed.object_value)
+            if resolved_path is not None:
+                answer, proof, confidence = resolved_path
+                return QueryResult(answer=answer, proof=proof, confidence=confidence, mode="path", reasoning=self._reasoning_from_proof(proof))
+        return None
+
+    def _answer_how_related_pair(self, left: str, right: str) -> QueryResult | None:
+        resolved_path = self._resolve_relation_path(left, right)
+        if resolved_path is not None:
+            answer, proof, confidence = resolved_path
+            return QueryResult(answer=answer, proof=proof, confidence=confidence, mode="path", reasoning=self._reasoning_from_proof(proof))
+        left_parents = self._concept_hierarchy(left)
+        right_parents = self._concept_hierarchy(right)
+        shared = next((parent for parent in left_parents if parent in set(right_parents)), None)
+        if shared is not None:
+            return QueryResult(
+                answer=shared,
+                proof=(f"ontology:{left}->is_a->{shared}", f"ontology:{right}->is_a->{shared}"),
+                confidence=0.7,
+                mode="path",
+                reasoning=self._reasoning_from_proof((f"ontology:{left}->is_a->{shared}", f"ontology:{right}->is_a->{shared}")),
+            )
+        return None
+
+    def _answer_what_changed_subject(self, subject: str) -> QueryResult | None:
+        contradictions = self.graph.get_contradictions(subject=subject)
+        if not contradictions:
+            return None
+        latest = contradictions[0]
+        return QueryResult(
+            answer=f"{latest.relation}:{latest.previous_object}->{latest.new_object}",
+            proof=(
+                f"revision:{latest.subject}-[{latest.relation}]->{latest.previous_object}",
+                f"revision:{latest.subject}-[{latest.relation}]->{latest.new_object}",
+            ),
+            confidence=1.0,
+            mode="revision",
+            reasoning=self._reasoning_from_proof((
+                f"revision:{latest.subject}-[{latest.relation}]->{latest.previous_object}",
+                f"revision:{latest.subject}-[{latest.relation}]->{latest.new_object}",
+            )),
+        )
+
+    def _answer_has_contradiction_subject(self, subject: str) -> QueryResult | None:
+        contradictions = self.graph.get_contradictions(subject=subject)
+        if not contradictions:
+            return QueryResult(
+                answer="no",
+                proof=(f"no_contradiction:{subject}",),
+                confidence=1.0,
+                mode="direct",
+                reasoning=(f"I do not find any stored contradiction for {self.graph.get_display_name(subject)}.",),
+            )
+        latest = contradictions[0]
+        return QueryResult(
+            answer="yes",
+            proof=(
+                f"contradiction:{latest.subject}-[{latest.relation}]->{latest.previous_object}",
+                f"contradiction:{latest.subject}-[{latest.relation}]->{latest.new_object}",
+            ),
+            confidence=1.0,
+            mode="contradiction",
+            reasoning=self._reasoning_from_proof((
+                f"contradiction:{latest.subject}-[{latest.relation}]->{latest.previous_object}",
+                f"contradiction:{latest.subject}-[{latest.relation}]->{latest.new_object}",
+            )),
+        )
+
+    def _answer_keep_location_lookup(self, subject: str, object_value: str) -> QueryResult | None:
+        keep_edge = self.graph.get_active_edge(subject, "keep")
+        if keep_edge is None:
+            keep_edge = self.graph.get_active_edge(subject, "keeps")
+        location_edges = self._location_candidates(subject)
+        if keep_edge is None or not location_edges or keep_edge.object != object_value:
+            return None
+        location_edge = max(location_edges, key=self._edge_rank)
+        return QueryResult(
+            answer=location_edge.object,
+            proof=(
+                self._edge_to_proof(keep_edge),
+                self._edge_to_proof(location_edge),
+                f"compose:{subject}-[keeps]->{object_value}; {subject}-[located_in]->{location_edge.object}",
+            ),
+            confidence=1.0,
+            mode="composed",
+            reasoning=self._reasoning_from_proof((
+                self._edge_to_proof(keep_edge),
+                self._edge_to_proof(location_edge),
+                f"compose:{subject}-[keeps]->{object_value}; {subject}-[located_in]->{location_edge.object}",
+            )),
+        )
+
+    def _answer_keep_location_from_query(self, query: str) -> QueryResult | None:
+        tokens = query.split()
+        if len(tokens) < 4 or tokens[0] != "where" or "keep" not in tokens:
+            return None
+        keep_index = tokens.index("keep")
+        subject_tokens = [token for token in tokens[1:keep_index] if token not in {"does", "is", "the", "a", "an"}]
+        object_tokens = [token for token in tokens[keep_index + 1 :] if token not in {"the", "a", "an"}]
+        if not subject_tokens or not object_tokens:
+            return None
+        subject = self.ontology.resolve(" ".join(subject_tokens)).concept_id
+        object_value = self.ontology.resolve(" ".join(object_tokens)).concept_id
+        return self._answer_keep_location_lookup(subject, object_value)
+
+    def _answer_plan_first_subject(self, target: str) -> QueryResult | None:
+        proof: list[str] = []
+        current = target
+        seen = {current}
+        while True:
+            edge = self._best_edge(current, "depend_on")
+            if edge is None or edge.object in seen:
+                break
+            proof.append(self._edge_to_proof(edge))
+            current = edge.object
+            seen.add(current)
+        if not proof:
+            return None
+        return QueryResult(
+            answer=current,
+            proof=tuple(proof),
+            confidence=1.0,
+            mode="plan",
+            reasoning=self._reasoning_from_proof(tuple(proof)),
+        )
+
+    def _answer_plan_next_anchor(self, anchor: str) -> QueryResult | None:
+        dependents = self.graph.get_subjects("depend_on", anchor)
+        if not dependents:
+            return None
+        edge = max(dependents, key=self._edge_rank)
+        return QueryResult(
+            answer=edge.subject,
+            proof=(self._edge_to_proof(edge),),
+            confidence=1.0,
+            mode="plan",
+            reasoning=self._reasoning_from_proof((self._edge_to_proof(edge),)),
+        )
+
+    def _answer_plan_previous_target(self, target: str) -> QueryResult | None:
+        edge = self._best_edge(target, "depend_on")
+        if edge is None:
+            return None
+        return QueryResult(
+            answer=edge.object,
+            proof=(self._edge_to_proof(edge),),
+            confidence=1.0,
+            mode="plan",
+            reasoning=self._reasoning_from_proof((self._edge_to_proof(edge),)),
+        )
+
+    def _answer_story_subject(self, subject: str, *, anchor: str = "") -> QueryResult | None:
+        allowed = {
+            "approved",
+            "bought",
+            "bought_in",
+            "carrying",
+            "depend_on",
+            "found",
+            "inspected",
+            "left",
+            "like",
+            "lives_in",
+            "located_in",
+            "met",
+            "planned",
+            "visited",
+            "prefer",
+            "reached",
+            "returned",
+            "scheduled",
+            "saw",
+            "started",
+            "stopped",
+            "watch",
+        }
+        edges = [
+            edge
+            for edge in self.graph.iter_outgoing_edges(subject)
+            if edge.relation in allowed and edge.source_kind != "derived"
+        ]
+        if not edges:
+            return None
+        edges.sort(key=lambda edge: edge.edge_id)
+        if anchor.strip():
+            anchor_index = self._story_anchor_index(edges, anchor.strip())
+            if anchor_index is not None:
+                edges = edges[anchor_index + 1 :]
+        if not edges:
+            return None
+        proof = tuple(self._edge_to_proof(edge) for edge in edges[:8])
+        return QueryResult(
+            answer=subject,
+            proof=proof,
+            confidence=0.92,
+            mode="story",
+            reasoning=self._reasoning_from_proof(proof),
+        )
+
+    def _story_anchor_index(self, edges: list[EdgeRecord], anchor_phrase: str) -> int | None:
+        anchor_normalized = self.ontology.normalize(anchor_phrase)
+        anchor_tokens = [token for token in anchor_normalized.split() if token]
+        if not anchor_tokens:
+            return None
+        for index, edge in enumerate(edges):
+            candidates = {
+                self.ontology.normalize(f"{edge.relation} {edge.object}"),
+                self.ontology.normalize(self.graph.get_display_name(edge.relation)),
+                self.ontology.normalize(self.graph.get_display_name(edge.object)),
+                self.ontology.normalize(f"{self.graph.get_display_name(edge.relation)} {self.graph.get_display_name(edge.object)}"),
+            }
+            for candidate in candidates:
+                candidate_tokens = candidate.split()
+                if candidate_tokens and all(token in candidate_tokens for token in anchor_tokens):
+                    return index
+        return None
+
+    def _infer_carried_object_location(self, object_value: str) -> QueryResult | None:
+        carriers = self.graph.get_subjects("carrying", object_value)
+        if not carriers:
+            return None
+        best_carrier = max(carriers, key=self._edge_rank)
+        carrier_locations = self._location_candidates(best_carrier.subject)
+        if not carrier_locations:
+            return None
+        location_edge = max(carrier_locations, key=self._edge_rank)
+        proof = (
+            self._edge_to_proof(best_carrier),
+            self._edge_to_proof(location_edge),
+            f"compose:{best_carrier.subject}-[carrying]->{object_value}; {best_carrier.subject}-[located_in]->{location_edge.object}",
+        )
+        return QueryResult(
+            answer=location_edge.object,
+            proof=proof,
+            confidence=0.92,
+            mode="composed",
+            reasoning=self._reasoning_from_proof(proof),
+        )
+
+    def _answer_who_chases_object(self, obj: str) -> QueryResult | None:
+        direct_subjects = self.graph.get_subjects("chase", obj)
+        if direct_subjects:
+            edge = direct_subjects[0]
+            return QueryResult(
+                answer=edge.subject,
+                proof=(f"direct:{edge.subject}-[chase]->{edge.object}",),
+                confidence=1.0,
+                mode="direct",
+                reasoning=self._reasoning_from_proof((f"direct:{edge.subject}-[chase]->{edge.object}",)),
+            )
+        hierarchical_subject = self._subject_from_object_hierarchy("chase", obj)
+        if hierarchical_subject is not None:
+            return hierarchical_subject
+        candidate_rules = [
+            rule
+            for rule in self.abstraction.derive_rules()
+            if rule.relation == "chase" and rule.object_class in set(self._concept_hierarchy(obj))
+        ]
+        candidate_rules.sort(key=self._rule_specificity, reverse=True)
+        for rule in candidate_rules:
+            return QueryResult(
+                answer=rule.subject_class,
+                proof=(f"abstract:{rule.subject_class}-[chase]->{rule.object_class}", f"object:{obj}->is_a->{rule.object_class}"),
+                confidence=0.65,
+                mode="abstract",
+                reasoning=self._reasoning_from_proof((f"abstract:{rule.subject_class}-[chase]->{rule.object_class}", f"object:{obj}->is_a->{rule.object_class}")),
+            )
+        return None
+
+    def _direct_or_abstract(self, subject: str, relation: str) -> QueryResult | None:
+        direct = self._best_edge(subject, relation)
+        if direct is not None:
+            return QueryResult(
+                answer=direct.object,
+                proof=(self._edge_to_proof(direct),),
+                confidence=1.0,
+                mode="derived" if direct.source_kind == "derived" else "direct",
+                reasoning=self._reasoning_from_proof((self._edge_to_proof(direct),)),
+            )
+        inherited = self._inherit_relation_from_parents(subject, relation)
+        if inherited is not None:
+            return inherited
+        exemplar_inference = self._infer_relation_from_exemplars(subject, relation)
+        if exemplar_inference is not None:
+            return exemplar_inference
+
+        subject_parents = set(self._concept_hierarchy(subject))
+        candidate_rules = [
+            rule
+            for rule in self.abstraction.derive_rules()
+            if rule.relation == relation and rule.subject_class in subject_parents
+        ]
+        candidate_rules.sort(key=self._rule_specificity, reverse=True)
+        for rule in candidate_rules:
+            return QueryResult(
+                answer=rule.object_class,
+                proof=(f"abstract:{rule.subject_class}-[{relation}]->{rule.object_class}", f"subject:{subject}->is_a->{rule.subject_class}"),
+                confidence=0.7,
+                mode="abstract",
+                reasoning=self._reasoning_from_proof((f"abstract:{rule.subject_class}-[{relation}]->{rule.object_class}", f"subject:{subject}->is_a->{rule.subject_class}")),
+            )
+        return None
+
+    def _inherit_relation_from_parents(self, subject: str, relation: str) -> QueryResult | None:
+        for parent in self._concept_hierarchy(subject):
+            inherited_edge = self._best_edge(parent, relation)
+            if inherited_edge is None:
+                continue
+            proof = (
+                f"subject:{subject}->is_a->{parent}",
+                self._edge_to_proof(inherited_edge),
+            )
+            return QueryResult(
+                answer=inherited_edge.object,
+                proof=proof,
+                confidence=0.76 if inherited_edge.source_kind != "derived" else 0.7,
+                mode="abstract",
+                reasoning=self._reasoning_from_proof(proof),
+            )
+        return None
+
+    def _subject_from_object_hierarchy(self, relation: str, object_value: str) -> QueryResult | None:
+        for parent in self._concept_hierarchy(object_value):
+            direct_subjects = self.graph.get_subjects(relation, parent)
+            if not direct_subjects:
+                continue
+            edge = max(direct_subjects, key=self._edge_rank)
+            proof = (
+                self._edge_to_proof(edge),
+                f"object:{object_value}->is_a->{parent}",
+            )
+            return QueryResult(
+                answer=edge.subject,
+                proof=proof,
+                confidence=0.74 if edge.source_kind != "derived" else 0.68,
+                mode="abstract",
+                reasoning=self._reasoning_from_proof(proof),
+            )
+        exemplar_inference = self._infer_subject_from_exemplars(relation, object_value)
+        if exemplar_inference is not None:
+            return exemplar_inference
+        return None
+
+    def _resolve_relation_path(self, left: str, right: str) -> tuple[str, tuple[str, ...], float] | None:
+        grounded_location = self._resolve_grounded_location_path(left, right)
+        if grounded_location is not None:
+            return grounded_location
+        anchors_left = [left, *self._concept_hierarchy(left)]
+        anchors_right = [right, *self._concept_hierarchy(right)]
+        best: tuple[int, int, int, int, int, list[EdgeRecord], str, str] | None = None
+        for left_anchor in anchors_left[:6]:
+            for right_anchor in anchors_right[:6]:
+                path = self.graph.find_path(left_anchor, right_anchor, max_hops=6, include_derived=False)
+                if path is None:
+                    path = self.graph.find_path(left_anchor, right_anchor, max_hops=6, include_derived=True)
+                if path is None:
+                    continue
+                hierarchy_cost = int(left_anchor != left) + int(right_anchor != right)
+                location_penalty = 0 if all(edge.relation in {"lives_in", "located_in"} for edge in path) else 1
+                reverse_penalty = sum(
+                    1 for edge in path if edge.relation in {"contains", "home_of", "has_instance"}
+                )
+                derived_penalty = sum(1 for edge in path if edge.source_kind == "derived")
+                candidate = (
+                    hierarchy_cost,
+                    location_penalty,
+                    reverse_penalty,
+                    derived_penalty,
+                    len(path),
+                    path,
+                    left_anchor,
+                    right_anchor,
+                )
+                if best is None or candidate[:5] < best[:5]:
+                    best = candidate
+        if best is None:
+            return None
+        _, _, _, _, _, path, left_anchor, right_anchor = best
+        proof: list[str] = []
+        if left_anchor != left:
+            proof.append(f"subject:{left}->is_a->{left_anchor}")
+        proof.extend(self._edge_to_proof(edge) for edge in path)
+        if right_anchor != right:
+            proof.append(f"object:{right}->is_a->{right_anchor}")
+        answer = " -> ".join(edge.relation for edge in path)
+        confidence = 1.0 if left_anchor == left and right_anchor == right else 0.78
+        return answer, tuple(proof), confidence
+
+    def _resolve_grounded_location_path(self, left: str, right: str) -> tuple[str, tuple[str, ...], float] | None:
+        allowed_relations = {"lives_in", "located_in"}
+        queue: deque[tuple[str, list[EdgeRecord]]] = deque([(left, [])])
+        seen = {left}
+        while queue:
+            node, path = queue.popleft()
+            if len(path) >= 6:
+                continue
+            for relation in ("lives_in", "located_in"):
+                for edge in self.graph.get_objects(node, relation):
+                    if edge.source_kind == "derived":
+                        continue
+                    next_path = [*path, edge]
+                    if edge.object == right and all(item.relation in allowed_relations for item in next_path):
+                        proof = tuple(self._edge_to_proof(item) for item in next_path)
+                        answer = " -> ".join(item.relation for item in next_path)
+                        return answer, proof, 1.0
+                    if edge.object not in seen:
+                        seen.add(edge.object)
+                        queue.append((edge.object, next_path))
+        return None
+
+    def _infer_relation_from_exemplars(self, subject: str, relation: str) -> QueryResult | None:
+        for subject_class in self._concept_hierarchy(subject):
+            exemplars = self.graph.get_subjects("is_a", subject_class)
+            if not exemplars:
+                continue
+            class_votes: dict[str, list[str]] = {}
+            for exemplar in exemplars:
+                for edge in self.graph.get_objects(exemplar.subject, relation):
+                    for object_class in self._concept_hierarchy(edge.object):
+                        class_votes.setdefault(object_class, []).append(self._edge_to_proof(edge))
+            if not class_votes:
+                continue
+            object_class, proofs = max(class_votes.items(), key=lambda item: (len(item[1]), len(self._concept_hierarchy(item[0]))))
+            if not proofs:
+                continue
+            proof = [f"subject:{subject}->is_a->{subject_class}"]
+            proof.extend(proofs[:2])
+            proof.append(f"object:{self._parse_reasoning_edge(proofs[0])[2]}->is_a->{object_class}")
+            proof_tuple = tuple(proof)
+            return QueryResult(
+                answer=object_class,
+                proof=proof_tuple,
+                confidence=0.73,
+                mode="abstract",
+                reasoning=self._reasoning_from_proof(proof_tuple),
+            )
+        return None
+
+    def _infer_subject_from_exemplars(self, relation: str, object_value: str) -> QueryResult | None:
+        for object_class in self._concept_hierarchy(object_value):
+            exemplars = self.graph.get_subjects("is_a", object_class)
+            if not exemplars:
+                continue
+            class_votes: dict[str, list[str]] = {}
+            for exemplar in exemplars:
+                for edge in self.graph.get_subjects(relation, exemplar.subject):
+                    for subject_class in self._concept_hierarchy(edge.subject):
+                        class_votes.setdefault(subject_class, []).append(self._edge_to_proof(edge))
+            if not class_votes:
+                continue
+            subject_class, proofs = max(class_votes.items(), key=lambda item: (len(item[1]), len(self._concept_hierarchy(item[0]))))
+            if not proofs:
+                continue
+            proof = [f"object:{object_value}->is_a->{object_class}"]
+            proof.extend(proofs[:2])
+            proof.append(f"subject:{self._parse_reasoning_edge(proofs[0])[0]}->is_a->{subject_class}")
+            proof_tuple = tuple(proof)
+            return QueryResult(
+                answer=subject_class,
+                proof=proof_tuple,
+                confidence=0.73,
+                mode="abstract",
+                reasoning=self._reasoning_from_proof(proof_tuple),
+            )
+        return None
+
+    @staticmethod
+    def _edge_to_proof(edge: EdgeRecord) -> str:
+        if edge.source_kind == "derived" and edge.source_text:
+            return f"{edge.source_kind}:{edge.subject}-[{edge.relation}]->{edge.object}|{edge.source_text}"
+        return f"{edge.source_kind}:{edge.subject}-[{edge.relation}]->{edge.object}"
+
+    def _rule_specificity(self, rule) -> tuple[int, int, int]:
+        subject_depth = len(self._concept_hierarchy(rule.subject_class))
+        object_depth = len(self._concept_hierarchy(rule.object_class))
+        return (object_depth, subject_depth, rule.support)
+
+    def _best_edge(self, subject: str, relation: str) -> EdgeRecord | None:
+        candidates = self.graph.get_objects(subject, relation)
+        if not candidates:
+            return None
+        if relation == "located_in":
+            return self._best_location_edge(candidates)
+        return max(candidates, key=self._edge_rank)
+
+    def _edge_rank(self, edge: EdgeRecord) -> tuple[int, int, int]:
+        is_direct = 1 if edge.source_kind != "derived" else 0
+        object_depth = len(self._concept_hierarchy(edge.object))
+        return (is_direct, object_depth, edge.edge_id)
+
+    def _best_location_edge(self, candidates: list[EdgeRecord]) -> EdgeRecord:
+        def specificity(edge: EdgeRecord) -> int:
+            score = 0
+            for other in candidates:
+                if other.edge_id == edge.edge_id:
+                    continue
+                if any(child.object == other.object for child in self.graph.get_objects(edge.object, "located_in")):
+                    score += 1
+            return score
+
+        return max(candidates, key=lambda edge: (specificity(edge),) + self._edge_rank(edge))
+
+    def _location_candidates(self, subject: str) -> list[EdgeRecord]:
+        return self.graph.get_objects(subject, "located_in") + self.graph.get_objects(subject, "lives_in")
+
+    def _select_ontology_parent(self, parents: tuple[str, ...]) -> str:
+        if len(parents) == 1:
+            return parents[0]
+        derived_rules = self.abstraction.derive_rules()
+        scored: list[tuple[int, int, int, int, str]] = []
+        for index, parent in enumerate(parents):
+            outgoing = [
+                edge
+                for edge in self.graph.iter_outgoing_edges(parent)
+                if edge.relation not in {"is_a", "has_instance", "contains", "located_in"}
+            ]
+            exemplars = self.graph.get_subjects("is_a", parent)
+            exemplar_count = len(exemplars)
+            exemplar_behavior = 0
+            for exemplar in exemplars:
+                exemplar_behavior += sum(
+                    1
+                    for edge in self.graph.iter_outgoing_edges(exemplar.subject)
+                    if edge.relation not in {"is_a", "has_instance", "contains", "located_in"}
+                )
+            abstract_behavior = sum(
+                1
+                for rule in derived_rules
+                if rule.subject_class == parent and rule.relation not in {"is_a", "has_instance", "contains", "located_in"}
+            )
+            scored.append((exemplar_behavior, abstract_behavior, len(outgoing), exemplar_count, -index, parent))
+        best = max(scored)
+        if best[0] == 0 and best[1] == 0 and best[2] == 0 and best[3] == 0:
+            salient = [parent for parent in parents if parent in self._SALIENT_CLASSES]
+            if salient:
+                return salient[-1]
+            return parents[0]
+        return best[5]
+
+    def _object_after_phrase(self, raw_query: str, phrase: str) -> str | None:
+        normalized = self.ontology.normalize(raw_query)
+        if phrase.strip() not in normalized:
+            return None
+        _, tail = normalized.split(phrase.strip(), 1)
+        candidate = tail.strip()
+        if not candidate:
+            return None
+        return self.ontology.resolve(candidate).concept_id
+
+    def _concept_hierarchy(self, concept: str) -> list[str]:
+        seen: set[str] = set()
+        ordered: list[str] = []
+
+        def visit(node: str) -> None:
+            for edge in self.graph.get_objects(node, "is_a"):
+                if edge.object not in seen:
+                    seen.add(edge.object)
+                    ordered.append(edge.object)
+                    visit(edge.object)
+            for parent in self.ontology.lift(node):
+                if parent not in seen:
+                    seen.add(parent)
+                    ordered.append(parent)
+
+        visit(concept)
+        return ordered
+
+    def _reasoning_from_proof(self, proof: tuple[str, ...]) -> tuple[str, ...]:
+        steps: list[str] = []
+        openers = (
+            "I start from",
+            "Then I use",
+            "Next I rely on",
+            "After that I connect",
+            "From there I infer",
+            "Finally I conclude from",
+        )
+        expanded_proof = self._expand_reasoning_steps(proof)
+        for index, step in enumerate(expanded_proof, start=1):
+            rendered = self._render_reasoning_step(step)
+            opener = openers[(index - 1) % len(openers)]
+            steps.append(f"{opener} {rendered}.")
+        return tuple(steps)
+
+    def _expand_reasoning_steps(self, proof: tuple[str, ...]) -> tuple[str, ...]:
+        expanded: list[str] = []
+        for step in proof:
+            expanded.append(step)
+            if not step.startswith("derived:") or "|" not in step:
+                continue
+            _, source_text = step.split("|", 1)
+            for detail in source_text.split("|"):
+                detail = detail.strip()
+                if not detail:
+                    continue
+                expanded.append(detail)
+        return tuple(expanded)
+
+    def _render_reasoning_step(self, step: str) -> str:
+        if "-[" in step and "]->" in step:
+            parsed = self._parse_reasoning_edge(step)
+            if parsed is not None:
+                subject, relation, object_value = parsed
+                return (
+                    f"{self.graph.get_display_name(subject)} "
+                    f"{relation.replace('_', ' ')} "
+                    f"{self.graph.get_display_name(object_value)}"
+                )
+        if step.startswith("ontology:"):
+            payload = step.split(":", 1)[1]
+            subject, _, parent = payload.partition("->is_a->")
+            return f"{self.graph.get_display_name(subject)} belongs to {self.graph.get_display_name(parent)}"
+        if step.startswith("subject:"):
+            payload = step.split(":", 1)[1]
+            subject, _, parent = payload.partition("->is_a->")
+            return f"{self.graph.get_display_name(subject)} belongs to {self.graph.get_display_name(parent)}"
+        if step.startswith("object:"):
+            payload = step.split(":", 1)[1]
+            obj, _, parent = payload.partition("->is_a->")
+            return f"{self.graph.get_display_name(obj)} belongs to {self.graph.get_display_name(parent)}"
+        if step.startswith("compose:"):
+            payload = step.split(":", 1)[1]
+            return f"the composed link {payload}".replace("_", " ")
+        if step.startswith("revision:"):
+            payload = step.split(":", 1)[1]
+            return f"the revision {payload}".replace("_", " ")
+        if step.startswith("contradiction:"):
+            payload = step.split(":", 1)[1]
+            return f"the contradiction {payload}".replace("_", " ")
+        if step.startswith("no_contradiction:"):
+            payload = step.split(":", 1)[1]
+            return f"there is no stored contradiction for {self.graph.get_display_name(payload)}"
+        if step.startswith("emoji:"):
+            payload = step.split(":", 1)[1]
+            return f"the symbol {payload}".replace("_", " ")
+        if step.startswith("math:"):
+            payload = step.split(":", 1)[1]
+            return f"the computation {payload}".replace("_", " ")
+        if step.startswith("reason:"):
+            payload = step.split(":", 1)[1]
+            return f"the rule {payload}".replace("_", " ")
+        return step.replace("_", " ")
+
+    @staticmethod
+    def _parse_reasoning_edge(step: str) -> tuple[str, str, str] | None:
+        payload = step.split(":", 1)[-1].split("|", 1)[0]
+        if "-[" not in payload or "]->" not in payload:
+            return None
+        subject, rest = payload.split("-[", 1)
+        relation, object_value = rest.split("]->", 1)
+        return subject, relation, object_value
+
+    @staticmethod
+    def _normalize_self_reference(query: str) -> str:
+        normalized = query.strip()
+        lowered = normalized.lower()
+        if lowered.startswith("who are you"):
+            return "What is Aethon?"
+        if lowered.startswith("what are you"):
+            return "What is Aethon?"
+        if lowered.startswith("what is your tokenizer"):
+            return "What is Aethon tokenizer?"
+        if lowered.startswith("what is your size unit"):
+            return "What is Aethon size unit?"
+        if lowered.startswith("what is aethon tokenizer"):
+            return "What is Aethon tokenizer?"
+        if lowered.startswith("what is aethon size unit"):
+            return "What is Aethon size unit?"
+        replaced: list[str] = []
+        for token in normalized.split():
+            lower = token.lower()
+            if lower == "your":
+                replaced.append("Aethon")
+            elif lower == "you":
+                replaced.append("Aethon")
+            else:
+                replaced.append(token)
+        return " ".join(replaced)
+
+    def _with_query_awareness(self, result: QueryResult, original_query: str, corrections: list[tuple[str, str]]) -> QueryResult:
+        if not corrections:
+            return result
+        seen: set[tuple[str, str]] = set()
+        notes: list[str] = []
+        for source, target in corrections:
+            pair = (source.lower(), target.lower())
+            if pair in seen or source.lower() == target.lower():
+                continue
+            seen.add(pair)
+            notes.append(
+                f'I read "{source}" as "{self.graph.get_display_name(target.lower().replace(" ", "_")) if "_" in target or target.islower() else target}" so the prompt still stays grounded.'
+            )
+        if not notes:
+            return result
+        return QueryResult(
+            answer=result.answer,
+            proof=result.proof,
+            confidence=result.confidence,
+            mode=result.mode,
+            reasoning=tuple(notes) + result.reasoning,
+        )
+
+    def _soft_correct_query(self, query: str) -> tuple[str, list[tuple[str, str]]]:
+        tokens = query.split()
+        if not tokens:
+            return query, []
+        vocabulary = self._query_vocabulary()
+        corrected: list[str] = []
+        corrections: list[tuple[str, str]] = []
+        for token in tokens:
+            prefix_end = 0
+            while prefix_end < len(token) and not token[prefix_end].isalnum():
+                prefix_end += 1
+            suffix_start = len(token)
+            while suffix_start > prefix_end and not token[suffix_start - 1].isalnum():
+                suffix_start -= 1
+            prefix = token[:prefix_end]
+            suffix = token[suffix_start:]
+            core = token[len(prefix) : len(token) - len(suffix) if suffix else len(token)]
+            lower_core = core.lower()
+            if lower_core in self._PROTECTED_QUERY_TOKENS:
+                corrected.append(token)
+                continue
+            if lower_core in self.ontology.semantic_lexicon.typo_map:
+                replacement = self.ontology.semantic_lexicon.typo_map[lower_core]
+                if core[:1].isupper():
+                    replacement = replacement.capitalize()
+                corrections.append((core, replacement))
+                corrected.append(f"{prefix}{replacement}{suffix}")
+                continue
+            if len(lower_core) <= 2 or not lower_core or lower_core in vocabulary:
+                corrected.append(token)
+                continue
+            match = difflib.get_close_matches(lower_core, vocabulary, n=1, cutoff=0.72)
+            if match:
+                replacement = match[0]
+                if core[:1].isupper():
+                    replacement = replacement.capitalize()
+                corrections.append((core, replacement))
+                corrected.append(f"{prefix}{replacement}{suffix}")
+            else:
+                corrected.append(token)
+        return " ".join(corrected), corrections
+
+    def _query_vocabulary(self) -> list[str]:
+        if (
+            self._query_vocabulary_cache is not None
+            and self._query_vocabulary_version == self.graph.mutation_version
+        ):
+            return self._query_vocabulary_cache
+        base_words = {
+            "what",
+            "who",
+            "where",
+            "how",
+            "is",
+            "are",
+            "does",
+            "did",
+            "the",
+            "aethon",
+            "tokenizer",
+            "size",
+            "unit",
+            "your",
+            "you",
+            "please",
+            "thanks",
+            "happy",
+            "sad",
+            "thinking",
+            "love",
+            "approve",
+            "correct",
+            "wrong",
+            "related",
+            "return",
+            "returns",
+            "depend",
+            "depends",
+            "on",
+            "work",
+            "works",
+            "live",
+            "like",
+            "prefer",
+            "carrying",
+            "buy",
+            "bought",
+            "watch",
+            "chase",
+            "solve",
+            "plus",
+            "minus",
+            "times",
+            "divided",
+            "by",
+        }
+        for concept in self.graph.list_concepts():
+            base_words.update(part for part in concept.split("_") if part)
+            base_words.add(concept.replace("_", " "))
+        self._query_vocabulary_cache = sorted(base_words)
+        self._query_vocabulary_version = self.graph.mutation_version
+        return self._query_vocabulary_cache

runtime/aethon/rfi_query_forms.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class QueryForm:
+    intent: str
+    prefix: tuple[str, ...]
+    relation: str = ""
+    relation_mode: str = "fixed"
+    subject_mode: str = "tail"
+    subject_start: int = 0
+    subject_end_anchor: str = ""
+    object_start_anchor: str = ""
+    object_mode: str = "none"
+    requires: tuple[str, ...] = ()
+
+
+class NativeQueryFormSet:
+    DEFAULT_PATH = Path(__file__).resolve().parents[1] / "data" / "native" / "query" / "aethon_query_forms_v1.json"
+
+    def __init__(self, path: str | Path | None = None, payload: list[dict[str, object]] | None = None) -> None:
+        self.path = Path(path) if path is not None else self.DEFAULT_PATH
+        self.forms = self._load_forms(payload)
+
+    def _load_forms(self, payload: list[dict[str, object]] | None) -> tuple[QueryForm, ...]:
+        if payload is not None:
+            return tuple(self._row_to_form(row) for row in payload)
+        if not self.path.exists():
+            return ()
+        data = json.loads(self.path.read_text(encoding="utf-8"))
+        return tuple(self._row_to_form(row) for row in data)
+
+    @staticmethod
+    def _row_to_form(row: dict[str, object]) -> QueryForm:
+        return QueryForm(
+            intent=str(row["intent"]).strip(),
+            prefix=tuple(str(item).strip() for item in row.get("prefix", [])),
+            relation=str(row.get("relation", "")).strip(),
+            relation_mode=str(row.get("relation_mode", "fixed")).strip(),
+            subject_mode=str(row.get("subject_mode", "tail")).strip(),
+            subject_start=int(row.get("subject_start", 0)),
+            subject_end_anchor=str(row.get("subject_end_anchor", "")).strip(),
+            object_start_anchor=str(row.get("object_start_anchor", "")).strip(),
+            object_mode=str(row.get("object_mode", "none")).strip(),
+            requires=tuple(str(item).strip() for item in row.get("requires", [])),
+        )
+
+    def to_payload(self) -> list[dict[str, object]]:
+        return [
+            {
+                "intent": form.intent,
+                "prefix": list(form.prefix),
+                "relation": form.relation,
+                "relation_mode": form.relation_mode,
+                "subject_mode": form.subject_mode,
+                "subject_start": form.subject_start,
+                "subject_end_anchor": form.subject_end_anchor,
+                "object_start_anchor": form.object_start_anchor,
+                "object_mode": form.object_mode,
+                "requires": list(form.requires),
+            }
+            for form in self.forms
+        ]

runtime/aethon/rfi_reasoner.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from collections import Counter
+
+from .rfi_graph import EdgeRecord, RelationalGraphStore
+from .rfi_reasoning_rules import NativeReasoningRuleSet, ReasoningRule
+
+
+class StructuralReasoner:
+    """Executes native reasoning rules over the relation graph."""
+
+    def __init__(self, graph: RelationalGraphStore, rules_path: str | None = None, rules_payload: dict | None = None) -> None:
+        self.graph = graph
+        self.rule_set = NativeReasoningRuleSet(rules_path, rules_payload)
+        self.base_rules = self.rule_set.rules
+        self.induced_rules: tuple[ReasoningRule, ...] = ()
+
+    def materialize(self, *, max_rounds: int = 4, induce_min_support: int = 2) -> list[int]:
+        created: list[int] = []
+        self.induced_rules = self.induce_rules(min_support=induce_min_support)
+        for _ in range(max_rounds):
+            round_ids: list[int] = []
+            for rule in self._all_rules():
+                round_ids.extend(self._apply_rule(rule))
+            if not round_ids:
+                break
+            created.extend(round_ids)
+        if created:
+            self.graph.commit()
+        return created
+
+    def induce_rules(self, *, min_support: int = 2) -> tuple[ReasoningRule, ...]:
+        counts: Counter[tuple[str, str, str]] = Counter()
+        existing = {
+            (rule.kind, rule.left_relation, rule.right_relation, rule.output_relation)
+            for rule in self.base_rules
+        }
+        active_edges = self.graph.iter_active_edges()
+        outgoing: dict[str, list[EdgeRecord]] = {}
+        direct_lookup: dict[tuple[str, str, str], bool] = {}
+        for edge in active_edges:
+            outgoing.setdefault(edge.subject, []).append(edge)
+            direct_lookup[(edge.subject, edge.relation, edge.object)] = True
+        for left in active_edges:
+            for right in outgoing.get(left.object, ()):
+                if left.subject == right.object:
+                    continue
+                for candidate in outgoing.get(left.subject, ()):
+                    if candidate.object != right.object:
+                        continue
+                    counts[(left.relation, right.relation, candidate.relation)] += 1
+        induced: list[ReasoningRule] = []
+        for (left_relation, right_relation, output_relation), support in counts.items():
+            signature = ("via_chain", left_relation, right_relation, output_relation)
+            if support < min_support or signature in existing:
+                continue
+            induced.append(
+                ReasoningRule(
+                    name=f"induced_{left_relation}_{right_relation}_{output_relation}",
+                    kind="via_chain",
+                    left_relation=left_relation,
+                    right_relation=right_relation,
+                    output_relation=output_relation,
+                    confidence=0.65,
+                )
+            )
+        return tuple(induced)
+
+    def _all_rules(self) -> tuple[ReasoningRule, ...]:
+        return self.base_rules + self.induced_rules
+
+    def _apply_rule(self, rule: ReasoningRule) -> list[int]:
+        if rule.kind == "transitive":
+            return self._apply_transitive(rule)
+        if rule.kind == "via_chain":
+            return self._apply_via_chain(rule)
+        if rule.kind == "copy":
+            return self._apply_copy(rule)
+        if rule.kind == "suffix_copy":
+            return self._apply_suffix_copy(rule)
+        if rule.kind == "object_support":
+            return self._apply_object_support(rule)
+        if rule.kind == "object_bridge":
+            return self._apply_object_bridge(rule)
+        if rule.kind == "via_object":
+            return self._apply_via_object(rule)
+        return []
+
+    def _apply_transitive(self, rule: ReasoningRule) -> list[int]:
+        created: list[int] = []
+        for left in self.graph.iter_active_edges():
+            if left.relation != rule.left_relation:
+                continue
+            for right in self.graph.get_objects(left.object, rule.right_relation):
+                created_id = self._add_if_supported(
+                    subject=left.subject,
+                    relation=rule.output_relation,
+                    object_value=right.object,
+                    rule_name=rule.name,
+                    support_edges=(left, right),
+                )
+                if created_id is not None:
+                    created.append(created_id)
+        return created
+
+    def _apply_via_chain(self, rule: ReasoningRule) -> list[int]:
+        created: list[int] = []
+        for left in self.graph.iter_active_edges():
+            if left.relation != rule.left_relation:
+                continue
+            for right in self.graph.get_objects(left.object, rule.right_relation):
+                created_id = self._add_if_supported(
+                    subject=left.subject,
+                    relation=rule.output_relation,
+                    object_value=right.object,
+                    rule_name=rule.name,
+                    support_edges=(left, right),
+                )
+                if created_id is not None:
+                    created.append(created_id)
+        return created
+
+    def _apply_copy(self, rule: ReasoningRule) -> list[int]:
+        created: list[int] = []
+        for edge in self.graph.iter_active_edges():
+            if edge.relation != rule.source_relation:
+                continue
+            created_id = self._add_if_supported(
+                subject=edge.subject,
+                relation=rule.output_relation,
+                object_value=edge.object,
+                rule_name=rule.name,
+                support_edges=(edge, edge),
+            )
+            if created_id is not None:
+                created.append(created_id)
+        return created
+
+    def _apply_suffix_copy(self, rule: ReasoningRule) -> list[int]:
+        created: list[int] = []
+        excluded = set(rule.exclude_relations)
+        for edge in self.graph.iter_active_edges():
+            if not edge.relation.endswith("_in"):
+                continue
+            if edge.relation in excluded:
+                continue
+            created_id = self._add_if_supported(
+                subject=edge.subject,
+                relation=rule.output_relation,
+                object_value=edge.object,
+                rule_name=rule.name,
+                support_edges=(edge, edge),
+            )
+            if created_id is not None:
+                created.append(created_id)
+        return created
+
+    def _apply_object_support(self, rule: ReasoningRule) -> list[int]:
+        created: list[int] = []
+        support_relations = set(rule.support_relation_set)
+        for edge in self.graph.iter_active_edges():
+            if edge.relation != rule.left_relation:
+                continue
+            for support_relation in support_relations:
+                for support in self.graph.get_objects(edge.subject, support_relation):
+                    created_id = self._add_if_supported(
+                        subject=edge.object,
+                        relation=rule.output_relation,
+                        object_value=support.object,
+                        rule_name=rule.name,
+                        support_edges=(edge, support),
+                    )
+                    if created_id is not None:
+                        created.append(created_id)
+        return created
+
+    def _apply_object_bridge(self, rule: ReasoningRule) -> list[int]:
+        created: list[int] = []
+        for left in self.graph.iter_active_edges():
+            if left.relation != rule.left_relation:
+                continue
+            support = self.graph.get_active_edge(left.subject, rule.support_relation)
+            if support is None:
+                continue
+            created_id = self._add_if_supported(
+                subject=left.object,
+                relation=rule.output_relation,
+                object_value=support.object,
+                rule_name=rule.name,
+                support_edges=(left, support),
+            )
+            if created_id is not None:
+                created.append(created_id)
+        return created
+
+    def _apply_via_object(self, rule: ReasoningRule) -> list[int]:
+        created: list[int] = []
+        for left in self.graph.iter_active_edges():
+            if left.relation != rule.left_relation:
+                continue
+            right = self.graph.get_active_edge(left.object, rule.via_relation)
+            if right is None:
+                continue
+            created_id = self._add_if_supported(
+                subject=left.subject,
+                relation=rule.output_relation,
+                object_value=right.object,
+                rule_name=rule.name,
+                support_edges=(left, right),
+            )
+            if created_id is not None:
+                created.append(created_id)
+        return created
+
+    def _add_if_supported(
+        self,
+        *,
+        subject: str,
+        relation: str,
+        object_value: str,
+        rule_name: str,
+        support_edges: tuple[EdgeRecord, EdgeRecord],
+    ) -> int | None:
+        existing = self.graph.get_objects(subject, relation)
+        for edge in existing:
+            if edge.object == object_value:
+                return None
+        source_text = self._proof_source_text(rule_name, support_edges)
+        return self.graph.add_derived_fact(
+            subject=subject,
+            relation=relation,
+            object=object_value,
+            source_text=source_text,
+            supports_edge_id=support_edges[0].edge_id,
+            commit=False,
+        )
+
+    @staticmethod
+    def _proof_source_text(rule_name: str, support_edges: tuple[EdgeRecord, EdgeRecord]) -> str:
+        left, right = support_edges
+        return (
+            f"reason:{rule_name}|"
+            f"{left.subject}-[{left.relation}]->{left.object}|"
+            f"{right.subject}-[{right.relation}]->{right.object}"
+        )

runtime/aethon/rfi_reasoning_rules.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class ReasoningRule:
+    name: str
+    kind: str
+    output_relation: str
+    confidence: float
+    left_relation: str = ""
+    right_relation: str = ""
+    source_relation: str = ""
+    via_relation: str = ""
+    support_relation: str = ""
+    exclude_relations: tuple[str, ...] = ()
+    support_relation_set: tuple[str, ...] = ()
+
+
+class NativeReasoningRuleSet:
+    """Loads native reasoning rules from data instead of freezing rule metadata in code."""
+
+    DEFAULT_PATH = Path(__file__).resolve().parents[1] / "data" / "native" / "reasoning" / "aethon_reasoning_rules_v1.json"
+
+    def __init__(self, path: str | Path | None = None, payload: dict | None = None) -> None:
+        self.path = Path(path) if path is not None else self.DEFAULT_PATH
+        self.payload = self._load_payload(payload)
+        self.rules = self._load_rules()
+
+    def _load_payload(self, payload: dict | None) -> dict:
+        if payload is not None:
+            return payload
+        if not self.path.exists():
+            return {}
+        return json.loads(self.path.read_text(encoding="utf-8"))
+
+    def _load_rules(self) -> tuple[ReasoningRule, ...]:
+        return tuple(
+            ReasoningRule(
+                name=str(row["name"]),
+                kind=str(row.get("kind", "")),
+                output_relation=str(row["output_relation"]),
+                confidence=float(row["confidence"]),
+                left_relation=str(row.get("left_relation", "")),
+                right_relation=str(row.get("right_relation", "")),
+                source_relation=str(row.get("source_relation", "")),
+                via_relation=str(row.get("via_relation", "")),
+                support_relation=str(row.get("support_relation", "")),
+                exclude_relations=tuple(str(item) for item in row.get("exclude_relations", [])),
+                support_relation_set=tuple(str(item) for item in row.get("support_relation_set", [])),
+            )
+            for row in self.payload.get("rules", [])
+        )
+
+    def to_payload(self) -> dict:
+        return dict(self.payload)

runtime/aethon/rfi_runtime.py

@@ -0,0 +1,359 @@
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+import json
+from pathlib import Path
+import re
+
+from .rfi_bundle import NativeBundleManager
+from .rfi_abstraction import AbstractionEngine
+from .rfi_document_filter import DocumentQualityGate
+from .rfi_graph import RelationalGraphStore
+from .rfi_ingest import DeterministicTripleExtractor
+from .rfi_lexicon import AethonNativeConceptCodec
+from .rfi_metrics import StructuralCapacityMeter
+from .rfi_ontology import ConceptOntology
+from .rfi_query_forms import NativeQueryFormSet
+from .rfi_query import ProofQueryEngine, QueryResult
+from .rfi_reasoner import StructuralReasoner
+from .rfi_surface import GraphVerbalizer
+
+
+@dataclass(frozen=True)
+class NativeResponse:
+    answer: str
+    text: str
+    explanation: str
+    proof: tuple[str, ...]
+    reasoning: tuple[str, ...]
+    mode: str
+
+
+class AethonNativeBase:
+    """The first real no-weight Aethon base runtime."""
+
+    NAME = "Aethon N1 Base"
+    FAMILY = "Aethon Native"
+    TOKENIZER = f"{AethonNativeConceptCodec.NAME} ({AethonNativeConceptCodec.SHORT_NAME})"
+
+    def __init__(
+        self,
+        *,
+        db_path: str = ":memory:",
+        semantic_lexicon_path: str | None = None,
+        semantic_lexicon_payload: list[dict[str, str]] | None = None,
+        surface_lexicon_path: str | None = None,
+        surface_lexicon_payload: dict | None = None,
+        query_form_path: str | None = None,
+        query_form_payload: list[dict[str, object]] | None = None,
+        reasoning_rules_path: str | None = None,
+        reasoning_rules_payload: dict | None = None,
+    ) -> None:
+        self.semantic_lexicon_path = semantic_lexicon_path
+        self.semantic_lexicon_payload = semantic_lexicon_payload
+        self.surface_lexicon_path = surface_lexicon_path
+        self.surface_lexicon_payload = surface_lexicon_payload
+        self.query_form_path = query_form_path
+        self.query_form_payload = query_form_payload
+        self.reasoning_rules_path = reasoning_rules_path
+        self.reasoning_rules_payload = reasoning_rules_payload
+        self.ontology = ConceptOntology(semantic_lexicon_path, semantic_lexicon_payload)
+        self.codec = AethonNativeConceptCodec(self.ontology)
+        self.query_forms = NativeQueryFormSet(query_form_path, query_form_payload)
+        self.document_gate = DocumentQualityGate()
+        self.graph = RelationalGraphStore(db_path=db_path)
+        self.extractor = DeterministicTripleExtractor(self.ontology)
+        self.abstraction = AbstractionEngine(self.graph, self.ontology)
+        self.reasoner = StructuralReasoner(self.graph, reasoning_rules_path, reasoning_rules_payload)
+        self.query_engine = ProofQueryEngine(self.graph, self.ontology, self.abstraction, self.reasoner, self.query_forms)
+        self.surface = GraphVerbalizer(surface_lexicon_path, surface_lexicon_payload, self.graph)
+
+    def learn(self, text: str) -> dict[str, object]:
+        triples = self.extractor.extract(text)
+        edge_ids = self.graph.ingest_triples(triples, commit=False)
+        rules = self.abstraction.materialize_rules(min_support=2)
+        derived = self.reasoner.materialize()
+        self.graph.commit()
+        return {
+            "learned_edges": edge_ids,
+            "derived_edges": derived,
+            "rule_count": len(rules),
+            "lexicon": self.codec.export_tokens(text),
+        }
+
+    def learn_fast(self, text: str) -> dict[str, object]:
+        triples = self.extractor.extract(text)
+        edge_ids = self.graph.ingest_triples(triples, commit=False)
+        return {
+            "learned_edges": edge_ids,
+            "derived_edges": [],
+            "rule_count": 0,
+            "lexicon": self.codec.export_tokens(text),
+        }
+
+    def learn_ultra_fast(self, texts: list[str]) -> dict[str, int]:
+        triples = []
+        for text in texts:
+            if text.strip():
+                triples.extend(self.extractor.extract_ultra(text))
+        learned_edges = self.graph.ingest_triples_fast(triples, commit=False)
+        return {"learned_edges": learned_edges, "triple_count": len(triples)}
+
+    def capture_ultra_fast(self, lane: str, source: str, texts: list[str]) -> dict[str, int]:
+        units = [(lane, source, text.strip()) for text in texts if text.strip()]
+        captured = self.graph.ingest_raw_units(units, commit=False)
+        return {"captured_units": captured}
+
+    def digest_captured_units(
+        self,
+        *,
+        batch_size: int = 5000,
+        flush_every: int = 20000,
+        reason_rounds: int = 6,
+        purge_after_digest: bool = False,
+        progress_callback=None,
+    ) -> dict[str, int]:
+        total_units = self.graph.count_undigested_raw_units()
+        processed_units = 0
+        learned_edges = 0
+        derived_edges = 0
+        rule_count = 0
+        pending_units = 0
+        while True:
+            batch = self.graph.fetch_undigested_raw_units(limit=batch_size)
+            if not batch:
+                break
+            texts = [str(item["text"]) for item in batch if str(item["text"]).strip()]
+            if texts:
+                learned = self.learn_ultra_fast(texts)
+                learned_edges += int(learned["learned_edges"])
+            unit_ids = [int(item["unit_id"]) for item in batch]
+            self.graph.mark_raw_units_digested(unit_ids, commit=False)
+            processed_units += len(unit_ids)
+            pending_units += len(unit_ids)
+            if pending_units >= flush_every:
+                flushed = self.flush_learning(reason_rounds=2)
+                derived_edges += int(flushed["derived_edges"])
+                rule_count += int(flushed["rule_count"])
+                pending_units = 0
+            if progress_callback is not None:
+                progress_callback(
+                    {
+                        "processed_units": processed_units,
+                        "total_units": total_units,
+                        "learned_edges": learned_edges,
+                        "derived_edges": derived_edges,
+                        "rule_count": rule_count,
+                    }
+                )
+        if pending_units:
+            flushed = self.flush_learning(reason_rounds=reason_rounds)
+            derived_edges += int(flushed["derived_edges"])
+            rule_count += int(flushed["rule_count"])
+        else:
+            self.graph.commit()
+        purged_units = 0
+        if purge_after_digest:
+            purged_units = self.graph.purge_digested_raw_units(commit=True)
+        return {
+            "processed_units": processed_units,
+            "total_units": total_units,
+            "learned_edges": learned_edges,
+            "derived_edges": derived_edges,
+            "rule_count": rule_count,
+            "purged_units": purged_units,
+        }
+
+    def flush_learning(
+        self,
+        *,
+        min_support: int = 2,
+        reason_rounds: int = 4,
+        induce_min_support: int | None = None,
+    ) -> dict[str, int]:
+        rules = self.abstraction.materialize_rules(min_support=min_support)
+        derived = self.reasoner.materialize(
+            max_rounds=reason_rounds,
+            induce_min_support=induce_min_support if induce_min_support is not None else min_support,
+        )
+        self.graph.commit()
+        return {"rule_count": len(rules), "derived_edges": len(derived)}
+
+    def learn_document(self, title: str, text: str) -> dict[str, object]:
+        selection = self.document_gate.select(title, text)
+        if not selection.accepted:
+            return {"learned_edges": [], "derived_edges": [], "rule_count": 0, "lexicon": [], "reason": selection.reason}
+        learned_edges: list[int] = []
+        derived_edges: list[int] = []
+        rule_count = 0
+        lexicon: list[dict[str, object]] = []
+        for unit in selection.units:
+            learned = self.learn_fast(unit)
+            learned_edges.extend(learned["learned_edges"])
+            lexicon.extend(learned["lexicon"])
+        flushed = self.flush_learning()
+        derived_count = int(flushed["derived_edges"])
+        if derived_count:
+            derived_edges = [0] * derived_count
+        rule_count = int(flushed["rule_count"])
+        return {
+            "learned_edges": learned_edges,
+            "derived_edges": derived_edges,
+            "rule_count": rule_count,
+            "lexicon": lexicon,
+            "reason": selection.reason,
+            "units": list(selection.units),
+        }
+
+    def learn_jsonl(self, path: str) -> dict[str, int]:
+        source = Path(path)
+        rows = 0
+        facts = 0
+        with source.open("r", encoding="utf-8") as handle:
+            for line in handle:
+                row = json.loads(line)
+                title = str(row.get("title", "")).strip()
+                text = str(row.get("text", "")).strip()
+                if title or text:
+                    learned = self.learn_document(title, text)
+                    if learned["learned_edges"]:
+                        facts += 1
+                for field in ("memory", "facts", "fact"):
+                    payload = row.get(field)
+                    if isinstance(payload, str) and payload.strip():
+                        self.learn(payload)
+                        facts += 1
+                    elif isinstance(payload, list):
+                        for item in payload:
+                            if isinstance(item, str) and item.strip():
+                                self.learn(item)
+                                facts += 1
+                rows += 1
+        return {"rows": rows, "facts": facts}
+
+    def ask(self, query: str) -> NativeResponse:
+        parts = self._split_query_parts(query)
+        if len(parts) > 1:
+            responses = [self.ask(part) for part in parts]
+            return NativeResponse(
+                answer=" | ".join(response.answer for response in responses),
+                text=" ".join(response.text for response in responses if response.text),
+                explanation=" ".join(response.explanation for response in responses if response.explanation),
+                proof=tuple(step for response in responses for step in response.proof),
+                reasoning=tuple(step for response in responses for step in response.reasoning),
+                mode="multi",
+            )
+        self.surface.advance_response_state()
+        result = self.query_engine.answer(query)
+        if result is None:
+            return NativeResponse(
+                answer="<unknown>",
+                text=self.surface.verbalize_result(query, None),
+                explanation=self.surface.explain_result(query, None),
+                proof=(),
+                reasoning=(),
+                mode="unknown",
+            )
+        return self._render(query, result)
+
+    def inspect(self, text: str) -> list[dict[str, object]]:
+        return self.codec.export_tokens(text)
+
+    def capacity(self) -> dict[str, int]:
+        if self.graph.db_path != ":memory:":
+            return StructuralCapacityMeter.from_sqlite(self.graph.db_path).to_metadata()
+
+        import sqlite3
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir) / "graph.sqlite3"
+            destination = sqlite3.connect(str(temp_path))
+            try:
+                self.graph.conn.backup(destination)
+            finally:
+                destination.close()
+            return StructuralCapacityMeter.from_sqlite(temp_path).to_metadata()
+
+    def close(self) -> None:
+        self.graph.close()
+
+    def _render(self, query: str, result: QueryResult) -> NativeResponse:
+        return NativeResponse(
+            answer=result.answer,
+            text=self.surface.verbalize_result(query, result),
+            explanation=self.surface.explain_result(query, result),
+            proof=result.proof,
+            reasoning=result.reasoning,
+            mode=result.mode,
+        )
+
+    @staticmethod
+    def _split_query_parts(query: str) -> list[str]:
+        parts: list[str] = []
+        for part in re.split(
+            r"(?:\?\s+|\?\s*$|(?:\s+and\s+also\s+)|(?:\s+also\s+)|(?:\s*;\s*)|(?:\s+then\s+)|(?:\r?\n+))",
+            query,
+        ):
+            cleaned = part.strip()
+            cleaned = re.sub(r"^(?:also|and)\s+", "", cleaned, flags=re.IGNORECASE)
+            cleaned = re.sub(r"\s+", " ", cleaned).strip(" ?!.")
+            if cleaned:
+                parts.append(cleaned)
+        if len(parts) <= 1:
+            return [query.strip()]
+        return [part if part.endswith("?") else f"{part}?" for part in parts]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run the first real no-weight Aethon native base.")
+    parser.add_argument("--db-path", type=str, default=":memory:")
+    parser.add_argument("--learn", action="append", default=[])
+    parser.add_argument("--learn-jsonl", type=str, default="")
+    parser.add_argument("--ask", action="append", default=[])
+    parser.add_argument("--inspect", type=str, default="")
+    parser.add_argument("--capacity", action="store_true")
+    parser.add_argument("--save-bundle", type=str, default="")
+    parser.add_argument("--load-bundle", type=str, default="")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    runtime = NativeBundleManager.load(args.load_bundle) if args.load_bundle else AethonNativeBase(db_path=args.db_path)
+    try:
+        for fact in args.learn:
+            learned = runtime.learn(fact)
+            print(f"learned_edges={len(learned['learned_edges'])} derived_edges={len(learned['derived_edges'])} rule_count={learned['rule_count']}")
+        if args.learn_jsonl:
+            stats = runtime.learn_jsonl(args.learn_jsonl)
+            print(f"learned_rows={stats['rows']} learned_facts={stats['facts']}")
+        if args.inspect:
+            print(json.dumps(runtime.inspect(args.inspect), indent=2))
+        if args.capacity:
+            print(json.dumps(runtime.capacity(), indent=2))
+        for query in args.ask:
+            response = runtime.ask(query)
+            print(f"Q: {query}")
+            print(f"A: {response.answer}")
+            print(f"mode: {response.mode}")
+            print(f"text: {response.text}")
+            print(f"explain: {response.explanation}")
+            if response.reasoning:
+                print("reasoning:")
+                for step in response.reasoning:
+                    print(f"  - {step}")
+            if response.proof:
+                print("proof:")
+                for step in response.proof:
+                    print(f"  - {step}")
+        if args.save_bundle:
+            bundle = NativeBundleManager.save(runtime, args.save_bundle)
+            print(f"bundle={bundle}")
+    finally:
+        runtime.close()
+
+
+if __name__ == "__main__":
+    main()

runtime/aethon/rfi_semantics.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class SemanticEntry:
+    kind: str
+    symbol: str
+    meaning: str
+
+
+class NativeSemanticLexicon:
+    """Loads semantic normalization units from native data files instead of burying them in code."""
+
+    DEFAULT_PATH = Path(__file__).resolve().parents[1] / "data" / "native" / "semantics" / "aethon_semantic_lexicon_v1.jsonl"
+
+    def __init__(self, path: str | Path | None = None, payload: list[dict[str, str]] | None = None) -> None:
+        self.path = Path(path) if path is not None else self.DEFAULT_PATH
+        self.entries = self._load_entries(payload)
+        self.emoji_map = {entry.symbol: entry.meaning for entry in self.entries if entry.kind == "emoji"}
+        self.abbreviation_map = {entry.symbol.lower(): entry.meaning for entry in self.entries if entry.kind == "abbreviation"}
+        self.alias_map = {
+            entry.symbol.lower(): entry.meaning
+            for entry in self.entries
+            if entry.kind in {"abbreviation", "semantic_alias", "multilingual_alias"}
+        }
+        self.phrase_alias_map = {
+            entry.symbol.lower(): entry.meaning
+            for entry in self.entries
+            if entry.kind in {"phrase_alias", "multilingual_phrase"}
+        }
+        self.typo_map = {entry.symbol.lower(): entry.meaning for entry in self.entries if entry.kind == "typo"}
+        self.relation_prepositions = {
+            entry.symbol.lower()
+            for entry in self.entries
+            if entry.kind == "relation_preposition"
+        }
+        self.query_fillers = {
+            entry.symbol.lower()
+            for entry in self.entries
+            if entry.kind == "query_filler"
+        }
+
+    def _load_entries(self, payload: list[dict[str, str]] | None) -> tuple[SemanticEntry, ...]:
+        if payload is not None:
+            return tuple(self._entry_from_row(row) for row in payload)
+        if not self.path.exists():
+            return ()
+        entries: list[SemanticEntry] = []
+        with self.path.open("r", encoding="utf-8") as handle:
+            for line in handle:
+                entries.append(self._entry_from_row(json.loads(line)))
+        return tuple(entries)
+
+    @staticmethod
+    def _entry_from_row(row: dict[str, str]) -> SemanticEntry:
+        return SemanticEntry(
+            kind=str(row["kind"]).strip(),
+            symbol=str(row["symbol"]).strip(),
+            meaning=str(row["meaning"]).strip(),
+        )
+
+    def to_payload(self) -> list[dict[str, str]]:
+        return [
+            {
+                "kind": entry.kind,
+                "symbol": entry.symbol,
+                "meaning": entry.meaning,
+            }
+            for entry in self.entries
+        ]
+
+    def describe_emojis(self, text: str) -> list[tuple[str, str]]:
+        seen: list[tuple[str, str]] = []
+        for emoji, meaning in self.emoji_map.items():
+            if emoji in text and (emoji, meaning) not in seen:
+                seen.append((emoji, meaning))
+        return seen

runtime/aethon/rfi_surface.py

@@ -0,0 +1,546 @@
+from __future__ import annotations
+
+from .rfi_graph import RelationalGraphStore
+from .rfi_query import QueryResult
+from .rfi_surface_lexicon import NativeSurfaceLexicon
+
+
+class GraphVerbalizer:
+    """Turns proof-backed query results into direct language without weight-based decoding."""
+
+    def __init__(
+        self,
+        surface_lexicon_path: str | None = None,
+        surface_lexicon_payload: dict | None = None,
+        graph: RelationalGraphStore | None = None,
+    ) -> None:
+        self.lexicon = NativeSurfaceLexicon(surface_lexicon_path, surface_lexicon_payload)
+        self.graph = graph
+        self.response_index = 0
+        self.response_history: dict[str, list[str]] = {}
+
+    def advance_response_state(self) -> None:
+        self.response_index += 1
+
+    def verbalize_result(self, query: str, result: QueryResult | None) -> str:
+        if result is None:
+            return f"I cannot ground an answer to '{query}' from what I currently know."
+        history_key = f"text::{query}::{result.mode}::{result.answer}"
+        if result.mode == "direct":
+            if result.proof and result.proof[0].startswith("emoji:"):
+                return f"The emoji you used is {self._humanize(result.answer)}."
+            supports = self._proof_sentences(result)
+            if supports:
+                return self._compose_support_paragraph(query + result.answer, supports, self._humanize(result.answer))
+            return self._sentence(self._humanize(result.answer))
+        if result.mode == "derived":
+            if result.proof and result.proof[0].startswith("math:"):
+                candidates = (
+                    f"I computed the exact answer as {self._humanize(result.answer)}.",
+                    f"The exact result is {self._humanize(result.answer)}. I reached it by direct computation.",
+                    f"I evaluated the arithmetic structure and got {self._humanize(result.answer)}.",
+                    f"My computation resolves to {self._humanize(result.answer)}.",
+                    f"Working through the arithmetic gives {self._humanize(result.answer)}.",
+                    f"I solve the structure exactly and end at {self._humanize(result.answer)}.",
+                )
+                return self._choose_novel(history_key, candidates)
+            supports = self._proof_sentences(result)
+            if supports:
+                return self._compose_support_paragraph(query + result.answer, supports, self._humanize(result.answer))
+            candidates = (
+                f"I derive the answer as {self._humanize(result.answer)} from stored relations.",
+                f"My structural reasoning leads me to {self._humanize(result.answer)}.",
+                f"I do not retrieve {self._humanize(result.answer)} directly; I derive it from linked relations.",
+            )
+            return self._choose_novel(history_key, candidates)
+        if result.mode == "composed":
+            subject = self._subject_from_query(query)
+            if subject is not None:
+                supports = [self._proof_line_to_sentence(step) for step in result.proof if self._proof_line_to_sentence(step)]
+                if supports:
+                    return self._compose_support_paragraph(query + result.answer, supports, self._humanize(result.answer))
+            candidates = (
+                f"I connect the stored facts to answer with {self._humanize(result.answer)}.",
+                f"My answer is {self._humanize(result.answer)} because several linked facts converge on it.",
+                f"I compose multiple facts and end at {self._humanize(result.answer)}.",
+            )
+            return self._choose_novel(history_key, candidates)
+        if result.mode == "path":
+            supports = self._proof_sentences(result)
+            if supports:
+                return self._compose_support_paragraph(query + result.answer, supports, self._humanize(self._path_text(result.answer)))
+            path = self._humanize(self._path_text(result.answer))
+            return self._choose_novel(
+                history_key,
+                (
+                    f"I connect them through {path}.",
+                    f"The path between them runs through {path}.",
+                    f"My reasoning links them by way of {path}.",
+                ),
+            )
+        if result.mode == "plan":
+            supports = self._proof_sentences(result)
+            if supports:
+                return self._compose_support_paragraph(query + result.answer + "::plan", supports, self._humanize(result.answer))
+            return self._choose_novel(
+                history_key,
+                (
+                    f"The next grounded step is {self._humanize(result.answer)}.",
+                    f"My planning chain points to {self._humanize(result.answer)} first.",
+                    f"The structure says {self._humanize(result.answer)} should happen next.",
+                ),
+            )
+        if result.mode == "story":
+            supports = self._proof_sentences(result)
+            if supports:
+                return self._compose_story_paragraph(query + result.answer + "::story", supports)
+            return self._choose_novel(
+                history_key,
+                (
+                    f"I can ground a story around {self._humanize(result.answer)} from the graph, but I need more concrete events to tell it richly.",
+                    f"The graph mentions {self._humanize(result.answer)}, though I would need more events to narrate a fuller story.",
+                ),
+            )
+        if result.mode == "revision":
+            relation, transition = result.answer.split(":", 1)
+            previous_value, new_value = transition.split("->", 1)
+            return (
+                f"The stored {relation.replace('_', ' ')} changed from "
+                f"{self._humanize(previous_value)} to {self._humanize(new_value)}."
+            )
+        if result.mode == "contradiction":
+            return "Yes. The graph contains a revision or contradiction for that subject."
+        if result.mode == "abstract":
+            return self._compose_abstract_answer(result)
+        if result.mode == "ontology":
+            return f"{self._humanize(result.answer)}."
+        return f"{self._humanize(result.answer)}."
+
+    def verbalize_edge(self, subject: str, relation: str, object_value: str) -> str:
+        if subject == "aethon":
+            return self._compose_self_sentence(relation, object_value)
+        return self._compose_relation_sentence(subject, relation, object_value)
+
+    def verbalize_proof(self, result: QueryResult | None) -> str:
+        if result is None or not result.proof:
+            return "No proof trace is available."
+        lines = ["Proof trace:"]
+        for step in result.proof:
+            lines.append(f"- {step}")
+        return "\n".join(lines)
+
+    def verbalize_reasoning(self, result: QueryResult | None) -> str:
+        if result is None or not result.reasoning:
+            return "No reasoning steps are available."
+        intros = (
+            "I reason through the graph like this:",
+            "My reasoning chain is:",
+            "I connect the stored facts in this order:",
+        )
+        intro = intros[self.response_index % len(intros)]
+        lines = [intro]
+        for step in result.reasoning:
+            lines.append(f"- {step}")
+        return "\n".join(lines)
+
+    def explain_result(self, query: str, result: QueryResult | None) -> str:
+        if result is None:
+            return f"I do not have enough grounded structure yet to answer '{query}'."
+        edge = self._first_edge(result)
+        history_key = f"explain::{query}::{result.mode}::{result.answer}"
+        if result.mode in {"direct", "ontology"}:
+            if result.proof and result.proof[0].startswith("emoji:"):
+                return f"I identified {self._humanize(result.answer)} directly from the symbols in your message."
+            supports = self._proof_sentences(result)
+            if supports:
+                return self._compose_support_paragraph(query + result.answer + "::explain", supports, self._humanize(result.answer))
+            if edge is None:
+                return self.verbalize_result(query, result)
+            return self.verbalize_result(query, result)
+        if result.mode == "derived":
+            if not result.proof:
+                return self.verbalize_result(query, result)
+            proof = result.proof[0]
+            if proof.startswith("math:"):
+                return self._choose_novel(
+                    history_key,
+                    (
+                        f"I reached {self._humanize(result.answer)} by evaluating the arithmetic structure directly instead of guessing.",
+                        f"The result {self._humanize(result.answer)} comes from exact computation over the expression.",
+                        f"I solved the expression structurally, which yields {self._humanize(result.answer)}.",
+                    ),
+                )
+            if proof.startswith("derived:"):
+                supports = self._derived_support_lines(proof)
+                if supports:
+                    return self._compose_support_paragraph(
+                        query + result.answer + proof,
+                        supports,
+                        self._humanize(result.answer),
+                    )
+                detail = proof.split("|", 1)[-1]
+                return (
+                    f"The answer is {self._humanize(result.answer)} because Aethon derived a new fact from "
+                    f"earlier stored relations: {self._humanize(detail)}."
+                )
+            return self.verbalize_result(query, result)
+        if result.mode == "composed":
+            supports = [self._proof_line_to_sentence(step) for step in result.proof if self._proof_line_to_sentence(step)]
+            if supports:
+                return self._compose_support_paragraph(
+                    query + result.answer + "".join(result.proof),
+                    supports,
+                    self._humanize(result.answer),
+                )
+            return f"The answer is {self._humanize(result.answer)} because multiple linked facts point to it."
+        if result.mode == "path":
+            supports = self._proof_sentences(result)
+            if supports:
+                return self._compose_support_paragraph(query + result.answer + "::path", supports, self._humanize(self._path_text(result.answer)))
+            if not result.proof:
+                return self.verbalize_result(query, result)
+            relation_chain = " then ".join(self._humanize(self._extract_relation(step) or step) for step in result.proof)
+            return f"I connect the concepts by following {relation_chain}."
+        if result.mode == "plan":
+            supports = self._proof_sentences(result)
+            if supports:
+                return self._compose_support_paragraph(query + result.answer + "::plan_explain", supports, self._humanize(result.answer))
+            return f"The planning structure points to {self._humanize(result.answer)} as the next grounded step."
+        if result.mode == "story":
+            supports = self._proof_sentences(result)
+            if supports:
+                return self._compose_story_paragraph(query + result.answer + "::story_explain", supports)
+            return f"I need more concrete events about {self._humanize(result.answer)} before I can extend the story further."
+        if result.mode == "abstract":
+            return self._compose_abstract_explanation(result)
+        if result.mode == "revision":
+            return self.verbalize_result(query, result)
+        if result.mode == "contradiction":
+            return self.verbalize_result(query, result)
+        return self.verbalize_result(query, result)
+
+    @staticmethod
+    def _plain_humanize(text: str) -> str:
+        return text.replace("_", " ")
+
+    def _humanize(self, text: str) -> str:
+        if self.graph is not None and text and all(char.islower() or char.isdigit() or char == "_" for char in text):
+            return self.graph.get_display_name(text)
+        return self._plain_humanize(text)
+
+    def _sentence(self, text: str) -> str:
+        cleaned = text.strip()
+        if not cleaned:
+            return ""
+        cleaned = cleaned[0].upper() + cleaned[1:]
+        if cleaned[-1] not in ".!?":
+            cleaned += "."
+        return cleaned
+
+    @staticmethod
+    def _lower_sentence(text: str) -> str:
+        cleaned = text.strip()
+        if not cleaned:
+            return ""
+        if cleaned[-1] in ".!?":
+            cleaned = cleaned[:-1]
+        lowered = cleaned[0].lower() + cleaned[1:] if cleaned else ""
+        words = lowered.split()
+        return " ".join("I" if word == "i" else word for word in words)
+
+    def _first_edge(self, result: QueryResult | None) -> tuple[str, str, str] | None:
+        if result is None:
+            return None
+        for step in result.proof:
+            parsed = self._parse_edge(step)
+            if parsed is not None:
+                return parsed
+        return None
+
+    def _parse_edge(self, proof_line: str) -> tuple[str, str, str] | None:
+        if "-[" not in proof_line or "]->" not in proof_line:
+            return None
+        payload = proof_line.split("|", 1)[0]
+        _, edge = payload.split(":", 1)
+        subject, rest = edge.split("-[", 1)
+        relation, object_value = rest.split("]->", 1)
+        return subject, relation, object_value
+
+    def _proof_line_to_sentence(self, proof_line: str) -> str | None:
+        parsed = self._parse_edge(proof_line)
+        if parsed is not None:
+            subject, relation, object_value = parsed
+            return self.verbalize_edge(subject, relation, object_value)
+        if proof_line.startswith("compose:"):
+            return "Aethon combined linked facts to reach the final answer"
+        if proof_line.startswith("ontology:"):
+            payload = proof_line.split(":", 1)[1]
+            subject, _, object_value = payload.partition("->is_a->")
+            return f"{self._humanize(subject)} belongs to the class {self._humanize(object_value)}"
+        return None
+
+    def _derived_support_lines(self, proof_line: str) -> list[str]:
+        parts = proof_line.split("|")
+        supports: list[str] = []
+        seen: set[str] = set()
+        for part in parts[1:]:
+            parsed = self._parse_edge(f"derived:{part}") if "-[" in part and "]->" in part else None
+            if parsed is not None:
+                subject, relation, object_value = parsed
+                sentence = self.verbalize_edge(subject, relation, object_value)
+                if sentence not in seen:
+                    supports.append(sentence)
+                    seen.add(sentence)
+        return supports
+
+    def _proof_sentences(self, result: QueryResult) -> list[str]:
+        supports: list[str] = []
+        seen: set[str] = set()
+        for step in result.proof:
+            if step.startswith("derived:"):
+                for line in self._derived_support_lines(step):
+                    if line not in seen:
+                        supports.append(line)
+                        seen.add(line)
+                continue
+            sentence = self._proof_line_to_sentence(step)
+            if sentence and sentence not in seen:
+                supports.append(sentence)
+                seen.add(sentence)
+        return supports
+
+    def _extract_relation(self, proof_line: str) -> str | None:
+        parsed = self._parse_edge(proof_line)
+        if parsed is None:
+            return None
+        return parsed[1]
+
+    def _path_text(self, relation_chain: str) -> str:
+        pieces = [self._humanize(piece.strip()) for piece in relation_chain.split("->")]
+        if not pieces:
+            return relation_chain
+        if len(pieces) == 1:
+            return pieces[0]
+        return ", then ".join(pieces)
+
+    def _subject_from_query(self, query: str) -> str | None:
+        lowered = query.strip().rstrip(" ?")
+        words = lowered.split()
+        if len(words) >= 3 and words[:2] == ["where", "is"]:
+            return " ".join(words[2:])
+        if len(words) >= 4 and words[:2] == ["where", "does"]:
+            return words[2]
+        if len(words) >= 4 and words[:2] == ["what", "does"]:
+            return words[2]
+        if len(words) >= 4 and words[:2] == ["what", "did"]:
+            return words[2]
+        if len(words) >= 4 and words[:2] == ["what", "is"] and words[-1] == "carrying":
+            return " ".join(words[2:-1])
+        if len(words) >= 5 and words[:2] == ["which", "animal"] and "watch" in words:
+            watch_index = words.index("watch")
+            return " ".join(words[3:watch_index]) if watch_index > 3 else None
+        return None
+
+    def _compose_support_paragraph(self, seed: str, supports: list[str], answer: str) -> str:
+        cleaned = [self._sentence(line) for line in supports if line.strip()]
+        if not cleaned:
+            summaries = tuple(variant.format(answer=answer) for variant in self.lexicon.support_summary_variants)
+            if summaries:
+                return self._choose_novel(f"support::{seed}::{answer}", summaries)
+            return f"So I answer {answer}."
+        summaries = tuple(variant.format(answer=answer) for variant in self.lexicon.support_summary_variants)
+        candidates: list[str] = []
+        connectors = self.lexicon.support_connectors or ("Then",)
+        first_sentence = cleaned[0]
+        lowered_first = self._lower_sentence(first_sentence)
+        openings = (
+            first_sentence,
+            f"I start from this fact: {lowered_first}.",
+            f"The graph first gives me this: {lowered_first}.",
+            f"One grounded fact is that {lowered_first}.",
+            f"I begin with {lowered_first}.",
+            f"My first support fact is that {lowered_first}.",
+        )
+        reflections = (
+            f"Across that proof, the same answer keeps surfacing: {answer}.",
+            f"The linked structure stays consistent all the way to {answer}.",
+            f"Nothing in that chain breaks the answer {answer}.",
+            f"Those connected facts keep reinforcing {answer}.",
+        )
+        for offset in range(min(max(len(connectors), 1), 6)):
+            for opening in openings:
+                pieces = [opening]
+                for index, line in enumerate(cleaned[1:], start=1):
+                    connector = connectors[(offset + index - 1) % len(connectors)]
+                    pieces.append(f"{connector}, {self._lower_sentence(line)}.")
+                reflection = reflections[(offset + len(opening)) % len(reflections)]
+                pieces.append(reflection)
+                summary = summaries[(offset + len(candidates)) % len(summaries)] if summaries else f"So I answer {answer}."
+                pieces.append(summary)
+                candidates.append(" ".join(pieces))
+        return self._choose_novel(f"support::{seed}::{answer}", tuple(candidates))
+
+    def _compose_story_paragraph(self, seed: str, supports: list[str]) -> str:
+        cleaned = [self._sentence(line) for line in supports if line.strip()]
+        if not cleaned:
+            return ""
+        intros = (
+            "Here is the grounded story I can tell.",
+            "The graph lets me tell the story this way.",
+            "I can narrate the stored story like this.",
+        )
+        closers = (
+            "That is the grounded thread I can recover from what Aethon remembers.",
+            "Those events stay connected in memory, so the story holds together.",
+            "That sequence is how the stored events unfold in Aethon's graph.",
+        )
+        intro = self._choose_novel(f"story-intro::{seed}", intros)
+        closer = self._choose_novel(f"story-close::{seed}", closers)
+        body = " ".join(cleaned)
+        return f"{intro} {body} {closer}"
+
+    def _compose_abstract_answer(self, result: QueryResult) -> str:
+        explanation = self._compose_abstract_explanation(result)
+        if explanation:
+            return explanation
+        return f"I generalize the answer as {self._humanize(result.answer)}."
+
+    def _compose_abstract_explanation(self, result: QueryResult) -> str:
+        if not result.proof:
+            return f"I generalize the answer as {self._humanize(result.answer)}."
+        pieces: list[str] = []
+        seen: set[str] = set()
+        for step in result.proof:
+            sentence = self._abstract_proof_to_sentence(step)
+            if sentence and sentence not in seen:
+                pieces.append(sentence)
+                seen.add(sentence)
+        if not pieces:
+            return f"I generalize the answer as {self._humanize(result.answer)}."
+        closers = (
+            f"So I answer {self._humanize(result.answer)}.",
+            f"That is why I generalize the answer as {self._humanize(result.answer)}.",
+            f"So my generalized answer is {self._humanize(result.answer)}.",
+            f"That chain lets me answer with {self._humanize(result.answer)}.",
+        )
+        candidates = []
+        for offset in range(min(max(len(closers), 1), 6)):
+            ordered = list(pieces[offset % len(pieces):]) + list(pieces[:offset % len(pieces)])
+            rendered = " ".join(self._sentence(piece) for piece in ordered)
+            candidates.append(f"{rendered} {closers[offset % len(closers)]}")
+        return self._choose_novel(f"abstract::{result.answer}::{''.join(result.proof)}", tuple(candidates))
+
+    def _abstract_proof_to_sentence(self, proof_line: str) -> str | None:
+        if proof_line.startswith("abstract:"):
+            parsed = self._parse_edge(proof_line)
+            if parsed is None:
+                return None
+            subject, relation, object_value = parsed
+            return f"I know that {self._humanize(subject)} {relation.replace('_', ' ')} {self._humanize(object_value)}"
+        if proof_line.startswith("subject:") or proof_line.startswith("object:"):
+            payload = proof_line.split(":", 1)[1]
+            concept, _, parent = payload.partition("->is_a->")
+            if concept and parent:
+                return f"{self._humanize(concept)} belongs to {self._humanize(parent)}"
+        if proof_line.startswith("ontology:"):
+            payload = proof_line.split(":", 1)[1]
+            concept, _, parent = payload.partition("->is_a->")
+            if concept and parent:
+                return f"{self._humanize(concept)} belongs to {self._humanize(parent)}"
+        return None
+
+    @staticmethod
+    def _choose(seed: str, options: tuple[str, ...]) -> str:
+        if not options:
+            return ""
+        return options[sum(ord(char) for char in seed) % len(options)]
+
+    def _choose_novel(self, key: str, candidates: tuple[str, ...]) -> str:
+        if not candidates:
+            return ""
+        history = self.response_history.setdefault(key, [])
+        for candidate in candidates:
+            if candidate not in history:
+                history.append(candidate)
+                if len(history) > 24:
+                    del history[:-24]
+                return candidate
+        choice = candidates[self.response_index % len(candidates)]
+        history.append(choice)
+        if len(history) > 24:
+            del history[:-24]
+        return choice
+
+    def _compose_relation_sentence(self, subject: str, relation: str, object_value: str) -> str:
+        subject_text = self._humanize(subject)
+        object_text = self._humanize(object_value)
+        tokens = relation.split("_")
+        head = tokens[0] if tokens else relation
+        tail = " ".join(tokens[1:])
+
+        if relation in {"is_a", "be"}:
+            return f"{subject_text} is {self._article(object_text)} {object_text}"
+        if relation.endswith("_in"):
+            verb = head if head not in {"located", "lives", "work"} else {
+                "located": "is located",
+                "lives": "lives",
+                "work": "works",
+            }.get(head, head)
+            return f"{subject_text} {verb} in {object_text}"
+        if relation in {"return", "return_value"}:
+            return f"{subject_text} returns {object_text}"
+        if relation == "depend_on":
+            return f"{subject_text} depends on {object_text}"
+        if relation == "prefer":
+            return f"{subject_text} prefers {object_text}"
+        if relation == "not_like_anymore":
+            return f"{subject_text} no longer likes {object_text}"
+        if relation == "contains":
+            return f"{subject_text} contains {object_text}"
+        if relation == "home_of":
+            return f"{subject_text} is the home of {object_text}"
+        if relation == "purchase_site_of":
+            return f"{subject_text} is where {object_text} was bought"
+        if relation == "chased_by":
+            return f"{subject_text} is chased by {object_text}"
+        if relation == "attacked_by":
+            return f"{subject_text} is attacked by {object_text}"
+        if relation == "watched_by":
+            return f"{subject_text} is watched by {object_text}"
+        if relation == "kept_by":
+            return f"{subject_text} is kept by {object_text}"
+        if relation == "carried_by":
+            return f"{subject_text} is carried by {object_text}"
+        if tail:
+            return f"{subject_text} {head} {tail} {object_text}"
+        return f"{subject_text} {head}s {object_text}" if not head.endswith("s") else f"{subject_text} {head} {object_text}"
+
+    def _compose_self_sentence(self, relation: str, object_value: str) -> str:
+        object_text = self._humanize(object_value)
+        if relation in {"is_a", "be"}:
+            return f"I am {self._article(object_text)} {object_text}"
+        if relation == "use":
+            return f"I use {object_text}"
+        if relation == "report":
+            return f"I report {object_text}"
+        if relation == "depend_on":
+            return f"I depend on {object_text}"
+        if relation == "prefer":
+            return f"I prefer {object_text}"
+        if relation == "like":
+            return f"I like {object_text}"
+        if relation == "equals":
+            return f"My value is {object_text}"
+        if relation.endswith("_in"):
+            head = relation.split("_", 1)[0]
+            return f"I {head} in {object_text}"
+        tokens = relation.split("_")
+        if len(tokens) > 1:
+            return f"I {' '.join(tokens)} {object_text}"
+        return f"I {relation} {object_text}"
+
+    @staticmethod
+    def _article(text: str) -> str:
+        if not text:
+            return "a"
+        return "an" if text[0].lower() in {"a", "e", "i", "o", "u"} else "a"

runtime/aethon/rfi_surface_lexicon.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+class NativeSurfaceLexicon:
+    """Loads Aethon surface templates and phrasing variants from native data."""
+
+    DEFAULT_PATH = Path(__file__).resolve().parents[1] / "data" / "native" / "surface" / "aethon_surface_lexicon_v1.json"
+
+    def __init__(self, path: str | Path | None = None, payload: dict | None = None) -> None:
+        self.path = Path(path) if path is not None else self.DEFAULT_PATH
+        self.payload = self._load_payload(payload)
+        self.relation_templates: dict[str, str] = self.payload.get("relation_templates", {})
+        self.self_relation_templates: dict[str, str] = self.payload.get("self_relation_templates", {})
+        self.direct_fact_variants: tuple[str, ...] = tuple(self.payload.get("direct_fact_variants", ()))
+        self.direct_self_variants: tuple[str, ...] = tuple(self.payload.get("direct_self_variants", ()))
+        self.direct_emoji_variants: tuple[str, ...] = tuple(self.payload.get("direct_emoji_variants", ()))
+        self.direct_unknown_variants: tuple[str, ...] = tuple(self.payload.get("direct_unknown_variants", ()))
+        self.derived_math_variants: tuple[str, ...] = tuple(self.payload.get("derived_math_variants", ()))
+        self.derived_fact_variants: tuple[str, ...] = tuple(self.payload.get("derived_fact_variants", ()))
+        self.derived_fallback_variants: tuple[str, ...] = tuple(self.payload.get("derived_fallback_variants", ()))
+        self.composed_variants: tuple[str, ...] = tuple(self.payload.get("composed_variants", ()))
+        self.path_variants: tuple[str, ...] = tuple(self.payload.get("path_variants", ()))
+        self.abstract_variants: tuple[str, ...] = tuple(self.payload.get("abstract_variants", ()))
+        self.explain_unknown_variants: tuple[str, ...] = tuple(self.payload.get("explain_unknown_variants", ()))
+        self.explain_emoji_variants: tuple[str, ...] = tuple(self.payload.get("explain_emoji_variants", ()))
+        self.explain_math_variants: tuple[str, ...] = tuple(self.payload.get("explain_math_variants", ()))
+        self.support_connectors: tuple[str, ...] = tuple(self.payload.get("support_connectors", ()))
+        self.support_summary_variants: tuple[str, ...] = tuple(self.payload.get("support_summary_variants", ()))
+        self.path_explain_variants: tuple[str, ...] = tuple(self.payload.get("path_explain_variants", ()))
+        self.reasoning_intro_variants: tuple[str, ...] = tuple(self.payload.get("reasoning_intro_variants", ()))
+
+    def _load_payload(self, payload: dict | None) -> dict:
+        if payload is not None:
+            return payload
+        if not self.path.exists():
+            return {}
+        return json.loads(self.path.read_text(encoding="utf-8"))
+
+    def to_payload(self) -> dict:
+        return dict(self.payload)