nexo-brain 2.2.0 → 2.3.1

package/README.md

@@ -283,13 +283,13 @@ NEXO Brain doesn't just respond — it runs 15 autonomous processes in the backg
 | **prevent-sleep** | Always (daemon) | Keeps machine awake for nocturnal processes (caffeinate/systemd-inhibit) |
 | **evolution** | Weekly (Sun) | Self-improvement proposals — NEXO suggests and applies enhancements |
 | **followup-hygiene** | Weekly (Sun) | Normalizes statuses, flags stale followups, cleans orphans |
+| **learning-housekeep** | 03:15 daily | Dedup learnings, adjust weights by usage, process overdue reviews, reconcile decision outcomes |
 | **immune** | Every 30 min | Quarantine processing, memory promotion/rejection, synaptic pruning |
-| **synthesis** | Every 2 hours | Memory synthesis — discovers cross-memory patterns |
-| **backup** | Every hour | SQLite database backups |
-| **watchdog** | Every 5 min | Monitors services, LaunchAgents, and infrastructure health |
+| **synthesis** | 06:00 daily | Memory synthesis — discovers cross-memory patterns |
+| **watchdog** | Every 30 min | Monitors services, LaunchAgents, and infrastructure health |
 | **auto-close-sessions** | Every 5 min | Cleans stale sessions |
 
-All processes are defined in `src/crons/manifest.json` and auto-synced to your system by `nexo_update`. On macOS they run via LaunchAgents; on Linux via systemd user timers (or crontab fallback). Personal crons (your own scripts) are never touched by the sync. If your Mac was asleep during a scheduled process, the catch-up script re-runs everything in order when it wakes.
+Core processes are defined in `src/crons/manifest.json` and auto-synced to your system by `nexo_update`. On macOS they run via LaunchAgents; on Linux via systemd user timers. `tcc-approve`, `prevent-sleep`, and `backup` are platform/personal helpers — not in the manifest but listed above for completeness. Personal crons (your own scripts) are never touched by the sync. If your Mac was asleep during a scheduled process, the catch-up script re-runs everything in order when it wakes.
 
 ## Deep Sleep v2 — Overnight Learning (v2.1.0)
 
@@ -755,7 +755,7 @@ If NEXO Brain is useful to you, consider:
 - **Auto-resolve followups**: Change log entries automatically cross-reference and complete matching open followups.
 - **Free-form learning categories**: No more hardcoded category validation — use any category name.
 - **CLAUDE.md template rewrite**: 494 to 127 lines, compact procedural format with full heartbeat signal reactions.
-- **Complete sanitization**: All hardcoded paths use `NEXO_HOME` env var. Zero personal data in the repo.
+- **Complete sanitization**: All hardcoded paths use `NEXO_HOME` env var. No credentials or personal data in the distributed package. Migration scripts and maintainer tooling use configurable paths.
 
 ### v1.6.0 — Nervous System + Dashboard v2 (2026-03-30)
 - **Nervous System**: 11 autonomous scripts (decay, deep sleep, self-audit, catchup, evolution, followup hygiene, immune, watchdog, github monitor, learning validator)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Memory, emotional intelligence, overnight learning (Deep Sleep), cron management, trust scoring, and adaptive calibration.",
   "bin": {
@@ -56,8 +56,11 @@
     "bin/nexo-brain.js",
     "bin/postinstall.js",
     "src/",
+    "!src/**/__pycache__",
+    "!src/**/*.pyc",
+    "!src/**/*.pyo",
     "templates/",
-    "scripts/",
-    "tests/"
+    "README.md",
+    "LICENSE"
   ]
 }

package/src/auto_update.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """NEXO Auto-Update — lightweight startup check for git updates and file-based migrations.
 
 Called once per server startup. Respects a 1-hour cooldown to avoid redundant checks.
@@ -93,6 +94,27 @@ def _read_package_version() -> str:
     return "unknown"
 
 
+# ── Hook sync ────────────────────────────────────────────────────────
+
+def _sync_hooks():
+    """Copy hook scripts from src/hooks/ to NEXO_HOME/hooks/ after a git pull."""
+    import shutil
+    hooks_src = SRC_DIR / "hooks"
+    hooks_dest = NEXO_HOME / "hooks"
+    if not hooks_src.is_dir():
+        return
+    hooks_dest.mkdir(parents=True, exist_ok=True)
+    synced = 0
+    for f in hooks_src.iterdir():
+        if f.is_file() and f.suffix == ".sh":
+            dest = hooks_dest / f.name
+            shutil.copy2(str(f), str(dest))
+            os.chmod(str(dest), 0o755)
+            synced += 1
+    if synced:
+        _log(f"Synced {synced} hook(s) to {hooks_dest}")
+
+
 # ── Git-based auto-update ────────────────────────────────────────────
 
 def _check_git_updates() -> str | None:
@@ -140,6 +162,10 @@ def _check_git_updates() -> str | None:
     # Run DB migrations after pull
     _run_db_migrations()
 
+    # Sync hooks to NEXO_HOME (nexo-brain.js copies them on install,
+    # but auto-update via git pull bypasses nexo-brain.js)
+    _sync_hooks()
+
     msg = f"Auto-updated: {old_version} -> {new_version}" if old_version != new_version else f"Auto-updated (v{new_version}, new commits)"
     _log(msg)
     return msg

package/src/crons/manifest.json

@@ -70,35 +70,28 @@
     {
       "id": "followup-hygiene",
       "script": "scripts/nexo-followup-hygiene.py",
-      "schedule": {"hour": 5, "minute": 0},
+      "schedule": {"hour": 5, "minute": 0, "weekday": 0},
       "description": "Clean stale followups, archive completed, validate dates",
       "core": true
     },
     {
       "id": "synthesis",
       "script": "scripts/nexo-synthesis.py",
-      "interval_seconds": 7200,
-      "description": "Periodic synthesis — cross-reference learnings, decisions, changes",
+      "schedule": {"hour": 6, "minute": 0},
+      "description": "Daily synthesis — cross-reference learnings, decisions, changes",
       "core": true
     },
     {
       "id": "auto-close-sessions",
-      "script": "scripts/nexo-auto-close-sessions.py",
+      "script": "auto_close_sessions.py",
       "interval_seconds": 300,
       "description": "Close stale sessions that lost their parent process",
       "core": true
     },
-    {
-      "id": "github-monitor",
-      "script": "scripts/nexo-github-monitor.py",
-      "schedule": {"hour": 8, "minute": 0},
-      "description": "Monitor GitHub repo — issues, PRs, stars, auto-respond",
-      "core": true
-    },
-    {
+{
       "id": "catchup",
       "script": "scripts/nexo-catchup.py",
-      "schedule": {"hour": 8, "minute": 30},
+      "run_at_load": true,
       "description": "Morning catchup briefing for the user",
       "core": true
     }

package/src/crons/sync.py

@@ -42,15 +42,55 @@ def load_manifest() -> list[dict]:
     return data.get("crons", [])
 
 
+def _copy_script_to_nexo_home(src: Path) -> Path:
+    """Copy a script from NEXO_CODE to NEXO_HOME/scripts/ for Sandbox compatibility.
+
+    macOS Sandbox blocks LaunchAgents from executing scripts in ~/Documents/.
+    We copy scripts to NEXO_HOME/scripts/ which is outside the Sandbox restricted paths.
+    """
+    dest_dir = NEXO_HOME / "scripts"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    if src.is_dir():
+        import shutil
+        dest = dest_dir / src.name
+        if dest.exists():
+            shutil.rmtree(dest)
+        shutil.copytree(src, dest)
+        return dest
+    else:
+        dest = dest_dir / src.name
+        import shutil
+        shutil.copy2(src, dest)
+        dest.chmod(0o755)
+        return dest
+
+
 def build_plist(cron: dict) -> dict:
     """Build a macOS LaunchAgent plist dict from a manifest entry."""
     cron_id = cron["id"]
     label = f"{LABEL_PREFIX}{cron_id}"
-    script_path = str(NEXO_CODE / cron["script"])
+    script_src = NEXO_CODE / cron["script"]
     script_type = cron.get("type", "python")
 
+    # Copy scripts to NEXO_HOME/scripts/ to avoid macOS Sandbox restrictions
+    script_dest = _copy_script_to_nexo_home(script_src)
+    script_path = str(script_dest)
+
+    # Also copy the wrapper and any subdirectories (e.g., deep-sleep/)
+    wrapper_src = NEXO_CODE / "scripts" / "nexo-cron-wrapper.sh"
+    wrapper_dest = _copy_script_to_nexo_home(wrapper_src)
+    wrapper_path = str(wrapper_dest)
+
+    # Copy script subdirectories if they exist (e.g., deep-sleep/ for nexo-deep-sleep.sh)
+    script_name = script_src.stem  # e.g., "nexo-deep-sleep"
+    subdir_name = script_name.replace("nexo-", "")  # e.g., "deep-sleep"
+    subdir_src = NEXO_CODE / "scripts" / subdir_name
+    if subdir_src.is_dir():
+        _copy_script_to_nexo_home(subdir_src)
+
     if script_type == "shell":
-        program_args = ["/bin/bash", script_path]
+        program_args = ["/bin/bash", wrapper_path, cron_id, "/bin/bash", script_path]
     else:
         # Find python3
         python_candidates = [
@@ -64,7 +104,7 @@ def build_plist(cron: dict) -> dict:
             if Path(p).exists():
                 python_bin = p
                 break
-        program_args = [python_bin, script_path]
+        program_args = ["/bin/bash", wrapper_path, cron_id, python_bin, script_path]
 
     plist = {
         "Label": label,
@@ -84,7 +124,9 @@ def build_plist(cron: dict) -> dict:
     }
 
     # Schedule
-    if "interval_seconds" in cron:
+    if cron.get("run_at_load"):
+        plist["RunAtLoad"] = True
+    elif "interval_seconds" in cron:
         plist["StartInterval"] = cron["interval_seconds"]
     elif "schedule" in cron:
         cal = {}
@@ -126,6 +168,8 @@ def plist_needs_update(existing_path: Path, new_plist: dict) -> bool:
         return True
     if existing.get("StartCalendarInterval") != new_plist.get("StartCalendarInterval"):
         return True
+    if existing.get("RunAtLoad") != new_plist.get("RunAtLoad"):
+        return True
     return False
 
 
@@ -157,8 +201,12 @@ def unload_plist(plist_path: Path, dry_run: bool):
 
 
 def sync(dry_run: bool = False):
-    if platform.system() != "Darwin":
-        log("Not macOS — cron sync only supports LaunchAgents. Skipping.")
+    system = platform.system()
+    if system == "Linux":
+        sync_linux(dry_run)
+        return
+    if system != "Darwin":
+        log(f"Unsupported platform: {system}. Skipping.")
         return
 
     LOG_DIR.mkdir(parents=True, exist_ok=True)
@@ -210,6 +258,102 @@ def sync(dry_run: bool = False):
     log("Sync complete.")
 
 
+def sync_linux(dry_run: bool = False):
+    """Sync manifest to systemd user timers (Linux)."""
+    unit_dir = Path.home() / ".config" / "systemd" / "user"
+    unit_dir.mkdir(parents=True, exist_ok=True)
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    manifest_crons = load_manifest()
+    wrapper_src = NEXO_CODE / "scripts" / "nexo-cron-wrapper.sh"
+    wrapper_dest = _copy_script_to_nexo_home(wrapper_src)
+
+    log(f"Manifest: {len(manifest_crons)} core crons")
+
+    python_bin = "/usr/bin/python3"
+    for p in ["/usr/bin/python3", "/usr/local/bin/python3"]:
+        if Path(p).exists():
+            python_bin = p
+            break
+
+    for cron in manifest_crons:
+        cron_id = cron["id"]
+        script_src = NEXO_CODE / cron["script"]
+        script_dest = _copy_script_to_nexo_home(script_src)
+        script_type = cron.get("type", "python")
+
+        # Copy subdirectories
+        subdir_name = script_src.stem.replace("nexo-", "")
+        subdir_src = NEXO_CODE / "scripts" / subdir_name
+        if subdir_src.is_dir():
+            _copy_script_to_nexo_home(subdir_src)
+
+        if script_type == "shell":
+            exec_cmd = f"/bin/bash {wrapper_dest} {cron_id} /bin/bash {script_dest}"
+        else:
+            exec_cmd = f"/bin/bash {wrapper_dest} {cron_id} {python_bin} {script_dest}"
+
+        service_path = unit_dir / f"nexo-{cron_id}.service"
+        timer_path = unit_dir / f"nexo-{cron_id}.timer"
+
+        service_content = f"""[Unit]
+Description=NEXO: {cron.get('description', cron_id)}
+
+[Service]
+Type=oneshot
+ExecStart={exec_cmd}
+Environment=NEXO_HOME={NEXO_HOME}
+Environment=NEXO_CODE={NEXO_CODE}
+Environment=HOME={Path.home()}
+"""
+
+        if cron.get("run_at_load"):
+            timer_spec = "OnBootSec=0"
+        elif "interval_seconds" in cron:
+            timer_spec = f"OnUnitActiveSec={cron['interval_seconds']}s\nOnBootSec=60s"
+        elif "schedule" in cron:
+            s = cron["schedule"]
+            h, m = s.get("hour", 0), s.get("minute", 0)
+            if "weekday" in s:
+                days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+                timer_spec = f"OnCalendar={days[s['weekday']]} *-*-* {h:02d}:{m:02d}:00"
+            else:
+                timer_spec = f"OnCalendar=*-*-* {h:02d}:{m:02d}:00"
+        else:
+            log(f"  SKIP {cron_id}: no schedule or interval")
+            continue
+
+        timer_content = f"""[Unit]
+Description=NEXO timer: {cron.get('description', cron_id)}
+
+[Timer]
+{timer_spec}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+"""
+
+        if dry_run:
+            log(f"  DRY-RUN: would install {cron_id}")
+            continue
+
+        service_path.write_text(service_content)
+        timer_path.write_text(timer_content)
+        log(f"  Installed: {cron_id}")
+
+    if not dry_run:
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+        for cron in manifest_crons:
+            subprocess.run(
+                ["systemctl", "--user", "enable", "--now", f"nexo-{cron['id']}.timer"],
+                capture_output=True
+            )
+        log("systemd timers enabled.")
+
+    log("Sync complete.")
+
+
 if __name__ == "__main__":
     dry_run = "--dry-run" in sys.argv
     if dry_run:

package/src/db/__init__.py

@@ -87,3 +87,16 @@ from db._evolution import (
     insert_evolution_metric, get_latest_metrics,
     insert_evolution_log, get_evolution_history, update_evolution_log_status,
 )
+
+# Cron execution history
+from db._cron_runs import (
+    cron_run_start, cron_run_end, cron_runs_recent, cron_runs_summary,
+)
+
+# Skills
+from db._skills import (
+    create_skill, get_skill, list_skills, search_skills,
+    update_skill, delete_skill,
+    record_usage as record_skill_usage,
+    match_skills, merge_skills, get_skill_stats, decay_unused_skills,
+)

package/src/db/_core.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """SQLite database for NEXO session coordination."""
 
 import sqlite3

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/_entities.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """NEXO DB — Entities module."""
 import time
 from db._core import get_db, _multi_word_like

package/src/db/_episodic.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """NEXO DB — Episodic module."""
 import datetime, time, json
 from db._core import get_db, now_epoch, _multi_word_like
@@ -568,17 +569,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 +605,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 +751,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/_learnings.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """NEXO DB — Learnings module."""
 import re, time
 from db._core import get_db, now_epoch

package/src/db/_reminders.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """NEXO DB — Reminders module."""
 import sqlite3, time, datetime
 from datetime import timedelta

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),
 ]
 
 

package/src/db/_sessions.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 """NEXO DB — Sessions module."""
 import time, secrets, string, sqlite3
 from datetime import datetime