nexo-brain 2.2.0 → 2.3.1

package/src/storage_router 2.py

@@ -1,32 +0,0 @@
-"""Storage Router — DB path abstraction for future multi-tenant support."""
-
-import os
-
-NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
-
-
-class StorageRouter:
-    def __init__(self, tenant_id: str = "default"):
-        self.tenant_id = tenant_id
-
-    def nexo_db_path(self) -> str:
-        if self.tenant_id == "default":
-            data_dir = os.path.join(NEXO_HOME, "data")
-            os.makedirs(data_dir, exist_ok=True)
-            return os.path.join(data_dir, "nexo.db")
-        return os.path.join(NEXO_HOME, "tenants", self.tenant_id, "nexo.db")
-
-    def cognitive_db_path(self) -> str:
-        if self.tenant_id == "default":
-            data_dir = os.path.join(NEXO_HOME, "data")
-            os.makedirs(data_dir, exist_ok=True)
-            return os.path.join(data_dir, "cognitive.db")
-        return os.path.join(NEXO_HOME, "tenants", self.tenant_id, "cognitive.db")
-
-
-_default_router = StorageRouter("default")
-
-def get_router(tenant_id: str = "default") -> StorageRouter:
-    if tenant_id == "default":
-        return _default_router
-    return StorageRouter(tenant_id)

package/src/tools_coordination 2.py

@@ -1,102 +0,0 @@
-"""Coordination tools: file tracking, messaging, Q&A."""
-
-from db import (
-    track_files, untrack_files, get_all_tracked_files,
-    send_message, get_inbox,
-    ask_question, answer_question, get_pending_questions, check_answer,
-    now_epoch,
-)
-from tools_sessions import _format_age
-
-
-def handle_track(sid: str, paths: list[str]) -> str:
-    """Track files being edited. Reports conflicts immediately."""
-    result = track_files(sid, paths)
-    if "error" in result:
-        return f"ERROR: {result['error']}"
-
-    lines = [f"Tracked: {', '.join(result['tracked'])}"]
-
-    if result["conflicts"]:
-        lines.append("")
-        lines.append("FILE CONFLICTS:")
-        for c in result["conflicts"]:
-            lines.append(f"  {c['sid']} ({c['task']}):")
-            for f in c["files"]:
-                lines.append(f"    {f}")
-        lines.append("")
-        lines.append("STOP and inform the user before editing.")
-
-    return "\n".join(lines)
-
-
-def handle_untrack(sid: str, paths: list[str] | None = None) -> str:
-    """Untrack files. If no paths given, untrack all."""
-    untrack_files(sid, paths)
-    if paths:
-        return f"Untracked: {', '.join(paths)}"
-    return "All files released."
-
-
-def handle_files() -> str:
-    """Show all tracked files across sessions."""
-    data = get_all_tracked_files()
-    if not data:
-        return "No tracked files."
-
-    lines = ["TRACKED FILES:"]
-    all_paths = {}
-    for sid, info in data.items():
-        for path in info["files"]:
-            all_paths.setdefault(path, []).append(sid)
-        lines.append(f"  {sid} ({info['task']}):")
-        for path in info["files"]:
-            lines.append(f"    {path}")
-
-    conflicts = {p: sids for p, sids in all_paths.items() if len(sids) > 1}
-    if conflicts:
-        lines.append("")
-        lines.append("CONFLICTS:")
-        for path, sids in conflicts.items():
-            lines.append(f"  {path} -> {', '.join(sids)}")
-
-    return "\n".join(lines)
-
-
-def handle_send(from_sid: str, to_sid: str, text: str) -> str:
-    """Send a message. to_sid='all' for broadcast."""
-    msg_id = send_message(from_sid, to_sid, text)
-    target = "all sessions" if to_sid == "all" else to_sid
-    return f"Message {msg_id} sent to {target}."
-
-
-def handle_ask(from_sid: str, to_sid: str, question: str) -> str:
-    """Create a question to another session (non-blocking)."""
-    qid = ask_question(from_sid, to_sid, question)
-    return (
-        f"Question sent: {qid}\n"
-        f"To: {to_sid}\n"
-        f"Question: {question}\n\n"
-        f"The other session will see this question on its next nexo_heartbeat.\n"
-        f"Use nexo_check_answer(qid='{qid}') to check for a response."
-    )
-
-
-def handle_answer(qid: str, answer_text: str) -> str:
-    """Answer a pending question."""
-    result = answer_question(qid, answer_text)
-    if "error" in result:
-        return f"ERROR: {result['error']}"
-    return f"Answered {qid}: {answer_text}"
-
-
-def handle_check_answer(qid: str) -> str:
-    """Check if a question has been answered."""
-    result = check_answer(qid)
-    if not result:
-        return f"Question {qid} not found."
-    if result["status"] == "answered":
-        return f"ANSWER for {qid}: {result['answer']}"
-    elif result["status"] == "expired":
-        return f"Question {qid} expired without answer."
-    return f"Question still pending. Retry in a few seconds."

package/src/tools_credentials 2.py

@@ -1,68 +0,0 @@
-"""Credentials CRUD tools: get, create, update, delete, list."""
-
-from db import create_credential, update_credential, delete_credential, get_credential, list_credentials
-
-
-def handle_credential_get(service: str, key: str = '') -> str:
-    """Retrieve credential(s) including their values. Use for reading secrets."""
-    results = get_credential(service, key if key else None)
-    if not results:
-        target = f"{service}/{key}" if key else service
-        return f"ERROR: No credentials found for '{target}'."
-    is_fuzzy = any(r.get("_fuzzy") for r in results)
-    lines = []
-    if is_fuzzy:
-        lines.append(f"⚠ No exact match for '{service}'. Similar results ({len(results)}):")
-        lines.append("")
-    for r in results:
-        lines.append(f"CREDENTIAL {r['service']}/{r['key']}:")
-        lines.append(f"  Value: {r['value']}")
-        notes = r.get("notes") or ""
-        lines.append(f"  Notes: {notes if notes else '—'}")
-    return "\n".join(lines)
-
-
-def handle_credential_create(service: str, key: str, value: str, notes: str = '') -> str:
-    """Create a new credential entry."""
-    result = create_credential(service, key, value, notes)
-    if "error" in result:
-        return f"ERROR: {result['error']}"
-    return f"Credential {service}/{key} created."
-
-
-def handle_credential_update(service: str, key: str, value: str = '', notes: str = '') -> str:
-    """Update the value and/or notes of an existing credential."""
-    result = update_credential(
-        service,
-        key,
-        value if value else None,
-        notes if notes else None,
-    )
-    if "error" in result:
-        return f"ERROR: {result['error']}"
-    return f"Credential {service}/{key} updated."
-
-
-def handle_credential_delete(service: str, key: str = '') -> str:
-    """Delete a credential or all credentials for a service."""
-    deleted = delete_credential(service, key if key else None)
-    if not deleted:
-        target = f"{service}/{key}" if key else service
-        return f"ERROR: No credentials found for '{target}'."
-    if key:
-        return f"Credential deleted."
-    return f"All credentials for service deleted."
-
-
-def handle_credential_list(service: str = '') -> str:
-    """List credential service/key names and notes — values are never shown."""
-    results = list_credentials(service if service else None)
-    label = service if service else "ALL"
-    if not results:
-        return f"CREDENTIALS {label.upper()}: No entries."
-    lines = [f"CREDENTIALS {label.upper()} ({len(results)}):"]
-    for r in results:
-        notes = r.get("notes") or ""
-        suffix = f" — {notes}" if notes else ""
-        lines.append(f"  {r['service']}/{r['key']}{suffix}")
-    return "\n".join(lines)

package/src/tools_learnings 2.py

@@ -1,220 +0,0 @@
-"""Learnings CRUD tools: add, search, update, delete, list."""
-
-from db import (create_learning, update_learning, delete_learning, search_learnings,
-                list_learnings, find_similar_learnings, get_db, now_epoch)
-
-def handle_learning_add(category: str, title: str, content: str, reasoning: str = '',
-                        prevention: str = '', applies_to: str = '', review_days: int = 30,
-                        priority: str = 'medium') -> str:
-    """Add a new learning entry to the specified category.
-
-    Args:
-        category: Free-form category name (e.g., 'backend', 'frontend', 'devops', 'infrastructure', 'security', 'nexo-ops'). Use consistent names — learnings are grouped and searched by category.
-        title: Short title for the learning
-        content: Full description of what was learned
-        reasoning: WHY this matters — what led to discovering this, what was the context
-        prevention: Concrete rule/check that prevents repeating this mistake
-        applies_to: Files, systems, or areas this learning applies to
-        review_days: Days until this learning should be reviewed again
-        priority: critical, high, medium, low (default: medium)
-    """
-    if priority not in ('critical', 'high', 'medium', 'low'):
-        priority = 'medium'
-    category = category.lower().strip()
-    if not category:
-        return "ERROR: Category cannot be empty."
-    result = create_learning(
-        category, title, content, reasoning=reasoning
-    )
-    if "error" in result:
-        return f"ERROR: {result['error']}"
-    if prevention or applies_to or review_days > 0 or priority != 'medium':
-        initial_weight = {'critical': 0.9, 'high': 0.7, 'medium': 0.5, 'low': 0.3}[priority]
-        conn = get_db()
-        conn.execute(
-            "UPDATE learnings SET prevention = ?, applies_to = ?, status = COALESCE(status, 'active'), "
-            "review_due_at = ?, updated_at = ?, priority = ?, weight = ? WHERE id = ?",
-            (prevention, applies_to, now_epoch() + (max(1, int(review_days)) * 86400), now_epoch(),
-             priority, initial_weight, result["id"])
-        )
-        conn.commit()
-        result = conn.execute("SELECT * FROM learnings WHERE id = ?", (result["id"],)).fetchone()
-        result = dict(result)
-
-    # Cognitive ingest — embed learning for semantic search
-    new_id = result["id"]
-    try:
-        import cognitive
-        cognitive.ingest(f"{title}: {content}", "learning", f"L{new_id}", title, category)
-    except Exception:
-        pass
-
-    # Similarity check — detect repeated errors
-    matches = find_similar_learnings(new_id, title, content, category)
-    repetition_msg = ""
-    if matches:
-        conn = get_db()
-        for original_id, similarity in matches:
-            conn.execute(
-                "INSERT INTO error_repetitions (new_learning_id, original_learning_id, similarity, area) VALUES (?,?,?,?)",
-                (new_id, original_id, similarity, category)
-            )
-        conn.commit()
-        repetition_msg = f"\n⚠️ REPETITION WARNING: Similar to {len(matches)} existing learning(s): " + \
-            ", ".join(f"#{m[0]} ({m[1]:.0%})" for m in matches[:3])
-
-    # Somatic event logging (append-only in nexo.db, projected to cognitive.db nightly)
-    try:
-        if applies_to:
-            for file_path in [f.strip() for f in applies_to.split(",") if f.strip()]:
-                get_db().execute(
-                    "INSERT INTO somatic_events (target, target_type, event_type, delta, source) VALUES (?, ?, ?, ?, ?)",
-                    (file_path, "file", "learning_add", 0.15, f"learning:{new_id}")
-                )
-        # Area + extra file pain ONLY for repeated errors
-        if matches:
-            get_db().execute(
-                "INSERT INTO somatic_events (target, target_type, event_type, delta, source) VALUES (?, ?, ?, ?, ?)",
-                (category, "area", "error_repetition", 0.15, f"learning:{new_id}")
-            )
-            if applies_to:
-                for file_path in [f.strip() for f in applies_to.split(",") if f.strip()]:
-                    get_db().execute(
-                        "INSERT INTO somatic_events (target, target_type, event_type, delta, source) VALUES (?, ?, ?, ?, ?)",
-                        (file_path, "file", "error_repetition", 0.25, f"learning:{new_id}")
-                    )
-        get_db().commit()
-    except Exception:
-        pass  # Somatic event logging is best-effort
-
-    # Knowledge graph incremental population
-    try:
-        from kg_populate import on_learning_add
-        on_learning_add(new_id, category, title, applies_to)
-    except Exception:
-        pass
-
-    meta = []
-    if prevention:
-        meta.append("with prevention")
-    if applies_to:
-        meta.append(f"applies_to={applies_to}")
-    meta_str = f" ({', '.join(meta)})" if meta else ""
-    return f"Learning #{result['id']} added in {category}: {title}{meta_str}{repetition_msg}"
-
-
-def handle_learning_search(query: str, category: str = '') -> str:
-    """Search learnings by query string, optionally filtered by category."""
-    results = search_learnings(query, category if category else None)
-    if not results:
-        return f"No results for '{query}'."
-    lines = [f"RESULTS ({len(results)}):"]
-    for r in results:
-        snippet = r["content"][:100] + "..." if len(r["content"]) > 100 else r["content"]
-        status = r.get("status", "active")
-        review_due = r.get("review_due_at")
-        review_note = f" | review_due={review_due:.0f}" if isinstance(review_due, (int, float)) and review_due else ""
-        pri = r.get("priority", "medium") or "medium"
-        w = r.get("weight", 0.5) or 0.5
-        pri_icon = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "⚪"}.get(pri, "🟡")
-        lines.append(f"  #{r['id']} [{r['category']}] [{status}] {pri_icon}{pri} w={w:.2f} {r['title']}{review_note}")
-        lines.append(f"    {snippet}")
-        if r.get("prevention"):
-            lines.append(f"    Prevention: {r['prevention'][:100]}")
-
-    # v1.2: Passive rehearsal — strengthen matching cognitive memories
-    try:
-        import cognitive
-        for r in results[:5]:
-            cognitive.rehearse_by_content(f"{r.get('title', '')} {r.get('content', '')[:200]}")
-    except Exception:
-        pass
-
-    return "\n".join(lines)
-
-
-def handle_learning_update(id: int, title: str = '', content: str = '', category: str = '',
-                           reasoning: str = '', prevention: str = '', applies_to: str = '',
-                           status: str = '', review_days: int = 0, priority: str = '') -> str:
-    """Update an existing learning, including review metadata and priority."""
-    kwargs = {}
-    if title:
-        kwargs["title"] = title
-    if content:
-        kwargs["content"] = content
-    if category:
-        kwargs["category"] = category.lower().strip()
-    if reasoning:
-        kwargs["reasoning"] = reasoning
-    if prevention:
-        kwargs["prevention"] = prevention
-    if applies_to:
-        kwargs["applies_to"] = applies_to
-    if status:
-        kwargs["status"] = status
-    if review_days > 0:
-        kwargs["review_days"] = review_days
-    if not kwargs:
-        return "ERROR: Nothing to update. Provide new fields."
-    basic_kwargs = {k: v for k, v in kwargs.items() if k in {"title", "content", "category", "reasoning"}}
-    result = update_learning(id, **basic_kwargs)
-    if "error" in result:
-        return f"ERROR: {result['error']}"
-    extra_updates = {}
-    if prevention:
-        extra_updates["prevention"] = prevention
-    if applies_to:
-        extra_updates["applies_to"] = applies_to
-    if status:
-        extra_updates["status"] = status
-    if priority and priority in ('critical', 'high', 'medium', 'low'):
-        extra_updates["priority"] = priority
-        extra_updates["weight"] = {'critical': 0.9, 'high': 0.7, 'medium': 0.5, 'low': 0.3}[priority]
-    if review_days > 0:
-        extra_updates["review_due_at"] = now_epoch() + (max(1, int(review_days)) * 86400)
-    if extra_updates:
-        extra_updates["updated_at"] = now_epoch()
-        set_clause = ", ".join(f"{k} = ?" for k in extra_updates)
-        values = list(extra_updates.values()) + [id]
-        conn = get_db()
-        conn.execute(f"UPDATE learnings SET {set_clause} WHERE id = ?", values)
-        conn.commit()
-    return f"Learning #{id} updated."
-
-
-def handle_learning_delete(id: int) -> str:
-    """Delete a learning entry by ID."""
-    deleted = delete_learning(id)
-    if not deleted:
-        return f"ERROR: Learning #{id} not found."
-    return f"Learning #{id} deleted."
-
-
-def handle_learning_list(category: str = '') -> str:
-    """List all learnings, grouped by category if no filter given."""
-    results = list_learnings(category if category else None)
-    if not results:
-        label = category if category else "ALL"
-        return f"LEARNINGS {label} (0): No entries."
-
-    if category:
-        label = category.upper()
-        lines = [f"LEARNINGS {label} ({len(results)}):"]
-        for r in results:
-            pri = r.get("priority", "medium") or "medium"
-            w = r.get("weight", 0.5) or 0.5
-            pri_icon = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "⚪"}.get(pri, "🟡")
-            lines.append(f"  #{r['id']} [{r.get('status','active')}] {pri_icon}{pri} w={w:.2f} {r['title']}")
-    else:
-        lines = [f"LEARNINGS ALL ({len(results)}):"]
-        current_cat = None
-        for r in results:
-            if r["category"] != current_cat:
-                current_cat = r["category"]
-                lines.append(f"\n  [{current_cat.upper()}]")
-            pri = r.get("priority", "medium") or "medium"
-            w = r.get("weight", 0.5) or 0.5
-            pri_icon = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "⚪"}.get(pri, "🟡")
-            lines.append(f"    #{r['id']} [{r.get('status','active')}] {pri_icon}{pri} w={w:.2f} {r['title']}")
-
-    return "\n".join(lines)

package/src/tools_menu 2.py

@@ -1,227 +0,0 @@
-"""Menu generator — NEXO operations center."""
-
-from datetime import datetime, timedelta
-import json
-import subprocess
-import sys
-from pathlib import Path
-from tools_sessions import handle_status
-from tools_reminders import handle_reminders
-from db import get_db
-
-
-def _get_date_str() -> str:
-    """Get formatted date in Madrid timezone."""
-    try:
-        result = subprocess.run(
-            ["date", "+%A %d %B %Y, %H:%M"],
-            capture_output=True, text=True,
-            env={"PATH": "/usr/bin:/bin"}
-        )
-        return result.stdout.strip()
-    except Exception:
-        return datetime.now().strftime("%Y-%m-%d %H:%M")
-
-
-MENU_ITEMS = [
-    ("Projects", [
-        ("1", "Projects - Review project status"),
-        ("9", "Claude Agent VPS - Review autonomous changes"),
-    ]),
-    ("Advertising", [
-        ("7", "Google Ads - Manage campaigns"),
-        ("7b", "Meta Ads - Manage Facebook/Instagram campaigns"),
-        ("7c", "Ads Tracking - Combined Google+Meta review"),
-    ]),
-    ("Shopify", [
-        ("4", "Shopify Theme Sync - Sync theme"),
-        ("5", "Shopify Scripts - Run periodic scripts"),
-        ("6", "Change Shopify Promotion"),
-    ]),
-    ("Server & Infrastructure", [
-        ("2", "Server - Health check your-server.example.com"),
-        ("3", "WhatsApp Logs - Review logs your-whatsapp-account"),
-        ("11", "File Tracker - PHP file report"),
-        ("12", "Google Cloud - Spend, usage and GCP status"),
-    ]),
-    ("Communication & Monitoring", [
-        ("8", "Recovery Optimizer - Weekly AI analysis (MONDAY)"),
-        ("10", "Recovery Monitor - Email/WA recovery status (24h)"),
-        ("13", "Review Monitor - Email/WA review status"),
-        ("14", "WhatsApp Full Analysis - Global statistics"),
-        ("15", "Google Analytics - Review web analytics"),
-        ("16", "Email Review - Check inboxes and spam"),
-    ]),
-    ("Reports & SEO", [
-        ("17", "Search Console Audit (every 2 weeks)"),
-        ("18", "Sitemap resubmission (every 30 days)"),
-        ("19", "SEO meta verification"),
-        ("20", "Weekly Email Report (Sundays)"),
-    ]),
-]
-
-
-def _get_dashboard_alerts() -> list[dict]:
-    """Run proactive dashboard and return alerts."""
-    try:
-        nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-        script = nexo_home / "scripts" / "nexo-proactive-dashboard.py"
-        if not script.exists():
-            return []
-        result = subprocess.run(
-            [sys.executable, str(script), "--json"],
-            capture_output=True, text=True, timeout=10
-        )
-        if result.stdout.strip():
-            return json.loads(result.stdout)
-    except Exception:
-        pass
-    return []
-
-
-def _get_memory_review_summary() -> dict:
-    """Return counts of due memory reviews."""
-    try:
-        conn = get_db()
-        now_epoch = datetime.now().timestamp()
-        now_iso = datetime.now().isoformat(timespec="seconds")
-        due_learnings = conn.execute(
-            "SELECT COUNT(*) FROM learnings WHERE review_due_at IS NOT NULL AND status != 'superseded' AND review_due_at <= ?",
-            (now_epoch,)
-        ).fetchone()[0]
-        due_decisions = conn.execute(
-            "SELECT COUNT(*) FROM decisions WHERE review_due_at IS NOT NULL AND status != 'reviewed' AND review_due_at <= ?",
-            (now_iso,)
-        ).fetchone()[0]
-        return {
-            "learnings": due_learnings,
-            "decisions": due_decisions,
-            "total": due_learnings + due_decisions,
-        }
-    except Exception:
-        return {"learnings": 0, "decisions": 0, "total": 0}
-
-
-def handle_menu() -> str:
-    """Generate the full operations menu with alerts."""
-    date_str = _get_date_str()
-    W = 56  # inner width
-
-    lines = []
-    lines.append("╔" + "═" * W + "╗")
-    lines.append("║" + "NEXO — OPERATIONS CENTER".center(W) + "║")
-    lines.append("║" + date_str.center(W) + "║")
-    lines.append("╠" + "═" * W + "╣")
-
-    # Proactive dashboard alerts
-    dashboard_alerts = _get_dashboard_alerts()
-    memory_reviews = _get_memory_review_summary()
-    due = handle_reminders("due")
-    has_alerts = dashboard_alerts or memory_reviews["total"] > 0 or (due and "No reminders" not in due)
-
-    if has_alerts:
-        lines.append("║" + "  PROACTIVE ALERTS".ljust(W) + "║")
-        lines.append("╠" + "═" * W + "╣")
-
-        if dashboard_alerts:
-            for alert in dashboard_alerts[:10]:  # Top 10
-                sev = alert.get("severity", "low")
-                icon = {"high": "!!!", "medium": " ! ", "low": " . "}.get(sev, " . ")
-                text = alert.get("title", "")[:W - 8]
-                lines.append("║" + f"  {icon} {text}".ljust(W) + "║")
-            if len(dashboard_alerts) > 10:
-                more = len(dashboard_alerts) - 10
-                lines.append("║" + f"  ... and {more} more alerts".ljust(W) + "║")
-
-        if memory_reviews["total"] > 0:
-            text = (
-                f"MEMORY: {memory_reviews['total']} pending reviews "
-                f"({memory_reviews['decisions']} decisions, {memory_reviews['learnings']} learnings)"
-            )[:W - 4]
-            lines.append("║" + f"  !  {text}".ljust(W) + "║")
-
-        if due and "No reminders" not in due:
-            for reminder_line in due.split("\n"):
-                if reminder_line.strip():
-                    truncated = reminder_line[:W - 2]
-                    lines.append("║" + f"  {truncated}".ljust(W) + "║")
-
-        lines.append("╠" + "═" * W + "╣")
-
-    # Menu categories
-    for category, items in MENU_ITEMS:
-        lines.append("║" + f"  {category.upper()}".ljust(W) + "║")
-        lines.append("║" + "─" * W + "║")
-        for num, desc in items:
-            entry = f"  {num:>3}. {desc}"
-            lines.append("║" + entry.ljust(W) + "║")
-        lines.append("╠" + "═" * W + "╣")
-
-    # Backlog: ideas, future projects, undated or distant tasks
-    try:
-        conn = get_db()
-        cutoff = (datetime.now() + timedelta(days=7)).strftime("%Y-%m-%d")
-        # Reminders without date (backlog/ideas)
-        no_date = conn.execute(
-            "SELECT id, description, category FROM reminders WHERE status LIKE 'PENDING%' AND (date IS NULL OR date='') ORDER BY category, id"
-        ).fetchall()
-        # Reminders with date > 7 days ahead (future)
-        future = conn.execute(
-            "SELECT id, description, date, category FROM reminders WHERE status LIKE 'PENDING%' AND date > ? ORDER BY date",
-            (cutoff,)
-        ).fetchall()
-        # Followups without date
-        nf_no_date = conn.execute(
-            "SELECT id, description FROM followups WHERE status NOT LIKE 'COMPLETED%' AND status NOT IN ('DELETED','archived','blocked','waiting') AND (date IS NULL OR date='') ORDER BY id"
-        ).fetchall()
-
-        if no_date or future or nf_no_date:
-            lines.append("║" + "  BACKLOG / IDEAS / FUTURE".ljust(W) + "║")
-            lines.append("║" + "─" * W + "║")
-
-            if no_date:
-                by_cat = {}
-                for r in no_date:
-                    cat = (r["category"] or "general").capitalize()
-                    by_cat.setdefault(cat, []).append(r)
-                for cat, items in by_cat.items():
-                    lines.append("║" + f"  [{cat}]".ljust(W) + "║")
-                    for r in items:
-                        short = r["description"][:W - 10]
-                        lines.append("║" + f"    {r['id']}: {short}".ljust(W) + "║")
-
-            if future:
-                lines.append("║" + f"  [Scheduled]".ljust(W) + "║")
-                for r in future:
-                    short = r["description"][:W - 18]
-                    lines.append("║" + f"    {r['id']} ({r['date']}): {short}".ljust(W) + "║")
-
-            if nf_no_date:
-                lines.append("║" + f"  [Pending followups]".ljust(W) + "║")
-                for r in nf_no_date:
-                    short = r["description"][:W - 12]
-                    lines.append("║" + f"    {r['id']}: {short}".ljust(W) + "║")
-
-            lines.append("╠" + "═" * W + "╣")
-    except Exception as e:
-        lines.append("║" + f"  ⚠ Error backlog: {e}".ljust(W) + "║")
-        lines.append("╠" + "═" * W + "╣")
-
-    # Active sessions
-    sessions = handle_status()
-    if "No sessions" not in sessions:
-        lines.append("║" + "  ACTIVE SESSIONS".ljust(W) + "║")
-        lines.append("║" + "─" * W + "║")
-        for s_line in sessions.split("\n"):
-            if s_line.strip() and "ACTIVE SESSIONS" not in s_line:
-                truncated = s_line[:W - 2]
-                lines.append("║" + f"  {truncated}".ljust(W) + "║")
-        lines.append("╠" + "═" * W + "╣")
-
-    # Replace last ╠═╣ with bottom border
-    if lines[-1].startswith("╠"):
-        lines[-1] = "╚" + "═" * W + "╝"
-    else:
-        lines.append("╚" + "═" * W + "╝")
-
-    return "\n".join(lines)