nexo-brain 5.3.26 → 5.3.28

package/src/tools_coordination 2.py

@@ -1,103 +0,0 @@
-from __future__ import annotations
-"""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_drive 2.py

@@ -1,487 +0,0 @@
-from __future__ import annotations
-"""NEXO Drive/Curiosity — autonomous investigation signals.
-
-Public MCP tool handlers + internal detection logic that feeds from
-heartbeat, task_close, and diary consolidation.
-"""
-
-import json
-import os
-import re
-import subprocess
-import time
-import unicodedata
-
-from db import (
-    create_drive_signal, reinforce_drive_signal, get_drive_signals,
-    get_drive_signal, update_drive_signal_status, decay_drive_signals,
-    find_similar_drive_signal, drive_signal_stats,
-)
-
-
-# ── Semantic signal detection ────────────────────────────────────────
-
-# Primary path: concept-level semantic scoring with multilingual cue families.
-# Regex remains as explicit fallback only when the semantic scorer cannot
-# separate the classes with enough confidence.
-
-_SEMANTIC_THRESHOLD = 0.75
-_SEMANTIC_MARGIN = 0.15
-_LLM_MIN_TEXT_CHARS = int(os.environ.get("NEXO_DRIVE_LLM_MIN_CHARS", "24"))
-_LLM_TIMEOUT_SECONDS = int(os.environ.get("NEXO_DRIVE_LLM_TIMEOUT", "20"))
-_LLM_CONFIDENCE_THRESHOLD = float(os.environ.get("NEXO_DRIVE_LLM_CONFIDENCE", "0.62"))
-_LLM_CACHE_TTL_SECONDS = int(os.environ.get("NEXO_DRIVE_LLM_CACHE_TTL", "21600"))
-_LLM_ALLOWED_LABELS = {"anomaly", "pattern", "gap", "opportunity", "none"}
-_LLM_CLASSIFICATION_CACHE: dict[str, dict] = {}
-
-_SIGNAL_CUES = {
-    "anomaly": {
-        "metric": (
-            "cpc", "ctr", "roas", "conversion", "conversiones", "revenue",
-            "ingresos", "traffic", "trafico", "latency", "latencia",
-            "error", "erro", "fehler", "failure", "fallo", "falla",
-            "incident", "incidente", "kpi", "metric", "metrica",
-        ),
-        "change": (
-            "subio*", "bajo*", "cayo*", "aumento*", "disminu*", "crecio*",
-            "drop*", "spik*", "jump*", "rose", "fell", "grew", "surg*",
-            "subiu*", "caiu*", "baixou*", "aumentou*", "stieg*", "fiel*",
-            "gesunk*", "anstieg*", "einbruch*", "regression*",
-        ),
-        "unexpected": (
-            "inesperad*", "unexpected*", "anom*", "raro*", "weird",
-            "strange", "estranh*", "seltsam*", "ungewohn*", "anomalia*",
-            "outlier*", "desviacion*", "abweich*",
-        ),
-        "degradation": (
-            "degrad*", "timeout*", "slow*", "lento*", "caida*", "degraded",
-            "down", "outage", "rot*", "broken", "rompio*", "broke",
-            "schlecht*", "falha*", "incidencia*",
-        ),
-    },
-    "pattern": {
-        "recurrence": (
-            "otra vez", "de nuevo", "again", "again and again", "recurr*",
-            "repe*", "keeps happ*", "siempre pasa", "vuelve a pasar",
-            "sempre", "sempre que", "de novo", "wieder", "immer wieder",
-            "wiederholt*", "stuck in a loop", "reincid*",
-        ),
-        "cadence": (
-            "cada vez que", "every time", "whenever", "cada semana",
-            "cada mes", "once more", "toda vez que", "jedes mal",
-            "wann immer", "all the time", "constantemente",
-        ),
-        "same_issue": (
-            "mismo problema", "mismo error", "same problem", "same issue",
-            "same error", "lo mismo", "same thing", "same blocker",
-            "mesmo problema", "gleiches problem", "gleicher fehler",
-        ),
-    },
-    "gap": {
-        "uncertainty": (
-            "no se como", "no entiendo", "no tengo claro", "unclear how",
-            "dont know how", "not sure how", "i do not know how",
-            "sem saber como", "nao sei como", "ich weiss nicht wie",
-            "ich weiß nicht wie", "unklar wie", "blocked by not knowing",
-        ),
-        "missing_knowledge": (
-            "falta documentacion", "missing docs", "missing documentation",
-            "undocumented", "not documented", "sin documentar", "sin guia",
-            "no hay runbook", "no hay playbook", "sem documentacao",
-            "fehlt dokumentation", "kein runbook", "unknown process",
-        ),
-        "blocked_execution": (
-            "bloqueado porque", "blocked because", "cannot proceed",
-            "no puedo seguir", "cant continue", "nao consigo avanzar",
-            "komme nicht weiter", "stuck because",
-        ),
-    },
-    "opportunity": {
-        "benchmark_gap": (
-            "media del sector", "industry average", "below peers",
-            "por debajo", "underperform*", "lagging", "low compared",
-            "abaixo do benchmark", "unter benchmark", "unter dem schnitt",
-        ),
-        "improvement": (
-            "automatiz*", "optimiz*", "mejor*", "improv*", "streamlin*",
-            "simplif*", "scale*", "accelerat*", "reduce manual",
-            "automat*", "melhor*", "verbesser*", "effizien*",
-        ),
-        "potential": (
-            "podriamos", "se podria", "could", "we could", "opportunity",
-            "worth exploring", "room to", "potencial", "oportunidade",
-            "chance to", "could unlock", "konnten", "man koennte",
-        ),
-    },
-}
-
-_SIGNAL_FAMILY_WEIGHTS = {
-    "anomaly": {"metric": 0.28, "change": 0.38, "unexpected": 0.30, "degradation": 0.28},
-    "pattern": {"recurrence": 0.36, "cadence": 0.34, "same_issue": 0.34},
-    "gap": {"uncertainty": 0.78, "missing_knowledge": 0.52, "blocked_execution": 0.36},
-    "opportunity": {"benchmark_gap": 0.78, "improvement": 0.38, "potential": 0.32},
-}
-
-_FALLBACK_PATTERNS = {
-    "anomaly": (
-        re.compile(r"\b(subió|bajó|cayó|dropped|spiked|jumped)\b.*\b\d+%", re.I),
-        re.compile(r"\b(inesperado|unexpected|anomal|raro|weird|strange)\b", re.I),
-    ),
-    "pattern": (
-        re.compile(r"\b(otra vez|again|de nuevo|siempre pasa|keeps happening|recurring)\b", re.I),
-        re.compile(r"\b(cada vez que|every time|whenever)\b", re.I),
-    ),
-    "gap": (
-        re.compile(r"\b(no sé cómo|don'?t know how|no entiendo|unclear how)\b", re.I),
-        re.compile(r"\b(falta documentación|missing docs|undocumented)\b", re.I),
-    ),
-    "opportunity": (
-        re.compile(r"\b(benchmark|media del sector|industry average)\b.*\b(bajo|low|por debajo|below)\b", re.I),
-        re.compile(r"\b(podríamos|could|se podría|we could|opportunity)\b.*\b(automatiz|improve|mejorar|optimiz)\b", re.I),
-    ),
-}
-
-
-def _normalize_text(text: str) -> str:
-    lowered = (text or "").lower().replace("ß", "ss").replace("'", "")
-    lowered = unicodedata.normalize("NFKD", lowered)
-    lowered = "".join(ch for ch in lowered if not unicodedata.combining(ch))
-    lowered = re.sub(r"[^a-z0-9%+\s]", " ", lowered)
-    return re.sub(r"\s+", " ", lowered).strip()
-
-
-def _extract_json_object(raw: str) -> dict | None:
-    text = (raw or "").strip()
-    if not text:
-        return None
-    try:
-        payload = json.loads(text)
-        return payload if isinstance(payload, dict) else None
-    except json.JSONDecodeError:
-        pass
-
-    start = text.find("{")
-    end = text.rfind("}")
-    if start == -1 or end == -1 or end <= start:
-        return None
-    try:
-        payload = json.loads(text[start : end + 1])
-        return payload if isinstance(payload, dict) else None
-    except json.JSONDecodeError:
-        return None
-
-
-def _tokenize(text: str) -> list[str]:
-    return [token for token in text.split() if token]
-
-
-def _matches_cue(cue: str, text_norm: str, tokens: list[str]) -> bool:
-    cue_norm = _normalize_text(cue)
-    if not cue_norm:
-        return False
-    if cue_norm.endswith("*"):
-        stem = cue_norm[:-1]
-        return bool(stem) and any(token.startswith(stem) for token in tokens)
-    if " " in cue_norm:
-        return cue_norm in text_norm
-    return cue_norm in tokens or any(token.startswith(cue_norm) for token in tokens if len(cue_norm) >= 5)
-
-
-def _has_numeric_signal(tokens: list[str]) -> bool:
-    for token in tokens:
-        raw = token.rstrip("%")
-        try:
-            float(raw)
-            return True
-        except ValueError:
-            continue
-    return False
-
-
-def _semantic_signal_scores(text: str) -> dict[str, float]:
-    text_norm = _normalize_text(text)
-    tokens = _tokenize(text_norm)
-    if not tokens:
-        return {}
-
-    numeric_signal = _has_numeric_signal(tokens)
-    scores = {signal_type: 0.0 for signal_type in _SIGNAL_CUES}
-    family_hits: dict[str, set[str]] = {signal_type: set() for signal_type in _SIGNAL_CUES}
-
-    for signal_type, families in _SIGNAL_CUES.items():
-        weights = _SIGNAL_FAMILY_WEIGHTS[signal_type]
-        for family_name, cues in families.items():
-            matches = [cue for cue in cues if _matches_cue(cue, text_norm, tokens)]
-            if not matches:
-                continue
-            family_hits[signal_type].add(family_name)
-            bonus = min(0.12, 0.04 * max(0, len(matches) - 1))
-            scores[signal_type] += weights[family_name] + bonus
-
-    anomaly_hits = family_hits["anomaly"]
-    if "metric" in anomaly_hits and "change" in anomaly_hits:
-        scores["anomaly"] += 0.22
-    if numeric_signal and ("change" in anomaly_hits or "metric" in anomaly_hits):
-        scores["anomaly"] += 0.14
-    if "unexpected" in anomaly_hits and ("change" in anomaly_hits or "degradation" in anomaly_hits):
-        scores["anomaly"] += 0.12
-    if "unexpected" in anomaly_hits and "metric" in anomaly_hits:
-        scores["anomaly"] += 0.10
-
-    pattern_hits = family_hits["pattern"]
-    if "recurrence" in pattern_hits and ("cadence" in pattern_hits or "same_issue" in pattern_hits):
-        scores["pattern"] += 0.18
-
-    gap_hits = family_hits["gap"]
-    if "uncertainty" in gap_hits and ("missing_knowledge" in gap_hits or "blocked_execution" in gap_hits):
-        scores["gap"] += 0.18
-
-    opportunity_hits = family_hits["opportunity"]
-    if "benchmark_gap" in opportunity_hits:
-        scores["opportunity"] += 0.16
-    if "improvement" in opportunity_hits and "potential" in opportunity_hits:
-        scores["opportunity"] += 0.18
-
-    return scores
-
-
-def _llm_cache_key(text: str) -> str:
-    return _normalize_text(text)[:1200]
-
-
-def _llm_classify_signal(text: str) -> dict:
-    text_norm = _normalize_text(text)
-    if len(text_norm) < _LLM_MIN_TEXT_CHARS:
-        return {"available": False, "label": None, "reason": "text_too_short"}
-
-    cache_key = _llm_cache_key(text)
-    now = time.time()
-    cached = _LLM_CLASSIFICATION_CACHE.get(cache_key)
-    if cached and cached.get("expires_at", 0) > now:
-        return {k: v for k, v in cached.items() if k != "expires_at"}
-
-    try:
-        from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
-    except Exception as exc:
-        return {"available": False, "label": None, "reason": f"runner_unavailable:{exc}"}
-
-    json_system_prompt = (
-        "You classify operational text into one of exactly five labels: "
-        "anomaly, pattern, gap, opportunity, none. "
-        "Return ONLY a valid JSON object with keys: label, confidence, reason. "
-        "confidence must be a number from 0 to 1. "
-        "Use anomaly for unexpected changes/degradation, pattern for recurrence, "
-        "gap for missing knowledge/documentation/blocker, opportunity for improvement/automation/benchmark gaps, "
-        "none when the text is normal progress without a useful signal."
-    )
-    prompt = (
-        "Classify this NEXO Drive signal candidate.\n\n"
-        f"TEXT:\n{text.strip()[:3000]}\n\n"
-        "Return JSON only."
-    )
-
-    try:
-        result = run_automation_prompt(
-            prompt,
-            task_profile="fast",
-            timeout=_LLM_TIMEOUT_SECONDS,
-            output_format="text",
-            append_system_prompt=json_system_prompt,
-        )
-    except (AutomationBackendUnavailableError, subprocess.TimeoutExpired) as exc:
-        return {"available": False, "label": None, "reason": f"automation_unavailable:{exc}"}
-    except Exception as exc:
-        return {"available": False, "label": None, "reason": f"automation_error:{exc}"}
-
-    if result.returncode != 0:
-        return {"available": False, "label": None, "reason": f"automation_returncode:{result.returncode}"}
-
-    parsed = _extract_json_object(result.stdout)
-    if not parsed:
-        return {"available": False, "label": None, "reason": "invalid_json"}
-
-    label = str(parsed.get("label", "") or "").strip().lower()
-    if label not in _LLM_ALLOWED_LABELS:
-        return {"available": False, "label": None, "reason": "invalid_label"}
-
-    try:
-        confidence = float(parsed.get("confidence", 0.0) or 0.0)
-    except (TypeError, ValueError):
-        confidence = 0.0
-
-    classification = {
-        "available": True,
-        "label": None if label == "none" else label,
-        "confidence": confidence,
-        "reason": str(parsed.get("reason", "") or ""),
-        "source": "llm",
-    }
-    _LLM_CLASSIFICATION_CACHE[cache_key] = {
-        **classification,
-        "expires_at": now + _LLM_CACHE_TTL_SECONDS,
-    }
-    return classification
-
-
-def _regex_fallback_classify(text: str) -> str | None:
-    for signal_type, patterns in _FALLBACK_PATTERNS.items():
-        if any(pattern.search(text) for pattern in patterns):
-            return signal_type
-    return None
-
-
-def _classify_signal(text: str, *, allow_llm: bool = True) -> str | None:
-    """Classify text into a signal type, or None if nothing interesting."""
-    if allow_llm:
-        llm_result = _llm_classify_signal(text)
-        if llm_result.get("available"):
-            confidence = float(llm_result.get("confidence", 0.0) or 0.0)
-            label = llm_result.get("label")
-            if label is None and confidence >= _LLM_CONFIDENCE_THRESHOLD:
-                return None
-            if isinstance(label, str) and confidence >= _LLM_CONFIDENCE_THRESHOLD:
-                return label
-
-    scores = _semantic_signal_scores(text)
-    if scores:
-        ordered = sorted(scores.items(), key=lambda item: item[1], reverse=True)
-        winner, winner_score = ordered[0]
-        runner_up = ordered[1][1] if len(ordered) > 1 else 0.0
-        if winner_score >= _SEMANTIC_THRESHOLD and (winner_score - runner_up) >= _SEMANTIC_MARGIN:
-            return winner
-        if winner_score >= 0.35:
-            return None
-    return _regex_fallback_classify(text)
-
-
-def _infer_area(text: str) -> str:
-    """Infer operational area from text keywords."""
-    text_lower = text.lower()
-    area_keywords = {
-        "shopify": ["shopify", "tienda", "pedido", "producto", "sku"],
-        "google-ads": ["google ads", "campaña", "campaign", "cpc", "pmax", "roas", "gads"],
-        "meta-ads": ["meta ads", "facebook", "instagram", "pixel", "capi"],
-        "wazion": ["wazion", "whatsapp", "wa ", "baileys"],
-        "nexo": ["nexo", "brain", "mcp", "cognitive"],
-        "canaririural": ["canarirural", "canari", "reserva", "hospedaje", "alojamiento", "propietario"],
-        "seo": ["seo", "search console", "indexación", "ranking"],
-        "email": ["email", "correo", "inbox", "smtp"],
-    }
-    for area, keywords in area_keywords.items():
-        for kw in keywords:
-            if kw in text_lower:
-                return area
-    return ""
-
-
-def detect_drive_signal(
-    context_hint: str,
-    source: str,
-    source_id: str = "",
-    area: str = "",
-    *,
-    allow_llm: bool = False,
-) -> dict | None:
-    """Analyze text for interesting signals. Creates or reinforces.
-
-    Called internally from heartbeat and task_close. Not a public MCP tool.
-    Returns the signal dict if created/reinforced, None otherwise.
-    """
-    if not context_hint or len(context_hint.strip()) < 15:
-        return None
-
-    signal_type = _classify_signal(context_hint, allow_llm=allow_llm)
-    if not signal_type:
-        return None
-
-    inferred_area = area or _infer_area(context_hint)
-
-    # Check for similar existing signal
-    existing = find_similar_drive_signal(context_hint, inferred_area)
-    if existing:
-        result = reinforce_drive_signal(existing["id"], context_hint[:500])
-        return result if result.get("ok") else None
-
-    # Create new
-    result = create_drive_signal(
-        signal_type=signal_type,
-        source=source,
-        source_id=source_id,
-        area=inferred_area,
-        summary=context_hint[:300],
-    )
-    return result if result.get("ok") else None
-
-
-# ── Public MCP tool handlers ─────────────────────────────────────────
-
-def handle_drive_signals(
-    status: str = "",
-    area: str = "",
-    limit: int = 20,
-) -> str:
-    """List drive signals, optionally filtered by status and area."""
-    signals = get_drive_signals(
-        status=status or None,
-        area=area or None,
-        limit=limit,
-    )
-    if not signals:
-        return "No drive signals found."
-
-    stats = drive_signal_stats()
-    lines = [
-        f"DRIVE SIGNALS ({len(signals)} shown, {stats['total']} total):",
-        f"  By status: {json.dumps(stats.get('by_status', {}), ensure_ascii=False)}",
-        "",
-    ]
-    for s in signals:
-        evidence_count = 0
-        try:
-            evidence_count = len(json.loads(s.get("evidence") or "[]"))
-        except (json.JSONDecodeError, TypeError):
-            pass
-        tension_bar = "█" * int(float(s.get("tension", 0)) * 10)
-        lines.append(
-            f"  [{s['id']}] {s['status'].upper()} {tension_bar} "
-            f"t={s['tension']:.2f} ({s['signal_type']}) "
-            f"{'[' + s['area'] + '] ' if s.get('area') else ''}"
-            f"{s['summary'][:80]}"
-            f" ({evidence_count} obs, decay={s.get('decay_rate', 0.05):.2f})"
-        )
-    return "\n".join(lines)
-
-
-def handle_drive_reinforce(signal_id: int, observation: str) -> str:
-    """Manually reinforce a drive signal with a new observation."""
-    if not observation.strip():
-        return "ERROR: observation cannot be empty"
-    result = reinforce_drive_signal(signal_id, observation)
-    if not result.get("ok"):
-        return f"ERROR: {result.get('error', 'unknown')}"
-    return (
-        f"Signal #{signal_id} reinforced: "
-        f"tension {result['old_tension']:.2f} → {result['new_tension']:.2f}, "
-        f"status {result['old_status']} → {result['new_status']}, "
-        f"{result['evidence_count']} observations total"
-    )
-
-
-def handle_drive_act(signal_id: int, outcome: str) -> str:
-    """Mark a drive signal as investigated with an outcome."""
-    if not outcome.strip():
-        return "ERROR: outcome cannot be empty"
-    result = update_drive_signal_status(signal_id, "acted", outcome)
-    if not result.get("ok"):
-        return f"ERROR: {result.get('error', 'unknown')}"
-    return f"Signal #{signal_id} marked as ACTED. Outcome recorded."
-
-
-def handle_drive_dismiss(signal_id: int, reason: str) -> str:
-    """Dismiss a drive signal with a reason (archived, not deleted)."""
-    if not reason.strip():
-        return "ERROR: reason cannot be empty"
-    result = update_drive_signal_status(signal_id, "dismissed", reason)
-    if not result.get("ok"):
-        return f"ERROR: {result.get('error', 'unknown')}"
-    return f"Signal #{signal_id} dismissed. Reason: {reason}"