loki-mode 7.7.16 → 7.7.18

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '7.7.16'
+__version__ = '7.7.18'

package/mcp/server.py

@@ -969,6 +969,94 @@ async def loki_metrics_efficiency() -> str:
         return json.dumps({"error": str(e)})
 
 
+@mcp.tool()
+async def loki_memory_capture_session_summary(
+    goal: str,
+    outcome: str = "success",
+    files_modified: Optional[List[str]] = None,
+    files_read: Optional[List[str]] = None,
+    tool_calls_summary: Optional[str] = None,
+    duration_seconds: int = 0,
+) -> str:
+    """v7.7.18 capture wedge: store an episode for the current agent session.
+
+    Call this voluntarily at iteration close (or session end) to write a
+    structured Episode into the project's .loki/memory/ store. Solves
+    the diagnosis root cause where memory only captured during `loki
+    start` sessions, missing all interactive Claude Code / Cursor /
+    Cline / Aider work.
+
+    Args:
+        goal: Short description of what the session tried to accomplish
+            (will be truncated to 500 chars, scrubbed for secrets).
+        outcome: One of "success" | "failure" | "partial". Default "success".
+        files_modified: List of file paths that were created or edited.
+        files_read: List of file paths that were read for context.
+        tool_calls_summary: Optional free-text summary of major actions
+            taken (truncated to 1000 chars, scrubbed).
+        duration_seconds: Approximate session duration. Default 0.
+
+    Returns:
+        JSON: {"episode_path": "<path>"} on success, or
+        {"error": "...", "disabled": true} if LOKI_MEMORY_CAPTURE_DISABLED
+        env var blocks capture, or {"error": "..."} on failure.
+    """
+    _emit_tool_event_async(
+        'loki_memory_capture_session_summary', 'start',
+        parameters={'goal_len': len(goal or ''), 'outcome': outcome,
+                    'files_modified_count': len(files_modified or []),
+                    'files_read_count': len(files_read or [])}
+    )
+    try:
+        from memory.ingest import ingest_from_summary, _capture_disabled
+
+        if _capture_disabled():
+            _emit_tool_event_async(
+                'loki_memory_capture_session_summary', 'complete',
+                result_status='skipped', error='disabled via env'
+            )
+            return json.dumps({
+                "error": "memory capture disabled via LOKI_MEMORY_CAPTURE_DISABLED",
+                "disabled": True,
+            })
+
+        base_path = safe_path_join('.loki', 'memory')
+        path = ingest_from_summary(
+            base_path,
+            goal=goal,
+            outcome=outcome,
+            files_modified=files_modified,
+            files_read=files_read,
+            tool_calls_summary=tool_calls_summary,
+            duration_seconds=duration_seconds,
+        )
+        if path is None:
+            _emit_tool_event_async(
+                'loki_memory_capture_session_summary', 'complete',
+                result_status='error', error='ingest_from_summary returned None'
+            )
+            return json.dumps({"error": "ingest failed (check .loki/memory/.errors.log)"})
+        _emit_tool_event_async(
+            'loki_memory_capture_session_summary', 'complete',
+            result_status='success', episode_path=path
+        )
+        return json.dumps({"episode_path": path})
+    except PathTraversalError as e:
+        logger.error(f"Path traversal attempt blocked: {e}")
+        _emit_tool_event_async(
+            'loki_memory_capture_session_summary', 'complete',
+            result_status='error', error='Access denied'
+        )
+        return json.dumps({"error": "Access denied"})
+    except Exception as e:
+        logger.error(f"loki_memory_capture_session_summary failed: {e}")
+        _emit_tool_event_async(
+            'loki_memory_capture_session_summary', 'complete',
+            result_status='error', error=str(e)
+        )
+        return json.dumps({"error": str(e)})
+
+
 @mcp.tool()
 async def loki_consolidate_memory(since_hours: int = 24) -> str:
     """

package/memory/error_log.py

@@ -0,0 +1,182 @@
+"""v7.7.17: structured error log for memory subsystem failures.
+
+Replaces the silent-fail (`except Exception: pass`) pattern in
+`autonomy/run.sh` memory call sites with explicit error logging to
+`.loki/memory/.errors.log`. Surfaces in `loki doctor --json` so
+developers see regressions early.
+
+Record format (tab-separated, one record per line):
+    <iso_timestamp>\\t<function_name>\\t<error_class>\\t<message>\\t<traceback_snippet>
+
+Rotation:
+    - At 10 MB the current file is renamed to `.errors.log.1`.
+    - Older generations shift down (`.1` -> `.2` -> `.3`).
+    - Up to 3 historical files retained; older ones are dropped.
+
+Failure mode:
+    - Logging never raises. If the log itself is unwriteable (perms,
+      read-only fs, full disk) the call silently drops the record.
+      Observability must not break the memory pipeline.
+"""
+from __future__ import annotations
+
+import re
+import traceback
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List
+
+MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024  # 10 MB
+MAX_HISTORICAL_FILES = 3
+# Doctor surface and read_recent_errors only consider the tail of the file.
+# Prevents an OOM on the doctor command if rotation ever fails (perms,
+# disk full mid-rotation, or external writer appending).
+TAIL_READ_BYTES = 64 * 1024  # 64 KB
+
+# v7.7.17 (council fix Opus 2): scrub credential-shaped substrings from
+# exception messages before writing to .errors.log. Doctor --json is
+# commonly pasted into bug reports / chats; without this scrub, a stray
+# `RuntimeError: Bearer sk-...` would leak.
+# Mirrors the v7.7.10 USAGE.md regen scrubber (autonomy/run.sh).
+_CREDENTIAL_KEYWORD_RE = re.compile(
+    r"(?i)(api[_-]?key|secret|password|token|private[_-]?key|credential|bearer)"
+)
+_HIGH_ENTROPY_TOKEN_RE = re.compile(
+    r"sk-[A-Za-z0-9_-]{16,}|pk_[A-Za-z0-9_-]{16,}|ghp_[A-Za-z0-9]{16,}|"
+    r"ghs_[A-Za-z0-9]{16,}|xox[bpoa]-[A-Za-z0-9-]{16,}|AIza[A-Za-z0-9_-]{32,}|"
+    r"AKIA[A-Z0-9]{12,}"
+)
+
+
+def _scrub(text: str) -> str:
+    """Redact credential-shaped substrings from `text`.
+
+    Two passes:
+        1. Any token containing a credential keyword: replace the whole
+           token (whitespace-delimited) with `[REDACTED]`.
+        2. Any literal high-entropy token shape (Stripe sk-, GitHub
+           ghp_/ghs_, Slack xox*, GCP AIza, AWS AKIA): replace inline
+           with `[REDACTED]`.
+    """
+    if not text:
+        return text
+    scrubbed_tokens = []
+    for token in text.split():
+        if _CREDENTIAL_KEYWORD_RE.search(token):
+            scrubbed_tokens.append("[REDACTED]")
+        else:
+            scrubbed_tokens.append(_HIGH_ENTROPY_TOKEN_RE.sub("[REDACTED]", token))
+    return " ".join(scrubbed_tokens)
+
+
+def _errors_log_path(memory_base: str) -> Path:
+    return Path(memory_base) / ".errors.log"
+
+
+def _rotate_if_needed(path: Path) -> None:
+    """Rotate `path` if it has grown past MAX_LOG_SIZE_BYTES.
+
+    Sequence (for MAX_HISTORICAL_FILES=3):
+        1. If `path.log.3` exists, delete it (it falls off the back).
+        2. Shift `path.log.2` -> `path.log.3`, `path.log.1` -> `path.log.2`.
+        3. Rename `path` -> `path.log.1`.
+
+    All failures are silently absorbed via fallback truncation. The
+    caller cannot afford rotation errors to propagate.
+    """
+    try:
+        if not path.exists() or path.stat().st_size < MAX_LOG_SIZE_BYTES:
+            return
+        # Drop oldest generation
+        oldest = path.with_suffix(f".log.{MAX_HISTORICAL_FILES}")
+        if oldest.exists():
+            oldest.unlink()
+        # Shift older -> newer (going from N-1 down to 1)
+        for n in range(MAX_HISTORICAL_FILES - 1, 0, -1):
+            src = path.with_suffix(f".log.{n}")
+            dst = path.with_suffix(f".log.{n + 1}")
+            if src.exists():
+                src.rename(dst)
+        # Move current -> .log.1
+        path.rename(path.with_suffix(".log.1"))
+    except OSError:
+        # Last-ditch: try to truncate the current file so future writes
+        # do not keep failing. Silent on failure.
+        try:
+            path.unlink()
+        except OSError:
+            pass
+
+
+def log_memory_error(memory_base: str, function_name: str, exc: BaseException) -> None:
+    """Append a structured error record to `<memory_base>/.errors.log`.
+
+    Never raises. Falls back to silent drop if the log is unwriteable.
+
+    Args:
+        memory_base: Absolute or relative path to a `.loki/memory/`
+            directory. Will be created if missing.
+        function_name: Short identifier of the call site (e.g.
+            "store_episode_trace", "auto_capture_episode").
+        exc: The caught exception to record.
+    """
+    try:
+        memory_dir = Path(memory_base)
+        memory_dir.mkdir(parents=True, exist_ok=True)
+        log_path = _errors_log_path(memory_base)
+        _rotate_if_needed(log_path)
+        # Tab-separated single-line record. Replace embedded tabs/newlines
+        # in user-provided strings so the format stays parseable.
+        tb_snippet = "".join(
+            traceback.format_exception_only(type(exc), exc)
+        ).strip()[:200].replace("\t", " ").replace("\n", " ")
+        msg = str(exc).replace("\t", " ").replace("\n", " ")[:200]
+        # v7.7.17 council fix (Opus 2): scrub credentials BEFORE writing
+        # to disk so doctor --json (often pasted in bug reports) cannot
+        # leak Bearer tokens, API keys, etc. embedded in exception text.
+        msg = _scrub(msg)
+        tb_snippet = _scrub(tb_snippet)
+        record = "\t".join([
+            datetime.now(timezone.utc).isoformat(),
+            function_name,
+            type(exc).__name__,
+            msg,
+            tb_snippet,
+        ])
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(record + "\n")
+    except Exception:
+        return
+
+
+def read_recent_errors(memory_base: str, limit: int = 5) -> List[str]:
+    """Read the last `limit` error records as raw lines (oldest-to-newest).
+
+    Returns an empty list if the log does not exist or cannot be read.
+    Never raises. The current file only is read (historical rotated
+    files are not consulted; recent enough for the doctor surface).
+
+    v7.7.17 council fix (Opus 2): seeks from end and reads at most
+    TAIL_READ_BYTES so an oversize log (rotation failed, disk-full
+    mid-rotate, external writer) cannot OOM the doctor command.
+    """
+    log_path = _errors_log_path(memory_base)
+    if not log_path.exists():
+        return []
+    try:
+        with open(log_path, "rb") as f:
+            f.seek(0, 2)  # end
+            size = f.tell()
+            offset = max(0, size - TAIL_READ_BYTES)
+            f.seek(offset)
+            chunk = f.read()
+        text = chunk.decode("utf-8", errors="replace")
+        # If we seeked into the middle of a line, drop the (possibly
+        # corrupt) first partial line.
+        lines = text.split("\n")
+        if offset > 0 and lines:
+            lines = lines[1:]
+        lines = [ln.strip() for ln in lines if ln.strip()]
+        return lines[-limit:]
+    except OSError:
+        return []