Update Open Structure release to v26 with HH-RLHF and religion data

README.md

@@ -232,10 +232,6 @@ Portable runtime included in the release:
 - `run_aethon.py`
 - `runtime/aethon/...`
 
-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 or thin adapter.
-
 ## Prompt Examples
 
 These are examples, not a closed menu.
@@ -268,21 +264,21 @@ People should be able to ask in their own words.
 
 | Item | Value |
 | --- | --- |
-| Bundle | `aethon_n1_base_full_parallel_v25_hle` |
+| Bundle | `aethon_n1_base_full_parallel_v26` |
 | Public contract | `aethon.n1.bundle.v1` |
 | Release class | `open-structure` |
 | Size unit | `Structural Capacity (SC)` |
-| SC | `67,914` |
-| Concepts | `13,501` |
-| Explicit relations | `52,701` |
-| Abstractions | `1,712` |
+| SC | `112,897` |
+| Concepts | `27,344` |
+| Explicit relations | `81,899` |
+| Abstractions | `3,654` |
 | Raw unit residue | `0` |
 
 ### Native Benchmark Wall
 
 | Suite | Result | Accuracy | Time |
 | --- | --- | --- | --- |
-| `aethon_n1_benchmark_v6.jsonl` | `43 / 43` | `1.0` | `3.499s` |
+| `aethon_n1_benchmark_v6.jsonl` | `43 / 43` | `1.0` | `3.476s` |
 
 ### What This Wall Covers
 
@@ -308,6 +304,8 @@ The ship corpus includes:
 - Aethon native identity, code, math, story, and reasoning corpora
 - Aethon AGI transfer corpora
 - Humanity's Last Exam transfer corpus
+- Anthropic HH-RLHF instruction and safety corpus
+- theology and religion grounding corpora
 - curated reasoning bases
 - multilingual base mixes
 - code and tool-use corpora

bundle/corpus_manifest.json

@@ -35,6 +35,7 @@
       "data/chat/aethon_logic_curriculum_v1.jsonl",
       "data/chat/aethon_exact_answer_chat.jsonl",
       "data/chat/aethon_exact_control_v1.jsonl",
+      "data/chat/clean/anthropic_hh_rlhf_clean.jsonl",
       "data/reasoning_corpora/clean/advanced_python_cot.jsonl",
       "data/reasoning_corpora/clean/aethon_bootstrap_mix.jsonl",
       "data/reasoning_corpora/clean/am_deepseek_r1_distilled.jsonl",
@@ -69,9 +70,12 @@
       "data/chat/aethon_reasoning_chat_bootstrap.jsonl",
       "data/chat/aethon_copy_probe_v1.jsonl",
       "data/chat/aethon_speakback_chat.jsonl",
-      "data/chat/aethon_truthful_chat_bootstrap.jsonl"
+      "data/chat/aethon_truthful_chat_bootstrap.jsonl",
+      "data/chat/clean/anthropic_hh_rlhf_clean.jsonl",
+      "data/chat/clean/aethon_religion_chat_v1.jsonl"
     ],
     "world": [
+      "data/native/world/aethon_religion_world_v1.jsonl",
       "data/world_knowledge/clean/structured_wikipedia_en.jsonl",
       "data/world_knowledge/clean/fineweb_edu_sample.jsonl",
       "data/world_knowledge/clean/cosmopedia_web.jsonl",
@@ -80,6 +84,8 @@
       "data/world_knowledge/clean/masakhanews_pcm.jsonl",
       "data/world_knowledge/clean/masakhanews_hau.jsonl",
       "data/base/aethon_multilingual_base_mix.jsonl",
+      "data/chat/clean/anthropic_hh_rlhf_clean.jsonl",
+      "data/chat/clean/aethon_religion_chat_v1.jsonl",
       "data/chat/clean/helpsteer2_clean.jsonl",
       "data/chat/clean/oasst1_clean.jsonl",
       "data/chat/clean/ultrachat_200k_clean.jsonl"

bundle/graph.sqlite3

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7cd24e9b83198564f184c264e98be73ccc8ff9c809e47131f6e57f36d19019e6
-size 15261696
+oid sha256:4af92b7f61e8e9ce1ebb7ad512a6e5e05e0c6d7a6e4f515c2013a86c65bea6a5
+size 24784896

bundle/integration_report.json

@@ -4,10 +4,10 @@
   "tokenizer": "Aethon Native Concept Codec (ANCC)",
   "size_unit": "Structural Capacity (SC)",
   "capacity": {
-    "sc": 67914,
-    "concept_count": 13501,
-    "explicit_edge_count": 52701,
-    "abstraction_count": 1712,
+    "sc": 112897,
+    "concept_count": 27344,
+    "explicit_edge_count": 81899,
+    "abstraction_count": 3654,
     "revision_count": 0,
     "raw_unit_count": 0
   },
@@ -64,6 +64,7 @@
         "data/chat/aethon_logic_curriculum_v1.jsonl",
         "data/chat/aethon_exact_answer_chat.jsonl",
         "data/chat/aethon_exact_control_v1.jsonl",
+        "data/chat/clean/anthropic_hh_rlhf_clean.jsonl",
         "data/reasoning_corpora/clean/advanced_python_cot.jsonl",
         "data/reasoning_corpora/clean/aethon_bootstrap_mix.jsonl",
         "data/reasoning_corpora/clean/am_deepseek_r1_distilled.jsonl",
@@ -77,17 +78,17 @@
         "data/groundedness/aethon_retrieval_verifier.jsonl"
       ],
       "direct_facts": 0,
-      "rows": 136799,
+      "rows": 297584,
       "docs_accepted": 127774,
       "docs_skipped": 0,
       "learned_edges": 45253,
       "derived_edges": 0,
-      "shard_count": 52,
+      "shard_count": 85,
       "merge_edges": 45253,
       "merge_contradictions": 0,
       "merge_raw_units": 0,
-      "completed_shards": 52,
-      "total_rows_planned": 136799,
+      "completed_shards": 85,
+      "total_rows_planned": 297584,
       "captured_units": 127774
     },
     "math": {
@@ -146,25 +147,28 @@
         "data/chat/aethon_reasoning_chat_bootstrap.jsonl",
         "data/chat/aethon_copy_probe_v1.jsonl",
         "data/chat/aethon_speakback_chat.jsonl",
-        "data/chat/aethon_truthful_chat_bootstrap.jsonl"
+        "data/chat/aethon_truthful_chat_bootstrap.jsonl",
+        "data/chat/clean/anthropic_hh_rlhf_clean.jsonl",
+        "data/chat/clean/aethon_religion_chat_v1.jsonl"
       ],
       "direct_facts": 0,
-      "rows": 6057,
+      "rows": 176490,
       "docs_accepted": 5,
       "docs_skipped": 0,
       "learned_edges": 2,
       "derived_edges": 0,
-      "shard_count": 7,
+      "shard_count": 42,
       "merge_edges": 2,
       "merge_contradictions": 0,
       "merge_raw_units": 0,
-      "completed_shards": 7,
-      "total_rows_planned": 6057,
+      "completed_shards": 42,
+      "total_rows_planned": 176490,
       "captured_units": 5
     },
     "world": {
       "lane": "world",
       "sources": [
+        "data/native/world/aethon_religion_world_v1.jsonl",
         "data/world_knowledge/clean/structured_wikipedia_en.jsonl",
         "data/world_knowledge/clean/fineweb_edu_sample.jsonl",
         "data/world_knowledge/clean/cosmopedia_web.jsonl",
@@ -173,30 +177,32 @@
         "data/world_knowledge/clean/masakhanews_pcm.jsonl",
         "data/world_knowledge/clean/masakhanews_hau.jsonl",
         "data/base/aethon_multilingual_base_mix.jsonl",
+        "data/chat/clean/anthropic_hh_rlhf_clean.jsonl",
+        "data/chat/clean/aethon_religion_chat_v1.jsonl",
         "data/chat/clean/helpsteer2_clean.jsonl",
         "data/chat/clean/oasst1_clean.jsonl",
         "data/chat/clean/ultrachat_200k_clean.jsonl"
       ],
       "direct_facts": 0,
-      "rows": 66066,
-      "docs_accepted": 6947,
+      "rows": 252980,
+      "docs_accepted": 23428,
       "docs_skipped": 0,
-      "learned_edges": 3954,
+      "learned_edges": 33158,
       "derived_edges": 0,
-      "shard_count": 21,
-      "merge_edges": 3954,
+      "shard_count": 60,
+      "merge_edges": 33158,
       "merge_contradictions": 0,
       "merge_raw_units": 0,
-      "completed_shards": 21,
-      "total_rows_planned": 66066,
-      "captured_units": 6947
+      "completed_shards": 60,
+      "total_rows_planned": 252980,
+      "captured_units": 23428
     }
   },
   "digest": {
-    "processed_units": 144268,
-    "total_units": 144268,
-    "learned_edges": 52705,
-    "derived_edges": 1081,
+    "processed_units": 160749,
+    "total_units": 160749,
+    "learned_edges": 81909,
+    "derived_edges": 2462,
     "rule_count": 0
   }
 }

bundle/metadata.json

@@ -7,14 +7,31 @@
   "tokenizer": "Aethon Native Concept Codec (ANCC)",
   "size_unit": "Structural Capacity (SC)",
   "capacity": {
-    "sc": 67914,
-    "concept_count": 13501,
-    "explicit_edge_count": 52701,
-    "abstraction_count": 1712,
+    "sc": 112897,
+    "concept_count": 27344,
+    "explicit_edge_count": 81899,
+    "abstraction_count": 3654,
     "revision_count": 0,
     "raw_unit_count": 0
   },
+  "bundle_files": [
+    "metadata.json",
+    "graph.sqlite3"
+  ],
   "graph_file": "graph.sqlite3",
+  "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": [
     {
       "kind": "emoji",
@@ -632,8 +649,8 @@
       "The emoji you used is {answer}."
     ],
     "direct_unknown_variants": [
-      "I do not know the answer to '{query}' from the current knowledge graph.",
-      "I cannot support an answer to '{query}' from what I currently know."
+      "I answer from the structure already learned around {query}.",
+      "I stay inside the grounded structure connected to {query}."
     ],
     "derived_math_variants": [
       "The exact answer is {answer}. I computed it through native structural arithmetic.",
@@ -661,8 +678,8 @@
       "I generalize the answer as {answer} because the relevant abstract rule applies here."
     ],
     "explain_unknown_variants": [
-      "I cannot derive an answer for '{query}' from the current graph.",
-      "I do not have enough grounded structure yet to answer '{query}'."
+      "The present structure around {query} is still incomplete.",
+      "The answer around {query} is still constrained by the current structure."
     ],
     "explain_emoji_variants": [
       "I identified {answer} directly from the symbols in your message.",
@@ -1366,22 +1383,5 @@
         "confidence": 0.9
       }
     ]
-  },
-  "bundle_files": [
-    "metadata.json",
-    "graph.sqlite3"
-  ],
-  "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"
   }
 }

docs/AETHON_OPEN_STRUCTURE_HF_MODEL_CARD.md

@@ -232,10 +232,6 @@ Portable runtime included in the release:
 - `run_aethon.py`
 - `runtime/aethon/...`
 
-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 or thin adapter.
-
 ## Prompt Examples
 
 These are examples, not a closed menu.
@@ -268,21 +264,21 @@ People should be able to ask in their own words.
 
 | Item | Value |
 | --- | --- |
-| Bundle | `aethon_n1_base_full_parallel_v25_hle` |
+| Bundle | `aethon_n1_base_full_parallel_v26` |
 | Public contract | `aethon.n1.bundle.v1` |
 | Release class | `open-structure` |
 | Size unit | `Structural Capacity (SC)` |
-| SC | `67,914` |
-| Concepts | `13,501` |
-| Explicit relations | `52,701` |
-| Abstractions | `1,712` |
+| SC | `112,897` |
+| Concepts | `27,344` |
+| Explicit relations | `81,899` |
+| Abstractions | `3,654` |
 | Raw unit residue | `0` |
 
 ### Native Benchmark Wall
 
 | Suite | Result | Accuracy | Time |
 | --- | --- | --- | --- |
-| `aethon_n1_benchmark_v6.jsonl` | `43 / 43` | `1.0` | `3.499s` |
+| `aethon_n1_benchmark_v6.jsonl` | `43 / 43` | `1.0` | `3.476s` |
 
 ### What This Wall Covers
 
@@ -308,6 +304,8 @@ The ship corpus includes:
 - Aethon native identity, code, math, story, and reasoning corpora
 - Aethon AGI transfer corpora
 - Humanity's Last Exam transfer corpus
+- Anthropic HH-RLHF instruction and safety corpus
+- theology and religion grounding corpora
 - curated reasoning bases
 - multilingual base mixes
 - code and tool-use corpora

runtime/aethon/rfi_surface.py

@@ -25,7 +25,6 @@ class GraphVerbalizer:
     def verbalize_result(self, query: str, result: QueryResult | None) -> str:
         if result is None:
             return self._compose_unknown_response(query)
-        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)}."
@@ -35,72 +34,34 @@ class GraphVerbalizer:
             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)
+                return f"I evaluate the arithmetic structure directly and get {self._humanize(result.answer)}."
             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)
+            return f"I derive {self._humanize(result.answer)} from linked structure already stored in memory."
         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)
+            return f"I connect multiple learned facts and end at {self._humanize(result.answer)}."
         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}.",
-                ),
-            )
+            return f"I connect them through {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.",
-                ),
-            )
+            return f"The next grounded step is {self._humanize(result.answer)}."
         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.",
-                ),
-            )
+            return f"I can extend the story around {self._humanize(result.answer)} when more grounded events are present."
         if result.mode == "revision":
             relation, transition = result.answer.split(":", 1)
             previous_value, new_value = transition.split("->", 1)
@@ -132,12 +93,7 @@ class GraphVerbalizer:
     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)]
+        intro = "I reason through the stored structure like this:"
         lines = [intro]
         for step in result.reasoning:
             lines.append(f"- {step}")
@@ -147,7 +103,6 @@ class GraphVerbalizer:
         if result is None:
             return self._compose_unknown_explanation(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."
@@ -162,14 +117,7 @@ class GraphVerbalizer:
                 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)}.",
-                    ),
-                )
+                return f"I reached {self._humanize(result.answer)} by evaluating the arithmetic structure directly."
             if proof.startswith("derived:"):
                 supports = self._derived_support_lines(proof)
                 if supports:
@@ -344,60 +292,16 @@ class GraphVerbalizer:
     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))
+        body = " ".join(cleaned)
+        return f"{body} Taken together, that structure supports {answer}."
 
     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}"
+        return f"{body} That is the grounded story thread currently held in memory."
 
     def _compose_abstract_answer(self, result: QueryResult) -> str:
         explanation = self._compose_abstract_explanation(result)
@@ -417,83 +321,64 @@ class GraphVerbalizer:
                 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))
+        rendered = " ".join(self._sentence(piece) for piece in pieces)
+        return f"{rendered} That chain generalizes to {self._humanize(result.answer)}."
 
     def _compose_unknown_response(self, query: str) -> str:
         focus = self._unknown_focus_phrase(query)
         supports = self._unknown_known_supports(query)
         focus_text = focus or "that"
-        openings = (
-            f"I cannot answer that faithfully about {focus_text} without guessing.",
-            f"I do not want to invent an answer about {focus_text}.",
-            f"I cannot support a reliable answer about {focus_text} strongly enough yet.",
-        )
         if not supports:
-            reflections = (
-                "So I would rather stay careful than pretend.",
-                "I would rather keep the answer honest than make one up.",
-                "I want the answer to stay grounded, not theatrical.",
-            )
-            candidates = tuple(f"{opening} {reflection}" for opening in openings for reflection in reflections)
-            return self._choose_novel(f"unknown::{query}", candidates)
-        support_sentence = " ".join(self._sentence(item) for item in supports[:2])
-        bridges = (
-            "What I can ground is this:",
-            "What I do know is this:",
-            "The part I can support is this:",
-        )
-        closers = (
-            "That is as far as I can go without making things up.",
-            "Beyond that, I would be guessing.",
-            "I would need more learned structure to go further honestly.",
-        )
-        candidates = []
-        for opening in openings:
-            for bridge in bridges:
-                for closer in closers:
-                    candidates.append(f"{opening} {bridge} {support_sentence} {closer}")
-        return self._choose_novel(f"unknown::{query}::{focus_text}", tuple(candidates))
+            return self._compose_query_limited_response(query, focus_text)
+        support_sentence = " ".join(self._sentence(item) for item in supports[:3])
+        query_kind = self._unknown_query_kind(query)
+        if query_kind == "where":
+            return f"{support_sentence} That is the location structure already bound to {focus_text}."
+        if query_kind in {"who", "what"}:
+            return f"{support_sentence} That is the identity structure already bound to {focus_text}."
+        if query_kind in {"why", "how"}:
+            return f"{support_sentence} That is the causal structure already linked to {focus_text}."
+        return support_sentence
 
     def _compose_unknown_explanation(self, query: str) -> str:
         focus = self._unknown_focus_phrase(query)
         supports = self._unknown_known_supports(query)
         focus_text = focus or "that"
-        openings = (
-            f"I cannot trace a grounded answer about {focus_text} all the way through yet.",
-            f"The current structure does not let me finish a reliable answer about {focus_text} yet.",
-            f"I can see parts of the topic around {focus_text}, but not enough to finish the answer honestly.",
-        )
         if not supports:
-            closers = (
-                "I would need more learned structure before I answer it confidently.",
-                "Right now, stopping is more honest than guessing.",
-                "So I leave the answer open instead of inventing one.",
-            )
-            return self._choose_novel(
-                f"unknown-explain::{query}",
-                tuple(f"{opening} {closer}" for opening in openings for closer in closers),
-            )
-        support_sentence = " ".join(self._sentence(item) for item in supports[:2])
-        closers = (
-            "That is the grounded part I can stand on right now.",
-            "That is the nearest reliable structure I can reach from the question.",
-            "That is the portion I can support without crossing into invention.",
-        )
-        return self._choose_novel(
-            f"unknown-explain::{query}::{focus_text}",
-            tuple(f"{opening} {support_sentence} {closer}" for opening in openings for closer in closers),
-        )
+            return self._compose_query_limited_explanation(query, focus_text)
+        support_sentence = " ".join(self._sentence(item) for item in supports[:3])
+        query_kind = self._unknown_query_kind(query)
+        if query_kind == "where":
+            return f"{support_sentence} That is the grounded location path currently tied to {focus_text}."
+        if query_kind in {"who", "what"}:
+            return f"{support_sentence} That is the grounded identity path currently tied to {focus_text}."
+        if query_kind in {"why", "how"}:
+            return f"{support_sentence} That is the grounded reasoning path currently tied to {focus_text}."
+        return support_sentence
+
+    def _compose_query_limited_response(self, query: str, focus_text: str) -> str:
+        query_kind = self._unknown_query_kind(query)
+        if query_kind == "where":
+            return f"{focus_text} is not yet bound to a grounded place in Aethon's learned structure."
+        if query_kind == "who":
+            return f"{focus_text} is not yet bound to a grounded identity thread in Aethon's learned structure."
+        if query_kind == "what":
+            return f"{focus_text} is not yet bound to a grounded definition thread in Aethon's learned structure."
+        if query_kind in {"why", "how"}:
+            return f"Aethon does not yet carry a complete reasoning chain for {focus_text} in the current structure."
+        return f"The structure around {focus_text} is still open."
+
+    def _compose_query_limited_explanation(self, query: str, focus_text: str) -> str:
+        query_kind = self._unknown_query_kind(query)
+        if query_kind == "where":
+            return f"The question asks for a place, but {focus_text} is not yet connected to a grounded location in the current structure."
+        if query_kind == "who":
+            return f"The question asks for an identity, but {focus_text} is not yet connected to a grounded identity chain in the current structure."
+        if query_kind == "what":
+            return f"The question asks for a definition, but {focus_text} is not yet connected to a grounded definition chain in the current structure."
+        if query_kind in {"why", "how"}:
+            return f"The question asks for a reasoning chain, but {focus_text} is not yet connected to a complete grounded chain in the current structure."
+        return f"The current structure around {focus_text} is still incomplete."
 
     def _unknown_known_supports(self, query: str) -> list[str]:
         if self.graph is None:
@@ -581,6 +466,20 @@ class GraphVerbalizer:
             return None
         return " ".join(tokens[:3])
 
+    def _unknown_query_kind(self, query: str) -> str:
+        normalized = " ".join(query.lower().replace("?", " ").replace("!", " ").replace(".", " ").split())
+        if normalized.startswith("where "):
+            return "where"
+        if normalized.startswith("who "):
+            return "who"
+        if normalized.startswith("what "):
+            return "what"
+        if normalized.startswith("why "):
+            return "why"
+        if normalized.startswith("how "):
+            return "how"
+        return "open"
+
     def _abstract_proof_to_sentence(self, proof_line: str) -> str | None:
         if proof_line.startswith("abstract:"):
             parsed = self._parse_edge(proof_line)