feat: implement hot-ingestion daemon and tactical state-responder plugin

src/core/affect.py

@@ -0,0 +1,23 @@
+import re, string
+
+_POS = {"great", "awesome", "fantastic", "good", "excellent", "optimal", "stable", "secure"}
+_NEG = {"bad", "terrible", "awful", "hate", "horrible", "angry", "frustrated", "error", "fail"}
+_HIGH_AROUSAL = {"!", "!!", "!!!"}
+_LOW_AROUSAL = {"...", "…"}
+
+def _clean(text: str) -> str:
+    return text.translate(str.maketrans("", "", string.punctuation)).lower()
+
+def extract_affect(text: str) -> tuple[float, float]:
+    tokens = set(_clean(text).split())
+    pos = len(tokens & _POS)
+    neg = len(tokens & _NEG)
+    
+    sentiment = 0.0 if pos == neg == 0 else (pos - neg) / max(pos + neg, 1)
+    valence = (sentiment + 1) / 2
+    
+    arousal = 0.5
+    if any(p in text for p in _HIGH_AROUSAL): arousal = 0.9
+    elif any(p in text for p in _LOW_AROUSAL): arousal = 0.2
+    
+    return round(valence, 3), round(arousal, 3)

src/core/session_mood.py

@@ -0,0 +1,13 @@
+import threading
+from collections import defaultdict
+from typing import Tuple
+
+_lock = threading.Lock()
+_default = (0.5, 0.5)
+_mood_store: defaultdict[str, Tuple[float, float]] = defaultdict(lambda: _default)
+
+def get_mood(client_id: str) -> Tuple[float, float]:
+    with _lock: return _mood_store[client_id]
+
+def set_mood(client_id: str, valence: float, arousal: float) -> None:
+    with _lock: _mood_store[client_id] = (valence, arousal)

src/plugins/affect_responder.py

@@ -0,0 +1,27 @@
+from typing import Dict, Any
+from src.core.session_mood import get_mood, set_mood
+from src.core.affect import extract_affect
+
+class AffectResponder:
+    name = "affect_responder"
+
+    def on_payload(self, payload: Dict[str, Any], client_id: str = "local_admin") -> Dict[str, Any]:
+        last_step = payload.get("steps", [{}])[-1] if payload.get("steps") else {}
+        text_input = last_step.get("text", "")
+        
+        valence, arousal = extract_affect(text_input)
+        
+        affect_msg = None
+        if valence < 0.35 and arousal > 0.7:
+            affect_msg = "[STATE: AGITATED] Switching to high-precision diagnostic output. State recorded."
+            set_mood(client_id, valence, arousal)
+        elif valence < 0.35 and arousal <= 0.7:
+            affect_msg = "[STATE: SUB-OPTIMAL] Acknowledged. Proceeding with factual resolution."
+            set_mood(client_id, valence, arousal)
+        else:
+            set_mood(client_id, 0.5, 0.5)
+
+        base_answer = payload.get("final_conclusion", {}).get("label", "Operation complete.")
+        final_reply = f"{affect_msg} {base_answer}" if affect_msg else base_answer
+
+        return {"final_reply": final_reply}

watcher.py

@@ -1,65 +1,30 @@
-import os
-import sys
-import time
-import json
-import urllib.request
+import time, os
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+from src.core.watchdog import update_manifest
+from src.core.memory_engine import MemoryEngine
 
-WATCH_DIR = os.path.join(os.getcwd(), "storage/knowledge")
-API_URL = "http://127.0.0.1:5000/api/ingest"
-
-def compute_directory_snapshot(target_directory):
-    """Generates an absolute structural state index based on file modification timestamps."""
-    snapshot = {}
-    if not os.path.exists(target_directory):
-        return snapshot
+class VaultHandler(FileSystemEventHandler):
+    def __init__(self):
+        self.engine = MemoryEngine()
         
-    for root, _, files in os.walk(target_directory):
-        for filename in files:
-            # Bypass system manifest layers to prevent tracking recursion loops
-            if filename in ["chunks_manifest.json", "vectors_cache.pt"]:
-                continue
-            file_path = os.path.join(root, filename)
-            try:
-                snapshot[file_path] = os.path.getmtime(file_path)
-            except OSError:
-                continue
-    return snapshot
-
-def signal_hot_ingestion():
-    """Dispatches an internal loopback network signal to trigger zero-downtime vector compilation."""
-    payload = json.dumps({"directory": "storage/knowledge"}).encode('utf-8')
-    req = urllib.request.Request(
-        API_URL, 
-        data=payload, 
-        headers={'Content-Type': 'application/json'}, 
-        method='POST'
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=30) as response:
-            res_data = json.loads(response.read().decode('utf-8'))
-            print(f"[+] Daemon: Matrix re-compilation complete. Active Nodes: {res_data.get('active_nodes')}")
-    except Exception as e:
-        print(f"[-] Daemon: Integrity signal delivery failed. Target endpoint error: {str(e)}")
-
-def start_daemon_loop():
-    print(f"[*] Initializing Sovereign File-Watcher Daemon tracking: {WATCH_DIR}")
-    last_known_state = compute_directory_snapshot(WATCH_DIR)
-    
-    while True:
-        try:
-            time.sleep(3)  # Low-overhead 3-second evaluation cycles
-            current_state = compute_directory_snapshot(WATCH_DIR)
-            
-            if current_state != last_known_state:
-                print("[*] Daemon: File-system mutation detected inside secure knowledge vault.")
-                signal_hot_ingestion()
-                last_known_state = current_state
-        except KeyboardInterrupt:
-            print("\n[*] Terminating File-Watcher Daemon safely.")
-            sys.exit(0)
-        except Exception as e:
-            print(f"[!] Daemon Runtime Exception: {str(e)}")
-            time.sleep(5)
+    def on_modified(self, event):
+        if event.src_path.endswith(".txt"):
+            print(f"[*] Change detected in {event.src_path}. Re-signing manifest & Hot-ingesting...")
+            update_manifest()
+            self.engine.ingest_knowledge() # Re-builds local FAISS tensors
+            print("[+] Hot-ingestion complete. System secure.")
 
 if __name__ == "__main__":
-    start_daemon_loop()
+    if not os.path.exists("storage/knowledge/manifest.sha256"):
+        update_manifest()
+    
+    observer = Observer()
+    observer.schedule(VaultHandler(), path='storage/knowledge', recursive=False)
+    observer.start()
+    print("[*] FSI Hot-Ingestion Daemon Active. Watching storage/knowledge...")
+    try:
+        while True: time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+    observer.join()