nexo-brain 7.23.13 → 7.25.0

package/src/tools_learnings.py

@@ -1,16 +1,25 @@
 """Learnings CRUD tools: add, search, update, delete, list."""
 
+import json
 import os
 import re
+import unicodedata
 from datetime import datetime
 
 from db import (create_learning, update_learning, delete_learning, search_learnings,
                 list_learnings, find_similar_learnings, get_db, now_epoch, supersede_learning, extract_keywords,
                 resolve_session_correction_requirements)
+from learning_resolver import (
+    applies_overlap as _canonical_applies_overlap,
+    looks_contradictory as _canonical_looks_contradictory,
+    resolve_learning_candidate,
+)
 
 NEGATION_PATTERNS = (
     "do not", "don't", "never", "avoid", "skip", "without", "forbid", "forbidden",
     "disable", "disabled", "remove", "ban", "bypass",
+    " no ", " nunca ", " evita ", " evitar ", " sin ", " prohibe ", " prohibido ",
+    " desactiva ", " desactivar ", " elimina ", " eliminar ", " bloquea ", " bloquear ",
 )
 CONTRADICTION_PAIRS = (
     ("enable", "disable"),
@@ -23,6 +32,15 @@ CONTRADICTION_PAIRS = (
     ("validate", "skip"),
     ("validate", "bypass"),
     ("include", "exclude"),
+    ("activar", "desactivar"),
+    ("usar", "evitar"),
+    ("usar", "no usar"),
+    ("editar", "no editar"),
+    ("tocar", "no tocar"),
+    ("anadir", "eliminar"),
+    ("permitir", "prohibir"),
+    ("validar", "saltar"),
+    ("incluir", "excluir"),
 )
 
 
@@ -40,26 +58,13 @@ def _normalize_applies_token(value: str) -> str:
 
 
 def _applies_overlap(left: str, right: str) -> bool:
-    left_tokens = {_normalize_applies_token(item) for item in _split_applies_to(left)}
-    right_tokens = {_normalize_applies_token(item) for item in _split_applies_to(right)}
-    left_tokens.discard("")
-    right_tokens.discard("")
-    if not left_tokens or not right_tokens:
-        return False
-    if left_tokens & right_tokens:
-        return True
-    for left_token in left_tokens:
-        for right_token in right_tokens:
-            if "/" in left_token or "/" in right_token:
-                if left_token.startswith(f"{right_token}/") or right_token.startswith(f"{left_token}/"):
-                    return True
-                if left_token.endswith(f"/{right_token}") or right_token.endswith(f"/{left_token}"):
-                    return True
-    return False
+    return _canonical_applies_overlap(left, right)
 
 
 def _normalize_text(text: str) -> str:
-    return re.sub(r"\s+", " ", str(text or "").strip().lower())
+    normalized = unicodedata.normalize("NFKD", str(text or ""))
+    ascii_text = "".join(ch for ch in normalized if not unicodedata.combining(ch))
+    return re.sub(r"\s+", " ", ascii_text.strip().lower())
 
 
 def _tokenize(text: str) -> list[str]:
@@ -67,7 +72,7 @@ def _tokenize(text: str) -> list[str]:
 
 
 def _contains_negation(text: str) -> bool:
-    lowered = _normalize_text(text)
+    lowered = f" {_normalize_text(text)} "
     return any(token in lowered for token in NEGATION_PATTERNS)
 
 
@@ -75,37 +80,16 @@ def _negated_action_verbs(text: str) -> set[str]:
     lowered = _normalize_text(text)
     matches = set()
     for pattern in (
-        r"(?:never|avoid|skip|disable|remove|forbid|bypass)\s+([a-z0-9_-]+)",
-        r"(?:do not|don't)\s+([a-z0-9_-]+)",
+        r"(?:never|avoid|skip|disable|remove|forbid|bypass|nunca|evita|evitar|desactiva|desactivar|elimina|eliminar|prohibe|prohibir|bloquea|bloquear)\s+([a-z0-9_-]+)",
+        r"(?:do not|don't|no)\s+([a-z0-9_-]+)",
+        r"(?:without|sin)\s+([a-z0-9_-]+)",
     ):
         matches.update(re.findall(pattern, lowered))
     return {match for match in matches if len(match) > 2}
 
 
 def _looks_contradictory(existing_text: str, new_text: str) -> bool:
-    existing_norm = _normalize_text(existing_text)
-    new_norm = _normalize_text(new_text)
-    if not existing_norm or not new_norm:
-        return False
-    existing_tokens = set(_tokenize(existing_norm))
-    new_tokens = set(_tokenize(new_norm))
-    if not (existing_tokens & new_tokens):
-        return False
-    existing_negated_verbs = _negated_action_verbs(existing_norm)
-    new_negated_verbs = _negated_action_verbs(new_norm)
-    if existing_negated_verbs & new_tokens and not existing_negated_verbs & new_negated_verbs:
-        return True
-    if new_negated_verbs & existing_tokens and not existing_negated_verbs & new_negated_verbs:
-        return True
-    if _contains_negation(existing_norm) != _contains_negation(new_norm):
-        return True
-    for positive, negative in CONTRADICTION_PAIRS:
-        existing_has_pair = positive in existing_norm or negative in existing_norm
-        new_has_pair = positive in new_norm or negative in new_norm
-        if existing_has_pair and new_has_pair:
-            if (positive in existing_norm and negative in new_norm) or (negative in existing_norm and positive in new_norm):
-                return True
-    return False
+    return _canonical_looks_contradictory(existing_text, new_text)
 
 
 def _find_conflicting_active_learning(conn, *, category: str, title: str, content: str,
@@ -286,7 +270,8 @@ def score_learning_quality(row: dict, conn=None) -> dict:
 
 def handle_learning_add(category: str, title: str, content: str, reasoning: str = '',
                         prevention: str = '', applies_to: str = '', review_days: int = 30,
-                        priority: str = 'medium', supersedes_id: int = 0) -> str:
+                        priority: str = 'medium', supersedes_id: int = 0,
+                        source_authority: str = 'explicit_instruction') -> str:
     """Add a new learning entry to the specified category.
 
     Args:
@@ -304,15 +289,55 @@ def handle_learning_add(category: str, title: str, content: str, reasoning: str
     category = category.lower().strip()
     if not category:
         return "ERROR: Category cannot be empty."
-    # Dedup guard: block exact title duplicates in same category
     conn = get_db()
-    existing = conn.execute(
-        "SELECT id, title FROM learnings WHERE LOWER(title) = LOWER(?) AND category = ? AND status = 'active'",
-        (title.strip(), category)
-    ).fetchone()
-    if existing:
-        _resolve_pending_correction_learning(int(existing["id"]))
-        return f"Learning #{existing['id']} already exists with same title in {category}: {existing['title']}. Use nexo_learning_update to modify it."
+    resolution = resolve_learning_candidate(
+        category=category,
+        title=title,
+        content=content,
+        reasoning=reasoning,
+        prevention=prevention,
+        applies_to=applies_to,
+        priority=priority,
+        supersedes_id=supersedes_id,
+        source_authority=source_authority,
+        conn=conn,
+    )
+    if resolution["action"] == "reject":
+        return f"ERROR: Learning candidate rejected: {resolution['reason']}."
+    if resolution["action"] == "merge":
+        existing_id = int(resolution.get("target_id") or 0)
+        existing = conn.execute("SELECT id, title, weight FROM learnings WHERE id = ?", (existing_id,)).fetchone()
+        if existing:
+            if resolution.get("reason") == "exact_title_duplicate":
+                _resolve_pending_correction_learning(existing_id)
+                return f"Learning #{existing['id']} already exists with same title in {category}: {existing['title']}. Use nexo_learning_update to modify it."
+            old_weight = float(existing["weight"] or 0.0)
+            new_weight = min(1.0, old_weight + 0.1)
+            conn.execute(
+                "UPDATE learnings SET weight = ?, updated_at = ? WHERE id = ?",
+                (new_weight, now_epoch(), existing_id),
+            )
+            conn.commit()
+            _resolve_pending_correction_learning(existing_id)
+            return (
+                f"Learning #{existing_id} resolved as merge ({resolution['reason']}, similarity "
+                f"{float(resolution.get('similarity') or 0):.2f}). No duplicate created. "
+                f"Weight bumped {old_weight:.2f} -> {new_weight:.2f}. Use nexo_learning_update(id={existing_id}) "
+                "to refine the canonical text."
+            )
+    if resolution["action"] == "conflict_review":
+        conflicting = {
+            "id": resolution.get("target_id"),
+            "title": resolution.get("target_title"),
+            "applies_to": applies_to,
+        }
+        return (
+            f"ERROR: Contradictory active learning #{conflicting['id']} already exists for applies_to="
+            f"{conflicting.get('applies_to', '')}: {conflicting['title']}. "
+            f"Supersede or update the existing canonical rule instead of creating two active file rules."
+        )
+    if resolution["action"] == "supersede":
+        supersedes_id = int(resolution.get("target_id") or supersedes_id or 0)
 
     # ── R05 (Fase 2 Protocol Enforcer): auto-merge on high Jaccard similarity ──
     # When a near-duplicate active learning exists (Jaccard >= R05 threshold),
@@ -356,19 +381,6 @@ def handle_learning_add(category: str, title: str, content: str, reasoning: str
                     f"→ {new_weight:.2f}. Use nexo_learning_update(id={existing_id}) if you need to "
                     "refine the canonical text."
                 )
-    conflicting = _find_conflicting_active_learning(
-        conn,
-        category=category,
-        title=title,
-        content=content,
-        applies_to=applies_to,
-    )
-    if conflicting and int(supersedes_id or 0) != int(conflicting["id"]):
-        return (
-            f"ERROR: Contradictory active learning #{conflicting['id']} already exists for applies_to="
-            f"{conflicting.get('applies_to', '')}: {conflicting['title']}. "
-            f"Supersede or update the existing canonical rule instead of creating two active file rules."
-        )
     result = create_learning(
         category, title, content, reasoning=reasoning, supersedes_id=(int(supersedes_id) if supersedes_id else None)
     )
@@ -508,6 +520,25 @@ def handle_learning_add(category: str, title: str, content: str, reasoning: str
     return f"Learning #{result['id']} added in {category}: {title}{meta_str} ✓verified{repetition_msg}{retro_meta_msg}{correction_msg}"
 
 
+def handle_learning_resolve_candidate(category: str, title: str, content: str, reasoning: str = '',
+                                      prevention: str = '', applies_to: str = '',
+                                      priority: str = 'medium', supersedes_id: int = 0,
+                                      source_authority: str = 'inference') -> str:
+    """Dry-run the canonical learning resolver without mutating state."""
+    result = resolve_learning_candidate(
+        category=category,
+        title=title,
+        content=content,
+        reasoning=reasoning,
+        prevention=prevention,
+        applies_to=applies_to,
+        priority=priority,
+        supersedes_id=supersedes_id,
+        source_authority=source_authority,
+    )
+    return json.dumps(result, ensure_ascii=False, indent=2)
+
+
 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)

package/src/tools_memory_v2.py

@@ -173,8 +173,8 @@ def handle_memory_timeline(
     result = memory_timeline(query, project_hint=project_hint, time_range=time_range, limit=limit)
     candidates = result.get("candidates") or []
     if not candidates:
-        return "No hay eventos suficientes para construir timeline."
-    lines = [f"MEMORY TIMELINE ({len(candidates)}) — {query or time_range or '(sin query)'}"]
+        return "There are not enough events to build a timeline."
+    lines = [f"MEMORY TIMELINE ({len(candidates)}) — {query or time_range or '(no query)'}"]
     for item in candidates:
         refs = item.get("evidence_refs") or []
         refs_note = f" refs={', '.join(refs[:3])}" if refs else ""

package/src/tools_sessions.py

@@ -1334,10 +1334,21 @@ def handle_context_packet(area: str, files: str = "") -> str:
         parts.append("")
 
     # 3. Active followups for this area
-    followups = conn.execute(
-        "SELECT id, description, date, verification FROM followups WHERE status = 'PENDING' AND (description LIKE ? OR verification LIKE ?) ORDER BY date ASC LIMIT 10",
+    from db import followup_lifecycle_lane, normalize_followup_status
+
+    followup_rows = conn.execute(
+        "SELECT id, description, date, verification, status, owner FROM followups "
+        "WHERE (description LIKE ? OR verification LIKE ?) ORDER BY date ASC LIMIT 50",
         (f"%{area}%", f"%{area}%")
     ).fetchall()
+    followups = []
+    for row in followup_rows:
+        item = dict(row)
+        item["status"] = normalize_followup_status(item.get("status"))
+        if followup_lifecycle_lane(item) == "active":
+            followups.append(item)
+        if len(followups) >= 10:
+            break
     if followups:
         parts.append("## ACTIVE FOLLOWUPS")
         for f in followups:
@@ -1479,11 +1490,18 @@ def handle_smart_startup_query() -> str:
         sent_email_block = ""
 
     # 1. Pending followups (what NEXO needs to do)
-    followups = conn.execute(
-        "SELECT description FROM followups WHERE status = 'PENDING' ORDER BY date ASC LIMIT 5"
-    ).fetchall()
-    for f in followups:
-        query_parts.append(f['description'][:100])
+    try:
+        from db import followup_lifecycle_snapshot
+
+        active_followups = (followup_lifecycle_snapshot(limit=500).get("lanes") or {}).get("active", [])[:5]
+        for f in active_followups:
+            query_parts.append(str(f.get("description") or "")[:100])
+    except Exception:
+        followups = conn.execute(
+            "SELECT description FROM followups WHERE status = 'PENDING' ORDER BY date ASC LIMIT 5"
+        ).fetchall()
+        for f in followups:
+            query_parts.append(f['description'][:100])
 
     # 2. Due reminders (what the user needs to know)
     reminders = conn.execute(

package/src/tools_transcripts.py

@@ -8,26 +8,53 @@ from transcript_utils import (
     load_transcript,
     search_transcripts,
 )
+from transcript_index import ensure_transcript_index, search_transcript_index
 
 
 def handle_transcript_search(query: str = "", hours: int = 24, client: str = "", limit: int = 10) -> str:
     """Search recent Claude Code / Codex transcripts as a fallback when memory is insufficient."""
     window = clamp_transcript_hours(hours)
-    rows = search_transcripts(query or "", hours=window, client=(client or "").strip(), limit=limit)
+    clean_client = (client or "").strip()
+    ensure_transcript_index(
+        hours=window,
+        client=clean_client,
+        limit=max(200, min(2000, int(limit or 10) * 50)),
+        min_user_messages=1,
+    )
+    rows = search_transcript_index(query or "", hours=window, client=clean_client, limit=limit)
+    source = "index"
+    if not rows:
+        rows = search_transcripts(
+            query or "",
+            hours=window,
+            client=clean_client,
+            limit=limit,
+            min_user_messages=1,
+        )
+        source = "raw"
     if not rows:
         scope = f"query='{query}'" if query else "recent transcripts"
         return f"No transcript matches for {scope} in the last {window}h."
 
-    lines = [f"TRANSCRIPTS ({len(rows)}) — last {window}h"]
+    lines = [f"TRANSCRIPTS ({len(rows)}) — last {window}h ({source})"]
     for item in rows:
+        session_file = item.get("session_file") or item.get("session_id") or item.get("display_name")
+        display_name = item.get("display_name") or item.get("path_ref") or item.get("session_path")
+        modified = item.get("modified") or item.get("modified_at")
         lines.append(
-            f"- {item.get('session_file')}: [{item.get('client')}] {item.get('display_name')} "
-            f"(modified={item.get('modified')}, messages={item.get('message_count')}, user={item.get('user_message_count')})"
+            f"- {session_file}: [{item.get('client') or item.get('source_client')}] {display_name} "
+            f"(modified={modified}, messages={item.get('message_count')}, user={item.get('user_message_count')})"
         )
         if item.get("cwd"):
             lines.append(f"  cwd: {item['cwd']}")
         if item.get("session_uid"):
             lines.append(f"  session_uid: {item['session_uid']}")
+        if item.get("conversation_id") and item.get("conversation_id") != item.get("session_id"):
+            lines.append(f"  conversation_id: {item['conversation_id']}")
+        if item.get("path_ref"):
+            lines.append(f"  path: {item['path_ref']}")
+        if item.get("sanitized_summary"):
+            lines.append(f"  summary: {item['sanitized_summary']}")
         for snippet in item.get("matched_messages") or []:
             lines.append(
                 f"  [{snippet.get('role')}#{snippet.get('index')}] {snippet.get('snippet')}"
@@ -38,15 +65,29 @@ def handle_transcript_search(query: str = "", hours: int = 24, client: str = "",
 def handle_transcript_recent(hours: int = 24, client: str = "", limit: int = 10) -> str:
     """List recent transcripts without searching full text."""
     window = clamp_transcript_hours(hours)
-    rows = list_recent_transcripts(hours=window, client=(client or "").strip(), limit=limit)
+    clean_client = (client or "").strip()
+    ensure_transcript_index(
+        hours=window,
+        client=clean_client,
+        limit=max(200, min(2000, int(limit or 10) * 50)),
+        min_user_messages=1,
+    )
+    rows = search_transcript_index("", hours=window, client=clean_client, limit=limit)
+    source = "index"
+    if not rows:
+        rows = list_recent_transcripts(hours=window, client=clean_client, limit=limit, min_user_messages=1)
+        source = "raw"
     if not rows:
         return f"No transcripts found in the last {window}h."
 
-    lines = [f"RECENT TRANSCRIPTS ({len(rows)}) — last {window}h"]
+    lines = [f"RECENT TRANSCRIPTS ({len(rows)}) — last {window}h ({source})"]
     for item in rows:
+        session_file = item.get("session_file") or item.get("session_id") or item.get("display_name")
+        display_name = item.get("display_name") or item.get("path_ref") or item.get("session_path")
+        modified = item.get("modified") or item.get("modified_at")
         lines.append(
-            f"- {item.get('session_file')}: [{item.get('client')}] {item.get('display_name')} "
-            f"(modified={item.get('modified')}, messages={item.get('message_count')}, user={item.get('user_message_count')})"
+            f"- {session_file}: [{item.get('client') or item.get('source_client')}] {display_name} "
+            f"(modified={modified}, messages={item.get('message_count')}, user={item.get('user_message_count')})"
         )
     return "\n".join(lines)
 
@@ -62,6 +103,7 @@ def handle_transcript_read(
         session_ref=(session_ref or "").strip(),
         transcript_path=(transcript_path or "").strip(),
         client=(client or "").strip(),
+        min_user_messages=1,
     )
     if not transcript:
         target = session_ref or transcript_path or "(empty ref)"

package/src/transcript_index.py

@@ -15,9 +15,12 @@ from typing import Any
 from db import get_db
 from transcript_utils import (
     DEFAULT_TRANSCRIPT_HOURS,
+    MAX_TRANSCRIPT_HOURS,
     _score_text_match,
     _tokenize,
     _truncate,
+    find_claude_session_files,
+    find_codex_session_files,
     list_recent_transcripts,
 )
 
@@ -103,6 +106,29 @@ def _sanitized_summary(session: dict[str, Any], *, limit: int = 900) -> str:
     return _truncate(summary, limit)
 
 
+def _row_ref_matches(query: str, row: dict[str, Any]) -> bool:
+    clean = str(query or "").strip().lower()
+    if len(clean) < 6:
+        return False
+    values = [
+        row.get("session_id"),
+        row.get("conversation_id"),
+        row.get("display_name"),
+        row.get("path_ref"),
+        Path(str(row.get("path_ref") or "")).name,
+        Path(str(row.get("path_ref") or "")).stem,
+    ]
+    for value in values:
+        candidate = str(value or "").strip().lower()
+        if not candidate:
+            continue
+        if candidate.startswith(clean):
+            return True
+        if candidate.split(":")[-1].startswith(clean):
+            return True
+    return False
+
+
 def index_transcript_session(session: dict[str, Any]) -> dict[str, Any]:
     """Upsert a single transcript metadata row and return it."""
     _ensure_transcript_index_table()
@@ -186,6 +212,81 @@ def index_recent_transcripts(
     return indexed
 
 
+def _latest_source_modified_ts(client: str = "") -> float:
+    paths: list[Path] = []
+    if not client or client == "claude_code":
+        paths.extend(find_claude_session_files())
+    if not client or client == "codex":
+        paths.extend(find_codex_session_files())
+    latest = 0.0
+    for path in paths:
+        try:
+            latest = max(latest, path.stat().st_mtime)
+        except OSError:
+            continue
+    return latest
+
+
+def _parse_iso_ts(value: str) -> float:
+    if not value:
+        return 0.0
+    try:
+        return datetime.fromisoformat(value).timestamp()
+    except Exception:
+        return 0.0
+
+
+def ensure_transcript_index(
+    *,
+    hours: int = MAX_TRANSCRIPT_HOURS,
+    client: str = "",
+    limit: int = 1000,
+    min_user_messages: int = 1,
+    force: bool = False,
+) -> dict[str, Any]:
+    """Keep the compact transcript DB index warm enough for fast lookup.
+
+    This is intentionally bounded. Raw JSONL remains the source of truth, but
+    normal MCP searches should hit this table before falling back to slow file
+    scans.
+    """
+    _ensure_transcript_index_table()
+    conn = get_db()
+    params: list[Any] = []
+    where = "1=1"
+    if client:
+        where += " AND source_client = ?"
+        params.append(client)
+    before = int(conn.execute(f"SELECT COUNT(*) AS total FROM transcript_index WHERE {where}", tuple(params)).fetchone()["total"] or 0)
+    latest_indexed = str(conn.execute(
+        f"SELECT MAX(modified_at) AS latest FROM transcript_index WHERE {where}",
+        tuple(params),
+    ).fetchone()["latest"] or "")
+    latest_source_ts = _latest_source_modified_ts(client)
+    latest_indexed_ts = _parse_iso_ts(latest_indexed)
+    stale = bool(latest_source_ts and latest_source_ts > latest_indexed_ts + 1.0)
+    should_index = bool(force or before == 0 or stale)
+    indexed: list[dict[str, Any]] = []
+    if should_index:
+        indexed = index_recent_transcripts(
+            hours=hours,
+            client=client,
+            limit=limit,
+            min_user_messages=min_user_messages,
+        )
+    after = int(conn.execute(f"SELECT COUNT(*) AS total FROM transcript_index WHERE {where}", tuple(params)).fetchone()["total"] or 0)
+    return {
+        "ok": True,
+        "before": before,
+        "after": after,
+        "indexed": len(indexed),
+        "forced": bool(force),
+        "stale": stale,
+        "hours": hours,
+        "client": client,
+    }
+
+
 def search_transcript_index(
     query: str = "",
     *,
@@ -201,7 +302,7 @@ def search_transcript_index(
         where += " AND source_client = ?"
         params.append(client)
     rows = [dict(row) for row in conn.execute(
-        f"SELECT * FROM transcript_index WHERE {where} ORDER BY modified_at DESC LIMIT 500",
+        f"SELECT * FROM transcript_index WHERE {where} ORDER BY modified_at DESC LIMIT 5000",
         tuple(params),
     ).fetchall()]
 
@@ -222,9 +323,11 @@ def search_transcript_index(
             continue
         haystack = " ".join(
             str(row.get(field) or "")
-            for field in ("sanitized_summary", "display_name", "session_id", "conversation_id", "metadata_json")
+            for field in ("sanitized_summary", "display_name", "session_id", "conversation_id", "path_ref", "metadata_json")
         )
         score = _score_text_match(query_tokens, haystack)
+        if _row_ref_matches(query, row):
+            score = max(score, 2.0)
         if score <= 0:
             continue
         row["_score"] = round(score, 4)

package/src/transcript_utils.py

@@ -110,7 +110,10 @@ def find_codex_session_files() -> list[Path]:
         if not root.exists():
             continue
         for jsonl in sorted(root.rglob("*.jsonl")):
-            key = jsonl.name
+            try:
+                key = str(jsonl.resolve())
+            except OSError:
+                key = str(jsonl)
             if key in seen:
                 continue
             seen.add(key)
@@ -346,8 +349,20 @@ def list_recent_transcripts(
     return filtered[: max(1, int(limit or 10))]
 
 
-def search_transcripts(query: str, *, hours: int = DEFAULT_TRANSCRIPT_HOURS, client: str = "", limit: int = 10) -> list[dict]:
-    rows = list_recent_transcripts(hours=hours, client=client, limit=200)
+def search_transcripts(
+    query: str,
+    *,
+    hours: int = DEFAULT_TRANSCRIPT_HOURS,
+    client: str = "",
+    limit: int = 10,
+    min_user_messages: int = MIN_USER_MESSAGES,
+) -> list[dict]:
+    rows = list_recent_transcripts(
+        hours=hours,
+        client=client,
+        limit=200,
+        min_user_messages=min_user_messages,
+    )
     query_tokens = _tokenize(query)
     if not query_tokens:
         return rows[: max(1, int(limit or 10))]
@@ -398,7 +413,46 @@ def search_transcripts(query: str, *, hours: int = DEFAULT_TRANSCRIPT_HOURS, cli
     return matches[: max(1, int(limit or 10))]
 
 
-def load_transcript(session_ref: str = "", transcript_path: str = "", client: str = "") -> dict | None:
+def _transcript_ref_matches(ref: str, session: dict, path: Path) -> bool:
+    clean = str(ref or "").strip()
+    if not clean:
+        return True
+    candidates = {
+        str(session.get("session_file", "")),
+        str(session.get("display_name", "")),
+        str(session.get("session_uid", "")),
+        str(session.get("conversation_id", "")),
+        str(path),
+        path.name,
+        path.stem,
+    }
+    if clean in candidates:
+        return True
+
+    # Operator-facing refs are often short prefixes copied from filenames
+    # or session ids. Require a minimum length so common words do not match
+    # arbitrary historical transcripts.
+    if len(clean) < 6:
+        return False
+    lowered = clean.lower()
+    for candidate in candidates:
+        value = str(candidate or "").strip().lower()
+        if not value:
+            continue
+        if value.startswith(lowered):
+            return True
+        if value.split(":")[-1].startswith(lowered):
+            return True
+    return False
+
+
+def load_transcript(
+    session_ref: str = "",
+    transcript_path: str = "",
+    client: str = "",
+    *,
+    min_user_messages: int = 1,
+) -> dict | None:
     ref = str(session_ref or "").strip()
     path_ref = str(transcript_path or "").strip()
 
@@ -416,17 +470,15 @@ def load_transcript(session_ref: str = "", transcript_path: str = "", client: st
                     continue
             except Exception:
                 continue
-        session = extract_codex_session(path) if detected_client == "codex" else extract_claude_session(path)
+        session = (
+            extract_codex_session(path, min_user_messages=min_user_messages)
+            if detected_client == "codex"
+            else extract_claude_session(path, min_user_messages=min_user_messages)
+        )
         if not session:
             continue
-        if ref:
-            if ref not in {
-                str(session.get("session_file", "")),
-                str(session.get("display_name", "")),
-                str(session.get("session_uid", "")),
-                str(path),
-            }:
-                continue
+        if ref and not _transcript_ref_matches(ref, session, path):
+            continue
         try:
             session["modified"] = datetime.fromtimestamp(path.stat().st_mtime).isoformat()
         except OSError:

package/templates/core-prompts/postmortem-consolidator.md

@@ -31,8 +31,8 @@ INSTRUCTIONS:
    - A feedback covering the same topic already exists
 
 4. For each rule to promote, create the file with Write en [[memory_dir]]/:
-   Nombre: feedback_postmortem_[slug_descriptivo].md
-   Formato:
+   Name: feedback_postmortem_[descriptive_slug].md
+   Format:
    ---
    name: [descriptive title]
    description: Behavioral rule extracted from self-critique — recurring pattern
@@ -49,7 +49,7 @@ INSTRUCTIONS:
    Sessions: X | Self-critiques: Y | Promoted: Z
 
    ## Today's self-critiques (summary)
-   [Lista breve]
+   [Brief list]
 
    ## Promoted to permanent memory
    [What you promoted and why]