nexo-brain 7.23.13 → 7.25.0

package/src/cli.py

@@ -20,8 +20,10 @@ Entry points:
   nexo scripts run NAME_OR_PATH [-- args...]
   nexo scripts doctor [NAME_OR_PATH] [--json]
   nexo scripts call TOOL --input JSON [--json-output]
+  nexo agents list|create|status|enable|disable|schedule|archive|run [--json]
   nexo pre-answer route [--json] [--payload JSON|--payload-file PATH|--payload-stdin] [--query TEXT]
-  nexo memory-observations process [--json]
+  nexo cognitive-control observatory [--json]
+  nexo memory-observations process|intraday [--json]
   nexo local-context status|run-once|reconcile|pause|resume|roots|exclusions|query|diagnostics|models [--json]
   nexo automations reactivate NAME [--test-run] [--json]
   nexo skills list [--level ...] [--source-kind ...] [--json]
@@ -1057,6 +1059,145 @@ def _automations_set_schedule(args):
     return 0
 
 
+def _agents_list(args):
+    from script_registry import list_agents
+
+    rows = list_agents(include_archived=bool(getattr(args, "all", False)))
+    if args.json:
+        print(json.dumps({"ok": True, "agents": rows}, indent=2, ensure_ascii=False))
+        return 0
+    if not rows:
+        print("No agents registered.")
+        return 0
+    for row in rows:
+        state = "archived" if row.get("archived") else ("enabled" if row.get("enabled", True) else "disabled")
+        schedule = str(row.get("effective_schedule_label") or "manual")
+        print(f"{row.get('name')} [{state}] · {schedule} · {row.get('title') or row.get('description') or ''}")
+    return 0
+
+
+def _agents_create(args):
+    from script_registry import create_agent_script
+
+    try:
+        result = create_agent_script(
+            args.name,
+            description=args.description,
+            runtime=args.runtime,
+            force=args.force,
+        )
+    except (FileExistsError, ValueError) as e:
+        if args.json:
+            print(json.dumps({"ok": False, "error": str(e)}, ensure_ascii=False))
+        else:
+            print(str(e), file=sys.stderr)
+        return 1
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(f"Created agent script: {result['path']}")
+    return 0
+
+
+def _agents_status(args):
+    from script_registry import get_agent_status
+
+    result = get_agent_status(args.name)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to read agent status"), file=sys.stderr)
+        return 1
+    agent = result.get("agent") or {}
+    state = "archived" if agent.get("archived") else ("enabled" if agent.get("enabled") else "DISABLED")
+    print(f"{agent.get('name')} [{state}] -> {agent.get('title') or agent.get('description') or ''}")
+    schedule = str(agent.get("effective_schedule_label") or "").strip()
+    if schedule:
+        print(f"  schedule: {schedule} ({agent.get('schedule_source') or 'metadata'})")
+    if agent.get("last_run_at"):
+        print(f"  last run: {agent.get('last_run_at')} (exit={agent.get('last_exit_code')})")
+    return 0
+
+
+def _agents_set_enabled(args, enabled):
+    from script_registry import set_agent_enabled
+
+    result = set_agent_enabled(args.name, enabled)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to toggle agent"), file=sys.stderr)
+        return 1
+    verb = "enabled" if enabled else "disabled"
+    print(f"Agent {result['name']} {verb}.")
+    return 0
+
+
+def _agents_archive(args):
+    from script_registry import archive_agent
+
+    result = archive_agent(args.name, archived=not bool(getattr(args, "restore", False)))
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to archive agent"), file=sys.stderr)
+        return 1
+    print(f"Agent {result['name']} {'restored' if args.restore else 'archived'}.")
+    return 0
+
+
+def _agents_set_schedule(args):
+    from script_registry import set_agent_schedule
+
+    interval_seconds = None
+    daily_at = None
+    if getattr(args, "every_minutes", None) is not None:
+        interval_seconds = int(args.every_minutes) * 60
+    elif getattr(args, "every_seconds", None) is not None:
+        interval_seconds = int(args.every_seconds)
+    elif getattr(args, "daily_at", None):
+        daily_at = str(args.daily_at).strip()
+
+    result = set_agent_schedule(
+        args.name,
+        interval_seconds=interval_seconds,
+        daily_at=daily_at,
+        clear=bool(getattr(args, "reset", False)),
+    )
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to update agent cadence"), file=sys.stderr)
+        return 1
+    agent = result.get("agent") or {}
+    label = str(agent.get("effective_schedule_label") or "").strip()
+    print(f"Agent schedule updated for {result['name']}: {label or 'manual'}")
+    return 0
+
+
+def _agents_run(args):
+    from script_registry import get_agent_status
+
+    status = get_agent_status(args.name)
+    if not status.get("ok"):
+        print(status.get("error", "Agent not found"), file=sys.stderr)
+        return 1
+    agent = status.get("agent") or {}
+    if agent.get("archived"):
+        print(f"Agent is archived: {agent.get('name') or args.name}", file=sys.stderr)
+        return 1
+    if agent.get("enabled") is False:
+        print(f"Agent is disabled: {agent.get('name') or args.name}", file=sys.stderr)
+        return 1
+    args.name = agent.get("path") or args.name
+    args.script_args = list(getattr(args, "script_args", []) or [])
+    return _scripts_run(args)
+
+
 def _core_schedules_list(args):
     from core_schedule_controls import list_core_schedules
 
@@ -1610,6 +1751,30 @@ def _memory_observations_process(args) -> int:
     )
 
 
+def _memory_observations_intraday(args) -> int:
+    from memory_observation_processor import process_intraday_cycle
+
+    return _print_json_or_text(
+        process_intraday_cycle(
+            process_limit=int(getattr(args, "limit", 20) or 20),
+            backfill_limit=int(getattr(args, "backfill_limit", 20) or 20),
+            pending_sla_seconds=int(getattr(args, "pending_sla_seconds", 3600) or 3600),
+        ),
+        as_json=bool(getattr(args, "json", False)),
+    )
+
+
+def _cognitive_control_observatory(args) -> int:
+    from cognitive_control_observatory import build_cognitive_control_observatory
+
+    return _print_json_or_text(
+        build_cognitive_control_observatory(
+            window_seconds=int(getattr(args, "window_seconds", 86400) or 86400),
+        ),
+        as_json=bool(getattr(args, "json", False)),
+    )
+
+
 def _local_context_status(args) -> int:
     import local_context
     return _local_context_emit(local_context.status(), args)
@@ -2217,13 +2382,13 @@ def _prompt_model_recommendations(*, interactive: bool) -> None:
         effort_str = f" / {entry['current_effort']}" if entry["current_effort"] else ""
         prev_effort = f" / {entry['user_effort']}" if entry["user_effort"] else ""
         print()
-        print(f"[NEXO] ⭐ Nueva recomendación de modelo para {client}:")
+        print(f"[NEXO] ⭐ New model recommendation for {client}:")
         print(
             f"       {entry['current_model']}{effort_str}  "
-            f"(antes: {entry['user_model']}{prev_effort})"
+            f"(previous: {entry['user_model']}{prev_effort})"
         )
-        print(f"       {entry['display_name']} — recomendado por NEXO.")
-        answer = input("       ¿Migrar tu configuración? [y/N/later]: ").strip().lower()
+        print(f"       {entry['display_name']} — recommended by NEXO.")
+        answer = input("       Migrate your configuration? [y/N/later]: ").strip().lower()
         client_key = normalize_client_key(client) or client
         if answer in {"y", "yes", "s", "si", "sí"}:
             updated_profiles[client_key] = {
@@ -2231,15 +2396,15 @@ def _prompt_model_recommendations(*, interactive: bool) -> None:
                 "reasoning_effort": entry["current_effort"],
             }
             updated_ack[client_key] = entry["current_version"]
-            print(f"       ✅ Migrado a {entry['current_model']}.")
+            print(f"       ✅ Migrated to {entry['current_model']}.")
             changed = True
         elif answer in {"later", "l", "luego"}:
             # Do NOT acknowledge — will prompt again next interactive update.
-            print("       ↻ Te lo preguntaré en el próximo update.")
+            print("       ↻ I will ask again during the next update.")
         else:
             # "N" / empty / anything else → record ack so we don't re-ask.
             updated_ack[client_key] = entry["current_version"]
-            print(f"       Mantenido {entry['user_model']}. No te preguntaré de nuevo para esta versión.")
+            print(f"       Kept {entry['user_model']}. I will not ask again for this version.")
             changed = True
 
     if changed:
@@ -3523,6 +3688,12 @@ def main():
     pre_answer_route_p.add_argument("--current-context", default="", help="Current conversation/task context")
     pre_answer_route_p.add_argument("--json", action="store_true", help="JSON output")
 
+    cognitive_control_parser = sub.add_parser("cognitive-control", help="Cognitive control observability")
+    cognitive_control_sub = cognitive_control_parser.add_subparsers(dest="cognitive_control_command")
+    cognitive_observatory_p = cognitive_control_sub.add_parser("observatory", help="Read-only cognitive quality metrics")
+    cognitive_observatory_p.add_argument("--window-seconds", type=int, default=86400, help="Observation window")
+    cognitive_observatory_p.add_argument("--json", action="store_true", help="JSON output")
+
     memory_observations_parser = sub.add_parser("memory-observations", help="Process Memory Observations v2 queue")
     memory_observations_sub = memory_observations_parser.add_subparsers(dest="memory_observations_command")
     memory_observations_process_p = memory_observations_sub.add_parser("process", help="Run one bounded observation processor cycle")
@@ -3530,6 +3701,11 @@ def main():
     memory_observations_process_p.add_argument("--backfill-limit", type=int, default=100, help="Maximum legacy events to enqueue or repair")
     memory_observations_process_p.add_argument("--pending-sla-seconds", type=int, default=3600, help="Pending queue SLA threshold")
     memory_observations_process_p.add_argument("--json", action="store_true", help="JSON output")
+    memory_observations_intraday_p = memory_observations_sub.add_parser("intraday", help="Run low-limit daytime observation cycle")
+    memory_observations_intraday_p.add_argument("--limit", type=int, default=20, help="Maximum pending rows to process")
+    memory_observations_intraday_p.add_argument("--backfill-limit", type=int, default=20, help="Maximum legacy events to enqueue or repair")
+    memory_observations_intraday_p.add_argument("--pending-sla-seconds", type=int, default=3600, help="Pending queue SLA threshold")
+    memory_observations_intraday_p.add_argument("--json", action="store_true", help="JSON output")
 
     local_context_parser = sub.add_parser("local-context", help="Manage the local memory index")
     local_context_sub = local_context_parser.add_subparsers(dest="local_context_command")
@@ -3632,6 +3808,50 @@ def main():
     local_context_asset_purge_p.add_argument("asset_id", help="Asset id")
     local_context_asset_purge_p.add_argument("--json", action="store_true", help="JSON output")
 
+    agents_parser = sub.add_parser("agents", help="Manage Home-facing personal agents")
+    agents_sub = agents_parser.add_subparsers(dest="agents_command")
+
+    agents_list_p = agents_sub.add_parser("list", help="List personal-script-backed agents")
+    agents_list_p.add_argument("--all", action="store_true", help="Include archived agents")
+    agents_list_p.add_argument("--json", action="store_true", help="JSON output")
+
+    agents_create_p = agents_sub.add_parser("create", help="Create a personal script marked as an agent")
+    agents_create_p.add_argument("name", help="Human/agent name")
+    agents_create_p.add_argument("--description", default="", help="One-line description")
+    agents_create_p.add_argument("--runtime", default="python", choices=["python", "shell"], help="Script runtime")
+    agents_create_p.add_argument("--force", action="store_true", help="Overwrite if the target file exists")
+    agents_create_p.add_argument("--json", action="store_true", help="JSON output")
+
+    agents_status_p = agents_sub.add_parser("status", help="Read agent status")
+    agents_status_p.add_argument("name", help="Agent name or path")
+    agents_status_p.add_argument("--json", action="store_true", help="JSON output")
+
+    agents_enable_p = agents_sub.add_parser("enable", help="Enable an agent")
+    agents_enable_p.add_argument("name", help="Agent name or path")
+    agents_enable_p.add_argument("--json", action="store_true", help="JSON output")
+
+    agents_disable_p = agents_sub.add_parser("disable", help="Disable an agent")
+    agents_disable_p.add_argument("name", help="Agent name or path")
+    agents_disable_p.add_argument("--json", action="store_true", help="JSON output")
+
+    agents_archive_p = agents_sub.add_parser("archive", help="Archive an agent without deleting its script")
+    agents_archive_p.add_argument("name", help="Agent name or path")
+    agents_archive_p.add_argument("--restore", action="store_true", help="Restore instead of archive")
+    agents_archive_p.add_argument("--json", action="store_true", help="JSON output")
+
+    agents_schedule_p = agents_sub.add_parser("schedule", help="Change an agent cadence")
+    agents_schedule_p.add_argument("name", help="Agent name or path")
+    agents_schedule_group = agents_schedule_p.add_mutually_exclusive_group(required=True)
+    agents_schedule_group.add_argument("--every-minutes", type=int, help="Run the agent every N minutes")
+    agents_schedule_group.add_argument("--every-seconds", type=int, help="Run the agent every N seconds")
+    agents_schedule_group.add_argument("--daily-at", type=str, help="Run the agent every day at HH:MM or HH:MM:weekday")
+    agents_schedule_group.add_argument("--reset", action="store_true", help="Clear the agent schedule")
+    agents_schedule_p.add_argument("--json", action="store_true", help="JSON output")
+
+    agents_run_p = agents_sub.add_parser("run", help="Run an agent now")
+    agents_run_p.add_argument("name", help="Agent name or path")
+    agents_run_p.add_argument("script_args", nargs=argparse.REMAINDER, help="Arguments passed to the script")
+
     automations_parser = sub.add_parser("automations", help="Manage Desktop-facing automations")
     automations_sub = automations_parser.add_subparsers(dest="automations_command")
 
@@ -4106,7 +4326,7 @@ def main():
         return 0
 
     if args.command == "email":
-        # Plan F1 — setup / list / test / remove cuentas email.
+        # Plan F1 — setup / list / test / remove email accounts.
         fn = getattr(args, "func", None)
         if fn is None:
             print("usage: nexo email {setup,list,test,remove}")
@@ -4156,9 +4376,16 @@ def main():
             return _pre_answer_route(args)
         pre_answer_parser.print_help()
         return 0
+    elif args.command == "cognitive-control":
+        if args.cognitive_control_command == "observatory":
+            return _cognitive_control_observatory(args)
+        cognitive_control_parser.print_help()
+        return 0
     elif args.command == "memory-observations":
         if args.memory_observations_command == "process":
             return _memory_observations_process(args)
+        if args.memory_observations_command == "intraday":
+            return _memory_observations_intraday(args)
         memory_observations_parser.print_help()
         return 0
     elif args.command == "local-context":
@@ -4201,6 +4428,25 @@ def main():
             return _local_context_asset(args)
         local_context_parser.print_help()
         return 0
+    elif args.command == "agents":
+        if args.agents_command == "list":
+            return _agents_list(args)
+        elif args.agents_command == "create":
+            return _agents_create(args)
+        elif args.agents_command == "status":
+            return _agents_status(args)
+        elif args.agents_command == "enable":
+            return _agents_set_enabled(args, True)
+        elif args.agents_command == "disable":
+            return _agents_set_enabled(args, False)
+        elif args.agents_command == "archive":
+            return _agents_archive(args)
+        elif args.agents_command == "schedule":
+            return _agents_set_schedule(args)
+        elif args.agents_command == "run":
+            return _agents_run(args)
+        agents_parser.print_help()
+        return 0
     elif args.command == "automations":
         if args.automations_command == "list":
             return _automations_list(args)

package/src/cognitive_control_observatory.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+"""Read-only observatory for the cognitive quality-control phases."""
+
+import json
+import os
+import sqlite3
+import time
+from typing import Any
+
+import db
+from local_context import usage_events
+
+
+DEFAULT_WINDOW_SECONDS = 24 * 60 * 60
+
+
+def _table_exists(conn: sqlite3.Connection, table_name: str) -> bool:
+    try:
+        row = conn.execute(
+            "SELECT 1 FROM sqlite_master WHERE type IN ('table', 'view') AND name = ? LIMIT 1",
+            (table_name,),
+        ).fetchone()
+    except sqlite3.OperationalError:
+        return False
+    return row is not None
+
+
+def _count(conn: sqlite3.Connection, table: str, where: str = "", params: tuple[Any, ...] = ()) -> int:
+    if not _table_exists(conn, table):
+        return 0
+    sql = f"SELECT COUNT(*) FROM {table}"
+    if where:
+        sql += f" WHERE {where}"
+    try:
+        return int(conn.execute(sql, params).fetchone()[0] or 0)
+    except sqlite3.Error:
+        return 0
+
+
+def _status_counts(conn: sqlite3.Connection, table: str) -> dict[str, int]:
+    if not _table_exists(conn, table):
+        return {}
+    try:
+        rows = conn.execute(
+            f"SELECT COALESCE(status, '') AS status, COUNT(*) AS cnt FROM {table} GROUP BY COALESCE(status, '')"
+        ).fetchall()
+    except sqlite3.Error:
+        return {}
+    return {str(row["status"] or ""): int(row["cnt"] or 0) for row in rows}
+
+
+def _local_context_status() -> dict[str, Any]:
+    try:
+        from local_context import api as local_context_api
+
+        status = local_context_api.status()
+        if not isinstance(status, dict):
+            return {"ok": False, "error": "invalid_status_payload"}
+        return status
+    except Exception as exc:
+        return {"ok": False, "error": f"{type(exc).__name__}: {exc}"}
+
+
+def _learning_quality(conn: sqlite3.Connection, limit: int = 100) -> dict[str, Any]:
+    if not _table_exists(conn, "learnings"):
+        return {"available": False, "total": 0, "active": 0, "status_counts": {}, "quality": {}}
+    rows = conn.execute(
+        """
+        SELECT *
+          FROM learnings
+         WHERE COALESCE(status, 'active') = 'active'
+         ORDER BY updated_at DESC, id DESC
+         LIMIT ?
+        """,
+        (max(1, min(int(limit or 100), 500)),),
+    ).fetchall()
+    quality_counts = {"strong": 0, "usable": 0, "weak": 0, "fragile": 0}
+    scored = 0
+    try:
+        from tools_learnings import score_learning_quality
+
+        for row in rows:
+            score = score_learning_quality(dict(row), conn)
+            label = str(score.get("label") or "fragile")
+            quality_counts[label] = quality_counts.get(label, 0) + 1
+            scored += 1
+    except Exception:
+        pass
+    return {
+        "available": True,
+        "total": _count(conn, "learnings"),
+        "active": _count(conn, "learnings", "COALESCE(status, 'active') = 'active'"),
+        "status_counts": _status_counts(conn, "learnings"),
+        "quality_sample_size": scored,
+        "quality": quality_counts,
+    }
+
+
+def _followups(conn: sqlite3.Connection) -> dict[str, Any]:
+    if not _table_exists(conn, "followups"):
+        return {
+            "ok": True,
+            "skipped": True,
+            "reason": "followups_table_unavailable",
+            "total": 0,
+            "counts": {},
+            "executable_now": 0,
+            "non_executable": 0,
+        }
+    try:
+        snapshot = db.followup_lifecycle_snapshot(limit=5000)
+    except Exception as exc:
+        return {"ok": False, "error": f"{type(exc).__name__}: {exc}"}
+    counts = dict(snapshot.get("counts") or {})
+    executable = int(counts.get("active", 0) or 0)
+    non_executable = sum(
+        int(counts.get(lane, 0) or 0)
+        for lane in ("waiting_user", "waiting_external", "blocked", "parked", "stale_review", "expired")
+    )
+    return {
+        "ok": bool(snapshot.get("ok", True)),
+        "total": int(snapshot.get("total") or 0),
+        "counts": counts,
+        "executable_now": executable,
+        "non_executable": non_executable,
+    }
+
+
+def _intraday_memory(conn: sqlite3.Connection, window_seconds: int, now_ts: float) -> dict[str, Any]:
+    cutoff = float(now_ts) - max(0, int(window_seconds or DEFAULT_WINDOW_SECONDS))
+    try:
+        health = db.memory_observation_health()
+    except Exception as exc:
+        health = {"ok": False, "error": f"{type(exc).__name__}: {exc}"}
+    try:
+        import memory_observation_processor
+
+        queue = memory_observation_processor.queue_health(now=now_ts)
+    except Exception as exc:
+        queue = {"ok": False, "error": f"{type(exc).__name__}: {exc}"}
+    facts = 0
+    latest_fact = None
+    if _table_exists(conn, "hot_context"):
+        try:
+            row = conn.execute(
+                """
+                SELECT COUNT(*) AS total, MAX(last_event_at) AS latest
+                  FROM hot_context
+                 WHERE context_type = 'intraday_fact'
+                   AND last_event_at >= ?
+                """,
+                (cutoff,),
+            ).fetchone()
+            facts = int(row["total"] or 0)
+            latest_fact = row["latest"]
+        except sqlite3.Error:
+            pass
+    schema_ready = not bool(health.get("missing_required"))
+    return {
+        "ok": (bool(health.get("ok", True)) or not schema_ready) and bool(queue.get("ok", True)),
+        "schema_ready": schema_ready,
+        "health": health,
+        "queue": queue,
+        "intraday_facts_window": facts,
+        "latest_intraday_fact_at": latest_fact,
+        "event_stats": db.memory_event_stats(days=max(1, int(window_seconds / 86400) or 1)),
+    }
+
+
+def build_cognitive_control_observatory(
+    *,
+    window_seconds: int = DEFAULT_WINDOW_SECONDS,
+    now_ts: float | None = None,
+) -> dict[str, Any]:
+    """Return read-only metrics for phases 0-4 without creating work."""
+
+    current = float(now_ts if now_ts is not None else time.time())
+    conn = db.get_db()
+    local_usage = usage_events.summarize_usage(window_seconds=window_seconds, now_ts=current)
+    local_status = _local_context_status()
+    learning_summary = _learning_quality(conn)
+    followup_summary = _followups(conn)
+    intraday_summary = _intraday_memory(conn, window_seconds, current)
+    local_mode = (
+        os.environ.get("NEXO_PRE_ANSWER_LOCAL_CONTEXT_MODE")
+        or os.environ.get("NEXO_LOCAL_CONTEXT_PRE_ANSWER_MODE")
+        or "inject"
+    )
+    payload = {
+        "ok": True,
+        "read_only": True,
+        "generated_at": current,
+        "window_seconds": max(0, int(window_seconds or DEFAULT_WINDOW_SECONDS)),
+        "phase_coverage": {
+            "phase_0_observatory": True,
+            "phase_1_local_context": True,
+            "phase_2_learning_resolver": True,
+            "phase_3_followup_lifecycle": True,
+            "phase_4_intraday_memory": True,
+        },
+        "local_context": {
+            "pre_answer_mode": str(local_mode).strip().lower(),
+            "usage": local_usage,
+            "status": local_status,
+        },
+        "learnings": learning_summary,
+        "followups": followup_summary,
+        "intraday_memory": intraday_summary,
+    }
+    payload["summary"] = {
+        "local_context_events": int(local_usage.get("total_events") or 0),
+        "active_learnings": int(learning_summary.get("active") or 0),
+        "active_followups": int((followup_summary.get("counts") or {}).get("active") or 0),
+        "intraday_facts": int(intraday_summary.get("intraday_facts_window") or 0),
+    }
+    return payload
+
+
+def format_observatory(payload: dict[str, Any]) -> str:
+    return json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True)
+
+
+__all__ = ["build_cognitive_control_observatory", "format_observatory"]

package/src/crons/manifest.json

@@ -302,6 +302,19 @@
       "run_on_boot": true,
       "run_on_wake": true
     },
+    {
+      "id": "memory-fabric",
+      "script": "scripts/nexo-memory-fabric.py",
+      "schedule": {"hour": 2, "minute": 35},
+      "description": "Daily Memory Fabric maintenance — refresh transcript search, historical backup diaries, and graph links",
+      "core": true,
+      "recovery_policy": "catchup",
+      "idempotent": true,
+      "max_catchup_age": 172800,
+      "stuck_after_seconds": 3600,
+      "run_on_boot": true,
+      "run_on_wake": true
+    },
     {
       "id": "local-index",
       "script": "scripts/nexo-local-index.py",

package/src/dashboard/app.py

@@ -227,7 +227,8 @@ def _normalize_item_status(status: object) -> str:
 
 
 def _dashboard_status_matches(status: object, requested: str | None) -> bool:
-    normalized = _normalize_item_status(status)
+    db = _db()
+    normalized = db.normalize_followup_status(status)
     requested_key = str(requested or "").strip().lower()
     if not requested_key:
         return normalized != "DELETED"
@@ -239,6 +240,11 @@ def _dashboard_status_matches(status: object, requested: str | None) -> bool:
         return normalized.startswith("COMPLETED")
     if requested_key == "deleted":
         return normalized == "DELETED"
+    if requested_key in {
+        "active", "waiting_user", "waiting_external", "blocked",
+        "parked", "stale_review", "expired", "completed",
+    }:
+        return db.followup_lifecycle_lane({"status": normalized}) == requested_key
     return normalized == requested_key.upper()
 
 
@@ -1019,6 +1025,10 @@ async def api_followups_list(
     """List followups."""
     db = _db()
     followups = db.get_followups("history")
+    for item in followups:
+        item["status"] = db.normalize_followup_status(item.get("status"))
+        item["lifecycle_lane"] = db.followup_lifecycle_lane(item)
+        item["due_state"] = db.followup_due_state(item)
     followups = [r for r in followups if _dashboard_status_matches(r.get("status"), status)]
     followups = sorted(followups, key=lambda item: item.get("updated_at") or item.get("created_at") or 0, reverse=True)
     return {"count": len(followups), "followups": followups}
@@ -2064,12 +2074,11 @@ async def api_backups():
 @app.get("/api/followup-health")
 async def api_followup_health():
     db = _db()
-    conn = db.get_db()
-    all_f = [dict(r) for r in conn.execute("SELECT * FROM followups").fetchall()]
-    today = datetime.date.today().isoformat()
-    pending = [f for f in all_f if f.get("status") not in ("completed", "archived", "deleted")]
-    completed = [f for f in all_f if f.get("status") == "completed"]
-    overdue = [f for f in pending if f.get("date") and f["date"] < today]
+    snapshot = db.followup_lifecycle_snapshot(limit=5000)
+    all_f = [item for lane_items in (snapshot.get("lanes") or {}).values() for item in lane_items]
+    active = list((snapshot.get("lanes") or {}).get("active", []))
+    completed = list((snapshot.get("lanes") or {}).get("completed", []))
+    overdue = [f for f in active if f.get("due_state") == "due"]
     rate = round(len(completed) / max(len(all_f), 1) * 100, 1)
     age_buckets = {"0-3d": 0, "4-7d": 0, "8-14d": 0, "15-30d": 0, "30d+": 0}
     for f in overdue:
@@ -2082,8 +2091,16 @@ async def api_followup_health():
             elif age <= 14: age_buckets["8-14d"] += 1
             elif age <= 30: age_buckets["15-30d"] += 1
             else: age_buckets["30d+"] += 1
-    return {"total": len(all_f), "pending": len(pending), "completed": len(completed),
-            "overdue": len(overdue), "completion_rate": rate, "age_buckets": age_buckets, "overdue_items": overdue[:20]}
+    return {
+        "total": len(all_f),
+        "pending": len(active),
+        "completed": len(completed),
+        "overdue": len(overdue),
+        "completion_rate": rate,
+        "age_buckets": age_buckets,
+        "overdue_items": overdue[:20],
+        "lifecycle": snapshot,
+    }
 
 
 # ---------------------------------------------------------------------------