nexo-brain 2.2.0 → 2.3.0

package/src/db/_cron_runs.py

@@ -0,0 +1,74 @@
+"""NEXO DB — Cron execution history."""
+from db._core import get_db
+
+
+def cron_run_start(cron_id: str) -> int:
+    """Record a cron starting. Returns the run ID."""
+    conn = get_db()
+    cursor = conn.execute(
+        "INSERT INTO cron_runs (cron_id) VALUES (?)", (cron_id,)
+    )
+    conn.commit()
+    return cursor.lastrowid
+
+
+def cron_run_end(run_id: int, exit_code: int, summary: str = '', error: str = ''):
+    """Record a cron finishing."""
+    conn = get_db()
+    conn.execute(
+        """UPDATE cron_runs
+           SET ended_at = datetime('now'),
+               exit_code = ?,
+               summary = ?,
+               error = ?,
+               duration_secs = ROUND((julianday(datetime('now')) - julianday(started_at)) * 86400, 1)
+           WHERE id = ?""",
+        (exit_code, summary[:500], error[:500], run_id)
+    )
+    conn.commit()
+
+
+def cron_runs_recent(hours: int = 24, cron_id: str = '') -> list[dict]:
+    """Get recent cron executions."""
+    conn = get_db()
+    if cron_id:
+        rows = conn.execute(
+            """SELECT * FROM cron_runs
+               WHERE cron_id = ? AND started_at >= datetime('now', ?)
+               ORDER BY started_at DESC""",
+            (cron_id, f"-{hours} hours")
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            """SELECT * FROM cron_runs
+               WHERE started_at >= datetime('now', ?)
+               ORDER BY started_at DESC""",
+            (f"-{hours} hours",)
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def cron_runs_summary(hours: int = 24) -> list[dict]:
+    """Get summary per cron: last run, success rate, avg duration."""
+    conn = get_db()
+    rows = conn.execute(
+        """SELECT
+               cron_id,
+               COUNT(*) as total_runs,
+               SUM(CASE WHEN exit_code = 0 THEN 1 ELSE 0 END) as succeeded,
+               SUM(CASE WHEN exit_code != 0 OR exit_code IS NULL THEN 1 ELSE 0 END) as failed,
+               ROUND(AVG(duration_secs), 1) as avg_duration,
+               MAX(started_at) as last_run,
+               (SELECT exit_code FROM cron_runs cr2
+                WHERE cr2.cron_id = cron_runs.cron_id
+                ORDER BY started_at DESC LIMIT 1) as last_exit_code,
+               (SELECT summary FROM cron_runs cr3
+                WHERE cr3.cron_id = cron_runs.cron_id AND cr3.summary != ''
+                ORDER BY started_at DESC LIMIT 1) as last_summary
+           FROM cron_runs
+           WHERE started_at >= datetime('now', ?)
+           GROUP BY cron_id
+           ORDER BY last_run DESC""",
+        (f"-{hours} hours",)
+    ).fetchall()
+    return [dict(r) for r in rows]

package/src/db/_episodic.py

@@ -568,17 +568,35 @@ def get_orphan_sessions(ttl_seconds: int = 900) -> list[dict]:
 
 
 def read_session_diary(session_id: str = '', last_n: int = 3, last_day: bool = False,
-                       domain: str = '') -> list[dict]:
+                       domain: str = '', include_automated: bool = False) -> list[dict]:
     """Read session diary entries.
 
     - session_id: returns entries for that specific session
     - last_day: returns ALL entries from the most recent day (multi-terminal aware)
     - last_n: returns last N entries (default)
     - domain: filter by project context (nexo, other)
+    - include_automated: if False (default), excludes automated sessions (auto-close,
+      cron diaries, etc.). Only returns human-interactive sessions.
+      Email sessions (user sends email, NEXO responds) ARE included — they're real interactions.
     """
     conn = get_db()
     domain_clause = " AND domain = ?" if domain else ""
     domain_params = (domain,) if domain else ()
+    # By default, filter out automated sessions so startup shows human sessions only.
+    # Keeps: interactive sessions + auto-closed sessions that had real user interaction.
+    # An auto-close is human if it has heartbeats > 0 (heartbeat only fires on user messages).
+    # Excludes: cron jobs, auto-closed crons (0 heartbeats or "Minimal diary").
+    if include_automated:
+        source_clause = ""
+    else:
+        source_clause = (
+            " AND ("
+            "  (source = 'claude' AND summary NOT LIKE '[AUTO-%')"
+            "  OR (source = 'auto-close'"
+            "      AND mental_state NOT LIKE '%0 heartbeats%'"
+            "      AND mental_state NOT LIKE '%Minimal diary%')"
+            ")"
+        )
 
     if session_id:
         rows = conn.execute(
@@ -586,25 +604,25 @@ def read_session_diary(session_id: str = '', last_n: int = 3, last_day: bool = F
             (session_id,) + domain_params
         ).fetchall()
     elif last_day:
-        # Get all entries from the most recent calendar day
+        # Get all entries from the most recent calendar day (human sessions only)
         if domain:
             latest = conn.execute(
-                "SELECT date(created_at) as day FROM session_diary WHERE domain = ? ORDER BY created_at DESC LIMIT 1",
+                f"SELECT date(created_at) as day FROM session_diary WHERE domain = ?{source_clause} ORDER BY created_at DESC LIMIT 1",
                 (domain,)
             ).fetchone()
         else:
             latest = conn.execute(
-                "SELECT date(created_at) as day FROM session_diary ORDER BY created_at DESC LIMIT 1"
+                f"SELECT date(created_at) as day FROM session_diary WHERE 1=1{source_clause} ORDER BY created_at DESC LIMIT 1"
             ).fetchone()
         if not latest:
             return []
         rows = conn.execute(
-            f"SELECT * FROM session_diary WHERE date(created_at) = ?{domain_clause} ORDER BY created_at DESC",
+            f"SELECT * FROM session_diary WHERE date(created_at) = ?{domain_clause}{source_clause} ORDER BY created_at DESC",
             (latest['day'],) + domain_params
         ).fetchall()
     else:
         rows = conn.execute(
-            f"SELECT * FROM session_diary WHERE 1=1{domain_clause} ORDER BY created_at DESC LIMIT ?",
+            f"SELECT * FROM session_diary WHERE 1=1{domain_clause}{source_clause} ORDER BY created_at DESC LIMIT ?",
             domain_params + (last_n,)
         ).fetchall()
     return [dict(r) for r in rows]
@@ -732,6 +750,22 @@ def recall(query: str, days: int = 30) -> list[dict]:
     """, [cutoff_str] + params).fetchall()
     results.extend([dict(r) for r in rows])
 
+    # Skills
+    try:
+        frag, params = _multi_word_like(query, ["name", "description", "tags", "trigger_patterns"])
+        rows = conn.execute(f"""
+            SELECT id, created_at, 'skill' AS source,
+                   name AS title,
+                   (COALESCE(description,'') || ' | ' || COALESCE(tags,'') || ' | ' || COALESCE(trigger_patterns,'')) AS snippet,
+                   level AS category, 0 AS rank
+            FROM skills
+            WHERE created_at >= ? AND ({frag})
+            ORDER BY trust_score DESC LIMIT 10
+        """, [cutoff_str] + params).fetchall()
+        results.extend([dict(r) for r in rows])
+    except Exception:
+        pass  # Table may not exist yet during migration
+
     results.sort(key=lambda r: r.get('created_at', ''), reverse=True)
     return results[:20]
 

package/src/db/_schema.py

@@ -295,7 +295,69 @@ def _m15_core_rules_tables(conn):
     conn.execute("CREATE INDEX IF NOT EXISTS idx_core_rules_active ON core_rules(is_active)")
 
 
+def _m16_skills_tables(conn):
+    """Skill Auto-Creation system — reusable procedures extracted from complex tasks.
+
+    Skills are procedural knowledge (step-by-step how-tos) vs learnings which are
+    declarative (don't do X). Pipeline: trace → draft → published, fully autonomous.
+    Trust score with decay controls quality without human approval gates.
+    """
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS skills (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            description TEXT DEFAULT '',
+            level TEXT NOT NULL DEFAULT 'trace',
+            trust_score INTEGER NOT NULL DEFAULT 50,
+            file_path TEXT DEFAULT '',
+            tags TEXT DEFAULT '[]',
+            trigger_patterns TEXT DEFAULT '[]',
+            source_sessions TEXT DEFAULT '[]',
+            linked_learnings TEXT DEFAULT '[]',
+            use_count INTEGER DEFAULT 0,
+            success_count INTEGER DEFAULT 0,
+            fail_count INTEGER DEFAULT 0,
+            created_at TEXT DEFAULT (datetime('now')),
+            last_used_at TEXT DEFAULT NULL,
+            updated_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS skill_usage (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+            session_id TEXT DEFAULT '',
+            success INTEGER NOT NULL DEFAULT 1,
+            context TEXT DEFAULT '',
+            notes TEXT DEFAULT '',
+            created_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    _migrate_add_index(conn, "idx_skills_level", "skills", "level")
+    _migrate_add_index(conn, "idx_skills_trust", "skills", "trust_score")
+    _migrate_add_index(conn, "idx_skills_last_used", "skills", "last_used_at")
+    _migrate_add_index(conn, "idx_skill_usage_skill_id", "skill_usage", "skill_id")
+    _migrate_add_index(conn, "idx_skill_usage_created", "skill_usage", "created_at")
+
+
 # Migration registry — APPEND ONLY, never reorder or delete
+def _m17_cron_runs(conn):
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS cron_runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            cron_id TEXT NOT NULL,
+            started_at TEXT NOT NULL DEFAULT (datetime('now')),
+            ended_at TEXT,
+            exit_code INTEGER,
+            summary TEXT DEFAULT '',
+            error TEXT DEFAULT '',
+            duration_secs REAL
+        )
+    """)
+    _migrate_add_index(conn, "idx_cron_runs_cron_id", "cron_runs", "cron_id")
+    _migrate_add_index(conn, "idx_cron_runs_started", "cron_runs", "started_at")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -312,6 +374,8 @@ MIGRATIONS = [
     (13, "claude_session_id", _m13_claude_session_id),
     (14, "learnings_priority_weight", _m14_learnings_priority_weight),
     (15, "core_rules_tables", _m15_core_rules_tables),
+    (16, "skills_tables", _m16_skills_tables),
+    (17, "cron_runs", _m17_cron_runs),
 ]