Upload folder using huggingface_hub

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,10 +1,48 @@
----
-title: AURA Beta Testing Website
-emoji: 👀
-colorFrom: gray
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AURA (Beta) — Architecture for Unified Reasoning & Awareness
+AURA is an experimental, non-LLM cognitive architecture focused on explicit, verifiable reasoning rather than probabilistic text generation. The system is designed as a modular reasoning engine composed of distinct memory layers, rule systems, and inference pipelines, with an emphasis on correctness, transparency, and epistemic humility. AURA does not attempt to predict the “most likely” answer to a query. Instead, it evaluates whether a conclusion can be justified based on known facts, rules, and external evidence, and will explicitly return uncertainty when justification is insufficient.
+At its core, AURA treats intelligence as a system behavior, not a monolithic model. Knowledge is represented through structured facts, relationships, and confidence values rather than latent token statistics. Reasoning occurs through deterministic or semi-deterministic processes such as rule application, dependency tracing, contradiction detection, and evidence aggregation. Each conclusion can be traced back to its originating data sources, rules, or assumptions, allowing developers to audit, debug, and refine reasoning pathways over time.
+AURA’s architecture separates cognition into multiple layers, including raw data ingestion (sensory memory), transient hypothesis and reasoning chains (working memory), persistent structured knowledge (long-term memory), and meta-cognitive tracking (e.g., confidence decay, contradictions, unresolved queries). This layered approach allows the system to reason incrementally, revise beliefs when new evidence is introduced, and avoid over-generalization. Unlike LLM-based systems, AURA does not collapse all reasoning into vector similarity; embeddings, when used, are strictly auxiliary and never authoritative.
+The system is designed to integrate large external knowledge sources such as Wikimedia/Wikipedia datasets, but ingestion is treated as evidence acquisition, not truth acceptance. Incoming data is parsed, normalized, and stored as candidate knowledge that must be validated or contextualized through rules and cross-reference mechanisms. AURA explicitly avoids answering questions purely because related text exists; relevance alone is not sufficient for verification.
+AURA is currently in Beta and should be considered unstable and under active development. APIs, internal representations, and reasoning pipelines are subject to change as the architecture evolves. Performance, scalability, and completeness are not yet guaranteed, and incorrect or incomplete conclusions are possible. The project is intended for developers and researchers interested in exploring alternative approaches to AI reasoning beyond transformer-based language models, particularly those focused on symbolic reasoning, hybrid systems, and explainable AI.
+The long-term goal of AURA is not to compete with LLMs in fluency, but to explore a different axis of intelligence—one centered on integrity, traceability, and genuine reasoning. Contributions, experiments, and architectural critiques are encouraged, especially from developers interested in cognitive systems, knowledge representation, and non-statistical approaches to artificial intelligence.
+# How to test:
+Keep in mind that AURA is still in beta and a stable release isn't yet to be published. Use at your own caution and don't expect everything to be perfect yet.
+In order to test AURA, first get your test device ready. Install Python 3.12 or above on your machine to run the code if not already. Then, clone the repository using git clone. Then, open up a terminal or command prompt window and type in: cd AURA-Beta
+Then, type: cd src-code
+Lastly, type in: python AURA-main-code.py
+Then, AURA Beta will run on your device so you can test it.
+
+# Testing instructions for cloud compute
+If you are using cloud compute like Google Colab, Kaggle, Hugging Face Spaces, etc, follow the instructions given below for your cloud compute provider:
+
+# Google Colab and Kaggle Notebooks
+First, make a blank notebook in Google Colab or Kaggle. Then paste the contents of AURA-Beta/src-code/AURA-main-code.py onto your code cell. (Contents can be viewed in GitHub). Now, run the code cell and easily test AURA Beta without installing or running anything on your local machine. This is guaranteed to work on Google Colab using T4 GPU because it was one of the testing environments we used to test AURA Beta.
+
+# Hugging Face Spaces
+If you are using Hugging Face Spaces, you have a repo like setup (similar to GitHub) which makes your job quite easy. All you have to do is create a Streamlit Template Space (Why Streamlit when there is going to be no Streamlit UI?: The Streamlit Template Space comes with a prebuilt Dockerfile that is perfect for our purposes). So make a Streamlit Template Space with the configuration of your choice. Now, go to your repository and follow these instructions: 
+
+Delete the existing app.py
+Do not do anything to the Dockerfile: Leave it as is: It's already preconfigured the way we need it
+Now come over to the AURA-Beta GitHub Repository and copy the contents of src-code/AURA-main-code.py.
+Now create a new file in your Hugging Face Repository called "src/streamlit_app.py" and paste the previously copied contents as the contents of your app.py
+Now, after you make the file, Hugging Face with automatically start building your space. Don't mind it. It will error out because you need to do an extra step
+Go to the "requirements.txt" file and edit it: Remove all existing items and copy this list: 
+
+
+torch
+sentence-transformers
+networkx
+datasets
+numpy
+scikit-learn
+tqdm
+transformers
+
+
+Then, paste this list as the contents of "requirements.txt"
+Now save it and Hugging Face will start building
+It might take a while, but then, it will say Starting and start your space
+Then you can test AURA-Beta as much as you want!
+
+Hugging Face might be the most tedious, but also the most rewarding, because now, you have a website program just to try AURA Beta out whenever you want to!
+

src-code/AURA-main-code.py

@@ -0,0 +1,1382 @@
+# ==========================Factories + Engines==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 1 / 10
+# Imports, Utilities, Embedding Service
+# ==========================
+
+import time
+import re
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional, Iterable, Tuple, Callable
+
+import torch
+import networkx as nx
+from sentence_transformers import SentenceTransformer, util
+from datasets import load_dataset
+
+
+# ==========================
+# Device & Embedding Model
+# ==========================
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+EMBEDDING_MODEL_NAME = "all-MiniLM-L6-v2"
+
+print("Using device:", DEVICE)
+
+
+# ==========================
+# Utility Functions
+# ==========================
+
+def normalize_text(text: str) -> str:
+    """Lowercase, strip punctuation, collapse whitespace."""
+    if text is None:
+        return ""
+    text = text.lower().strip()
+    text = re.sub(r"[^\w\s\?]", " ", text)
+    text = re.sub(r"\s+", " ", text)
+    return text
+
+
+def contains_negation(text: str) -> bool:
+    """Detect negation words in natural language."""
+    neg_words = ["not", "never", "no", "doesnt", "isnt", "arent", "without", "cannot", "can't"]
+    tokens = normalize_text(text).split()
+    return any(w in tokens for w in neg_words)
+
+
+def extract_prob_modifier(text: str) -> float:
+    """
+    Detect probabilistic language and convert to confidence multipliers.
+    Examples:
+        "always" -> 1.0
+        "usually" -> 0.8
+        "often" -> 0.7
+        "sometimes" -> 0.5
+        "rarely" -> 0.3
+        "never" -> 0.0
+    """
+    t = normalize_text(text)
+    if "always" in t:
+        return 1.0
+    if "usually" in t:
+        return 0.8
+    if "often" in t:
+        return 0.7
+    if "sometimes" in t:
+        return 0.5
+    if "rarely" in t:
+        return 0.3
+    if "never" in t:
+        return 0.0
+    return 1.0  # default
+
+
+def is_variable(token: Optional[str]) -> bool:
+    """Variables start with ? (e.g., ?x, ?y)."""
+    return isinstance(token, str) and token.startswith("?") and len(token) > 1
+
+
+# ==========================
+# Embedding Service
+# ==========================
+
+class EmbeddingService:
+    """Wrapper around SentenceTransformer for consistent encoding."""
+    def __init__(self, model_name: str = EMBEDDING_MODEL_NAME, device: torch.device = DEVICE):
+        self.model = SentenceTransformer(model_name, device=device)
+
+    def encode(self, text: str) -> torch.Tensor:
+        return self.model.encode(text, convert_to_tensor=True)
+
+    def encode_batch(self, texts: Iterable[str]) -> torch.Tensor:
+        return self.model.encode(list(texts), convert_to_tensor=True)
+
+
+# Global embedding service instance
+embedding_service = EmbeddingService()
+# ==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 2 / 10
+# Core Data Structures
+# ==========================
+
+@dataclass(frozen=True)
+class Fact:
+    """
+    A structured fact with:
+    - subject
+    - predicate
+    - object
+    - confidence (0–1)
+    - polarity (+1 = positive, -1 = negated)
+    - source (manual, induced, nl_input, dataset, etc.)
+    """
+    subject: str
+    predicate: str
+    obj: Optional[str] = None
+    confidence: float = 1.0
+    polarity: int = 1
+    verified: bool = True
+    source: str = "unknown"
+    timestamp: float = field(default_factory=time.time)
+    embedding: torch.Tensor = field(init=False, compare=False, repr=False)
+
+    def __post_init__(self):
+        # Normalize fields
+        object.__setattr__(self, "subject", normalize_text(self.subject))
+        object.__setattr__(self, "predicate", normalize_text(self.predicate))
+        if self.obj is not None:
+            object.__setattr__(self, "obj", normalize_text(self.obj))
+
+        # Create canonical text for embedding
+        canonical = self.to_text(include_polarity=False)
+        emb = embedding_service.encode(canonical)
+        object.__setattr__(self, "embedding", emb)
+
+    def to_text(self, include_polarity: bool = True) -> str:
+        """Return human-readable representation."""
+        base = f"{self.subject} {self.predicate}"
+        if self.obj:
+            base += f" {self.obj}"
+        if include_polarity and self.polarity == -1:
+            base = "NOT " + base
+        return base
+
+    def key(self) -> str:
+        """Unique key for memory storage."""
+        pol = "neg" if self.polarity == -1 else "pos"
+        return f"{pol}:{self.to_text(include_polarity=False)}"
+
+
+@dataclass
+class RulePattern:
+    """
+    A pattern used in rules, supporting variables (?x, ?y).
+    Includes polarity for negation-aware reasoning.
+    """
+    subject: str
+    predicate: str
+    obj: Optional[str] = None
+    polarity: int = 1
+
+    def normalized(self) -> "RulePattern":
+        return RulePattern(
+            subject=normalize_text(self.subject),
+            predicate=normalize_text(self.predicate),
+            obj=normalize_text(self.obj) if self.obj is not None else None,
+            polarity=self.polarity,
+        )
+
+
+@dataclass
+class Rule:
+    """
+    A rule with:
+    - name
+    - list of condition patterns
+    - conclusion pattern
+    - confidence
+    - source (manual, induced)
+    """
+    name: str
+    conditions: List[RulePattern]
+    conclusion: RulePattern
+    confidence: float = 1.0
+    source: str = "manual"
+
+    def normalized(self) -> "Rule":
+        return Rule(
+            name=self.name,
+            conditions=[c.normalized() for c in self.conditions],
+            conclusion=self.conclusion.normalized(),
+            confidence=self.confidence,
+            source=self.source,
+        )
+
+
+@dataclass
+class ReasoningEvent:
+    """
+    A log entry for meta-memory:
+    - which engine produced it
+    - message
+    - confidence
+    - timestamp
+    """
+    engine: str
+    message: str
+    confidence: float
+    timestamp: float = field(default_factory=time.time)
+# ==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 3 / 10
+# Retrieval Index + Memory Systems
+# ==========================
+
+# ==========================
+# Retrieval Index
+# ==========================
+
+class RetrievalIndex:
+    """
+    Stores embeddings for fast similarity search.
+    Used by semantic memory and analogy engine.
+    """
+    def __init__(self):
+        self.embeddings: List[torch.Tensor] = []
+        self.items: List[Any] = []
+
+    def add(self, embedding: torch.Tensor, item: Any):
+        self.embeddings.append(embedding)
+        self.items.append(item)
+
+    def search(self, query_embedding: torch.Tensor, top_k: int = 5) -> List[Tuple[Any, float]]:
+        if not self.embeddings:
+            return []
+        mat = torch.stack(self.embeddings)
+        sims = util.cos_sim(query_embedding, mat)[0]
+        k = min(top_k, len(sims))
+        topk = torch.topk(sims, k=k)
+        results = []
+        for idx in topk.indices:
+            i = idx.item()
+            results.append((self.items[i], sims[i].item()))
+        return results
+
+
+# ==========================
+# Sensory Memory
+# ==========================
+
+class SensoryMemory:
+    """
+    Stores raw text entries (e.g., dataset items, Wikipedia text).
+    Used as fallback when structured reasoning fails.
+    """
+    def __init__(self):
+        self.entries: List[str] = []
+        self.entry_embeddings: List[torch.Tensor] = []
+
+    def add_entry(self, text: str, embedding: Optional[torch.Tensor] = None):
+        self.entries.append(text)
+        if embedding is None:
+            embedding = embedding_service.encode(normalize_text(text))
+        self.entry_embeddings.append(embedding)
+
+
+# ==========================
+# Working Memory
+# ==========================
+
+class WorkingMemory:
+    """
+    Stores active facts used for reasoning.
+    """
+    def __init__(self):
+        self.facts: Dict[str, Fact] = {}
+
+    def add_fact(self, fact: Fact):
+        self.facts[fact.key()] = fact
+
+    def has_fact(self, fact: Fact) -> bool:
+        return fact.key() in self.facts
+
+    def all_facts(self) -> List[Fact]:
+        return list(self.facts.values())
+
+
+# ==========================
+# Semantic Memory
+# ==========================
+
+class SemanticMemory:
+    """
+    Stores long-term structured knowledge.
+    Uses a graph + retrieval index.
+    """
+    def __init__(self):
+        self.graph = nx.DiGraph()
+        self.index = RetrievalIndex()
+        self.fact_map: Dict[str, Fact] = {}
+
+    def add_fact(self, fact: Fact):
+        key = fact.key()
+        # If fact exists, keep the one with higher confidence
+        if key in self.fact_map:
+            existing = self.fact_map[key]
+            if fact.confidence > existing.confidence:
+                self.fact_map[key] = fact
+            return
+
+        self.fact_map[key] = fact
+        self.graph.add_node(key, data=fact)
+        self.index.add(fact.embedding, fact)
+
+    def add_relation(self, source: Fact, target: Fact, relation: str, weight: float = 1.0):
+        self.graph.add_edge(source.key(), target.key(), relation=relation, weight=weight)
+
+    def search_fact(self, query_embedding: torch.Tensor, threshold: float = 0.6) -> Optional[Fact]:
+        results = self.index.search(query_embedding, top_k=5)
+        best = [(f, score) for f, score in results if score >= threshold]
+        if not best:
+            return None
+        best.sort(key=lambda x: x[1], reverse=True)
+        return best[0][0]
+
+
+# ==========================
+# Episodic Memory
+# ==========================
+
+@dataclass
+class Episode:
+    description: str
+    facts: List[Fact]
+    timestamp: float = field(default_factory=time.time)
+
+
+class EpisodicMemory:
+    """
+    Stores episodes: groups of facts tied to a specific event or dataset item.
+    """
+    def __init__(self):
+        self.episodes: List[Episode] = []
+
+    def add_episode(self, description: str, facts: List[Fact]):
+        self.episodes.append(Episode(description=description, facts=facts))
+
+
+# ==========================
+# Procedural Memory
+# ==========================
+
+class ProceduralMemory:
+    """
+    Stores learned procedures (functions).
+    """
+    def __init__(self):
+        self.procedures: Dict[str, Callable] = {}
+
+    def add_procedure(self, name: str, func: Callable):
+        self.procedures[name] = func
+
+    def get_procedure(self, name: str) -> Optional[Callable]:
+        return self.procedures.get(name)
+
+
+# ==========================
+# Meta-Memory
+# ==========================
+
+class MetaMemory:
+    """
+    Tracks:
+    - reasoning events
+    - contradictions
+    - engine reliability scores
+    """
+    def __init__(self):
+        self.contradictions: List[str] = []
+        self.events: List[ReasoningEvent] = []
+        self.engine_scores: Dict[str, float] = {}  # reliability scores
+
+    def log(self, engine: str, message: str, confidence: float):
+        self.events.append(ReasoningEvent(engine=engine, message=message, confidence=confidence))
+        # Update engine reliability
+        self.engine_scores[engine] = self.engine_scores.get(engine, 0.5) * 0.9 + confidence * 0.1
+
+    def add_contradiction(self, fact1: Fact, fact2: Fact):
+        msg = f"CONTRADICTION: '{fact1.to_text()}' conflicts with '{fact2.to_text()}'"
+        self.contradictions.append(msg)
+        self.events.append(ReasoningEvent(engine="TMS", message=msg, confidence=0.0))
+
+    def recent_trace(self, n: int = 20) -> List[ReasoningEvent]:
+        return self.events[-n:]
+# ==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 4 / 10
+# Unification Engine
+# ==========================
+
+from abc import ABC, abstractmethod
+
+class ReasoningEngineBase(ABC):
+    """Abstract base class for all reasoning engines."""
+    name: str
+
+    @abstractmethod
+    def reason_forward(self, engine: "CognitiveEngine") -> Tuple[List["Fact"], List[str], float]:
+        pass
+
+    @abstractmethod
+    def reason_backward(self, engine: "CognitiveEngine", goal: "RulePattern") -> Tuple[List["Fact"], List[str], float]:
+        pass
+
+def unify_token(pattern: Optional[str], value: Optional[str], subst: Dict[str, str]) -> Optional[Dict[str, str]]:
+    """
+    Unify a single token:
+    - If pattern is a variable (?x), bind it.
+    - If pattern is a constant, it must match value.
+    """
+    if pattern is None and value is None:
+        return subst
+    if pattern is None or value is None:
+        return None
+
+    pattern = normalize_text(pattern)
+    value = normalize_text(value)
+
+    # Variable case
+    if is_variable(pattern):
+        var = pattern
+        if var in subst:
+            # Already bound → must match
+            return subst if subst[var] == value else None
+        # Bind new variable
+        new_subst = dict(subst)
+        new_subst[var] = value
+        return new_subst
+
+    # Constant case
+    if pattern == value:
+        return subst
+
+    return None
+
+
+def unify_fact(pattern: "RulePattern", fact: "Fact", subst: Dict[str, str]) -> Optional[Dict[str, str]]:
+    """
+    Unify a rule pattern with a fact.
+    Includes polarity matching.
+    """
+    # Polarity must match
+    if pattern.polarity != fact.polarity:
+        return None
+
+    # Subject
+    subst1 = unify_token(pattern.subject, fact.subject, subst)
+    if subst1 is None:
+        return None
+
+    # Predicate
+    subst2 = unify_token(pattern.predicate, fact.predicate, subst1)
+    if subst2 is None:
+        return None
+
+    # Object
+    subst3 = unify_token(pattern.obj, fact.obj, subst2)
+    return subst3
+
+
+def apply_substitution(pattern: "RulePattern", subst: Dict[str, str]) -> "RulePattern":
+    """
+    Apply variable bindings to a rule pattern.
+    """
+    def apply_token(token: Optional[str]) -> Optional[str]:
+        if token is None:
+            return None
+        token = normalize_text(token)
+        if is_variable(token) and token in subst:
+            return subst[token]
+        return token
+
+    return RulePattern(
+        subject=apply_token(pattern.subject),
+        predicate=apply_token(pattern.predicate),
+        obj=apply_token(pattern.obj),
+        polarity=pattern.polarity,
+    )
+# ==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 5 / 10
+# Deductive Engine (Forward + Backward)
+# ==========================
+
+class DeductiveEngine(ReasoningEngineBase):
+    name = "deductive"
+
+    # ---------------------------------------------------------
+    # Forward Chaining
+    # ---------------------------------------------------------
+    def reason_forward(self, engine: "CognitiveEngine") -> Tuple[List[Fact], List[str], float]:
+        new_facts: List[Fact] = []
+        trace: List[str] = []
+        avg_conf = 0.0
+        count = 0
+
+        facts = engine.working.all_facts()
+        rules = [r.normalized() for r in engine.rules]
+
+        for rule in rules:
+            matches = self._match_rule(rule, facts)
+
+            for subst, cond_facts in matches:
+                concl_pattern = apply_substitution(rule.conclusion, subst)
+
+                # Polarity propagation
+                polarity = concl_pattern.polarity
+
+                # Confidence propagation
+                conf = self._propagate_confidence(rule, cond_facts)
+
+                concl_fact = Fact(
+                    subject=concl_pattern.subject,
+                    predicate=concl_pattern.predicate,
+                    obj=concl_pattern.obj,
+                    polarity=polarity,
+                    confidence=conf,
+                    verified=True,
+                    source=f"rule:{rule.name}",
+                )
+
+                # Contradiction detection
+                self._check_contradictions(engine, concl_fact)
+
+                if not engine.working.has_fact(concl_fact):
+                    new_facts.append(concl_fact)
+                    used = ", ".join(f.to_text() for f in cond_facts)
+                    msg = (
+                        f"[Deduction] {rule.name} with {used} "
+                        f"-> {concl_fact.to_text()} (conf={concl_fact.confidence:.2f})"
+                    )
+                    trace.append(msg)
+                    avg_conf += concl_fact.confidence
+                    count += 1
+
+        if count > 0:
+            avg_conf /= count
+        else:
+            avg_conf = 0.0
+
+        return new_facts, trace, avg_conf
+
+    # ---------------------------------------------------------
+    # Backward Chaining
+    # ---------------------------------------------------------
+    def reason_backward(self, engine: "CognitiveEngine", goal: RulePattern) -> Tuple[List[Fact], List[str], float]:
+        trace: List[str] = []
+        proven_facts: List[Fact] = []
+        avg_conf = 0.0
+        count = 0
+
+        # 1. Check if goal already exists in working memory
+        for f in engine.working.all_facts():
+            if unify_fact(goal, f, {}) is not None:
+                proven_facts.append(f)
+                trace.append(f"[Backward-Deduction] Goal already known: {f.to_text()}")
+                avg_conf += f.confidence
+                count += 1
+                return proven_facts, trace, avg_conf / max(count, 1)
+
+        # 2. Try to prove goal using rules
+        rules = [r.normalized() for r in engine.rules]
+
+        for rule in rules:
+            subst = unify_fact(rule.conclusion, Fact(goal.subject, goal.predicate, goal.obj, polarity=goal.polarity), {})
+            if subst is None:
+                continue
+
+            # Try to prove all conditions
+            all_proven = True
+            cond_facts: List[Fact] = []
+
+            for cond in rule.conditions:
+                cond_goal = apply_substitution(cond, subst)
+                pf, pt, pc = self.reason_backward(engine, cond_goal)
+                trace.extend(pt)
+
+                if not pf:
+                    all_proven = False
+                    break
+
+                cond_facts.extend(pf)
+                avg_conf += pc
+                count += 1
+
+            if all_proven:
+                concl_pattern = apply_substitution(rule.conclusion, subst)
+                concl_fact = Fact(
+                    subject=concl_pattern.subject,
+                    predicate=concl_pattern.predicate,
+                    obj=concl_pattern.obj,
+                    polarity=concl_pattern.polarity,
+                    confidence=self._propagate_confidence(rule, cond_facts),
+                    verified=True,
+                    source=f"rule:{rule.name}",
+                )
+
+                proven_facts.append(concl_fact)
+                trace.append(f"[Backward-Deduction] Proved {concl_fact.to_text()} via {rule.name}")
+                avg_conf += concl_fact.confidence
+                count += 1
+                break
+
+        if count > 0:
+            avg_conf /= count
+        else:
+            avg_conf = 0.0
+
+        return proven_facts, trace, avg_conf
+
+    # ---------------------------------------------------------
+    # Rule Matching
+    # ---------------------------------------------------------
+    def _match_rule(self, rule: Rule, facts: List[Fact]) -> List[Tuple[Dict[str, str], List[Fact]]]:
+        results: List[Tuple[Dict[str, str], List[Fact]]] = []
+
+        def backtrack(i: int, subst: Dict[str, str], chosen: List[Fact]):
+            if i == len(rule.conditions):
+                results.append((subst, chosen.copy()))
+                return
+
+            pattern = rule.conditions[i]
+
+            for fact in facts:
+                new_subst = unify_fact(pattern, fact, subst)
+                if new_subst is not None and fact not in chosen:
+                    chosen.append(fact)
+                    backtrack(i + 1, new_subst, chosen)
+                    chosen.pop()
+
+        backtrack(0, {}, [])
+        return results
+
+    # ---------------------------------------------------------
+    # Confidence Propagation
+    # ---------------------------------------------------------
+    def _propagate_confidence(self, rule: Rule, cond_facts: List[Fact]) -> float:
+        conf = rule.confidence
+        for f in cond_facts:
+            conf *= f.confidence
+        return max(min(conf, 1.0), 0.0)
+
+    # ---------------------------------------------------------
+    # Contradiction Detection
+    # ---------------------------------------------------------
+    def _check_contradictions(self, engine: "CognitiveEngine", new_fact: Fact):
+        """
+        If a fact with opposite polarity exists, log contradiction.
+        """
+        opposite_key = ("neg:" if new_fact.polarity == 1 else "pos:") + new_fact.to_text(include_polarity=False)
+
+        if opposite_key in engine.semantic.fact_map:
+            engine.meta.add_contradiction(new_fact, engine.semantic.fact_map[opposite_key])
+# ==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 6 / 10
+# Inductive Engine + Analogical Engine
+# ==========================
+
+class InductiveEngine(ReasoningEngineBase):
+    """
+    Learns new rules from repeated relational patterns.
+    Example:
+        If we see:
+            fire is hot
+            touching_fire causes burn
+            stove is hot
+            touching_stove causes burn
+        → Induce rule: hot things burn
+    """
+    name = "inductive"
+
+    def reason_forward(self, engine: "CognitiveEngine") -> Tuple[List[Fact], List[str], float]:
+        trace: List[str] = []
+        new_facts: List[Fact] = []
+        avg_conf = 0.0
+        count = 0
+
+        facts = engine.working.all_facts()
+
+        # Collect patterns
+        hot_map = {}
+        burn_map = {}
+
+        for f in facts:
+            if f.predicate == "is" and f.obj == "hot" and f.polarity == 1:
+                hot_map[f.subject] = f
+            if f.predicate == "causes" and f.obj == "burn" and f.subject.startswith("touching_") and f.polarity == 1:
+                x = f.subject.replace("touching_", "")
+                burn_map[x] = f
+
+        # Look for repeated pattern
+        common = set(hot_map.keys()) & set(burn_map.keys())
+
+        if len(common) >= 2:
+            # Induce rule
+            rule = Rule(
+                name="induced_hot_things_burn_rule",
+                conditions=[RulePattern(subject="?x", predicate="is", obj="hot", polarity=1)],
+                conclusion=RulePattern(subject="touching_?x", predicate="causes", obj="burn", polarity=1),
+                confidence=0.8,
+                source="induced",
+            )
+
+            if rule.name not in [r.name for r in engine.rules]:
+                engine.rules.append(rule)
+                msg = "[Induction] Learned rule: if ?x is hot → touching_?x causes burn"
+                trace.append(msg)
+                avg_conf = 0.8
+                count = 1
+
+        return new_facts, trace, avg_conf
+
+    def reason_backward(self, engine: "CognitiveEngine", goal: RulePattern):
+        # Induction is forward-only
+        return [], [], 0.0
+
+
+# ==========================
+# Analogical Engine
+# ==========================
+
+class AnalogicalEngine(ReasoningEngineBase):
+    """
+    Structural analogy + embeddings.
+    Example:
+        fire is hot
+        touching_fire causes burn
+        stove is hot
+        → touching_stove causes burn (by analogy)
+    """
+    name = "analogical"
+
+    def reason_forward(self, engine: "CognitiveEngine") -> Tuple[List[Fact], List[str], float]:
+        trace = []
+        new_facts = []
+        avg_conf = 0.0
+        count = 0
+
+        facts = engine.working.all_facts()
+
+        hot_subjects = [f for f in facts if f.predicate == "is" and f.obj == "hot" and f.polarity == 1]
+        burn_facts = [f for f in facts if f.predicate == "causes" and f.obj == "burn" and f.subject.startswith("touching_")]
+
+        for hf in hot_subjects:
+            for bf in burn_facts:
+                x = bf.subject.replace("touching_", "")
+                if x == hf.subject:
+                    # Find analogous subjects
+                    for hf2 in hot_subjects:
+                        if hf2.subject == hf.subject:
+                            continue
+
+                        sim = util.cos_sim(hf.embedding, hf2.embedding).item()
+                        if sim > 0.6:
+                            concl = Fact(
+                                subject=f"touching_{hf2.subject}",
+                                predicate="causes",
+                                obj="burn",
+                                polarity=1,
+                                confidence=0.7 * sim,
+                                verified=False,
+                                source="analogical",
+                            )
+
+                            if not engine.working.has_fact(concl):
+                                new_facts.append(concl)
+                                msg = (
+                                    f"[Analogy] From {hf.subject}~{hf2.subject} and {bf.to_text()} "
+                                    f"→ {concl.to_text()} (sim={sim:.2f})"
+                                )
+                                trace.append(msg)
+                                avg_conf += concl.confidence
+                                count += 1
+
+        if count > 0:
+            avg_conf /= count
+        else:
+            avg_conf = 0.0
+
+        return new_facts, trace, avg_conf
+
+    def reason_backward(self, engine: "CognitiveEngine", goal: RulePattern):
+        # Analogy is forward-only
+        return [], [], 0.0
+# ==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 7 / 10
+# Counterfactual Engine + Meta‑Controller + CognitiveEngine
+# ==========================
+
+class CounterfactualEngine(ReasoningEngineBase):
+    """
+    Hybrid counterfactual reasoning:
+    - Symbolic intervention: replace a fact and re-run reasoning
+    - Causal-ish graph reasoning via semantic memory
+    """
+    name = "counterfactual"
+
+    def reason_forward(self, engine: "CognitiveEngine"):
+        # Counterfactuals are not automatically generated
+        return [], [], 0.0
+
+    def reason_backward(self, engine: "CognitiveEngine", goal: RulePattern):
+        # Counterfactuals require explicit user request
+        return [], [], 0.0
+
+    def simulate(self, engine: "CognitiveEngine", intervention_fact: Fact) -> Dict[str, Any]:
+        """
+        Perform a symbolic intervention:
+        - Temporarily add the fact
+        - Re-run forward reasoning
+        - Observe differences
+        """
+        temp_engine = engine.clone()
+
+        temp_engine.add_fact(intervention_fact)
+        temp_engine.reason_forward_until_fixpoint(max_iterations=3)
+
+        return {
+            "intervention": intervention_fact.to_text(),
+            "new_facts": [f.to_text() for f in temp_engine.working.all_facts()],
+        }
+
+
+# ==========================
+# Meta-Controller
+# ==========================
+
+class MetaController:
+    """
+    Chooses which reasoning engines to trust based on:
+    - Past performance (engine_scores)
+    - Confidence of recent outputs
+    """
+    def __init__(self, meta_memory: MetaMemory):
+        self.meta = meta_memory
+
+    def choose_engines_forward(self, engines: List[ReasoningEngineBase]) -> List[ReasoningEngineBase]:
+        scored = []
+        for e in engines:
+            score = self.meta.engine_scores.get(e.name, 0.5)
+            scored.append((score, e))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        return [e for _, e in scored]
+
+    def choose_engines_backward(self, engines: List[ReasoningEngineBase]) -> List[ReasoningEngineBase]:
+        return self.choose_engines_forward(engines)
+
+
+# ==========================
+# Cognitive Engine (Core Brain)
+# ==========================
+
+class CognitiveEngine:
+    """
+    The central orchestrator:
+    - Holds all memory systems
+    - Holds all reasoning engines
+    - Runs forward/backward reasoning
+    - Handles contradictions
+    """
+    def __init__(self):
+        # Memory systems
+        self.sensory = SensoryMemory()
+        self.working = WorkingMemory()
+        self.semantic = SemanticMemory()
+        self.episodic = EpisodicMemory()
+        self.procedural = ProceduralMemory()
+        self.meta = MetaMemory()
+
+        # Reasoning engines
+        self.engines: List[ReasoningEngineBase] = [
+            DeductiveEngine(),
+            InductiveEngine(),
+            AnalogicalEngine(),
+            CounterfactualEngine(),
+        ]
+
+        # Meta-controller
+        self.meta_controller = MetaController(self.meta)
+
+        # Rule store
+        self.rules: List[Rule] = []
+
+    # -------------------------
+    # Fact & Rule Management
+    # -------------------------
+
+    def add_fact(self, fact: Fact):
+        """
+        Add fact to working + semantic memory.
+        Check for contradictions.
+        """
+        # Check for contradictions
+        opposite_key = ("neg:" if fact.polarity == 1 else "pos:") + fact.to_text(include_polarity=False)
+        if opposite_key in self.semantic.fact_map:
+            self.meta.add_contradiction(fact, self.semantic.fact_map[opposite_key])
+
+        self.working.add_fact(fact)
+        self.semantic.add_fact(fact)
+
+    def add_rule(self, rule: Rule):
+        self.rules.append(rule)
+
+    # -------------------------
+    # Forward Reasoning Loop
+    # -------------------------
+
+    def reason_forward_until_fixpoint(self, max_iterations: int = 5):
+        """
+        Run forward reasoning until no new facts are produced.
+        """
+        for _ in range(max_iterations):
+            any_new = False
+
+            ordered_engines = self.meta_controller.choose_engines_forward(self.engines)
+
+            for engine in ordered_engines:
+                new_facts, trace, avg_conf = engine.reason_forward(self)
+
+                if new_facts:
+                    any_new = True
+                    for f in new_facts:
+                        self.add_fact(f)
+
+                    for t in trace:
+                        self.meta.log(engine.name, t, avg_conf if avg_conf > 0 else 0.5)
+
+            if not any_new:
+                break
+
+    # -------------------------
+    # Backward Reasoning
+    # -------------------------
+
+    def reason_backward(self, goal: RulePattern) -> Tuple[List[Fact], List[str], float]:
+        ordered_engines = self.meta_controller.choose_engines_backward(self.engines)
+
+        best_facts = []
+        best_trace = []
+        best_conf = 0.0
+
+        for engine in ordered_engines:
+            facts, trace, conf = engine.reason_backward(self, goal)
+            if facts and conf > best_conf:
+                best_facts = facts
+                best_trace = trace
+                best_conf = conf
+
+        return best_facts, best_trace, best_conf
+
+    # -------------------------
+    # Cloning (for counterfactuals)
+    # -------------------------
+
+    def clone(self) -> "CognitiveEngine":
+        """
+        Create a deep-ish clone of the engine for counterfactual simulation.
+        """
+        new = CognitiveEngine()
+
+        # Copy facts
+        for f in self.working.all_facts():
+            new.add_fact(f)
+
+        # Copy rules
+        for r in self.rules:
+            new.add_rule(r)
+
+        return new
+# ==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 8 / 10
+# Natural Language Parser (Hybrid)
+# ==========================
+
+class NLParser:
+    """
+    Hybrid natural language parser:
+    - Rule-based parsing for simple patterns
+    - Embedding-based fallback
+    - Negation detection
+    - Probabilistic modifier extraction
+    """
+
+    def __init__(self, engine: CognitiveEngine):
+        self.engine = engine
+
+    # ---------------------------------------------------------
+    # Assertion Parsing (creates Facts)
+    # ---------------------------------------------------------
+    def parse_assertion(self, text: str) -> Optional[Fact]:
+        """
+        Convert natural language assertions into structured Facts.
+        Handles:
+            - "X is Y"
+            - "X causes Y"
+            - Negation ("not", "never", etc.)
+            - Probabilistic modifiers ("usually", "rarely")
+        """
+        t = normalize_text(text)
+        neg = contains_negation(t)
+        polarity = -1 if neg else 1
+        prob = extract_prob_modifier(t)
+
+        # Remove negation words for cleaner parsing
+        t_clean = re.sub(r"\bnot\b|\bnever\b|\bdoesnt\b|\bisnt\b|\barent\b", "", t).strip()
+
+        # Pattern: "x is y"
+        m = re.match(r"(.+?) is (.+)", t_clean)
+        if m:
+            subj = m.group(1).strip()
+            obj = m.group(2).strip()
+            return Fact(
+                subject=subj,
+                predicate="is",
+                obj=obj,
+                polarity=polarity,
+                confidence=prob,
+                source="nl_input",
+            )
+
+        # Pattern: "x causes y"
+        m = re.match(r"(.+?) causes (.+)", t_clean)
+        if m:
+            subj = m.group(1).strip()
+            obj = m.group(2).strip()
+            return Fact(
+                subject=subj,
+                predicate="causes",
+                obj=obj,
+                polarity=polarity,
+                confidence=prob,
+                source="nl_input",
+            )
+
+        # Fallback: treat as descriptive fact
+        return Fact(
+            subject=t_clean,
+            predicate="describes",
+            obj=None,
+            polarity=polarity,
+            confidence=prob,
+            source="nl_input",
+        )
+
+    # ---------------------------------------------------------
+    # Query Parsing (creates RulePattern)
+    # ---------------------------------------------------------
+    def parse_query_to_goal(self, text: str) -> RulePattern:
+        """
+        Convert natural language questions into RulePatterns.
+        Handles:
+            - "Is X Y?"
+            - "Does X cause Y?"
+            - Negation ("not", "never")
+        """
+        t = normalize_text(text)
+        neg = contains_negation(t)
+        polarity = -1 if neg else 1
+
+        # Remove negation words for cleaner parsing
+        t_clean = re.sub(r"\bnot\b|\bnever\b|\bdoesnt\b|\bisnt\b|\barent\b", "", t).strip()
+
+        # Pattern: "is x y?"
+        m = re.match(r"is (.+?) (.+)\??", t_clean)
+        if m:
+            subj = m.group(1).strip()
+            obj = m.group(2).strip()
+            return RulePattern(
+                subject=subj,
+                predicate="is",
+                obj=obj,
+                polarity=polarity,
+            )
+
+        # Pattern: "does x cause y?"
+        m = re.match(r"does (.+?) cause (.+)\??", t_clean)
+        if m:
+            subj = m.group(1).strip()
+            obj = m.group(2).strip()
+            return RulePattern(
+                subject=subj,
+                predicate="causes",
+                obj=obj,
+                polarity=polarity,
+            )
+
+        # Fallback
+        return RulePattern(
+            subject=t_clean,
+            predicate="describes",
+            obj=None,
+            polarity=polarity,
+        )
+# ==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 9 / 10
+# Dataset Ingestion (Omniscience)
+# ==========================
+
+def ingest_omniscience(engine: CognitiveEngine, max_items: int = 200):
+    """
+    Ingests the ArtificialAnalysis/AA-Omniscience-Public dataset
+    into sensory, semantic, and episodic memory.
+
+    Each dataset item typically contains:
+        - "input": natural language prompt
+        - "output": natural language answer
+        - "metadata": optional
+    """
+
+    print("Loading Omniscience dataset...")
+    ds = load_dataset("ArtificialAnalysis/AA-Omniscience-Public")
+    data = ds["train"]
+
+    parser = NLParser(engine)
+    count = 0
+
+    for item in data:
+        text_in = item.get("input", "")
+        text_out = item.get("output", "")
+
+        if not text_in and not text_out:
+            continue
+
+        # -------------------------
+        # Sensory Memory
+        # -------------------------
+        combined_text = f"{text_in} -> {text_out}"
+        normalized = normalize_text(combined_text)
+        emb = embedding_service.encode(normalized)
+        engine.sensory.add_entry(combined_text, embedding=emb)
+
+        # -------------------------
+        # Structured Fact Extraction
+        # -------------------------
+        fact_in = parser.parse_assertion(text_in) if text_in else None
+        fact_out = parser.parse_assertion(text_out) if text_out else None
+
+        # Add to semantic + working memory
+        local_facts = []
+        if fact_in:
+            engine.add_fact(fact_in)
+            local_facts.append(fact_in)
+        if fact_out:
+            engine.add_fact(fact_out)
+            local_facts.append(fact_out)
+
+        # -------------------------
+        # Episodic Memory
+        # -------------------------
+        if local_facts:
+            engine.episodic.add_episode(
+                description="omniscience_item",
+                facts=local_facts
+            )
+
+        count += 1
+        if count >= max_items:
+            break
+
+    print(f"Ingested {count} items from AA-Omniscience-Public dataset.")
+# ==========================
+# AURA v7 — Neuro‑Symbolic Hybrid Brain
+# Chunk 10 / 10
+# AURA Interface + main()
+# ==========================
+
+class AURAInterface:
+    """
+    High-level interface for interacting with AURA:
+    - assert_fact(text)
+    - query(text)
+    """
+
+    def __init__(self, engine: CognitiveEngine):
+        self.engine = engine
+        self.parser = NLParser(engine)
+
+    # ---------------------------------------------------------
+    # Assertions
+    # ---------------------------------------------------------
+    def assert_fact(self, text: str) -> Fact:
+        fact = self.parser.parse_assertion(text)
+        self.engine.add_fact(fact)
+        return fact
+
+    # ---------------------------------------------------------
+    # Queries
+    # ---------------------------------------------------------
+    def query(self, text: str) -> Dict[str, Any]:
+        normalized = normalize_text(text)
+        query_embedding = embedding_service.encode(normalized)
+
+        # Parse into structured goal
+        goal = self.parser.parse_query_to_goal(text)
+
+        # If negated, require explicit proof
+        if goal.polarity == -1:
+            facts, trace, conf = self.engine.reason_backward(goal)
+            if facts:
+                best = max(facts, key=lambda f: f.confidence)
+                return {
+                    "response": "Yes",
+                    "explanation": f"Proved negated fact: '{best.to_text()}'",
+                    "confidence": float(best.confidence),
+                    "trace": trace + [e.message for e in self.engine.meta.recent_trace()],
+                }
+            else:
+                return {
+                    "response": "No",
+                    "explanation": "No rule or fact supports the negated claim.",
+                    "confidence": 0.0,
+                    "trace": [e.message for e in self.engine.meta.recent_trace()],
+                }
+
+        # Try backward reasoning first
+        facts, trace, conf = self.engine.reason_backward(goal)
+        if facts:
+            best = max(facts, key=lambda f: f.confidence)
+            return {
+                "response": "Yes" if best.polarity == 1 else "No",
+                "explanation": f"Proved: '{best.to_text()}' via backward reasoning.",
+                "confidence": float(best.confidence),
+                "trace": trace + [e.message for e in self.engine.meta.recent_trace()],
+            }
+
+        # Semantic memory fallback
+        fact = self.engine.semantic.search_fact(query_embedding, threshold=0.6)
+        if fact:
+            return {
+                "response": "Yes" if fact.polarity == 1 else "No",
+                "explanation": f"Found in semantic memory: '{fact.to_text()}'",
+                "confidence": float(fact.confidence),
+                "trace": [e.message for e in self.engine.meta.recent_trace()],
+            }
+
+        # Sensory memory fallback
+        best_idx = None
+        best_score = 0.0
+        for idx, emb in enumerate(self.engine.sensory.entry_embeddings):
+            sim = util.cos_sim(query_embedding, emb).item()
+            if sim > best_score:
+                best_score = sim
+                best_idx = idx
+
+        if best_idx is not None and best_score >= 0.35:
+            best_entry = self.engine.sensory.entries[best_idx]
+            return {
+                "response": "Possibly",
+                "explanation": f"Sensory memory match: {best_entry[:200]}...",
+                "confidence": float(best_score),
+                "trace": [e.message for e in self.engine.meta.recent_trace()],
+            }
+
+        # Unknown
+        return {
+            "response": "Unknown",
+            "explanation": f"No information found for '{text}'",
+            "confidence": 0.0,
+            "trace": [e.message for e in self.engine.meta.recent_trace()],
+        }
+
+
+# ==========================
+# Core Knowledge Initialization
+# ==========================
+
+def build_core_knowledge(engine: CognitiveEngine):
+    """
+    Load basic commonsense knowledge + rules.
+    """
+    fire_hot = Fact(subject="fire", predicate="is", obj="hot", confidence=0.95, polarity=1, source="core")
+    stove_hot = Fact(subject="stove", predicate="is", obj="hot", confidence=0.9, polarity=1, source="core")
+    touching_fire_burn = Fact(subject="touching_fire", predicate="causes", obj="burn", confidence=0.95, polarity=1, source="core")
+
+    engine.add_fact(fire_hot)
+    engine.add_fact(stove_hot)
+    engine.add_fact(touching_fire_burn)
+
+    # Manual rules
+    rule1 = Rule(
+        name="hot_things_burn_rule",
+        conditions=[RulePattern(subject="?x", predicate="is", obj="hot", polarity=1)],
+        conclusion=RulePattern(subject="touching_?x", predicate="causes", obj="burn", polarity=1),
+        confidence=0.9,
+        source="manual",
+    )
+
+    rule2 = Rule(
+        name="burn_implies_danger_rule",
+        conditions=[RulePattern(subject="touching_?x", predicate="causes", obj="burn", polarity=1)],
+        conclusion=RulePattern(subject="?x", predicate="is", obj="dangerous", polarity=1),
+        confidence=0.9,
+        source="manual",
+    )
+
+    # Negation rule example
+    rule3 = Rule(
+        name="cold_things_do_not_burn_rule",
+        conditions=[RulePattern(subject="?x", predicate="is", obj="cold", polarity=1)],
+        conclusion=RulePattern(subject="touching_?x", predicate="causes", obj="burn", polarity=-1),
+        confidence=0.9,
+        source="manual",
+    )
+
+    engine.add_rule(rule1)
+    engine.add_rule(rule2)
+    engine.add_rule(rule3)
+
+
+# ==========================
+# Main REPL
+# ==========================
+
+def main():
+    engine = CognitiveEngine()
+    api = AURAInterface(engine)
+
+    # Load core knowledge
+    build_core_knowledge(engine)
+    engine.reason_forward_until_fixpoint(max_iterations=5)
+
+    # Load Omniscience dataset
+    ingest_omniscience(engine, max_items=50)
+
+    print("\nAURA v7 ready. Type assertions or questions.")
+    print("Examples:")
+    print("  - 'fire is hot'")
+    print("  - 'ice is cold'")
+    print("  - 'does touching fire cause burn?'")
+    print("  - 'does touching ice cause burn?'")
+    print("  - 'is stove dangerous?'")
+    print("  - 'do hot things NOT burn with fire?'")
+    print("Type 'exit' to quit.\n")
+
+    while True:
+        try:
+            query = input("You: ")
+        except EOFError:
+            break
+
+        if query.lower() in {"exit", "quit"}:
+            print("Goodbye.")
+            break
+
+        # Assertions
+        if query.lower().startswith("assert "):
+            fact = api.assert_fact(query[len("assert "):])
+            engine.reason_forward_until_fixpoint(max_iterations=3)
+            print(f"AURA: Asserted '{fact.to_text()}' (conf={fact.confidence:.2f})\n")
+            continue
+
+        # Queries
+        response = api.query(query)
+        print(f"AURA Response: {response['response']}")
+        print(f"Explanation: {response['explanation']}")
+        print(f"Confidence: {response['confidence']:.2f}")
+
+        if response.get("trace"):
+            print("Recent reasoning trace:")
+            for line in response["trace"][-10:]:
+                print("  -", line)
+        print()
+
+
+if __name__ == "__main__":
+    main()