loki-mode 7.7.17 → 7.7.18

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes a spec (PRD, GitHub issue, OpenAPI doc, etc.) to deployed product with minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v7.7.17
+# Loki Mode v7.7.18
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -381,4 +381,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v7.7.17 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.7.18 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.7.17
+7.7.18

package/autonomy/loki

@@ -15034,6 +15034,88 @@ except Exception as e:
             echo "  loki memory namespace stats"
             ;;
 
+        ingest)
+            # v7.7.18 capture wedge: ingest a Claude Code session transcript
+            # into the project's .loki/memory/ store. Solves the diagnosis
+            # root cause where memory only captured during `loki start`.
+            #
+            # Usage:
+            #   loki memory ingest --from-claude-transcript <path>
+            #   loki memory ingest --from-stdin   (reads a JSON summary doc)
+            shift  # drop "ingest"
+            local _ingest_mode=""
+            local _ingest_path=""
+            while [ $# -gt 0 ]; do
+                case "$1" in
+                    --from-claude-transcript)
+                        _ingest_mode="transcript"
+                        _ingest_path="${2:-}"
+                        if [ $# -ge 2 ]; then shift 2; else shift; fi
+                        ;;
+                    --from-stdin)
+                        _ingest_mode="stdin"
+                        shift
+                        ;;
+                    -h|--help)
+                        echo "Usage: loki memory ingest --from-claude-transcript <path>"
+                        echo "       loki memory ingest --from-stdin   (JSON doc on stdin)"
+                        echo ""
+                        echo "Honors LOKI_MEMORY_CAPTURE_DISABLED=true (escape hatch)."
+                        return 0
+                        ;;
+                    *) shift ;;
+                esac
+            done
+            if [ -z "$_ingest_mode" ]; then
+                echo -e "${RED}Usage: loki memory ingest --from-claude-transcript <path> | --from-stdin${NC}"
+                exit 1
+            fi
+            local _project_root_for_ingest="${SKILL_DIR:-$(pwd)}"
+            local _target_memory_dir
+            _target_memory_dir="$(pwd)/.loki/memory"
+            mkdir -p "$_target_memory_dir" 2>/dev/null || true
+            if [ "$_ingest_mode" = "transcript" ]; then
+                if [ -z "$_ingest_path" ] || [ ! -f "$_ingest_path" ]; then
+                    echo -e "${RED}Transcript not found: $_ingest_path${NC}"
+                    exit 1
+                fi
+                PYTHONPATH="$_project_root_for_ingest" \
+                    python3 -c "
+import sys, json
+from memory.ingest import ingest_from_claude_transcript
+path = ingest_from_claude_transcript(sys.argv[1], sys.argv[2])
+print(json.dumps({'episode_path': path}))
+" "$_ingest_path" "$_target_memory_dir"
+            else
+                PYTHONPATH="$_project_root_for_ingest" \
+                    python3 -c "
+import sys, json
+from memory.ingest import ingest_from_summary
+doc = json.loads(sys.stdin.read())
+path = ingest_from_summary(
+    sys.argv[1],
+    goal=doc.get('goal',''),
+    outcome=doc.get('outcome','success'),
+    files_modified=doc.get('files_modified',[]),
+    files_read=doc.get('files_read',[]),
+    tool_calls_summary=doc.get('tool_calls_summary',''),
+    duration_seconds=int(doc.get('duration_seconds',0) or 0),
+)
+print(json.dumps({'episode_path': path}))
+" "$_target_memory_dir"
+            fi
+            ;;
+
+        # NOTE (v7.7.18 council fix Opus 2): hook installer (enable-hook /
+        # disable-hook) DEFERRED to v7.7.19. Claude Code SessionEnd schema
+        # requires {matcher, hooks:[{type,command}]} nested format -- not
+        # the {id, command} format originally drafted. Also only fires on
+        # /clear (not normal exits), and payload is JSON on stdin (not the
+        # $CLAUDE_TRANSCRIPT_PATH env var). The sample hook script at
+        # claude/hooks/loki-session-end.sh ships for users who want to
+        # install manually; the automated installer comes after we verify
+        # the exact schema empirically against a real Claude Code install.
+
         *)
             echo -e "${RED}Unknown memory command: $subcommand${NC}"
             echo "Run 'loki memory help' for usage."

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "7.7.17"
+__version__ = "7.7.18"
 
 # Expose the control app for easy import
 try:

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v7.7.17
+**Version:** v7.7.18
 
 ---
 

package/loki-ts/dist/loki.js

@@ -1,5 +1,5 @@
 // @bun
-var _7=Object.defineProperty;var I7=(K)=>K;function P7(K,$){this[K]=I7.bind(null,$)}var v=(K,$)=>{for(var Q in $)_7(K,Q,{get:$[Q],enumerable:!0,configurable:!0,set:P7.bind($,Q)})};var R=(K,$)=>()=>(K&&($=K(K=0)),$);var t=import.meta.require;var e1={};v(e1,{lokiDir:()=>P,homeLokiDir:()=>k1,findRepoRootForVersion:()=>N1,REPO_ROOT:()=>p});import{resolve as u,dirname as S1}from"path";import{fileURLToPath as L7}from"url";import{existsSync as J1}from"fs";import{homedir as R7}from"os";function E7(){let K=i1;for(let $=0;$<6;$++){if(J1(u(K,"VERSION"))&&J1(u(K,"autonomy/run.sh")))return K;let Q=S1(K);if(Q===K)break;K=Q}return u(i1,"..","..","..")}function N1(K){let $=K;for(let Q=0;Q<6;Q++){if(J1(u($,"VERSION"))&&J1(u($,"autonomy/run.sh")))return $;let X=S1($);if(X===$)break;$=X}return u(K,"..","..","..")}function P(){return process.env.LOKI_DIR??u(process.cwd(),".loki")}function k1(){return u(R7(),".loki")}var i1,p;var g=R(()=>{i1=S1(L7(import.meta.url));p=E7()});import{readFileSync as F7}from"fs";import{resolve as w7,dirname as x7}from"path";import{fileURLToPath as S7}from"url";function G1(){if(n!==null)return n;let K="7.7.17";if(typeof K==="string"&&K.length>0)return n=K,n;try{let $=x7(S7(import.meta.url)),Q=N1($);n=F7(w7(Q,"VERSION"),"utf-8").trim()}catch{n="unknown"}return n}var n=null;var D1=R(()=>{g()});var $0={};v($0,{runOrThrow:()=>N7,run:()=>S,commandVersion:()=>D7,commandExists:()=>h,ShellError:()=>C1});async function S(K,$={}){let Q=Bun.spawn({cmd:[...K],stdout:"pipe",stderr:"pipe",env:$.env?{...process.env,...$.env}:process.env,cwd:$.cwd}),X,Z;if($.timeoutMs&&$.timeoutMs>0)X=setTimeout(()=>{try{Q.kill("SIGTERM")}catch{}Z=setTimeout(()=>{try{Q.kill("SIGKILL")}catch{}},2000)},$.timeoutMs);try{let[W,z,q]=await Promise.all([new Response(Q.stdout).text(),new Response(Q.stderr).text(),Q.exited]);return{stdout:W,stderr:z,exitCode:q}}finally{if(X)clearTimeout(X);if(Z)clearTimeout(Z)}}async function N7(K,$={}){let Q=await S(K,$);if(Q.exitCode!==0)throw new C1(`command failed (${Q.exitCode}): ${K.join(" ")}`,Q.exitCode,Q.stdout,Q.stderr);return Q}async function h(K){let $=k7(K),Q=await S(["sh","-c",`command -v ${$}`],{timeoutMs:5000});if(Q.exitCode===0)return Q.stdout.trim()||null;return null}function k7(K){if(!/^[A-Za-z0-9._/-]+$/.test(K))throw Error(`refused to shell-escape suspect token: ${K}`);return K}async function D7(K,$="--version"){if(!await h(K))return null;let X=await S([K,$],{timeoutMs:5000});if(X.exitCode!==0)return null;return((X.stdout||X.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var C1;var c=R(()=>{C1=class C1 extends Error{message;exitCode;stdout;stderr;constructor(K,$,Q,X){super(K);this.message=K;this.exitCode=$;this.stdout=Q;this.stderr=X;this.name="ShellError"}}});function l(K){return C7?"":K}var C7,E,b,F,T6,O,D,w,H;var a=R(()=>{C7=(process.env.NO_COLOR??"").length>0;E=l("\x1B[0;31m"),b=l("\x1B[0;32m"),F=l("\x1B[1;33m"),T6=l("\x1B[0;34m"),O=l("\x1B[0;36m"),D=l("\x1B[1m"),w=l("\x1B[2m"),H=l("\x1B[0m")});import{existsSync as c7}from"fs";async function i(){if(X1!==void 0)return X1;let K="/opt/homebrew/bin/python3.12";if(c7(K))return X1=K,K;let $=await h("python3.12");if($)return X1=$,$;let Q=await h("python3");return X1=Q,Q}async function s(K,$={}){let Q=await i();if(!Q)return{stdout:"",stderr:"python3 not found",exitCode:127};return S([Q,"-c",K],$)}var X1;var Z1=R(()=>{c()});var G0={};v(G0,{runStatus:()=>Q5});import{existsSync as k,readFileSync as W1,readdirSync as W0,statSync as H0}from"fs";import{resolve as x,basename as a7}from"path";async function r7(){if(await h("jq"))return!0;return process.stdout.write(`${E}Error: jq is required but not installed.${H}
+var _7=Object.defineProperty;var I7=(K)=>K;function P7(K,$){this[K]=I7.bind(null,$)}var v=(K,$)=>{for(var Q in $)_7(K,Q,{get:$[Q],enumerable:!0,configurable:!0,set:P7.bind($,Q)})};var R=(K,$)=>()=>(K&&($=K(K=0)),$);var t=import.meta.require;var e1={};v(e1,{lokiDir:()=>P,homeLokiDir:()=>k1,findRepoRootForVersion:()=>N1,REPO_ROOT:()=>p});import{resolve as u,dirname as S1}from"path";import{fileURLToPath as L7}from"url";import{existsSync as J1}from"fs";import{homedir as R7}from"os";function E7(){let K=i1;for(let $=0;$<6;$++){if(J1(u(K,"VERSION"))&&J1(u(K,"autonomy/run.sh")))return K;let Q=S1(K);if(Q===K)break;K=Q}return u(i1,"..","..","..")}function N1(K){let $=K;for(let Q=0;Q<6;Q++){if(J1(u($,"VERSION"))&&J1(u($,"autonomy/run.sh")))return $;let X=S1($);if(X===$)break;$=X}return u(K,"..","..","..")}function P(){return process.env.LOKI_DIR??u(process.cwd(),".loki")}function k1(){return u(R7(),".loki")}var i1,p;var g=R(()=>{i1=S1(L7(import.meta.url));p=E7()});import{readFileSync as F7}from"fs";import{resolve as w7,dirname as x7}from"path";import{fileURLToPath as S7}from"url";function G1(){if(n!==null)return n;let K="7.7.18";if(typeof K==="string"&&K.length>0)return n=K,n;try{let $=x7(S7(import.meta.url)),Q=N1($);n=F7(w7(Q,"VERSION"),"utf-8").trim()}catch{n="unknown"}return n}var n=null;var D1=R(()=>{g()});var $0={};v($0,{runOrThrow:()=>N7,run:()=>S,commandVersion:()=>D7,commandExists:()=>h,ShellError:()=>C1});async function S(K,$={}){let Q=Bun.spawn({cmd:[...K],stdout:"pipe",stderr:"pipe",env:$.env?{...process.env,...$.env}:process.env,cwd:$.cwd}),X,Z;if($.timeoutMs&&$.timeoutMs>0)X=setTimeout(()=>{try{Q.kill("SIGTERM")}catch{}Z=setTimeout(()=>{try{Q.kill("SIGKILL")}catch{}},2000)},$.timeoutMs);try{let[W,z,q]=await Promise.all([new Response(Q.stdout).text(),new Response(Q.stderr).text(),Q.exited]);return{stdout:W,stderr:z,exitCode:q}}finally{if(X)clearTimeout(X);if(Z)clearTimeout(Z)}}async function N7(K,$={}){let Q=await S(K,$);if(Q.exitCode!==0)throw new C1(`command failed (${Q.exitCode}): ${K.join(" ")}`,Q.exitCode,Q.stdout,Q.stderr);return Q}async function h(K){let $=k7(K),Q=await S(["sh","-c",`command -v ${$}`],{timeoutMs:5000});if(Q.exitCode===0)return Q.stdout.trim()||null;return null}function k7(K){if(!/^[A-Za-z0-9._/-]+$/.test(K))throw Error(`refused to shell-escape suspect token: ${K}`);return K}async function D7(K,$="--version"){if(!await h(K))return null;let X=await S([K,$],{timeoutMs:5000});if(X.exitCode!==0)return null;return((X.stdout||X.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var C1;var c=R(()=>{C1=class C1 extends Error{message;exitCode;stdout;stderr;constructor(K,$,Q,X){super(K);this.message=K;this.exitCode=$;this.stdout=Q;this.stderr=X;this.name="ShellError"}}});function l(K){return C7?"":K}var C7,E,b,F,T6,O,D,w,H;var a=R(()=>{C7=(process.env.NO_COLOR??"").length>0;E=l("\x1B[0;31m"),b=l("\x1B[0;32m"),F=l("\x1B[1;33m"),T6=l("\x1B[0;34m"),O=l("\x1B[0;36m"),D=l("\x1B[1m"),w=l("\x1B[2m"),H=l("\x1B[0m")});import{existsSync as c7}from"fs";async function i(){if(X1!==void 0)return X1;let K="/opt/homebrew/bin/python3.12";if(c7(K))return X1=K,K;let $=await h("python3.12");if($)return X1=$,$;let Q=await h("python3");return X1=Q,Q}async function s(K,$={}){let Q=await i();if(!Q)return{stdout:"",stderr:"python3 not found",exitCode:127};return S([Q,"-c",K],$)}var X1;var Z1=R(()=>{c()});var G0={};v(G0,{runStatus:()=>Q5});import{existsSync as k,readFileSync as W1,readdirSync as W0,statSync as H0}from"fs";import{resolve as x,basename as a7}from"path";async function r7(){if(await h("jq"))return!0;return process.stdout.write(`${E}Error: jq is required but not installed.${H}
 `),process.stdout.write(`Install with:
 `),process.stdout.write(`  brew install jq    (macOS)
 `),process.stdout.write(`  apt install jq     (Debian/Ubuntu)
@@ -585,4 +585,4 @@ Set LOKI_LEGACY_BASH=1 to force the bash CLI for every command.
 `),2}default:return process.stderr.write(`Unknown command: ${$}
 `),process.stderr.write(j7),2}}process.on("SIGINT",()=>process.exit(130));process.on("SIGTERM",()=>process.exit(143));var X6=await Q6(Bun.argv.slice(2));process.exit(X6);
 
-//# debugId=508CDF0AB125EA5664756E2164756E21
+//# debugId=33B2B334220BB7A164756E2164756E21

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '7.7.17'
+__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/ingest.py

@@ -0,0 +1,450 @@
+"""v7.7.18: ingest non-`loki start` sessions into the memory store.
+
+Diagnosis at ~/git/loki-plan/MEMORY-DIAGNOSIS-2026-05-27.md root cause:
+`auto_capture_episode` only fires inside `run_autonomous()` reached via
+`loki start <prd>`. The 167 release sessions in 2026 happened in regular
+Claude Code, never producing episodes. This module + the MCP capture
+tool in `mcp/server.py` + the `loki memory ingest` CLI together close
+that gap.
+
+Two entry points:
+    - `ingest_from_claude_transcript(path)` -> reads a Claude Code
+      session transcript JSONL, extracts tool_use traces, produces an
+      EpisodeTrace with populated action_log + files_read + files_modified.
+    - `ingest_from_summary(goal, outcome, files_modified, ...)` -> builds
+      an episode from explicit fields (used by the MCP capture tool the
+      agent calls at iteration close).
+
+Both call `memory.engine.MemoryEngine.store_episode` under the hood.
+
+Safety:
+    - Secret scrubber (mirrors memory/error_log.py + v7.7.10) applied
+      to goal text, tool inputs, file paths.
+    - Honors `LOKI_MEMORY_CAPTURE_DISABLED=true` env var (capture wedge
+      escape hatch).
+    - Never raises; returns None on any failure and logs to .errors.log.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+# Local imports deferred to call time to keep this module importable
+# without the heavier memory.engine + memory.schemas dependency tree.
+
+
+# Same scrubber regex set as memory/error_log.py + v7.7.10 USAGE.md regen.
+_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,}"
+)
+
+# Tool names that indicate a file was READ.
+READ_TOOL_NAMES = frozenset({"Read", "ReadFile", "read_file", "Grep", "Glob"})
+# Tool names that indicate a file was MODIFIED (created or edited).
+WRITE_TOOL_NAMES = frozenset(
+    {"Edit", "Write", "MultiEdit", "Patch", "NotebookEdit", "ApplyDiff"}
+)
+# Tool names that are shell command executions (no specific file).
+SHELL_TOOL_NAMES = frozenset({"Bash", "Shell", "Exec"})
+
+
+def _scrub(text: str) -> str:
+    """Redact credential-shaped substrings. Single-pass tokenizer."""
+    if not text:
+        return text
+    out_tokens = []
+    for token in text.split():
+        if _CREDENTIAL_KEYWORD_RE.search(token):
+            out_tokens.append("[REDACTED]")
+        else:
+            out_tokens.append(_HIGH_ENTROPY_TOKEN_RE.sub("[REDACTED]", token))
+    return " ".join(out_tokens)
+
+
+# v7.7.18 council fix (Opus 2): path-aware redaction for file paths.
+# `_scrub` is whitespace-tokenized and misses sensitive paths like
+# `/Users/me/.aws/credentials` (no whitespace, no credential keyword).
+# Per Opus 2: "Document as known boundary or add path-aware redaction
+# (e.g. drop `.aws/`, `.ssh/`, `credentials`, `.env*` segments)."
+_SENSITIVE_PATH_SUBSTRINGS = (
+    "/.aws/",
+    "/.ssh/",
+    "/.gnupg/",
+    "/.docker/config",
+    "/credentials",
+    "/.netrc",
+    "/.npmrc",
+    "/.pypirc",
+)
+_SENSITIVE_PATH_BASENAMES = (
+    ".env",
+    ".env.local",
+    ".env.production",
+    ".env.development",
+    ".env.staging",
+    "credentials",
+    "credentials.json",
+    "secrets.json",
+    "id_rsa",
+    "id_ed25519",
+    "private.key",
+)
+
+
+def _scrub_path(path: str) -> str:
+    """Redact file paths that point to commonly-sensitive locations.
+
+    Returns the original path if benign; returns a `[REDACTED:<reason>]`
+    marker (with the directory portion preserved) if the path looks
+    sensitive. Preserves directory context so dashboards can still
+    surface "this session touched credential files" without leaking
+    the specific file name.
+    """
+    if not path:
+        return path
+    # Normalize separators for matching but keep original for return
+    norm = path.replace("\\", "/")
+    lowered = norm.lower()
+    for substr in _SENSITIVE_PATH_SUBSTRINGS:
+        if substr in lowered:
+            head = path.rsplit("/", 1)[0] if "/" in path else ""
+            return f"{head}/[REDACTED:sensitive-dir]" if head else "[REDACTED:sensitive-dir]"
+    basename = path.rsplit("/", 1)[-1] if "/" in path else path
+    if basename.lower() in _SENSITIVE_PATH_BASENAMES or basename.lower().startswith(".env"):
+        head = path.rsplit("/", 1)[0] if "/" in path else ""
+        return f"{head}/[REDACTED:sensitive-file]" if head else "[REDACTED:sensitive-file]"
+    return path
+
+
+def _capture_disabled() -> bool:
+    """Honor `LOKI_MEMORY_CAPTURE_DISABLED=true` escape hatch."""
+    return os.environ.get("LOKI_MEMORY_CAPTURE_DISABLED", "").lower() in (
+        "true",
+        "1",
+        "yes",
+    )
+
+
+def _log_to_errors(memory_base: str, function_name: str, exc: BaseException) -> None:
+    """Best-effort error log; never raises. Mirrors error_log.log_memory_error
+    but accessed lazily so this module imports without circular deps."""
+    try:
+        from memory.error_log import log_memory_error
+        log_memory_error(memory_base, function_name, exc)
+    except Exception:
+        return
+
+
+def _parse_transcript_line(line: str) -> Optional[Dict[str, Any]]:
+    """Parse one JSONL line; return None on parse error."""
+    try:
+        return json.loads(line)
+    except (json.JSONDecodeError, ValueError):
+        return None
+
+
+def _extract_tool_uses(transcript_entries: List[Dict[str, Any]]) -> List[Tuple[str, Dict[str, Any], Optional[str]]]:
+    """Walk transcript entries; yield (tool_name, input_dict, timestamp) tuples.
+
+    Claude Code transcript shape (observed v7.7.x): top-level entries
+    with `type: assistant|user|...`. Assistant entries have a nested
+    `message.content` array containing items with `type: text|tool_use`.
+    """
+    tool_uses = []
+    for entry in transcript_entries:
+        if entry.get("type") != "assistant":
+            continue
+        msg = entry.get("message") or {}
+        if not isinstance(msg, dict):
+            continue
+        content = msg.get("content") or []
+        if not isinstance(content, list):
+            continue
+        ts = entry.get("timestamp") or msg.get("timestamp")
+        for item in content:
+            if not isinstance(item, dict):
+                continue
+            if item.get("type") == "tool_use":
+                name = item.get("name", "")
+                inp = item.get("input", {})
+                if not isinstance(inp, dict):
+                    inp = {}
+                tool_uses.append((name, inp, ts))
+    return tool_uses
+
+
+def _extract_files(tool_uses: List[Tuple[str, Dict[str, Any], Optional[str]]]) -> Tuple[List[str], List[str]]:
+    """Return (files_read, files_modified) deduped, in first-seen order."""
+    read_seen: Dict[str, None] = {}
+    mod_seen: Dict[str, None] = {}
+    for name, inp, _ts in tool_uses:
+        path = inp.get("file_path") or inp.get("path") or inp.get("filepath")
+        if not isinstance(path, str) or not path:
+            continue
+        if name in READ_TOOL_NAMES and path not in read_seen:
+            read_seen[path] = None
+        if name in WRITE_TOOL_NAMES and path not in mod_seen:
+            mod_seen[path] = None
+    return list(read_seen.keys()), list(mod_seen.keys())
+
+
+def _build_action_log(
+    tool_uses: List[Tuple[str, Dict[str, Any], Optional[str]]],
+    start_ts: Optional[datetime],
+    max_entries: int = 100,
+) -> List[Any]:
+    """Convert tool_use tuples to ActionEntry objects (scrubbed).
+
+    Returns a list of `memory.schemas.ActionEntry` instances. Defers the
+    import so this module is testable without the full schema chain.
+    Caps at `max_entries` to bound episode size on long sessions.
+    """
+    from memory.schemas import ActionEntry
+    entries = []
+    for i, (name, inp, ts) in enumerate(tool_uses[:max_entries]):
+        rel_ts = 0
+        if start_ts and ts:
+            try:
+                t = datetime.fromisoformat(str(ts).replace("Z", "+00:00"))
+                rel_ts = int((t - start_ts).total_seconds())
+            except (ValueError, TypeError):
+                rel_ts = i
+        # Choose a compact input representation
+        target = (
+            inp.get("file_path")
+            or inp.get("path")
+            or inp.get("command")
+            or inp.get("query")
+            or json.dumps(inp, default=str)[:200]
+        )
+        target = _scrub(str(target))[:300]
+        entries.append(ActionEntry(
+            tool=name or "?",
+            input=target,
+            output="",  # transcript does not always include tool_result inline; v7.7.19 may enrich
+            timestamp=rel_ts,
+        ))
+    return entries
+
+
+def _derive_goal(transcript_entries: List[Dict[str, Any]]) -> str:
+    """Best-effort goal extraction: first user message text, OR aiTitle, OR ''."""
+    for entry in transcript_entries:
+        if entry.get("type") == "user":
+            msg = entry.get("message") or {}
+            if isinstance(msg, dict):
+                content = msg.get("content")
+                if isinstance(content, str):
+                    return _scrub(content)[:500]
+                if isinstance(content, list):
+                    for item in content:
+                        if isinstance(item, dict) and item.get("type") == "text":
+                            t = item.get("text", "")
+                            if t:
+                                return _scrub(t)[:500]
+    for entry in transcript_entries:
+        if entry.get("type") == "ai-title":
+            title = entry.get("title") or entry.get("aiTitle")
+            if title:
+                return _scrub(str(title))[:500]
+    return ""
+
+
+def _derive_timestamps(transcript_entries: List[Dict[str, Any]]) -> Tuple[Optional[datetime], Optional[datetime]]:
+    """Return (start, end) datetimes from first/last entry with timestamp."""
+    timestamps: List[datetime] = []
+    for entry in transcript_entries:
+        for key in ("timestamp", "ts", "createdAt"):
+            v = entry.get(key)
+            if v:
+                try:
+                    timestamps.append(datetime.fromisoformat(str(v).replace("Z", "+00:00")))
+                    break
+                except (ValueError, TypeError):
+                    pass
+    if not timestamps:
+        return None, None
+    return min(timestamps), max(timestamps)
+
+
+def ingest_from_claude_transcript(
+    transcript_path: str,
+    memory_base: str,
+    *,
+    task_id: Optional[str] = None,
+    agent: str = "claude-code",
+    phase: str = "INTERACTIVE",
+    outcome: str = "success",
+) -> Optional[str]:
+    """Read a Claude Code session transcript JSONL and store an Episode.
+
+    Args:
+        transcript_path: Path to a Claude Code session transcript JSONL
+            (typically under `~/.claude/projects/<dir>/<session>.jsonl`).
+        memory_base: Path to the project's `.loki/memory/` directory.
+        task_id: Override the task id. Default: `claude-session-<8-char>`
+            from the transcript's `sessionId` field or filename.
+        agent: Stamped on the episode. Default "claude-code".
+        phase: Stamped on the episode. Default "INTERACTIVE".
+        outcome: Stamped on the episode. Default "success".
+
+    Returns:
+        Path to the written episode JSON on success; None on failure
+        (silent fail, error logged to `.errors.log`).
+    """
+    if _capture_disabled():
+        return None
+    try:
+        path = Path(transcript_path)
+        if not path.is_file():
+            return None
+        # v7.7.18 council fix (Opus 2): cap transcript file size at 50 MB
+        # so a runaway transcript cannot OOM the ingester. Long sessions
+        # are rare; 50 MB is ~100k tool_use entries which is plenty.
+        try:
+            file_size = path.stat().st_size
+            if file_size > 50 * 1024 * 1024:
+                _log_to_errors(
+                    memory_base,
+                    "ingest_from_claude_transcript",
+                    RuntimeError(
+                        f"transcript too large ({file_size} bytes); skipping ingest"
+                    ),
+                )
+                return None
+        except OSError:
+            pass
+        entries: List[Dict[str, Any]] = []
+        # Also cap entry count at 50k to bound memory regardless of file size.
+        MAX_ENTRIES = 50_000
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            for line in f:
+                obj = _parse_transcript_line(line.strip())
+                if obj is not None:
+                    entries.append(obj)
+                    if len(entries) >= MAX_ENTRIES:
+                        break
+        if not entries:
+            return None
+
+        tool_uses = _extract_tool_uses(entries)
+        files_read, files_modified = _extract_files(tool_uses)
+        start_ts, end_ts = _derive_timestamps(entries)
+        goal = _derive_goal(entries)
+        duration = 0
+        if start_ts and end_ts:
+            duration = max(0, int((end_ts - start_ts).total_seconds()))
+
+        # Derive task_id from transcript metadata or filename
+        if task_id is None:
+            session_id = None
+            for entry in entries:
+                sid = entry.get("sessionId") or entry.get("session_id")
+                if sid:
+                    session_id = str(sid)
+                    break
+            if not session_id:
+                session_id = path.stem
+            task_id = f"claude-session-{session_id[:12]}"
+
+        # Lazy imports
+        from memory.engine import MemoryEngine, create_storage
+        from memory.schemas import EpisodeTrace
+
+        storage = create_storage(memory_base)
+        engine = MemoryEngine(storage=storage, base_path=memory_base)
+        engine.initialize()
+
+        trace = EpisodeTrace.create(
+            task_id=task_id,
+            agent=agent,
+            phase=phase,
+            goal=goal,
+        )
+        trace.outcome = outcome
+        trace.duration_seconds = duration
+        # v7.7.18 council fix: apply BOTH scrubbers to file paths --
+        # _scrub catches inline credentials, _scrub_path catches sensitive
+        # paths the whitespace tokenizer misses (~/.aws/, .env, etc.).
+        trace.files_read = [_scrub_path(_scrub(p)) for p in files_read]
+        trace.files_modified = [_scrub_path(_scrub(p)) for p in files_modified]
+        trace.action_log = _build_action_log(tool_uses, start_ts)
+
+        engine.store_episode(trace)
+        # storage.py:439-442 writes to episodic/<date>/task-<id>.json.
+        # Reconstruct that path here so the caller gets the real file.
+        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        return str(Path(memory_base) / "episodic" / date_str / f"task-{trace.id}.json")
+    except Exception as e:
+        _log_to_errors(memory_base, "ingest_from_claude_transcript", e)
+        return None
+
+
+def ingest_from_summary(
+    memory_base: str,
+    *,
+    goal: str,
+    outcome: str = "success",
+    files_modified: Optional[List[str]] = None,
+    files_read: Optional[List[str]] = None,
+    tool_calls_summary: Optional[str] = None,
+    task_id: Optional[str] = None,
+    agent: str = "claude-code-mcp",
+    phase: str = "INTERACTIVE",
+    duration_seconds: int = 0,
+) -> Optional[str]:
+    """Build an Episode from explicit summary fields.
+
+    Called by the MCP capture tool when the agent voluntarily reports
+    iteration close. Pre-validated inputs; minimal heuristics.
+
+    Returns episode path on success, None on failure.
+    """
+    if _capture_disabled():
+        return None
+    try:
+        from memory.engine import MemoryEngine, create_storage
+        from memory.schemas import EpisodeTrace, ActionEntry
+
+        storage = create_storage(memory_base)
+        engine = MemoryEngine(storage=storage, base_path=memory_base)
+        engine.initialize()
+
+        if task_id is None:
+            ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S")
+            task_id = f"mcp-capture-{ts}"
+
+        trace = EpisodeTrace.create(
+            task_id=task_id,
+            agent=agent,
+            phase=phase,
+            goal=_scrub(goal)[:500],
+        )
+        trace.outcome = outcome if outcome in ("success", "failure", "partial") else "success"
+        trace.duration_seconds = max(0, int(duration_seconds))
+        trace.files_read = [_scrub_path(_scrub(p)) for p in (files_read or [])]
+        trace.files_modified = [_scrub_path(_scrub(p)) for p in (files_modified or [])]
+        if tool_calls_summary:
+            trace.action_log = [ActionEntry(
+                tool="mcp-summary",
+                input=_scrub(tool_calls_summary)[:1000],
+                output="",
+                timestamp=0,
+            )]
+        engine.store_episode(trace)
+        # storage.py:439-442 writes to episodic/<date>/task-<id>.json.
+        # Reconstruct that path here so the caller gets the real file.
+        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        return str(Path(memory_base) / "episodic" / date_str / f"task-{trace.id}.json")
+    except Exception as e:
+        _log_to_errors(memory_base, "ingest_from_summary", e)
+        return None

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "7.7.17",
+  "version": "7.7.18",
   "description": "Loki Mode by Autonomi. Multi-agent autonomous SDLC framework. Spec to deployed app: PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief. 4 AI providers (Claude Code, OpenAI Codex, Cline, Aider). 11 quality gates.",
   "keywords": [
     "agent",