@geravant/sinain 1.12.0 → 1.14.0

package/sinain-memory/memory-config.json

@@ -14,7 +14,7 @@
     "eval_reporter":       { "model": "smart", "maxTokens": 1000 },
     "triple_extractor":    { "model": "fast",  "maxTokens": 1500, "timeout": 30 },
     "session_distiller":   { "model": "smart", "maxTokens": 1500, "timeout": 30 },
-    "knowledge_integrator": { "model": "smart", "maxTokens": 3000, "timeout": 60 }
+    "knowledge_integrator": { "model": "smart", "maxTokens": 4000, "timeout": 60 }
   },
   "defaults": { "model": "fast", "maxTokens": 1500 },
   "triplestore": {

package/sinain-memory/session_distiller.py

@@ -28,7 +28,7 @@ from common import (
 
 SYSTEM_PROMPT = """\
 You are a session distiller for a personal AI overlay system (sinain).
-Your job: analyze a session transcript and extract structured knowledge.
+Your job: analyze a session transcript and extract ALL knowledge worth remembering.
 
 The transcript contains feed items from sinain-core:
 - audio: transcribed speech from the user's environment
@@ -37,24 +37,42 @@ The transcript contains feed items from sinain-core:
 - system: system events and status messages
 
 Extract:
-1. whatHappened: 2-3 sentences summarizing what was accomplished in this session
-2. patterns: up to 5 reusable patterns discovered (things that worked, techniques used)
-3. antiPatterns: up to 3 things that failed and why
-4. preferences: up to 3 user preferences or workflow habits observed
-5. entities: key domains, tools, technologies, or topics worked with (for graph linking)
-6. toolInsights: tool usage insights (e.g., "grep before read reduces misses")
-
-Focus on ACTIONABLE knowledge that would help a future agent in similar contexts.
-Skip trivial observations. If the session was idle or empty, say so briefly.
+1. whatHappened: 2-3 sentences summarizing what occurred in this session
+2. facts: up to 15 concrete factual claims. Each must be a self-contained sentence. \
+IMPORTANT — spread across these dimensions (do not let one theme dominate):
+   - WHO: people mentioned, their roles, backgrounds, relationships to each other
+   - WHAT: specific claims, properties, descriptions of things discussed
+   - HOW MUCH: any numbers, quantities, dates, durations, counts stated
+   - WHAT CHANGED: decisions made, agreements reached, state changes
+   - WHAT'S NEXT: commitments, action items, plans, deadlines
+   If you have 5+ facts about one dimension and 0 about another that was discussed, \
+you are missing something. Breadth over depth.
+   Good: "The CTO of Al-Futaim previously worked at Citibank for 17 years as Director of IT in Singapore"
+   Good: "Citibank has 2400 IntelliJ subscriptions and heavy TeamCity usage"
+   Good: "The meeting is 45 minutes, scheduled for Tuesday"
+   Bad: "client-understanding-key: True"
+   Bad: five variations of "Al-Futaim is moving to the cloud"
+3. decisions: up to 5 decisions or agreements made (who decided what, with any deadline)
+4. entities: named things discussed or interacted with — as objects with name \
+(lowercase-hyphenated slug) and type (freeform — person, org, tool, file, concept, \
+service, framework, error, whatever fits the context).
+   Examples: {"name": "citibank", "type": "org"}, {"name": "auth-module", "type": "file"}, \
+{"name": "react-native", "type": "framework"}
+5. patterns: up to 3 reusable techniques or workflows (if any — skip if none)
+6. preferences: up to 3 user preferences or habits observed
+
+If existing entities are provided, reference them by name to enable reinforcement.
+Focus on CONCRETE, SPECIFIC knowledge. Skip vague observations.
+If the session was idle or empty, say so briefly.
 
 Respond with ONLY a JSON object:
 {
   "whatHappened": "string",
-  "patterns": ["string", ...],
-  "antiPatterns": ["string", ...],
-  "preferences": ["string", ...],
-  "entities": ["string", ...],
-  "toolInsights": ["string", ...],
+  "facts": ["self-contained factual sentence", ...],
+  "decisions": ["decision sentence with who/what/when", ...],
+  "entities": [{"name": "citibank", "type": "org"}, {"name": "artom", "type": "person"}, ...],
+  "patterns": ["reusable technique or workflow", ...],
+  "preferences": ["user preference or habit", ...],
   "isEmpty": false
 }"""
 
@@ -95,6 +113,7 @@ def main() -> None:
     parser.add_argument("--memory-dir", required=True, help="Path to memory/ directory")
     parser.add_argument("--transcript", required=True, help="JSON array of feed items")
     parser.add_argument("--session-meta", default="{}", help="JSON session metadata")
+    parser.add_argument("--existing-entities", default="", help="Compact summary of existing knowledge graph entities")
     args = parser.parse_args()
 
     # Parse inputs
@@ -111,11 +130,11 @@ def main() -> None:
     if not items or len(items) < 2:
         output_json({
             "whatHappened": "Empty or trivial session",
+            "facts": [],
+            "decisions": [],
+            "entities": [],
             "patterns": [],
-            "antiPatterns": [],
             "preferences": [],
-            "entities": [],
-            "toolInsights": [],
             "isEmpty": True,
         })
         return
@@ -130,11 +149,16 @@ def main() -> None:
         lines = [l for l in playbook.splitlines() if l.strip() and not l.startswith("<!--")]
         playbook_summary = f"\n\n## Current Playbook (for reference — don't repeat known patterns)\n{chr(10).join(lines[:30])}"
 
+    # Include existing entities for retrieve-before-extract (Mem0 pattern)
+    existing_section = ""
+    if args.existing_entities and args.existing_entities.strip():
+        existing_section = f"\n\n## Existing Knowledge (reinforce or update these if the session confirms/changes them)\n{args.existing_entities}"
+
     user_prompt = f"""## Session Transcript ({len(items)} items)
 {transcript_text}
 
 ## Session Metadata
-{json.dumps(meta, indent=2)}{playbook_summary}"""
+{json.dumps(meta, indent=2)}{playbook_summary}{existing_section}"""
 
     try:
         raw = call_llm_with_fallback(

package/sinain-memory/triplestore.py

@@ -79,6 +79,40 @@ CREATE INDEX IF NOT EXISTS idx_avet
     ON triples(attribute, value, entity_id, tx_id);
 """
 
+_FTS_SQL = """
+-- Full-text search on fact values (for hybrid retrieval)
+CREATE VIRTUAL TABLE IF NOT EXISTS triples_fts
+    USING fts5(entity_id, value, content=triples, content_rowid=id);
+
+-- Triggers to keep FTS in sync with triples table
+CREATE TRIGGER IF NOT EXISTS triples_ai AFTER INSERT ON triples BEGIN
+    INSERT INTO triples_fts(rowid, entity_id, value) VALUES (new.id, new.entity_id, new.value);
+END;
+
+CREATE TRIGGER IF NOT EXISTS triples_ad AFTER DELETE ON triples BEGIN
+    INSERT INTO triples_fts(triples_fts, rowid, entity_id, value) VALUES ('delete', old.id, old.entity_id, old.value);
+END;
+
+CREATE TRIGGER IF NOT EXISTS triples_au AFTER UPDATE ON triples BEGIN
+    INSERT INTO triples_fts(triples_fts, rowid, entity_id, value) VALUES ('delete', old.id, old.entity_id, old.value);
+    INSERT INTO triples_fts(rowid, entity_id, value) VALUES (new.id, new.entity_id, new.value);
+END;
+"""
+
+_TOUCHED_SQL = """
+-- Track which entities are modified per transaction (for fast novelty checks)
+CREATE TABLE IF NOT EXISTS touched_entities (
+    tx_id INTEGER NOT NULL,
+    entity_id TEXT NOT NULL,
+    PRIMARY KEY (tx_id, entity_id)
+);
+
+CREATE TRIGGER IF NOT EXISTS track_touched AFTER INSERT ON triples BEGIN
+    INSERT OR IGNORE INTO touched_entities (tx_id, entity_id)
+    VALUES (new.tx_id, new.entity_id);
+END;
+"""
+
 
 def _now_iso() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
@@ -119,6 +153,14 @@ class TripleStore:
         self._conn.execute("PRAGMA journal_mode=WAL")
         self._conn.execute("PRAGMA busy_timeout=10000")
         self._conn.executescript(_SCHEMA_SQL)
+        try:
+            self._conn.executescript(_FTS_SQL)
+        except sqlite3.OperationalError:
+            pass  # FTS5 not available on this Python build — degrade gracefully
+        try:
+            self._conn.executescript(_TOUCHED_SQL)
+        except sqlite3.OperationalError:
+            pass
         self._migrate()
         self._conn.commit()
 
@@ -409,6 +451,24 @@ class TripleStore:
             ).fetchall()
         return [dict(r) for r in rows]
 
+    # ----- Touched entities (fast novelty check) -----
+
+    def was_touched(self, entity_id: str, since_tx: int) -> bool:
+        """Check if entity was modified since a given transaction. O(1) via index."""
+        row = self._conn.execute(
+            "SELECT 1 FROM touched_entities WHERE entity_id = ? AND tx_id > ? LIMIT 1",
+            (entity_id, since_tx),
+        ).fetchone()
+        return row is not None
+
+    def touched_entities_since(self, since_tx: int) -> list[str]:
+        """Return entity_ids modified since a transaction."""
+        rows = self._conn.execute(
+            "SELECT DISTINCT entity_id FROM touched_entities WHERE tx_id > ?",
+            (since_tx,),
+        ).fetchall()
+        return [r[0] for r in rows]
+
     # ----- Stats -----
 
     def stats(self) -> dict:

package/sinain-memory/eval/assertions.py

@@ -1,267 +0,0 @@
-"""Behavioral assertion library for sinain-koog tick evaluation.
-
-Each assertion function validates a runtime invariant of the pipeline.
-Returns ``{"name": str, "passed": bool, "detail": str}``.
-"""
-
-from __future__ import annotations
-
-
-def _result(name: str, passed: bool, detail: str) -> dict:
-    return {"name": name, "passed": passed, "detail": detail}
-
-
-# ---------------------------------------------------------------------------
-# Playbook curator assertions
-# ---------------------------------------------------------------------------
-
-def assert_playbook_under_limit(curator_result: dict, limit: int = 50) -> dict:
-    """Verify playbook body stays under the line limit."""
-    lines = curator_result.get("playbookLines", 0)
-    if lines <= limit:
-        return _result("playbook_under_limit", True, f"body has {lines} lines (limit {limit})")
-    return _result("playbook_under_limit", False, f"body has {lines} lines, exceeds limit of {limit}")
-
-
-def assert_curator_respected_directive(curator_result: dict, directive: str) -> dict:
-    """Check that curator changes align with the curate directive."""
-    changes = curator_result.get("changes", {})
-    added = len(changes.get("added", []))
-    pruned = len(changes.get("pruned", []))
-
-    if directive == "aggressive_prune":
-        # Should have pruned items
-        if pruned > 0:
-            return _result("curator_respected_directive", True,
-                           f"aggressive_prune: pruned {pruned} items")
-        if added == 0 and pruned == 0:
-            return _result("curator_respected_directive", True,
-                           "aggressive_prune: no changes (acceptable if playbook already lean)")
-        return _result("curator_respected_directive", False,
-                       f"aggressive_prune: added {added} but pruned {pruned} — expected pruning")
-
-    if directive == "stability":
-        # Should not aggressively prune established patterns
-        if pruned > added + 2:
-            return _result("curator_respected_directive", False,
-                           f"stability: pruned {pruned} items (only added {added}) — too aggressive for stability mode")
-        return _result("curator_respected_directive", True,
-                       f"stability: added {added}, pruned {pruned} — conservative")
-
-    # normal / insufficient_data — any reasonable mix is fine
-    return _result("curator_respected_directive", True,
-                   f"{directive}: added {added}, pruned {pruned}")
-
-
-# ---------------------------------------------------------------------------
-# Signal analyzer assertions
-# ---------------------------------------------------------------------------
-
-def assert_no_repeat_action(signal_result: dict, recent_logs: list[dict], window: int = 3) -> dict:
-    """Verify recommendedAction doesn't repeat the last N ticks' actions."""
-    action = signal_result.get("recommendedAction")
-    if action is None or action.get("action") == "skip":
-        return _result("no_repeat_action", True, "no action recommended (skip/null)")
-
-    task = (action.get("task") or "").lower().strip()
-    if not task:
-        return _result("no_repeat_action", True, "no task description to compare")
-
-    # Collect recent action tasks
-    recent_tasks: list[str] = []
-    for log in recent_logs[:window]:
-        log_actions = log.get("actionsConsidered", [])
-        for a in log_actions:
-            if a.get("chosen"):
-                recent_tasks.append((a.get("reason") or a.get("task") or "").lower().strip())
-
-    # Check for near-duplicate (substring match to catch rephrasing)
-    for prev_task in recent_tasks:
-        if not prev_task:
-            continue
-        # If >60% of words overlap, consider it a repeat
-        task_words = set(task.split())
-        prev_words = set(prev_task.split())
-        if not task_words or not prev_words:
-            continue
-        overlap = len(task_words & prev_words) / max(len(task_words), len(prev_words))
-        if overlap > 0.6:
-            return _result("no_repeat_action", False,
-                           f"action task '{task[:60]}' overlaps with recent '{prev_task[:60]}' ({overlap:.0%} word overlap)")
-
-    return _result("no_repeat_action", True,
-                   f"action task is distinct from last {window} ticks")
-
-
-def assert_signal_confidence_threshold(signal_result: dict, threshold: float = 0.5) -> dict:
-    """Verify actions are only recommended above the confidence threshold."""
-    action = signal_result.get("recommendedAction")
-    if action is None or action.get("action") == "skip":
-        return _result("signal_confidence_threshold", True, "no action recommended")
-
-    confidence = action.get("confidence")
-    if confidence is None:
-        return _result("signal_confidence_threshold", False,
-                       "action recommended but no confidence value provided")
-
-    if confidence >= threshold:
-        return _result("signal_confidence_threshold", True,
-                       f"confidence {confidence:.2f} >= threshold {threshold}")
-    return _result("signal_confidence_threshold", False,
-                   f"confidence {confidence:.2f} < threshold {threshold}")
-
-
-# ---------------------------------------------------------------------------
-# Insight synthesizer assertions
-# ---------------------------------------------------------------------------
-
-def assert_insight_char_limit(synth_result: dict, limit: int = 500) -> dict:
-    """Verify suggestion+insight stays under the character limit."""
-    if synth_result.get("skip", False):
-        return _result("insight_char_limit", True, "output skipped")
-
-    suggestion = synth_result.get("suggestion", "")
-    insight = synth_result.get("insight", "")
-    total = len(suggestion) + len(insight)
-
-    if total <= limit:
-        return _result("insight_char_limit", True, f"total {total} chars (limit {limit})")
-    return _result("insight_char_limit", False, f"total {total} chars exceeds limit of {limit}")
-
-
-def assert_skip_reason_specific(synth_result: dict) -> dict:
-    """If skip=true, verify the reason is specific (not generic boilerplate)."""
-    if not synth_result.get("skip", False):
-        return _result("skip_reason_specific", True, "output not skipped")
-
-    reason = (synth_result.get("skipReason") or "").strip()
-    if not reason:
-        return _result("skip_reason_specific", False, "skip=true but no skipReason provided")
-
-    # Check against known-generic patterns
-    generic_phrases = [
-        "no new data",
-        "nothing new",
-        "no updates",
-        "insufficient data",
-        "not enough information",
-        "no changes",
-    ]
-    reason_lower = reason.lower()
-    for phrase in generic_phrases:
-        if reason_lower == phrase or (len(reason_lower) < 30 and phrase in reason_lower):
-            return _result("skip_reason_specific", False,
-                           f"skipReason is too generic: '{reason}'")
-
-    return _result("skip_reason_specific", True, f"skipReason is specific ({len(reason)} chars)")
-
-
-# ---------------------------------------------------------------------------
-# Memory miner assertions
-# ---------------------------------------------------------------------------
-
-def assert_miner_references_sources(miner_result: dict, daily_files: list[str]) -> dict:
-    """Verify mining findings reference actual source files that were provided."""
-    mined = miner_result.get("minedSources", [])
-    if not mined:
-        return _result("miner_references_sources", True, "no sources mined (early return)")
-
-    # daily_files contains basenames like "2026-02-21.md"
-    known_basenames = set(daily_files)
-    unknown = [s for s in mined if s not in known_basenames]
-
-    if unknown:
-        return _result("miner_references_sources", False,
-                       f"minedSources references unknown files: {unknown}")
-    return _result("miner_references_sources", True,
-                   f"all {len(mined)} mined sources are valid")
-
-
-# ---------------------------------------------------------------------------
-# Cross-script / structural assertions
-# ---------------------------------------------------------------------------
-
-def assert_schema_valid(script_name: str, output: dict, schema_errors: list[str]) -> dict:
-    """Wrap schema validation result as an assertion."""
-    if not schema_errors:
-        return _result(f"schema_valid_{script_name}", True, "output matches schema")
-    return _result(f"schema_valid_{script_name}", False,
-                   f"{len(schema_errors)} schema errors: {'; '.join(schema_errors[:3])}")
-
-
-def assert_playbook_header_footer_intact(playbook_text: str) -> dict:
-    """Verify the playbook still has its mining-index header and effectiveness footer."""
-    has_header = "<!-- mining-index:" in playbook_text
-    has_footer = "<!-- effectiveness:" in playbook_text
-
-    if has_header and has_footer:
-        return _result("playbook_header_footer_intact", True,
-                       "both mining-index and effectiveness comments present")
-    missing = []
-    if not has_header:
-        missing.append("mining-index")
-    if not has_footer:
-        missing.append("effectiveness")
-    return _result("playbook_header_footer_intact", False,
-                   f"missing playbook comments: {', '.join(missing)}")
-
-
-# ---------------------------------------------------------------------------
-# Runner: execute all applicable assertions for a tick
-# ---------------------------------------------------------------------------
-
-def run_tick_assertions(
-    log_entry: dict,
-    recent_logs: list[dict],
-    playbook_text: str,
-    daily_files: list[str],
-) -> list[dict]:
-    """Run all applicable assertions against a single tick's log entry.
-
-    Returns a list of assertion result dicts.
-    """
-    results: list[dict] = []
-
-    # Signal analyzer assertions
-    signals = log_entry.get("signals")
-    if signals is not None:
-        results.append(assert_signal_confidence_threshold(
-            {"signals": signals, "recommendedAction": log_entry.get("recommendedAction")},
-        ))
-        results.append(assert_no_repeat_action(
-            {"signals": signals, "recommendedAction": log_entry.get("recommendedAction")},
-            recent_logs,
-        ))
-
-    # Curator assertions — playbookChanges can be {"note": "skipped"} or full output
-    curator = log_entry.get("playbookChanges")
-    if isinstance(curator, dict) and "changes" in curator:
-        curator_with_lines = {**curator}
-        if "playbookLines" not in curator_with_lines:
-            curator_with_lines["playbookLines"] = curator.get("playbookLines", 0)
-        results.append(assert_playbook_under_limit(curator_with_lines))
-
-        directive = log_entry.get("curateDirective", "normal")
-        results.append(assert_curator_respected_directive(curator_with_lines, directive))
-
-    # Insight synthesizer assertions — output can be null (pipeline-level skip)
-    output = log_entry.get("output")
-    if isinstance(output, dict):
-        results.append(assert_insight_char_limit(output))
-        results.append(assert_skip_reason_specific(output))
-
-    # Mining assertions — log uses miningFindings (str) and minedSources (list)
-    mining = log_entry.get("miningResult")
-    if mining is not None:
-        results.append(assert_miner_references_sources(mining, daily_files))
-    elif log_entry.get("minedSources"):
-        # Reconstruct mining result from flat log fields
-        results.append(assert_miner_references_sources(
-            {"minedSources": log_entry.get("minedSources", [])}, daily_files
-        ))
-
-    # Playbook health (if we have playbook text)
-    if playbook_text:
-        results.append(assert_playbook_header_footer_intact(playbook_text))
-
-    return results

package/sinain-memory/eval/benchmarks/base_adapter.py

@@ -1,43 +0,0 @@
-"""Base adapter and data classes for benchmark evaluation."""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-
-
-@dataclass
-class BenchmarkQuestion:
-    id: str
-    text: str
-    gold_answer: str
-    category: str  # single-session, multi-session, temporal, etc.
-    evidence_session_ids: list[str] = field(default_factory=list)
-    metadata: dict = field(default_factory=dict)
-
-
-@dataclass
-class BenchmarkInstance:
-    """A set of conversations + questions that share the same context."""
-    id: str
-    sessions: list[list[dict]]  # list of sessions, each a list of feed items {source, text, ts}
-    questions: list[BenchmarkQuestion] = field(default_factory=list)
-    raw_sessions: list[dict] = field(default_factory=list)  # original benchmark format (for full-context condition)
-    metadata: dict = field(default_factory=dict)
-
-
-class BenchmarkAdapter(ABC):
-    """Abstract adapter: converts a published benchmark into sinain's format."""
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Benchmark name (e.g. 'longmemeval', 'locomo')."""
-
-    @abstractmethod
-    def load_dataset(self, data_dir: str) -> list[BenchmarkInstance]:
-        """Download (if needed) and parse the benchmark dataset."""
-
-    @abstractmethod
-    def format_full_context(self, instance: BenchmarkInstance) -> str:
-        """Render the full conversation history as a text string for the baseline condition."""

package/sinain-memory/eval/benchmarks/config.py

@@ -1,23 +0,0 @@
-"""Benchmark configuration — models, paths, thresholds."""
-
-from pathlib import Path
-
-BENCHMARKS_DIR = Path(__file__).resolve().parent
-DATA_DIR = BENCHMARKS_DIR / "data"
-RESULTS_DIR = BENCHMARKS_DIR / "results"
-
-# LLM models (via OpenRouter)
-QA_MODEL = "google/gemini-2.5-flash"
-JUDGE_MODEL = "openai/gpt-4o"
-
-# Retrieval
-K_VALUES = [1, 3, 5, 10]
-MAX_FACTS_PER_QUERY = 10
-
-# Ingestion
-DISTILLER_TIMEOUT_S = 30
-INTEGRATOR_TIMEOUT_S = 60
-
-# Dataset URLs
-LONGMEMEVAL_HF = "xiaowu0162/longmemeval-cleaned"
-LOCOMO_GITHUB = "https://raw.githubusercontent.com/snap-research/locomo/main/data/locomo10.json"