nexo-brain 0.2.1 → 0.3.2

package/src/plugins/cognitive_memory.py

@@ -1,5 +1,13 @@
 """Cognitive Memory plugin — RAG retrieval over NEXO's Atkinson-Shiffrin memory stores."""
 
+import sys
+import os
+
+# Ensure site-packages is in path for numpy/fastembed
+_site = "/opt/homebrew/lib/python{}.{}/site-packages".format(sys.version_info.major, sys.version_info.minor)
+if os.path.isdir(_site) and _site not in sys.path:
+    sys.path.insert(0, _site)
+
 import cognitive
 
 
@@ -10,6 +18,9 @@ def handle_cognitive_retrieve(
     stores: str = "both",
     source_type: str = "",
     domain: str = "",
+    include_archived: bool = False,
+    use_hyde: bool = False,
+    spreading_depth: int = 0,
 ) -> str:
     """RAG query over cognitive memory (STM + LTM). Triggers rehearsal on retrieved memories.
 
@@ -19,7 +30,10 @@ def handle_cognitive_retrieve(
         min_score: Minimum cosine similarity score (default 0.5)
         stores: Which store to search — "both", "stm", or "ltm" (default "both")
         source_type: Filter by source type e.g. "change", "learning", "diary" (default: all)
-        domain: Filter by domain e.g. "infrastructure", "general" (default: all)
+        domain: Filter by domain e.g. "wazion", "shopify" (default: all)
+        include_archived: If True, also search archived memories (default False)
+        use_hyde: If True, use HyDE query expansion — embeds 3-5 query variants and searches with centroid. Better recall for conceptual queries. (default False)
+        spreading_depth: If >0, boost co-activated neighbors (memories frequently retrieved together). 1=direct neighbors only. (default 0)
     """
     if not query or not query.strip():
         return "ERROR: query is required."
@@ -32,6 +46,9 @@ def handle_cognitive_retrieve(
         exclude_dormant=True,
         rehearse=True,
         source_type_filter=source_type,
+        include_archived=include_archived,
+        use_hyde=use_hyde,
+        spreading_depth=spreading_depth,
     )
 
     # Apply domain filter post-search (cognitive.search doesn't filter by domain natively)
@@ -39,7 +56,12 @@ def handle_cognitive_retrieve(
         results = [r for r in results if r.get("domain", "") == domain]
 
     formatted = cognitive.format_results(results)
-    header = f"COGNITIVE RETRIEVE — query: '{query}' | {len(results)} results (stores={stores}, min_score={min_score})\n\n"
+    mode_parts = [f"stores={stores}", f"min_score={min_score}"]
+    if use_hyde:
+        mode_parts.append("hyde=ON")
+    if spreading_depth > 0:
+        mode_parts.append(f"spreading={spreading_depth}")
+    header = f"COGNITIVE RETRIEVE — query: '{query}' | {len(results)} results ({', '.join(mode_parts)})\n\n"
     return header + formatted
 
 
@@ -68,6 +90,21 @@ def handle_cognitive_stats() -> str:
         for domain, cnt in stats["top_domains_ltm"]:
             lines.append(f"    {domain}: {cnt}")
 
+    if "quarantine" in stats:
+        q = stats["quarantine"]
+        lines.append(f"  Quarantine pending:  {q.get('pending', 0)}")
+        lines.append(f"  Quarantine promoted: {q.get('promoted', 0)}")
+        lines.append(f"  Quarantine rejected: {q.get('rejected', 0)}")
+        lines.append(f"  Quarantine expired:  {q.get('expired', 0)}")
+
+    if "prediction_error_gate" in stats:
+        g = stats["prediction_error_gate"]
+        lines.append("  PE Gate (session):")
+        lines.append(f"    Accepted (novel):     {g['accepted_novel']}")
+        lines.append(f"    Accepted (refine):    {g['accepted_refinement']}")
+        lines.append(f"    Rejected (redundant): {g['rejected']}")
+        lines.append(f"    Rejection rate:       {g['rejection_rate_pct']}%")
+
     return "\n".join(lines)
 
 
@@ -104,6 +141,12 @@ def handle_cognitive_inspect(memory_id: int, store: str = "ltm") -> str:
         f"  last_accessed: {row['last_accessed']}",
     ]
 
+    # Lifecycle state
+    lifecycle = row["lifecycle_state"] or "active"
+    lines.append(f"  lifecycle:     {lifecycle}")
+    if row["snooze_until"]:
+        lines.append(f"  snooze_until:  {row['snooze_until']}")
+
     if store == "ltm":
         dormant_label = "YES" if row["is_dormant"] else "no"
         lines.append(f"  dormant:       {dormant_label}")
@@ -120,7 +163,7 @@ def handle_cognitive_inspect(memory_id: int, store: str = "ltm") -> str:
 
 
 def handle_cognitive_metrics(days: int = 7) -> str:
-    """Cognitive memory performance metrics.
+    """Cognitive memory performance metrics (spec section 9).
 
     Returns retrieval relevance %, repeat error rate, score distribution,
     and whether multilingual model switch is recommended.
@@ -155,7 +198,7 @@ def handle_cognitive_metrics(days: int = 7) -> str:
 
     if metrics["needs_multilingual"]:
         lines.append("")
-        lines.append("RECOMMENDATION: Switch to multilingual model (intfloat/multilingual-e5-small)")
+        lines.append("⚠ RECOMMENDATION: Switch to multilingual model (intfloat/multilingual-e5-small)")
         lines.append(f"  Reason: relevance {metrics['retrieval_relevance_pct']}% < 70% with {metrics['total_retrievals']}+ retrievals")
 
     if repeats["duplicates"]:
@@ -165,17 +208,27 @@ def handle_cognitive_metrics(days: int = 7) -> str:
             lines.append(f"  [{d['score']}] STM#{d['new_stm_id']}: {d['new_content'][:60]}...")
             lines.append(f"         ≈ LTM#{d['ltm_id']}: {d['ltm_content'][:60]}...")
 
+    # Prediction Error Gate stats
+    gate = cognitive.get_gate_stats()
+    if gate["total_evaluated"] > 0:
+        lines.append("")
+        lines.append("Prediction Error Gate (session):")
+        lines.append(f"  Novel accepted:      {gate['accepted_novel']}")
+        lines.append(f"  Refinements:         {gate['accepted_refinement']}")
+        lines.append(f"  Rejected redundant:  {gate['rejected']}")
+        lines.append(f"  Rejection rate:      {gate['rejection_rate_pct']}%")
+
     return "\n".join(lines)
 
 
 def handle_cognitive_sentiment(text: str) -> str:
-    """Detect user sentiment from their text. Returns mood, intensity, and guidance.
+    """Detect the user's sentiment from his text. Returns mood, intensity, and guidance.
 
     Call this with the user's recent message to adapt NEXO's tone and behavior.
     Also logs the sentiment for historical tracking.
 
     Args:
-        text: User's recent message or instruction
+        text: the user's recent message or instruction
     """
     result = cognitive.log_sentiment(text)
     trust = cognitive.get_trust_score()
@@ -241,27 +294,27 @@ def handle_cognitive_trust(event: str = '', context: str = '', delta: float = No
 def handle_cognitive_dissonance(instruction: str, force: bool = False) -> str:
     """Detect cognitive dissonance: find established memories that conflict with a new instruction.
 
-    Use BEFORE applying a new preference or rule that might contradict existing knowledge.
-    If conflicts found, verbalize them and ask to resolve.
+    Use BEFORE applying a new preference or rule from the user that might contradict
+    existing knowledge. If conflicts found, verbalize them and ask the user to resolve.
 
     Args:
         instruction: The new instruction or preference to check against LTM
         force: If True, skip discussion — execute instruction, auto-resolve all conflicts as
-               'exception', and flag for review.
+               'exception', and flag for review in the nocturnal process (23:30).
     """
     conflicts = cognitive.detect_dissonance(instruction)
     if not conflicts:
         return f"No dissonance detected. Instruction '{instruction[:80]}' is consistent with existing LTM."
 
     if force:
-        # Auto-resolve all as exceptions
+        # Auto-resolve all as exceptions, log for nocturnal review
         for c in conflicts:
             cognitive.resolve_dissonance(
                 c["memory_id"], "exception",
-                f"[FORCE] {instruction[:200]} — auto-exception, pending review"
+                f"[FORCE] {instruction[:200]} — auto-exception, pending nocturnal review"
             )
         return (f"FORCE: {len(conflicts)} conflicts auto-resolved as exceptions. "
-                f"Instruction executed. Flagged for review.")
+                f"Instruction executed. Flagged for review at 23:30.")
 
     lines = [
         f"COGNITIVE DISSONANCE DETECTED — {len(conflicts)} conflicting memories:",
@@ -275,7 +328,7 @@ def handle_cognitive_dissonance(instruction: str, force: bool = False) -> str:
         lines.append("")
 
     lines.append("RESOLVE with nexo_cognitive_resolve, or use force=True to skip:")
-    lines.append("  - 'paradigm_shift': Permanent preference change.")
+    lines.append("  - 'paradigm_shift': the user changed his mind permanently.")
     lines.append("  - 'exception': One-time override. Old memory stays.")
     lines.append("  - 'override': Old memory was wrong.")
 
@@ -283,7 +336,7 @@ def handle_cognitive_dissonance(instruction: str, force: bool = False) -> str:
 
 
 def handle_cognitive_resolve(memory_id: int, resolution: str, context: str = '') -> str:
-    """Resolve a cognitive dissonance.
+    """Resolve a cognitive dissonance by applying the user's decision.
 
     Args:
         memory_id: The LTM memory ID from the dissonance detection
@@ -293,13 +346,219 @@ def handle_cognitive_resolve(memory_id: int, resolution: str, context: str = '')
     return cognitive.resolve_dissonance(memory_id, resolution, context)
 
 
+def handle_cognitive_pin(memory_id: int, store: str = "auto") -> str:
+    """Pin a memory so it NEVER decays and gets boosted in search results (+0.2 similarity).
+
+    Args:
+        memory_id: Integer ID of the memory to pin
+        store: Which store — "stm", "ltm", or "auto" (tries both, default "auto")
+    """
+    return cognitive.set_lifecycle(memory_id, "pinned", store)
+
+
+def handle_cognitive_snooze(memory_id: int, until_date: str, store: str = "auto") -> str:
+    """Snooze a memory — hidden from searches until the given date, then auto-restores to active.
+
+    Args:
+        memory_id: Integer ID of the memory to snooze
+        until_date: Date to restore the memory (YYYY-MM-DD format)
+        store: Which store — "stm", "ltm", or "auto" (tries both, default "auto")
+    """
+    return cognitive.set_lifecycle(memory_id, "snoozed", store, snooze_until=until_date)
+
+
+def handle_cognitive_archive(memory_id: int, store: str = "auto") -> str:
+    """Archive a memory — stored but excluded from normal searches. Can be restored later.
+
+    Args:
+        memory_id: Integer ID of the memory to archive
+        store: Which store — "stm", "ltm", or "auto" (tries both, default "auto")
+    """
+    return cognitive.set_lifecycle(memory_id, "archived", store)
+
+
+def handle_cognitive_restore(memory_id: int, store: str = "auto") -> str:
+    """Restore a memory to active state (from pinned, snoozed, or archived).
+
+    Args:
+        memory_id: Integer ID of the memory to restore
+        store: Which store — "stm", "ltm", or "auto" (tries both, default "auto")
+    """
+    return cognitive.set_lifecycle(memory_id, "active", store)
+
+
+def handle_cognitive_quarantine_list(status: str = "pending", limit: int = 20) -> str:
+    """List quarantine queue items. Shows memories awaiting promotion to STM.
+
+    Args:
+        status: Filter — 'pending', 'promoted', 'rejected', 'expired', or 'all' (default 'pending')
+        limit: Max items to return (default 20)
+    """
+    items = cognitive.quarantine_list(status=status, limit=limit)
+    stats = cognitive.quarantine_stats()
+
+    lines = [
+        f"QUARANTINE QUEUE — {stats['pending']} pending | {stats['promoted']} promoted | {stats['rejected']} rejected | {stats['expired']} expired",
+        f"Showing: {status} (limit {limit})",
+        "",
+    ]
+
+    if not items:
+        lines.append("No items found.")
+    else:
+        for item in items:
+            lines.append(f"  #{item['id']} [{item['status']}] source={item['source']} type={item['source_type']} domain={item['domain'] or '-'}")
+            lines.append(f"    confidence={item['confidence']:.1f} checks={item['promotion_checks']} created={item['created_at'][:16]}")
+            if item['promoted_at']:
+                lines.append(f"    promoted_at={item['promoted_at'][:16]}")
+            lines.append(f"    {item['content']}")
+            lines.append("")
+
+    return "\n".join(lines)
+
+
+def handle_cognitive_quarantine_promote(quarantine_id: int) -> str:
+    """Manually promote a quarantine item to STM, bypassing the automatic promotion policy.
+
+    Args:
+        quarantine_id: ID of the quarantine entry to promote
+    """
+    return cognitive.quarantine_promote(quarantine_id)
+
+
+def handle_cognitive_quarantine_reject(quarantine_id: int, reason: str = "") -> str:
+    """Manually reject a quarantine item.
+
+    Args:
+        quarantine_id: ID of the quarantine entry to reject
+        reason: Optional reason for rejection
+    """
+    return cognitive.quarantine_reject(quarantine_id, reason)
+
+
+def handle_cognitive_quarantine_process() -> str:
+    """Run the quarantine promotion cycle. Evaluates all pending items against the promotion policy.
+
+    Promotion rules:
+    - source='user_direct' → already promoted at ingest
+    - source='inferred' + second occurrence found → promote
+    - source='agent_observation' + >24h old + no LTM contradiction → promote
+    - Contradicts LTM (cosine >0.8) → reject
+    - >7 days old → expire
+    """
+    result = cognitive.process_quarantine()
+    lines = [
+        "QUARANTINE PROCESSING COMPLETE",
+        f"  Promoted:      {result['promoted']}",
+        f"  Rejected:      {result['rejected']}",
+        f"  Expired:       {result['expired']}",
+        f"  Still pending: {result['still_pending']}",
+        f"  Total:         {result['total_processed']}",
+    ]
+    return "\n".join(lines)
+
+
+# ============================================================================
+# Prospective Memory trigger handlers (Feature 3)
+# ============================================================================
+
+def handle_cognitive_trigger_create(pattern: str, action: str, context: str = "") -> str:
+    """Create a prospective memory trigger — fires when text matches pattern.
+
+    Args:
+        pattern: Keywords to match (case-insensitive, comma-separated for OR matching)
+        action: What to do / remind about when the trigger fires
+        context: Optional context about why this trigger was created
+    """
+    trigger_id = cognitive.create_trigger(pattern, action, context)
+    return f"Trigger #{trigger_id} created — armed. Pattern: '{pattern}' | Action: '{action}'"
+
+
+def handle_cognitive_trigger_list(status: str = "armed") -> str:
+    """List prospective memory triggers.
+
+    Args:
+        status: Filter — 'armed' (active, waiting), 'fired' (already triggered), 'all'
+    """
+    triggers = cognitive.list_triggers(status)
+    if not triggers:
+        return f"No {status} triggers found."
+
+    lines = [f"PROSPECTIVE TRIGGERS ({status}) — {len(triggers)} total", ""]
+    for t in triggers:
+        status_icon = "+" if t["status"] == "armed" else "x"
+        lines.append(f"  [{status_icon}] #{t['id']} pattern='{t['trigger_pattern']}'")
+        lines.append(f"      action: {t['action']}")
+        if t.get("context"):
+            lines.append(f"      context: {t['context']}")
+        lines.append(f"      created: {t['created_at'][:16]}")
+        if t.get("fired_at"):
+            lines.append(f"      fired: {t['fired_at'][:16]}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def handle_cognitive_trigger_check(text: str, use_semantic: bool = False) -> str:
+    """Check text against all armed triggers and fire matching ones.
+
+    Args:
+        text: Text to check against triggers (e.g. user message, heartbeat context)
+        use_semantic: Also use embedding similarity (slower but catches conceptual matches)
+    """
+    fired = cognitive.check_triggers(text, use_semantic=use_semantic)
+    if not fired:
+        return "No triggers fired."
+
+    lines = [f"TRIGGERS FIRED: {len(fired)}", ""]
+    for t in fired:
+        lines.append(f"  #{t['id']} [{t['match_type']}] pattern='{t['pattern']}'")
+        lines.append(f"    ACTION: {t['action']}")
+        if t.get("context"):
+            lines.append(f"    context: {t['context']}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def handle_cognitive_trigger_delete(trigger_id: int) -> str:
+    """Delete a prospective memory trigger.
+
+    Args:
+        trigger_id: ID of the trigger to delete
+    """
+    return cognitive.delete_trigger(trigger_id)
+
+
+def handle_cognitive_trigger_rearm(trigger_id: int) -> str:
+    """Re-arm a fired trigger so it can fire again.
+
+    Args:
+        trigger_id: ID of the trigger to re-arm
+    """
+    return cognitive.rearm_trigger(trigger_id)
+
+
 TOOLS = [
     (handle_cognitive_retrieve, "nexo_cognitive_retrieve", "RAG query over cognitive memory (STM+LTM). Triggers rehearsal on retrieved results."),
-    (handle_cognitive_stats, "nexo_cognitive_stats", "Cognitive memory system metrics: STM/LTM counts, strengths, retrieval stats"),
+    (handle_cognitive_stats, "nexo_cognitive_stats", "Cognitive memory system metrics: STM/LTM counts, strengths, retrieval stats, quarantine counts"),
     (handle_cognitive_inspect, "nexo_cognitive_inspect", "Inspect a specific memory by ID (debug). Does NOT trigger rehearsal."),
-    (handle_cognitive_metrics, "nexo_cognitive_metrics", "Performance metrics: retrieval relevance %, repeat error rate, multilingual recommendation"),
+    (handle_cognitive_metrics, "nexo_cognitive_metrics", "Performance metrics: retrieval relevance %, repeat error rate, multilingual recommendation (spec section 9)"),
     (handle_cognitive_dissonance, "nexo_cognitive_dissonance", "Detect conflicts between a new instruction and established LTM memories. force=True to skip discussion."),
     (handle_cognitive_resolve, "nexo_cognitive_resolve", "Resolve a cognitive dissonance: paradigm_shift, exception, or override."),
-    (handle_cognitive_sentiment, "nexo_cognitive_sentiment", "Detect user sentiment and get tone guidance. Also logs for tracking."),
+    (handle_cognitive_sentiment, "nexo_cognitive_sentiment", "Detect the user's sentiment and get tone guidance. Also logs for tracking."),
     (handle_cognitive_trust, "nexo_cognitive_trust", "View or adjust trust score (0-100). Without args: view. With event: adjust."),
+    (handle_cognitive_pin, "nexo_cognitive_pin", "Pin a memory — never decays, boosted +0.2 in search results."),
+    (handle_cognitive_snooze, "nexo_cognitive_snooze", "Snooze a memory — hidden from searches until a date, then auto-restores."),
+    (handle_cognitive_archive, "nexo_cognitive_archive", "Archive a memory — excluded from searches, can be restored."),
+    (handle_cognitive_restore, "nexo_cognitive_restore", "Restore a memory to active state (from pinned/snoozed/archived)."),
+    (handle_cognitive_quarantine_list, "nexo_cognitive_quarantine_list", "List quarantine queue items awaiting promotion to STM."),
+    (handle_cognitive_quarantine_promote, "nexo_cognitive_quarantine_promote", "Manually promote a quarantine item to STM."),
+    (handle_cognitive_quarantine_reject, "nexo_cognitive_quarantine_reject", "Manually reject a quarantine item."),
+    (handle_cognitive_quarantine_process, "nexo_cognitive_quarantine_process", "Run quarantine promotion cycle — evaluate pending items against policy."),
+    (handle_cognitive_trigger_create, "nexo_cognitive_trigger_create", "Create a prospective memory trigger — 'when X is mentioned, remind about Y'."),
+    (handle_cognitive_trigger_list, "nexo_cognitive_trigger_list", "List prospective triggers by status (armed/fired/all)."),
+    (handle_cognitive_trigger_check, "nexo_cognitive_trigger_check", "Check text against armed triggers. Returns fired triggers with actions."),
+    (handle_cognitive_trigger_delete, "nexo_cognitive_trigger_delete", "Delete a prospective trigger by ID."),
+    (handle_cognitive_trigger_rearm, "nexo_cognitive_trigger_rearm", "Re-arm a fired trigger so it can fire again."),
 ]

package/src/scripts/nexo-catchup.py

@@ -8,6 +8,7 @@ runs them in the correct order.
 
 Scheduled tasks (ordered by intended run time):
   03:00 — cognitive-decay (Ebbinghaus decay + STM→LTM promotion)
+  03:00 — evolution (weekly, Sundays only)
   04:00 — sleep (session cleanup)
   07:00 — self-audit (health checks + weekly cognitive GC on Sundays)
   23:30 — postmortem (consolidation + sensory register)
@@ -23,14 +24,15 @@ import sys
 from datetime import datetime, timedelta
 from pathlib import Path
 
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-LOG_DIR = NEXO_HOME / "logs"
+HOME = Path.home()
+LOG_DIR = HOME / "claude" / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 LOG_FILE = LOG_DIR / "catchup.log"
-STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
-SCRIPTS = NEXO_HOME / "src" / "scripts"
+STATE_FILE = HOME / "claude" / "operations" / ".catchup-state.json"
 
-PYTHON = sys.executable
+PYTHON_BREW = "/opt/homebrew/bin/python3"
+PYTHON_SYS = "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3"
+SCRIPTS = HOME / "claude" / "scripts"
 
 
 def log(msg: str):
@@ -93,7 +95,7 @@ def should_run(task_name: str, hour: int, minute: int, state: dict, weekday: int
     return last_run < last_scheduled
 
 
-def run_task(name: str, script: str, state: dict) -> bool:
+def run_task(name: str, python: str, script: str, state: dict) -> bool:
     """Execute a task and update state."""
     script_path = str(SCRIPTS / script)
     if not Path(script_path).exists():
@@ -103,9 +105,9 @@ def run_task(name: str, script: str, state: dict) -> bool:
     log(f"  RUNNING {name}: {script}")
     try:
         result = subprocess.run(
-            [PYTHON, script_path],
+            [python, script_path],
             capture_output=True, text=True, timeout=300,
-            env={**os.environ, "HOME": str(Path.home()), "NEXO_HOME": str(NEXO_HOME), "NEXO_CATCHUP": "1"}
+            env={**os.environ, "HOME": str(HOME), "NEXO_CATCHUP": "1"}
         )
         if result.returncode == 0:
             log(f"  OK {name} (exit 0)")
@@ -129,20 +131,35 @@ def main():
     state = load_state()
 
     # Define tasks in execution order (matching their intended schedule order)
+    # Auto-update check FIRST
+    update_script = SCRIPTS / "nexo-auto-update.py"
+    if update_script.exists():
+        log("Checking for NEXO updates...")
+        try:
+            subprocess.run(
+                [PYTHON_BREW if os.path.exists(PYTHON_BREW) else PYTHON_SYS, str(update_script)],
+                capture_output=True, text=True, timeout=60,
+                env={**os.environ, "HOME": str(HOME), "NEXO_HOME": str(HOME / "claude" / "nexo-mcp")}
+            )
+        except Exception as e:
+            log(f"  Update check failed: {e}")
+
     tasks = [
-        # (name, hour, minute, script, weekday)
-        ("cognitive-decay", 3, 0, "nexo-cognitive-decay.py", None),
-        ("sleep", 4, 0, "nexo-sleep.py", None),
-        ("self-audit", 7, 0, "nexo-daily-self-audit.py", None),
-        ("postmortem", 23, 30, "nexo-postmortem-consolidator.py", None),
+        # (name, hour, minute, python, script, weekday)
+        ("cognitive-decay", 3, 0, PYTHON_BREW, "nexo-cognitive-decay.py", None),
+        ("evolution", 3, 0, PYTHON_SYS, "nexo-evolution-run.py", 6),  # Sunday = 6
+        ("sleep", 4, 0, PYTHON_SYS, "nexo-sleep.py", None),
+        ("self-audit", 7, 0, PYTHON_SYS, "nexo-daily-self-audit.py", None),
+        ("github-monitor", 8, 0, PYTHON_BREW, "nexo-github-monitor.py", None),
+        ("postmortem", 23, 30, PYTHON_BREW, "nexo-postmortem-consolidator.py", None),
     ]
 
     ran = 0
     skipped = 0
-    for name, hour, minute, script, weekday in tasks:
+    for name, hour, minute, python, script, weekday in tasks:
         if should_run(name, hour, minute, state, weekday):
             log(f"  {name} — missed scheduled run, catching up...")
-            if run_task(name, script, state):
+            if run_task(name, python, script, state):
                 ran += 1
         else:
             skipped += 1

package/src/scripts/nexo-cognitive-decay.py

@@ -5,13 +5,11 @@ import json
 import sys
 from pathlib import Path
 from datetime import datetime
-import os
 
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-sys.path.insert(0, str(NEXO_HOME / "src"))
+sys.path.insert(0, str(Path.home() / "claude" / "nexo-mcp"))
 import cognitive
 
-STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
+STATE_FILE = Path.home() / "claude" / "operations" / ".catchup-state.json"
 
 
 def update_catchup_state():