nexo-brain 7.23.13 → 7.24.0

package/src/scripts/deep-sleep/apply_findings.py

@@ -33,6 +33,7 @@ if str(NEXO_CODE) not in sys.path:
 import db as nexo_db
 import paths
 from cognitive_paths import resolve_cognitive_db
+from learning_resolver import resolve_learning_candidate
 
 def _resolve_nexo_db() -> Path:
     candidates = [
@@ -161,21 +162,24 @@ def _top_followups_by_impact(limit: int = 5) -> list[dict]:
             conn.close()
             return []
         impact_factors_sql = ", impact_factors" if "impact_factors" in columns else ""
-        rows = [
-            dict(row)
-            for row in conn.execute(
-                f"""SELECT id, description, date, priority, impact_score{impact_factors_sql}
-                    FROM followups
-                    WHERE status IN ('PENDING', 'ACTIVE', 'WAITING', 'BLOCKED')
-                    ORDER BY
-                      CASE WHEN COALESCE(impact_score, 0) > 0 THEN 0 ELSE 1 END ASC,
-                      COALESCE(impact_score, 0) DESC,
-                      CASE WHEN date IS NULL OR date = '' THEN 1 ELSE 0 END ASC,
-                      date ASC
-                    LIMIT ?""",
-                (max(1, int(limit)),),
-            ).fetchall()
-        ]
+        owner_sql = ", owner" if "owner" in columns else ""
+        rows = []
+        for row in conn.execute(
+            f"""SELECT id, description, date, priority, impact_score, status{owner_sql}{impact_factors_sql}
+                FROM followups
+                ORDER BY
+                  CASE WHEN COALESCE(impact_score, 0) > 0 THEN 0 ELSE 1 END ASC,
+                  COALESCE(impact_score, 0) DESC,
+                  CASE WHEN date IS NULL OR date = '' THEN 1 ELSE 0 END ASC,
+                  date ASC
+                LIMIT ?""",
+            (max(20, int(limit) * 4),),
+        ).fetchall():
+            item = dict(row)
+            if nexo_db.followup_lifecycle_lane(item) == "active":
+                rows.append(item)
+            if len(rows) >= max(1, int(limit)):
+                break
         conn.close()
     except Exception:
         return []
@@ -501,6 +505,18 @@ def _find_learning_match(category: str, title: str, content: str) -> dict | None
     return candidates[0]
 
 
+def _learning_by_id(learning_id: int) -> dict | None:
+    if not learning_id or not NEXO_DB.exists():
+        return None
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    try:
+        row = conn.execute("SELECT * FROM learnings WHERE id = ?", (int(learning_id),)).fetchone()
+        return dict(row) if row else None
+    finally:
+        conn.close()
+
+
 def _update_learning_row(learning_id: int, updates: dict[str, object]) -> None:
     if not updates:
         return
@@ -545,7 +561,34 @@ def add_learning(category: str, title: str, content: str) -> dict:
     if not NEXO_DB.exists():
         return {"success": False, "error": "nexo.db not found"}
     try:
-        existing = _find_learning_match(category, title, content)
+        resolution = resolve_learning_candidate(
+            category=category,
+            title=title,
+            content=content,
+            source_authority="deep_sleep",
+        )
+        if resolution["action"] == "reject":
+            return {"success": False, "error": resolution["reason"], "outcome": "rejected_learning"}
+        if resolution["action"] == "conflict_review":
+            return _flag_learning_contradiction(
+                {
+                    "id": resolution.get("target_id"),
+                    "title": resolution.get("target_title"),
+                    "_similarity": resolution.get("similarity", 0.0),
+                },
+                category,
+                title,
+                content,
+            )
+
+        canonical_supersedes_id = int(resolution.get("target_id") or 0) if resolution["action"] == "supersede" else 0
+        existing = None if canonical_supersedes_id else _find_learning_match(category, title, content)
+        if resolution["action"] == "merge" and int(resolution.get("target_id") or 0):
+            row = _learning_by_id(int(resolution["target_id"]))
+            if row:
+                existing = dict(row)
+                existing["_similarity"] = float(resolution.get("similarity") or 1.0)
+                existing["_contradiction"] = False
         if existing:
             similarity = existing.get("_similarity", 0.0)
             if existing.get("_contradiction"):
@@ -631,7 +674,21 @@ def add_learning(category: str, title: str, content: str) -> dict:
         learning_id = cursor.lastrowid
         conn.commit()
         conn.close()
-        return {"success": True, "id": learning_id, "outcome": "new_learning"}
+        if canonical_supersedes_id:
+            try:
+                nexo_db.supersede_learning(
+                    int(canonical_supersedes_id),
+                    int(learning_id),
+                    f"Superseded by Deep Sleep canonical learning #{learning_id}.",
+                )
+            except Exception:
+                pass
+        return {
+            "success": True,
+            "id": learning_id,
+            "outcome": "new_learning" if not canonical_supersedes_id else "superseding_learning",
+            "supersedes_id": canonical_supersedes_id,
+        }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
@@ -677,6 +734,11 @@ def create_followup(description: str, date: str = "", reasoning_note: str = "",
         )
         if followup_result.get("error"):
             return {"success": False, "error": followup_result["error"]}
+        if desired_status.lower() == "archived":
+            conn = sqlite3.connect(str(NEXO_DB))
+            conn.execute("UPDATE followups SET status = ? WHERE id = ?", ("archived", fid))
+            conn.commit()
+            conn.close()
         if desired_status != "PENDING":
             nexo_db.add_followup_note(
                 fid,

package/src/scripts/nexo-daily-self-audit.py

@@ -75,6 +75,7 @@ from constants import AUTOMATION_SUBPROCESS_TIMEOUT
 from core_prompts import render_core_prompt
 from cognitive_paths import audit_cognitive_db_paths, resolve_cognitive_db
 import db as nexo_db
+from learning_resolver import applies_overlap, looks_contradictory, resolve_learning_candidate
 from public_evolution_queue import queue_public_port_candidate
 
 try:
@@ -390,12 +391,34 @@ def _upsert_inline_learning(
         return {"ok": False, "reason": "learnings_missing"}
 
     columns = _table_columns(conn, "learnings")
+    resolution = resolve_learning_candidate(
+        category=category,
+        title=title,
+        content=content,
+        reasoning=reasoning,
+        prevention=prevention,
+        applies_to=applies_to,
+        priority=priority,
+        source_authority="code_test_evidence",
+        conn=conn,
+    )
+    if resolution["action"] == "reject":
+        return {"ok": False, "reason": resolution["reason"], "resolver": resolution}
+    if resolution["action"] == "conflict_review":
+        return {"ok": False, "reason": "conflict_review_required", "resolver": resolution}
+    resolver_target_id = int(resolution.get("target_id") or 0)
+    supersede_target_id = resolver_target_id if resolution["action"] == "supersede" else 0
     rows = conn.execute(
         "SELECT * FROM learnings WHERE COALESCE(status, 'active') != 'superseded' ORDER BY updated_at DESC, id DESC LIMIT 200"
     ).fetchall()
     target_signature = _topic_signature(f"{title} {content}")
     existing = None
     for row in rows:
+        if resolution["action"] == "merge" and resolver_target_id and int(row["id"]) == resolver_target_id:
+            existing = row
+            break
+        if supersede_target_id:
+            continue
         row_title = str(row["title"] or "").strip() if "title" in columns else ""
         row_content = str(row["content"] or "").strip() if "content" in columns else ""
         row_applies = str(row["applies_to"] or "").strip() if "applies_to" in columns else ""
@@ -471,6 +494,13 @@ def _upsert_inline_learning(
         list(values.values()),
     )
     learning_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
+    if supersede_target_id:
+        _supersede_learning_inline(
+            conn,
+            keep_id=int(learning_id),
+            retire_id=supersede_target_id,
+            note=f"Self-audit canonical resolver superseded learning #{supersede_target_id}.",
+        )
     return {"ok": True, "action": "created", "learning_id": int(learning_id)}
 
 
@@ -681,8 +711,8 @@ def _retire_stale_audit_goals_inline(
                    closed_at = ?
                WHERE goal_id = ?""",
             (
-                "Ninguna. Placeholder stale retirado automáticamente; el self-audit lo recreará si el patrón reaparece.",
-                f"Self-audit placeholder stale >{max_age_hours}h sin workflow runs abiertos.",
+                "None. Stale placeholder removed automatically; self-audit will recreate it if the pattern reappears.",
+                f"Self-audit placeholder stale >{max_age_hours}h without open workflow runs.",
                 now_iso,
                 now_iso,
                 row["goal_id"],
@@ -853,15 +883,20 @@ def check_overdue_reminders():
 def check_overdue_followups():
     if not NEXO_DB.exists():
         return
-    conn = sqlite3.connect(str(NEXO_DB))
     today = datetime.now().strftime("%Y-%m-%d")
-    rows = conn.execute(
-        "SELECT description, date FROM followups WHERE status='PENDING' AND date < ? AND date != '' ORDER BY date",
-        (today,)
-    ).fetchall()
-    conn.close()
+    try:
+        active = (nexo_db.followup_lifecycle_snapshot(limit=5000).get("lanes") or {}).get("active", [])
+        rows = [item for item in active if item.get("date") and str(item["date"]) < today]
+        rows.sort(key=lambda item: str(item.get("date") or ""))
+    except Exception:
+        conn = sqlite3.connect(str(NEXO_DB))
+        rows = conn.execute(
+            "SELECT description, date FROM followups WHERE status='PENDING' AND date < ? AND date != '' ORDER BY date",
+            (today,)
+        ).fetchall()
+        conn.close()
     if rows:
-        finding("WARN", "followups", f"{len(rows)} overdue: {', '.join(r[0][:40] for r in rows[:5])}")
+        finding("WARN", "followups", f"{len(rows)} overdue: {', '.join(str((r.get('description') if isinstance(r, dict) else r[0]) or '')[:40] for r in rows[:5])}")
 
 
 def check_uncommitted_changes():
@@ -1156,8 +1191,6 @@ def check_learning_contradictions():
         conn.close()
         return
 
-    from tools_learnings import _applies_overlap, _looks_contradictory
-
     rows = conn.execute(
         """SELECT id, title, content, applies_to
            FROM learnings
@@ -1168,9 +1201,9 @@ def check_learning_contradictions():
     contradictions: list[tuple[sqlite3.Row, sqlite3.Row]] = []
     for index, left in enumerate(rows):
         for right in rows[index + 1:]:
-            if not _applies_overlap(left["applies_to"], right["applies_to"]):
+            if not applies_overlap(left["applies_to"], right["applies_to"]):
                 continue
-            if not _looks_contradictory(
+            if not looks_contradictory(
                 f"{left['title']} {left['content']}",
                 f"{right['title']} {right['content']}",
             ):

package/src/scripts/nexo-email-migrate-config.py

@@ -171,8 +171,8 @@ def main(argv: list[str]) -> int:
             is_default=False,
         )
         print(
-            f"(cuenta '{args.label}' ya existe — email={account.get('email')}, "
-            "normalizo el contrato agente y sólo completo buzones del operador faltantes)."
+            f"(account '{args.label}' already exists — email={account.get('email')}, "
+            "normalizing the agent contract and only filling missing operator mailboxes)."
         )
     else:
         account = add_email_account(

package/src/scripts/nexo-email-monitor.py

@@ -395,12 +395,12 @@ def load_config():
             return cfg
     except Exception:
         pass
-    # v0.32.5 — graceful return None when no email setup yet. Antes esto
-    # lanzaba FileNotFoundError y el cron de cada minuto generaba 1440
-    # filas de error/día por cliente sin email configurado. 50 clientes
-    # pagados sin email setup → 72k filas de error/día → watchdog L2
-    # alertas falsas → ruido en logs y posible token burn. Ahora el
-    # cron retorna sin error cuando no hay config.
+    # v0.32.5 — return None gracefully when no email setup exists yet. Before
+    # this, FileNotFoundError bubbled up and the once-per-minute cron generated
+    # 1,440 error rows per day per client without configured email. 50 paid
+    # clients without email setup meant 72k error rows/day, false watchdog L2
+    # alerts, log noise, and possible token burn. The cron now returns without
+    # error when config is absent.
     try:
         with open(CONFIG_PATH) as f:
             payload = json.load(f)
@@ -952,8 +952,8 @@ def scan_debt(db_path=EMAIL_DB_PATH, *, max_items=5):
             {
                 "email_id": row["email_id"],
                 "kind": "ack",
-                "label": f"ACK sin cierre >{DEBT_SLA_HOURS}h — {row['subject'] or row['email_id']} [{row['email_id']}]",
-                "detail": f"ack desde {row['last_ack_ts']}",
+                "label": f"ACK without closure >{DEBT_SLA_HOURS}h — {row['subject'] or row['email_id']} [{row['email_id']}]",
+                "detail": f"ack since {row['last_ack_ts']}",
             }
         )
 
@@ -979,8 +979,8 @@ def scan_debt(db_path=EMAIL_DB_PATH, *, max_items=5):
             {
                 "email_id": row["email_id"],
                 "kind": "commitment",
-                "label": f"COMPROMISO sin cierre >{DEBT_SLA_HOURS}h — {row['subject'] or row['email_id']} [{row['email_id']}]",
-                "detail": f"commitment desde {row['last_commitment_ts']}",
+                "label": f"COMMITMENT without closure >{DEBT_SLA_HOURS}h — {row['subject'] or row['email_id']} [{row['email_id']}]",
+                "detail": f"commitment since {row['last_commitment_ts']}",
             }
         )
 
@@ -1932,13 +1932,13 @@ def _localized_operator_escalation_email(
     details: str,
 ) -> tuple[str, str]:
     if _uses_spanish(operator_language):
-        subject = f"[NEXO] Emails que necesitan atención manual ({exhausted_count})"
+        subject = f"[NEXO] Emails requiring manual attention ({exhausted_count})"
         body = (
-            f"Hola {operator_name},\n\n"
-            f"Los siguientes emails ya se han intentado {MAX_EMAIL_ATTEMPTS} veces "
-            f"sin completarse correctamente (la sesión cae antes de terminar):\n\n{details}\n\n"
-            "Los he marcado como `needs_interactive`. "
-            f"Abre {assistant_name} Desktop y pregúntale por ese email para resolverlo manualmente.\n\n"
+            f"Hello {operator_name},\n\n"
+            f"The following emails have already been attempted {MAX_EMAIL_ATTEMPTS} times "
+            f"without succeeding (the session dies before completion):\n\n{details}\n\n"
+            "I marked them as `needs_interactive`. "
+            f"Open {assistant_name} Desktop and ask about the affected email so it can be resolved manually.\n\n"
             f"— {assistant_name}"
         )
         return subject, body
@@ -2494,9 +2494,9 @@ def main():
             return
 
         config = load_config()
-        # v0.32.5 — exit cleanly cuando no hay email setup.
-        # Antes el FileNotFoundError propagaba a 1440 errores/día por
-        # cliente Win sin email. Ahora salimos en silencio.
+        # v0.32.5 — exit cleanly when no email setup exists. Before this,
+        # FileNotFoundError bubbled up to 1,440 errors/day per Windows client
+        # without email. Now the monitor exits silently.
         if config is None:
             log.info("No email config — skipping monitor check.")
             return

package/src/scripts/nexo-followup-hygiene.py

@@ -5,8 +5,9 @@ NEXO Followup Hygiene — Weekly cleanup of followup/reminder statuses.
 
 Runs Sundays via LaunchAgent (or manually). Tasks:
 1. Normalize dirty statuses (COMPLETED YYYY-MM-DD -> COMPLETED)
-2. Escalate PENDING followups >14 days without updates to needs_decision
-3. Generate summary of orphaned/forgotten followups for synthesis
+2. Move PENDING followups >14 days without updates to stale_review
+3. Expire stale_review followups that stayed untouched for the TTL window
+4. Generate summary of orphaned/forgotten followups for synthesis
 
 No CLI needed — this is pure mechanical cleanup.
 """
@@ -32,6 +33,7 @@ COORD_DIR = paths.coordination_dir()
 LOG_FILE = paths.logs_dir() / "followup-hygiene.log"
 
 TODAY = date.today().isoformat()
+EXPIRE_STALE_REVIEW_DAYS = int(os.environ.get("NEXO_FOLLOWUP_EXPIRE_STALE_REVIEW_DAYS", "90") or "90")
 
 
 def log(msg):
@@ -91,7 +93,7 @@ def main():
     stale = conn.execute(
         "SELECT id, description, date, updated_at FROM followups "
         "WHERE status NOT LIKE 'COMPLETED%' "
-        "AND status NOT IN ('DELETED','archived','blocked','waiting','needs_decision','waiting_user') "
+        "AND UPPER(COALESCE(status, '')) NOT IN ('DELETED','ARCHIVED','BLOCKED','WAITING','WAITING_EXTERNAL','NEEDS_DECISION','WAITING_USER','PARKED','STALE_REVIEW','EXPIRED','DONE') "
         "AND date != '' AND date < ? "
         "AND (updated_at IS NULL OR updated_at = '' OR updated_at < ?) "
         "ORDER BY date",
@@ -106,23 +108,51 @@ def main():
         for s in stale:
             result = nexo_db.update_followup(
                 str(s["id"]),
-                status="needs_decision",
+                status="stale_review",
                 date=TODAY,
                 history_actor="followup-hygiene",
                 history_event="stale_triage",
                 history_note=(
-                    "Weekly hygiene escalated this old due followup to needs_decision "
+                    "Weekly hygiene moved this old due followup to stale_review "
                     "instead of leaving it in the executable briefing indefinitely."
                 ),
             )
             if not result.get("error"):
                 escalated_stale.append(str(s["id"]))
 
-    # 3. Orphaned followups (no date, no recent update)
+    # 3. Expire stale_review followups that received no decision for the TTL window
+    expire_cutoff = datetime.now().timestamp() - (max(1, EXPIRE_STALE_REVIEW_DAYS) * 24 * 60 * 60)
+    expirable = conn.execute(
+        "SELECT id, description, updated_at FROM followups "
+        "WHERE UPPER(COALESCE(status, '')) = 'STALE_REVIEW' "
+        "AND (updated_at IS NULL OR updated_at = '' OR updated_at < ?) "
+        "ORDER BY updated_at ASC",
+        (expire_cutoff,),
+    ).fetchall()
+    expired_ids = []
+    if expirable:
+        log(f"Expiring {len(expirable)} stale_review followups untouched for >{EXPIRE_STALE_REVIEW_DAYS} days:")
+        for item in expirable[:10]:
+            log(f"  {item['id']}: {item['description'][:60]}")
+        for item in expirable:
+            result = nexo_db.update_followup(
+                str(item["id"]),
+                status="expired",
+                history_actor="followup-hygiene",
+                history_event="expired",
+                history_note=(
+                    f"Weekly hygiene expired stale_review followup after "
+                    f"{EXPIRE_STALE_REVIEW_DAYS} days without movement."
+                ),
+            )
+            if not result.get("error"):
+                expired_ids.append(str(item["id"]))
+
+    # 4. Orphaned followups (no date, no recent update)
     orphans = conn.execute(
         "SELECT id, description FROM followups "
         "WHERE status NOT LIKE 'COMPLETED%' "
-        "AND status NOT IN ('DELETED','archived','blocked','waiting') "
+        "AND UPPER(COALESCE(status, '')) NOT IN ('DELETED','ARCHIVED','BLOCKED','WAITING','WAITING_EXTERNAL','NEEDS_DECISION','WAITING_USER','PARKED','STALE_REVIEW','EXPIRED','DONE') "
         "AND (date IS NULL OR date = '') "
         "ORDER BY id"
     ).fetchall()
@@ -141,9 +171,11 @@ def main():
         "dirty_normalized": dirty_f + dirty_r,
         "stale_count": len(stale) if stale else 0,
         "stale_escalated_count": len(escalated_stale),
+        "expired_count": len(expired_ids),
         "orphan_count": len(orphans) if orphans else 0,
         "stale_ids": [s["id"] for s in stale[:20]] if stale else [],
         "stale_escalated_ids": escalated_stale[:20],
+        "expired_ids": expired_ids[:20],
         "orphan_ids": [o["id"] for o in orphans[:20]] if orphans else [],
     }
 
@@ -151,7 +183,7 @@ def main():
     summary_file.parent.mkdir(parents=True, exist_ok=True)
     summary_file.write_text(json.dumps(summary, indent=2))
 
-    log(f"Summary: {dirty_f + dirty_r} normalized, {len(escalated_stale)} stale escalated, {len(orphans) if orphans else 0} orphans")
+    log(f"Summary: {dirty_f + dirty_r} normalized, {len(escalated_stale)} stale escalated, {len(expired_ids)} expired, {len(orphans) if orphans else 0} orphans")
     log("=== Followup Hygiene complete ===")
 
 

package/src/scripts/nexo-followup-runner.py

@@ -73,7 +73,7 @@ RESULTS_FILE = data_dir() / "followup-runner-results.json"
 CLI_TIMEOUT = AUTOMATION_SUBPROCESS_TIMEOUT
 LOCK_FILE = LOG_DIR / "followup-runner.lock"
 MAX_FOLLOWUPS_PER_RUN = 5  # Focus: Opus can actually execute 5, not 30
-COOLDOWN_DAYS = 3  # Don't retry needs_decision/blocked for 3 days
+COOLDOWN_DAYS = 3  # Don't retry waiting_user/stale_review/blocked for 3 days
 STALE_FOLLOWUP_TRIAGE_DAYS = 14
 MAX_STALE_TRIAGE_PER_RUN = 8
 MAX_NEEDS_OPERATOR_BRIEFING = 12
@@ -134,7 +134,7 @@ def _history_has_recent_movement(history, *, days: int = STALE_FOLLOWUP_TRIAGE_D
 
 def _is_stale_followup_for_triage(followup: dict) -> bool:
     status = str(followup.get("status") or "").strip().lower()
-    if status in {"needs_decision", "waiting_user", "blocked", "waiting"}:
+    if status in {"needs_decision", "waiting_user", "blocked", "waiting", "stale_review"}:
         return False
     if _followup_days_overdue(str(followup.get("date") or "")) < STALE_FOLLOWUP_TRIAGE_DAYS:
         return False
@@ -148,7 +148,7 @@ def _is_in_cooldown(fu_id: str, state: dict) -> bool:
     if not last:
         return False
     last_status = last.get("status", "")
-    if last_status not in ("needs_decision", "blocked"):
+    if last_status not in ("needs_decision", "waiting_user", "stale_review", "blocked"):
         return False
     last_date_str = last.get("date", "")
     if not last_date_str:
@@ -298,17 +298,17 @@ def get_all_active_followups(state: dict) -> dict:
     conn = sqlite3.connect(str(NEXO_DB))
     conn.row_factory = sqlite3.Row
     try:
-        rows = conn.execute(
-            "SELECT id, description, date, reasoning, verification, priority, recurrence, status, owner, updated_at "
-            "FROM followups WHERE status NOT LIKE 'COMPLETED%' "
-            "AND UPPER(COALESCE(status, '')) NOT IN ('BLOCKED', 'ARCHIVED', 'DELETED', 'WAITING', 'DONE') "
-            "AND description NOT LIKE '[Abandoned]%' "
-            "ORDER BY "
-            "  CASE priority "
-            "    WHEN 'critical' THEN 1 WHEN 'high' THEN 2 "
-            "    WHEN 'medium' THEN 3 WHEN 'low' THEN 4 ELSE 5 END, "
-            "  date ASC"
-        ).fetchall()
+        snapshot = nexo_db.followup_lifecycle_snapshot(limit=5000)
+        rows = [
+            item for item in (snapshot.get("lanes") or {}).get("active", [])
+            if not str(item.get("description") or "").startswith("[Abandoned]")
+        ]
+        rows.sort(
+            key=lambda item: (
+                {"critical": 1, "high": 2, "medium": 3, "low": 4}.get(str(item.get("priority") or "medium"), 5),
+                str(item.get("date") or "9999-12-31"),
+            )
+        )
 
         result = {"actionable": [], "needs_operator": [], "future": [], "backlog": [], "cooled_down": [], "stale_triage": []}
         undated_triage_budget = 2
@@ -429,7 +429,7 @@ def complete_followup_if_needed(fu_id: str, result_summary: str = ""):
         return
     try:
         nexo_db.complete_followup(fu_id, result_summary)
-        log(f"  {fu_id}: marcado completado por el runner")
+        log(f"  {fu_id}: marked completed por el runner")
     except Exception as exc:
         log(f"  {fu_id}: failed to mark followup as completed ({exc})")
 
@@ -488,7 +488,7 @@ def attention_reminder_id(fu_id: str) -> str:
 
 
 def attention_reminder_category(status: str) -> str:
-    return "decisions" if status == "needs_decision" else "waiting"
+    return "decisions" if status in {"needs_decision", "waiting_user", "stale_review"} else "waiting"
 
 
 def attention_reminder_description(
@@ -502,14 +502,14 @@ def attention_reminder_description(
     detail = " ".join((summary or "").split())
     if not detail:
         detail = (
-            "El runner no puede cerrar este punto sin intervención del operador."
+            "The runner cannot close this item without operator input."
             if _uses_spanish(operator_language)
             else "The runner cannot close this item without operator input."
         )
     description = f"{fu_id}: {detail}"
     opts_text = render_options(options)
     if opts_text:
-        description += f" {'Opciones' if _uses_spanish(operator_language) else 'Options'}: {opts_text}"
+        description += f" {'Options' if _uses_spanish(operator_language) else 'Options'}: {opts_text}"
     return description[:480]
 
 
@@ -548,7 +548,7 @@ def upsert_attention_reminder(
             log(f"  {fu_id}: failed to update reminder {reminder_id} ({result['error']})")
             return
         nexo_db.add_reminder_note(reminder_id, description, actor="followup-runner")
-        log(f"  {fu_id}: reminder {reminder_id} actualizado para orchestrator")
+        log(f"  {fu_id}: reminder {reminder_id} updated for orchestrator")
         return
 
     result = nexo_db.create_reminder(
@@ -565,7 +565,7 @@ def upsert_attention_reminder(
         f"source_followup={fu_id} status={status}",
         actor="followup-runner",
     )
-    log(f"  {fu_id}: reminder {reminder_id} creado para orchestrator")
+    log(f"  {fu_id}: reminder {reminder_id} created for orchestrator")
 
 
 def resolve_attention_reminder(fu_id: str, *, resolution: str = ""):
@@ -579,14 +579,14 @@ def resolve_attention_reminder(fu_id: str, *, resolution: str = ""):
     if resolution:
         nexo_db.add_reminder_note(
             reminder_id,
-            f"Resuelto desde {fu_id}: {resolution[:300]}",
+            f"Resolved from {fu_id}: {resolution[:300]}",
             actor="followup-runner",
         )
     result = nexo_db.complete_reminder(reminder_id)
     if result.get("error"):
         log(f"  {fu_id}: failed to complete reminder {reminder_id} ({result['error']})")
         return
-    log(f"  {fu_id}: reminder {reminder_id} marcado completado")
+    log(f"  {fu_id}: reminder {reminder_id} marked completed")
 
 
 def defer_followup_after_attention(
@@ -602,7 +602,7 @@ def defer_followup_after_attention(
     details = summary.strip()
     opts_text = render_options(options)
     if opts_text:
-        details = f"{details}\nOpciones: {opts_text}"
+        details = f"{details}\nOptions: {opts_text}"
     if details:
         note_result = nexo_db.add_followup_note(
             fu_id,
@@ -690,10 +690,10 @@ def get_recent_activity(hours: int = 24) -> str:
 
         # Recent followup notes from the runner
         notes = conn.execute(
-            "SELECT followup_id, note, created_at FROM followup_history "
-            "WHERE actor='followup-runner' AND created_at >= datetime('now', ?)"
+            "SELECT item_id AS followup_id, note, created_at FROM item_history "
+            "WHERE item_type='followup' AND actor='followup-runner' AND created_at >= ? "
             "ORDER BY created_at DESC LIMIT 10",
-            (f"-{hours} hours",)
+            ((datetime.now() - timedelta(hours=hours)).timestamp(),),
         ).fetchall()
         if notes:
             lines.append("\nFOLLOWUP NOTES WRITTEN (last 24h):")
@@ -821,7 +821,7 @@ def main():
         update_followup_fields(
             fid,
             date_value=date.today().isoformat(),
-            status="needs_decision",
+            status="stale_review",
             history_event="stale_triage",
             history_note=summary,
         )
@@ -829,10 +829,10 @@ def main():
             fid,
             summary=summary,
             options={"a": "close obsolete", "b": "reschedule", "c": "convert to next action"},
-            status="needs_decision",
+            status="stale_review",
             operator_language=_operator_language(),
         )
-        record_attempt(state, fid, "needs_decision")
+        record_attempt(state, fid, "stale_review")
 
     results = []
 
@@ -914,7 +914,7 @@ def main():
             advance_recurrent(fid, recurrence, summary)
             resolve_attention_reminder(fid, resolution=summary)
             record_attempt(state, fid, "checked")
-        elif r["status"] in ("needs_decision", "blocked"):
+        elif r["status"] in ("needs_decision", "waiting_user", "stale_review", "blocked"):
             defer_followup_after_attention(
                 fid,
                 summary=summary,
@@ -929,7 +929,7 @@ def main():
 
     total = len(all_actionable) + len(groups["needs_operator"]) + len(groups["future"]) + len(groups["backlog"]) + len(stale_triage)
     attention_handed_off = any(
-        r.get("needs_attention") or r["status"] in ("needs_decision", "blocked")
+        r.get("needs_attention") or r["status"] in ("needs_decision", "waiting_user", "stale_review", "blocked")
         for r in results
     )
     if total > 0 or results:

package/src/scripts/nexo-inbox-hook.sh

@@ -65,7 +65,7 @@ if [ -n "$MESSAGES" ]; then
 fi
 
 if [ -n "$QUESTIONS" ]; then
-    echo "  ⚠ PREGUNTAS de otra terminal — responder con nexo_answer:"
+    echo "  ⚠ QUESTIONS from another terminal — answer with nexo_answer:"
     echo "$QUESTIONS" | while IFS='|' read -r qid from question; do
         echo "  Q[$qid] de [$from]: $question"
     done