cognitive-engine 0.2.0__py3-none-any.whl

cognitive_engine/memory/hybrid_memory.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from cognitive_engine.core.types import (
+    CompressedKnowledge,
+    GraphQuery,
+    MemoryBundleV2,
+    MemoryQueryV2,
+    PreferenceRecord,
+    ProcedureMemory,
+    ProjectMemoryRecord,
+)
+from cognitive_engine.memory.graph_memory import CognitiveGraphMemory
+
+
+class HybridCognitiveMemory:
+    name = "hybrid_cognitive_memory"
+
+    def __init__(self, base_memory: Any, graph_memory: CognitiveGraphMemory) -> None:
+        self.base_memory = base_memory
+        self.graph_memory = graph_memory
+        self.procedural_records: List[ProcedureMemory] = []
+        self.project_records: Dict[str, ProjectMemoryRecord] = {}
+        self.preferences: Dict[str, PreferenceRecord] = {}
+
+    def describe(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "base": self.base_memory.describe(),
+            "graph": self.graph_memory.describe(),
+            "procedures": len(self.procedural_records),
+            "projects": len(self.project_records),
+            "preferences": len(self.preferences),
+        }
+
+    def update_working_memory(self, semantic_state: Any) -> Dict[str, Any]:
+        return self.base_memory.update_working_memory(semantic_state)
+
+    def retrieve(self, query: Any) -> Any:
+        return self.base_memory.retrieve(query)
+
+    def retrieve_v2(self, query: MemoryQueryV2) -> MemoryBundleV2:
+        base = self.base_memory.retrieve(query)
+        graph_query = query.graph_query or GraphQuery(seeds=query.concepts, project_id=query.project_id, top_k=query.top_k)
+        subgraph = self.graph_memory.query_subgraph(graph_query) if query.include_graph else None
+        project_records = []
+        if query.include_project:
+            if query.project_id and query.project_id in self.project_records:
+                project_records.append(self.project_records[query.project_id])
+            else:
+                project_records.extend(list(self.project_records.values())[: query.top_k])
+        procedures = self._search_procedures(query.concepts, query.top_k) if query.include_procedures else []
+        preferences = list(self.preferences.values())[: query.top_k] if query.include_preferences else []
+        return MemoryBundleV2(
+            short_term=base.short_term,
+            working_memory=base.working_memory,
+            semantic_long_term=base.semantic_long_term,
+            episodic=base.episodic,
+            procedural=procedures,
+            project=project_records,
+            graph_subgraph=subgraph,
+            preferences=preferences,
+            evidence=[],
+        )
+
+    def write(self, knowledge: CompressedKnowledge) -> None:
+        self.base_memory.write(knowledge)
+
+    def write_v2(self, bundle: Any) -> None:
+        for knowledge in getattr(bundle, "compressed_knowledge", []):
+            self.base_memory.write(knowledge)
+        if getattr(bundle, "graph_patch", None):
+            self.graph_memory.apply_patch(bundle.graph_patch)
+        for procedure in getattr(bundle, "procedures", []):
+            self.add_procedure(procedure)
+        for preference in getattr(bundle, "preferences", []):
+            self.preferences[preference.key] = preference
+
+    def add_project_record(self, record: ProjectMemoryRecord) -> None:
+        self.project_records[record.project_id] = record
+
+    def add_procedure(self, procedure: ProcedureMemory) -> None:
+        existing = {item.procedure_id: item for item in self.procedural_records}
+        existing[procedure.procedure_id] = procedure
+        self.procedural_records = list(existing.values())
+
+    def snapshot(self) -> Dict[str, Any]:
+        base = self.base_memory.snapshot()
+        return {
+            **base,
+            "graph": self.graph_memory.snapshot(),
+            "procedural_size": len(self.procedural_records),
+            "project_size": len(self.project_records),
+            "preference_size": len(self.preferences),
+        }
+
+    def consolidate(self) -> Any:
+        return self.base_memory.consolidate()
+
+    def _search_procedures(self, concepts: List[str], top_k: int) -> List[ProcedureMemory]:
+        roots = {concept.lower()[:4] for concept in concepts if len(concept) >= 4}
+        scored = []
+        for procedure in self.procedural_records:
+            text = " ".join([procedure.title, *procedure.domains, *procedure.steps]).lower()
+            score = sum(1 for root in roots if root in text)
+            scored.append((score, procedure))
+        scored.sort(key=lambda item: item[0], reverse=True)
+        return [item for score, item in scored[:top_k] if score > 0]
+

cognitive_engine/memory/project_memory.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+from typing import Any, Dict, Iterable, List
+
+from cognitive_engine.core.types import GraphPatch, ProjectMemoryRecord
+from cognitive_engine.memory.graph_memory import CognitiveGraphMemory
+
+
+class ProjectIndexer:
+    name = "project_indexer"
+
+    def __init__(self, graph_memory: CognitiveGraphMemory) -> None:
+        self.graph_memory = graph_memory
+
+    def describe(self) -> Dict[str, Any]:
+        return {"name": self.name}
+
+    def index_project(self, root_path: str | Path, project_id: str | None = None) -> ProjectMemoryRecord:
+        root = Path(root_path).resolve()
+        project_id = project_id or root.name
+        py_files = [path for path in root.rglob("*.py") if ".venv" not in path.parts and "__pycache__" not in path.parts]
+        modules: List[str] = []
+        dependencies: set[str] = set()
+        tests: List[str] = []
+
+        project_node = self.graph_memory.upsert_node(project_id, "Project", project_id=project_id, metadata={"root": str(root)})
+        for file_path in py_files:
+            rel = str(file_path.relative_to(root))
+            file_node = self.graph_memory.upsert_node(rel, "File", namespace=project_id, project_id=project_id)
+            self.graph_memory.upsert_edge(project_node, file_node, "owns", metadata={"path": rel})
+            if "test" in file_path.name:
+                tests.append(rel)
+            module_name = rel.replace("\\", ".").replace("/", ".").removesuffix(".py")
+            modules.append(module_name)
+            module_node = self.graph_memory.upsert_node(module_name, "Module", namespace=project_id, project_id=project_id)
+            self.graph_memory.upsert_edge(file_node, module_node, "defines")
+            self._index_python_file(file_path, file_node, module_node, dependencies, project_id)
+
+        return ProjectMemoryRecord(
+            project_id=project_id,
+            root_path=str(root),
+            files_indexed=len(py_files),
+            modules=sorted(modules)[:80],
+            dependencies=sorted(dependencies),
+            tests=sorted(tests),
+            commands=["pytest -q"] if tests else [],
+            metadata={"graph": self.graph_memory.snapshot()},
+        )
+
+    def _index_python_file(self, file_path: Path, file_node: Any, module_node: Any, dependencies: set[str], project_id: str) -> None:
+        try:
+            tree = ast.parse(file_path.read_text(encoding="utf-8"))
+        except UnicodeDecodeError:
+            tree = ast.parse(file_path.read_text(encoding="latin-1"))
+        except SyntaxError:
+            return
+
+        for item in ast.walk(tree):
+            if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                fn = self.graph_memory.upsert_node(item.name, "Function", namespace=str(file_path), project_id=project_id, metadata={"line": item.lineno})
+                self.graph_memory.upsert_edge(file_node, fn, "defines")
+                self.graph_memory.upsert_edge(module_node, fn, "defines")
+            elif isinstance(item, ast.ClassDef):
+                cls = self.graph_memory.upsert_node(item.name, "Class", namespace=str(file_path), project_id=project_id, metadata={"line": item.lineno})
+                self.graph_memory.upsert_edge(file_node, cls, "defines")
+                self.graph_memory.upsert_edge(module_node, cls, "defines")
+            elif isinstance(item, ast.Import):
+                for alias in item.names:
+                    dep = alias.name.split(".")[0]
+                    dependencies.add(dep)
+                    dep_node = self.graph_memory.upsert_node(dep, "Dependency", project_id=project_id)
+                    self.graph_memory.upsert_edge(file_node, dep_node, "imports")
+            elif isinstance(item, ast.ImportFrom) and item.module:
+                dep = item.module.split(".")[0]
+                dependencies.add(dep)
+                dep_node = self.graph_memory.upsert_node(dep, "Dependency", project_id=project_id)
+                self.graph_memory.upsert_edge(file_node, dep_node, "imports")
+

cognitive_engine/memory/stores.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from collections import Counter, deque
+from typing import Any, Deque, Dict, List
+
+import numpy as np
+
+from cognitive_engine.config.schema import MemoryConfig
+from cognitive_engine.core.types import CompressedKnowledge, ConsolidationReport, MemoryBundle, MemoryQuery, SemanticState
+from cognitive_engine.memory.vector_store import NumpyVectorIndex
+
+
+class HierarchicalMemorySystem:
+    name = "hierarchical_memory_system"
+
+    def __init__(self, config: MemoryConfig) -> None:
+        self.config = config
+        self.embedding_dim = 64
+        self.short_term: Deque[CompressedKnowledge] = deque(maxlen=config.short_term_capacity)
+        self.episodic: Deque[CompressedKnowledge] = deque(maxlen=config.episodic_capacity)
+        self.semantic_records: Dict[str, CompressedKnowledge] = {}
+        self.vector_index = NumpyVectorIndex()
+        self.working_state: Dict[str, Any] = {
+            "active_intent": None,
+            "active_concepts": [],
+            "recent_entities": [],
+            "session_goals": [],
+        }
+
+    def describe(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "short_term_capacity": self.config.short_term_capacity,
+            "episodic_capacity": self.config.episodic_capacity,
+            "semantic_capacity": self.config.semantic_capacity,
+        }
+
+    def update_working_memory(self, semantic_state: SemanticState) -> Dict[str, Any]:
+        concepts = [concept.label for concept in semantic_state.concepts[:6]]
+        self.working_state["active_intent"] = semantic_state.intent
+        self.working_state["active_concepts"] = concepts
+        self.working_state["recent_entities"] = semantic_state.entities[:6]
+        return dict(self.working_state)
+
+    def retrieve(self, query: MemoryQuery) -> MemoryBundle:
+        semantic_hits = []
+        aligned_query = self._align_embedding(query.embedding)
+        query_roots = {concept.lower()[:4] for concept in query.concepts if len(concept) >= 4}
+        scored_records = []
+        for record_id, record in self.semantic_records.items():
+            record_vector = record.embedding / (np.linalg.norm(record.embedding) or 1.0)
+            query_vector = aligned_query / (np.linalg.norm(aligned_query) or 1.0)
+            vector_score = float(np.dot(query_vector, record_vector))
+            record_roots = {concept.lower()[:4] for concept in record.concepts if len(concept) >= 4}
+            lexical_score = 0.0
+            if query_roots:
+                lexical_score = len(query_roots & record_roots) / len(query_roots)
+            score = 0.65 * vector_score + 0.35 * lexical_score
+            if query.intent == "question" and lexical_score > 0:
+                score += 0.25 * lexical_score
+            if query.intent == "question" and any(root in {"pref", "gust"} for root in query_roots):
+                if record.provenance.get("intent") == "preference" or "preference" in record.summary.lower():
+                    score += 0.35
+            scored_records.append((record_id, score))
+
+        scored_records.sort(key=lambda item: item[1], reverse=True)
+        for record_id, score in scored_records[: query.top_k]:
+            record = self.semantic_records[record_id]
+            enriched = CompressedKnowledge(
+                **{
+                    **record.__dict__,
+                    "metadata": {**record.metadata, "similarity": score},
+                }
+            )
+            semantic_hits.append(enriched)
+        return MemoryBundle(
+            short_term=list(self.short_term)[-query.top_k:],
+            working_memory=dict(self.working_state),
+            semantic_long_term=semantic_hits,
+            episodic=list(self.episodic)[-query.top_k:],
+        )
+
+    def write(self, knowledge: CompressedKnowledge) -> None:
+        knowledge.embedding = self._align_embedding(knowledge.embedding)
+        self.short_term.append(knowledge)
+        self.episodic.append(knowledge)
+        existing_id = self._find_duplicate(knowledge)
+        if existing_id:
+            existing = self.semantic_records[existing_id]
+            existing.reinforced_count += 1
+            existing.importance = max(existing.importance, knowledge.importance)
+            existing.confidence = max(existing.confidence, knowledge.confidence)
+            existing.summary = knowledge.summary if knowledge.importance >= existing.importance else existing.summary
+            existing.concepts = list(dict.fromkeys(existing.concepts + knowledge.concepts))
+            self.vector_index.upsert(existing_id, existing.embedding)
+            return
+
+        if len(self.semantic_records) >= self.config.semantic_capacity:
+            weakest = min(
+                self.semantic_records.items(),
+                key=lambda item: item[1].importance * item[1].confidence * max(item[1].reinforced_count, 1),
+            )[0]
+            self.semantic_records.pop(weakest, None)
+            self.vector_index.delete(weakest)
+        self.semantic_records[knowledge.record_id] = knowledge
+        self.vector_index.upsert(knowledge.record_id, knowledge.embedding)
+
+    def snapshot(self) -> Dict[str, Any]:
+        concept_counter = Counter()
+        for record in self.semantic_records.values():
+            concept_counter.update(record.concepts)
+        return {
+            "short_term_size": len(self.short_term),
+            "episodic_size": len(self.episodic),
+            "semantic_size": len(self.semantic_records),
+            "top_concepts": concept_counter.most_common(10),
+            "working_state": dict(self.working_state),
+        }
+
+    def consolidate(self) -> ConsolidationReport:
+        merged = 0
+        pruned = 0
+        records = list(self.semantic_records.values())
+        visited = set()
+        for left in records:
+            if left.record_id in visited:
+                continue
+            for right in records:
+                if left.record_id == right.record_id or right.record_id in visited:
+                    continue
+                similarity = float(np.dot(left.embedding, right.embedding))
+                overlap = len(set(left.concepts) & set(right.concepts))
+                if similarity > 0.97 or overlap >= 3:
+                    left.reinforced_count += right.reinforced_count
+                    left.importance = max(left.importance, right.importance)
+                    left.confidence = max(left.confidence, right.confidence)
+                    left.concepts = list(dict.fromkeys(left.concepts + right.concepts))
+                    visited.add(right.record_id)
+                    merged += 1
+        for record_id in visited:
+            self.semantic_records.pop(record_id, None)
+            self.vector_index.delete(record_id)
+
+        if len(self.semantic_records) > self.config.semantic_capacity:
+            items = sorted(
+                self.semantic_records.values(),
+                key=lambda record: record.importance * record.confidence * max(record.reinforced_count, 1),
+                reverse=True,
+            )
+            keep = {record.record_id for record in items[: self.config.semantic_capacity]}
+            for record_id in list(self.semantic_records):
+                if record_id not in keep:
+                    self.semantic_records.pop(record_id, None)
+                    self.vector_index.delete(record_id)
+                    pruned += 1
+        return ConsolidationReport(
+            merged_records=merged,
+            pruned_records=pruned,
+            replay_reweighted=0,
+            notes="Merged highly similar concepts and trimmed low-value semantic residues.",
+        )
+
+    def _find_duplicate(self, knowledge: CompressedKnowledge) -> str | None:
+        hits = self.vector_index.search(knowledge.embedding, top_k=1)
+        if not hits:
+            return None
+        record_id, score = hits[0]
+        if score > 0.985 or len(set(self.semantic_records[record_id].concepts) & set(knowledge.concepts)) >= 3:
+            return record_id
+        return None
+
+    def _align_embedding(self, embedding: np.ndarray) -> np.ndarray:
+        if embedding.shape[0] < self.embedding_dim:
+            return np.pad(embedding, (0, self.embedding_dim - embedding.shape[0]))
+        if embedding.shape[0] > self.embedding_dim:
+            return embedding[: self.embedding_dim]
+        return embedding

cognitive_engine/memory/vector_store.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple
+
+import numpy as np
+
+
+@dataclass
+class NumpyVectorIndex:
+    embeddings: Dict[str, np.ndarray] = field(default_factory=dict)
+
+    def upsert(self, record_id: str, embedding: np.ndarray) -> None:
+        norm = np.linalg.norm(embedding) or 1.0
+        self.embeddings[record_id] = embedding.astype(np.float32) / norm
+
+    def delete(self, record_id: str) -> None:
+        self.embeddings.pop(record_id, None)
+
+    def search(self, embedding: np.ndarray, top_k: int = 5) -> List[Tuple[str, float]]:
+        if not self.embeddings:
+            return []
+        query = embedding.astype(np.float32)
+        query /= np.linalg.norm(query) or 1.0
+        scores = [(record_id, float(np.dot(query, stored))) for record_id, stored in self.embeddings.items()]
+        scores.sort(key=lambda item: item[1], reverse=True)
+        return scores[:top_k]
+

cognitive_engine/models/__init__.py

@@ -0,0 +1,2 @@
+"""Stable core models."""
+

cognitive_engine/models/stable_core.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import torch
+from torch import nn
+
+from cognitive_engine.core.types import CoreInference, MemoryBundle, RoutingDecision, SemanticState
+from cognitive_engine.interfaces.base import StableCore
+
+
+class StableReasoningCore(nn.Module, StableCore):
+    name = "stable_reasoning_core"
+
+    def __init__(self, latent_dim: int = 64, device: str = "cpu") -> None:
+        super().__init__()
+        self.device = device
+        self.projector = nn.Sequential(nn.Linear(latent_dim, latent_dim), nn.Tanh(), nn.Linear(latent_dim, latent_dim))
+        for parameter in self.projector.parameters():
+            parameter.requires_grad = False
+        self.to(self.device)
+
+    def describe(self) -> Dict[str, Any]:
+        return {"name": self.name, "latent_dim": 64, "frozen": True}
+
+    def infer(
+        self,
+        semantic_state: SemanticState,
+        memory_bundle: MemoryBundle,
+        routing: RoutingDecision,
+        plastic_output: Optional[CoreInference] = None,
+    ) -> CoreInference:
+        latent = self._project(semantic_state.pooled_embedding.float().to(self.device))
+        if semantic_state.modality == "numeric" and plastic_output is not None:
+            summaries = [record.summary for record in memory_bundle.semantic_long_term[:2]]
+            memory_hint = " | ".join(summaries) if summaries else "No previous arithmetic consolidation available."
+            explanation = (
+                f"Resultado estimado: {plastic_output.prediction:.3f}. "
+                f"Confianza={plastic_output.confidence:.3f}. "
+                f"Memoria relevante: {memory_hint}"
+            )
+            return CoreInference(
+                prediction=plastic_output.prediction,
+                confidence=plastic_output.confidence,
+                explanation=explanation,
+                hidden_state=latent.squeeze(0),
+                artifacts={"memory_hint": memory_hint, "route": routing.rationale},
+            )
+
+        summaries = [record.summary for record in memory_bundle.semantic_long_term[:3]]
+        current_action = semantic_state.metadata.get("importance_action", "observe")
+        if semantic_state.intent == "question":
+            if summaries:
+                answer = " | ".join(summaries)
+            else:
+                answer = "No hay conocimiento consolidado suficiente; la consulta queda en modo exploratorio."
+        elif current_action in {"learn", "reinforce", "consolidate"}:
+            answer = f"Información analizada y comprimida como: {semantic_state.compressed_context}"
+        else:
+            answer = f"Información observada sin actualización fuerte de memoria: {semantic_state.compressed_context}"
+        return CoreInference(
+            prediction=answer,
+            confidence=0.72,
+            explanation=answer,
+            hidden_state=latent.squeeze(0),
+            artifacts={
+                "active_concepts": memory_bundle.working_memory.get("active_concepts", []),
+                "retrieved_summaries": summaries,
+            },
+        )
+
+    def _project(self, pooled_embedding: torch.Tensor) -> torch.Tensor:
+        vector = pooled_embedding.unsqueeze(0)
+        if vector.shape[-1] < 64:
+            vector = torch.nn.functional.pad(vector, (0, 64 - vector.shape[-1]))
+        elif vector.shape[-1] > 64:
+            vector = vector[:, :64]
+        return self.projector(vector)
+

cognitive_engine/modules/__init__.py

@@ -0,0 +1,2 @@
+"""Input and semantic processing modules."""
+

cognitive_engine/modules/importance_evaluator.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+import numpy as np
+
+from cognitive_engine.config.schema import ThresholdConfig
+from cognitive_engine.core.types import ImportanceAssessment, MemoryBundle, SemanticState, tensor_to_numpy
+from cognitive_engine.interfaces.base import ImportanceEvaluator
+
+
+class AdaptiveImportanceEvaluator(ImportanceEvaluator):
+    name = "adaptive_importance_evaluator"
+
+    def __init__(self, thresholds: ThresholdConfig) -> None:
+        self.thresholds = thresholds
+
+    def describe(self) -> Dict[str, Any]:
+        return {"name": self.name, "thresholds": self.thresholds.__dict__}
+
+    def evaluate(self, semantic_state: SemanticState, memory_bundle: MemoryBundle) -> ImportanceAssessment:
+        if memory_bundle.semantic_long_term:
+            similarities = [record.metadata.get("similarity", 0.0) for record in memory_bundle.semantic_long_term]
+            redundancy = float(np.mean(similarities))
+            novelty = 1.0 - redundancy
+        else:
+            redundancy = 0.0
+            novelty = 1.0
+
+        intent_weight = {
+            "correction": 0.95,
+            "knowledge_share": 0.85,
+            "preference": 0.9,
+            "question": 0.42,
+            "small_talk": 0.12,
+        }
+        utility = intent_weight.get(semantic_state.intent, 0.55)
+        concept_count = len(semantic_state.concepts)
+        coherence = min(1.0, 0.35 + 0.1 * concept_count)
+        frequency = min(1.0, len(memory_bundle.short_term) / 10.0)
+        correction_signal = 1.0 if semantic_state.intent == "correction" else 0.15
+        future_relevance = min(
+            1.0,
+            0.25 + 0.2 * concept_count + (0.25 if semantic_state.intent in {"knowledge_share", "preference"} else 0.0),
+        )
+        if semantic_state.intent == "preference":
+            future_relevance = min(1.0, future_relevance + 0.1)
+        contradiction_risk = 0.15 + (0.35 if semantic_state.intent == "correction" and redundancy > 0.7 else 0.0)
+        importance_score = (
+            novelty * 0.28
+            + utility * 0.24
+            + coherence * 0.12
+            + future_relevance * 0.18
+            + correction_signal * 0.1
+            + frequency * 0.08
+            - redundancy * 0.12
+            - contradiction_risk * 0.08
+        )
+        importance_score = float(max(0.0, min(1.0, importance_score)))
+        confidence_score = float(max(0.05, min(1.0, coherence * (1.0 - contradiction_risk * 0.5))))
+        learning_priority = float(max(0.0, min(1.0, importance_score * 0.7 + confidence_score * 0.3)))
+
+        if contradiction_risk > self.thresholds.contradiction and confidence_score < self.thresholds.uncertainty:
+            action = "uncertain"
+            rationale = "Potential contradiction detected, holding update until corroboration arrives."
+        elif learning_priority >= self.thresholds.consolidate:
+            action = "consolidate"
+            rationale = "High-value information with durable relevance; consolidate into long-term semantic memory."
+        elif learning_priority >= self.thresholds.reinforce:
+            action = "reinforce"
+            rationale = "Related knowledge already exists; reinforce instead of broad plastic updates."
+        elif learning_priority >= self.thresholds.learn:
+            action = "learn"
+            rationale = "Novel information passed learning threshold and can be compressed for memory."
+        elif semantic_state.intent == "preference" and confidence_score >= 0.65:
+            action = "learn"
+            rationale = "User preference retained despite moderate novelty because it affects future dialogue behavior."
+        else:
+            action = "ignore"
+            rationale = "Signal is too weak or redundant to justify memory update."
+
+        return ImportanceAssessment(
+            novelty=novelty,
+            utility=utility,
+            frequency=frequency,
+            coherence=coherence,
+            correction_signal=correction_signal,
+            redundancy=redundancy,
+            future_relevance=future_relevance,
+            contradiction_risk=contradiction_risk,
+            importance_score=importance_score,
+            confidence_score=confidence_score,
+            learning_priority=learning_priority,
+            action=action,
+            rationale=rationale,
+        )

cognitive_engine/modules/input_processing.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+import torch
+
+from cognitive_engine.core.types import ProcessedInput
+from cognitive_engine.interfaces.base import InputProcessor
+from cognitive_engine.utils.numeric import OPERATIONS
+from cognitive_engine.utils.text import detect_intent, hashed_token_ids, normalize_text, tokenize_text
+
+
+class TextInputProcessor(InputProcessor):
+    name = "text_input_processor"
+
+    def __init__(self, vocab_size: int = 4096, max_length: int = 96, device: str = "cpu") -> None:
+        self.vocab_size = vocab_size
+        self.max_length = max_length
+        self.device = device
+
+    def describe(self) -> Dict[str, Any]:
+        return {"name": self.name, "vocab_size": self.vocab_size, "max_length": self.max_length}
+
+    def supports(self, payload: Any) -> bool:
+        return isinstance(payload, str)
+
+    def process(self, payload: Any) -> ProcessedInput:
+        text = normalize_text(str(payload))
+        tokens = tokenize_text(text)[: self.max_length]
+        token_ids = hashed_token_ids(tokens, self.vocab_size) or [0]
+        tensor = torch.tensor(token_ids, dtype=torch.long, device=self.device).unsqueeze(0)
+        attention = torch.ones_like(tensor)
+        return ProcessedInput(
+            raw_input=payload,
+            modality="text",
+            normalized_text=text,
+            tokens=tokens,
+            token_tensor=tensor,
+            attention_mask=attention,
+            metadata={"intent_hint": detect_intent(text)},
+        )
+
+
+class NumericInputProcessor(InputProcessor):
+    name = "numeric_input_processor"
+
+    def __init__(self, device: str = "cpu", scale: float = 12.0) -> None:
+        self.device = device
+        self.scale = scale
+        self.operation_to_id = dict(OPERATIONS)
+
+    def describe(self) -> Dict[str, Any]:
+        return {"name": self.name, "scale": self.scale, "operations": self.operation_to_id}
+
+    def supports(self, payload: Any) -> bool:
+        return isinstance(payload, dict) and payload.get("modality") == "numeric"
+
+    def process(self, payload: Any) -> ProcessedInput:
+        left = float(payload["a"])
+        right = float(payload["b"])
+        operation = str(payload["operation"])
+        features = torch.tensor([[left / self.scale, right / self.scale]], dtype=torch.float32, device=self.device)
+        metadata = {
+            "a": left,
+            "b": right,
+            "scale": self.scale,
+            "operation_id": self.operation_to_id[operation],
+            "intent_hint": "knowledge_share" if "target" in payload else "question",
+        }
+        if "target" in payload:
+            metadata["target"] = float(payload["target"])
+        return ProcessedInput(
+            raw_input=payload,
+            modality="numeric",
+            numeric_tensor=features,
+            operation=operation,
+            metadata=metadata,
+        )