methodproof 0.8.0__tar.gz → 0.8.2__tar.gz

{methodproof-0.8.0 → methodproof-0.8.2}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.8.1] — 2026-04-17
+
+### Added
+- **File rename detection** — watcher `on_moved` handler emits `file_rename` atoms with `old_path`/`new_path` instead of producing two incorrect atoms (delete + create).
+- **`git_branch_switch` event** — git poller reads `.git/HEAD` on each 2s cycle and emits `git_branch_switch` with `old_branch`/`new_branch` when the active branch changes.
+- **`git_commit` branch name** — commits now carry a `branch` field read from `.git/HEAD`.
+- **`git_commit` per-file change status** — `files_changed` is now accompanied by `file_statuses` (`{path: "A"|"M"|"D"|"R"}`) via `--name-status` instead of `--name-only`.
+- **11 new test frameworks** — detection and result parsing for vitest, mocha, rspec, minitest, phpunit, unittest, dotnet test, swift test, gradle test, maven test, and ExUnit (total: 15).
+- **`test_run` carries `cwd`** — forwarded from the shell hook JSONL instead of being discarded.
+- **`is_journal_mode()` public API** — exposed on `agents.base` for agents making structural-vs-full content capture decisions.
+
+### Fixed
+- **15 hook event types bypassed consent gates** — `claude_session_end`, `agent_turn_end`, `agent_turn_error`, `context_compact_start/end`, `permission_request/denied`, `mcp_elicitation/result`, `worktree_create/remove`, `cwd_changed`, `tool_failure`, plus new `file_rename` and `git_branch_switch` — all now properly gated in `_EVENT_GATES`.
+- **Removed all arbitrary data truncation** — no more 50KB diff cap, 2000-line hunk cap, 2000-char commit body cap, 500-char terminal output cap, or 200-char error cap. The CLI captures faithfully; downstream consumers decide what to do with large payloads. Preview fields (derived summaries alongside raw data) are unchanged.
+
+### Changed
+- **TUI inline detail screen** — `mp log` enter key opens a full-screen `DetailScreen` with event mix breakdown and per-type timeline instead of exiting to an external viewer.
+- **SHOMEN/KINMYAKU theme toggle** — `MP_THEME=shomen` selects the light theme; default remains `kinmyaku` (dark). `Theme` dataclass adds `accent`, `cursor_bg`, `cursor_fg` semantic roles. DataTable cursor CSS for both themes.
+
 ## [0.8.0] — 2026-04-15
 
 ### Added

{methodproof-0.8.0 → methodproof-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.8.0
+Version: 0.8.2
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE

{methodproof-0.8.0 → methodproof-0.8.2}/methodproof/__init__.py

@@ -1,3 +1,3 @@
 """MethodProof — see how you code."""
 
-__version__ = "0.7.21"
+__version__ = "0.8.1"

{methodproof-0.8.0 → methodproof-0.8.2}/methodproof/agents/base.py

@@ -68,6 +68,24 @@ _EVENT_GATES: dict[str, str] = {
     "gemini_session_end": "ai_responses",
     "kiro_session_start": "ai_prompts",
     "kiro_session_end": "ai_responses",
+    # Hook lifecycle events (continued)
+    "claude_session_end": "ai_responses",
+    "agent_turn_end": "ai_responses",
+    "agent_turn_error": "ai_responses",
+    "context_compact_start": "ai_responses",
+    "context_compact_end": "ai_responses",
+    "permission_request": "ai_responses",
+    "permission_denied": "ai_responses",
+    "mcp_elicitation": "ai_responses",
+    "mcp_elicitation_result": "ai_responses",
+    "worktree_create": "ai_responses",
+    "worktree_remove": "ai_responses",
+    "cwd_changed": "ai_responses",
+    "tool_failure": "ai_responses",
+    # File system events
+    "file_rename": "file_changes",
+    # Git events
+    "git_branch_switch": "git_commits",
 }
 
 # Maps capture categories to (event_type, field) pairs for field-level gating.
@@ -142,6 +160,13 @@ def is_content_captured() -> bool:
     return bool(_capture.get("code_capture", False))
 
 
+def is_journal_mode() -> bool:
+    """True when journal_mode is enabled — full content capture (prompts,
+    completions, diffs, terminal output). Agents use this to decide whether
+    to include content fields that are stripped in structural-only mode."""
+    return _journal_mode
+
+
 def emit(event_type: str, metadata: dict[str, Any]) -> None:
     if not _initialized:
         log("warning", "emit.before_init", type=event_type)
@@ -226,6 +251,10 @@ def _stream_event(entry: dict[str, Any]) -> None:
         detail = f'{meta.get("path", "?")} ({meta.get("size", 0)}B)'
     elif etype == "file_delete":
         detail = meta.get("path", "?")
+    elif etype == "file_rename":
+        detail = f'{meta.get("old_path", "?")} → {meta.get("new_path", "?")}'
+    elif etype == "git_branch_switch":
+        detail = f'{meta.get("old_branch", "?")} → {meta.get("new_branch", "?")}'
     elif etype == "terminal_cmd":
         detail = f'{meta.get("command", "?")[:60]} → exit {meta.get("exit_code", "?")}'
     elif etype == "test_run":

{methodproof-0.8.0 → methodproof-0.8.2}/methodproof/agents/terminal.py

@@ -20,11 +20,27 @@ TEST_FRAMEWORKS = {
     "jest": re.compile(r"\bjest\b|npx jest|npm test"),
     "go_test": re.compile(r"\bgo test\b"),
     "cargo_test": re.compile(r"\bcargo test\b"),
+    "vitest": re.compile(r"\bvitest\b|npx vitest"),
+    "mocha": re.compile(r"\bmocha\b|npx mocha"),
+    "rspec": re.compile(r"\brspec\b|bundle exec rspec"),
+    "minitest": re.compile(r"\bruby\b.*test|rake test"),
+    "phpunit": re.compile(r"\bphpunit\b|vendor/bin/phpunit"),
+    "unittest": re.compile(r"python.*-m\s+unittest|python.*-m\s+nose"),
+    "dotnet_test": re.compile(r"\bdotnet test\b"),
+    "swift_test": re.compile(r"\bswift test\b"),
+    "gradle_test": re.compile(r"\bgradle\b.*\btest\b|gradlew.*\btest\b"),
+    "maven_test": re.compile(r"\bmvn\b.*\btest\b|mvnw.*\btest\b"),
+    "exunit": re.compile(r"\bmix test\b"),
 }
 
 _PYTEST_RE = re.compile(r"(\d+) passed(?:.*?(\d+) failed)?(?:.*?(\d+) skipped)?")
 _JEST_RE = re.compile(r"Tests:\s+(?:(\d+) failed,\s+)?(\d+) passed(?:,\s+(\d+) skipped)?")
 _CARGO_RE = re.compile(r"(\d+) passed.*?(\d+) failed")
+_VITEST_RE = re.compile(r"Tests\s+(\d+) passed(?:\s*\|\s*(\d+) failed)?(?:\s*\|\s*(\d+) skipped)?")
+_RSPEC_RE = re.compile(r"(\d+) examples?,\s*(\d+) failures?(?:,\s*(\d+) pending)?")
+_PHPUNIT_RE = re.compile(r"OK \((\d+) tests?|Tests:\s*(\d+).*?Failures:\s*(\d+)")
+_DOTNET_RE = re.compile(r"Passed!\s+-\s+Failed:\s+(\d+),\s+Passed:\s+(\d+),\s+Skipped:\s+(\d+)")
+_EXUNIT_RE = re.compile(r"(\d+) tests?,\s*(\d+) failures?(?:,\s*(\d+) excluded)?")
 
 
 def _detect_test(command: str) -> str | None:
@@ -40,9 +56,12 @@ def _parse_test_results(output: str, framework: str, exit_code: int) -> tuple[in
         m = _PYTEST_RE.search(output)
         if m:
             return int(m.group(1)), int(m.group(2) or 0), int(m.group(3) or 0)
-    elif framework == "jest":
-        m = _JEST_RE.search(output)
+    elif framework in ("jest", "vitest"):
+        pat = _VITEST_RE if framework == "vitest" else _JEST_RE
+        m = pat.search(output)
         if m:
+            if framework == "vitest":
+                return int(m.group(1) or 0), int(m.group(2) or 0), int(m.group(3) or 0)
             return int(m.group(2) or 0), int(m.group(1) or 0), int(m.group(3) or 0)
     elif framework == "go_test":
         return output.count("--- PASS"), output.count("--- FAIL"), output.count("--- SKIP")
@@ -50,6 +69,24 @@ def _parse_test_results(output: str, framework: str, exit_code: int) -> tuple[in
         m = _CARGO_RE.search(output)
         if m:
             return int(m.group(1)), int(m.group(2)), 0
+    elif framework == "rspec":
+        m = _RSPEC_RE.search(output)
+        if m:
+            return int(m.group(1)) - int(m.group(2)), int(m.group(2)), int(m.group(3) or 0)
+    elif framework == "phpunit":
+        m = _PHPUNIT_RE.search(output)
+        if m:
+            if m.group(1):
+                return int(m.group(1)), 0, 0
+            return int(m.group(2) or 0) - int(m.group(3) or 0), int(m.group(3) or 0), 0
+    elif framework == "dotnet_test":
+        m = _DOTNET_RE.search(output)
+        if m:
+            return int(m.group(2)), int(m.group(1)), int(m.group(3))
+    elif framework == "exunit":
+        m = _EXUNIT_RE.search(output)
+        if m:
+            return int(m.group(1)) - int(m.group(2)), int(m.group(2)), int(m.group(3) or 0)
     if exit_code == 0:
         return 1, 0, 0
     return 0, 1, 0
@@ -91,7 +128,7 @@ def _process(line: str) -> None:
         return
     exit_code = entry.get("exit_code", 0)
     duration = entry.get("duration_ms", 0)
-    output = entry.get("output", "")[:500]
+    output = entry.get("output", "")
     if SENSITIVE.search(output):
         output = "[redacted — contains sensitive content]"
     cwd = entry.get("cwd", "")
@@ -107,7 +144,10 @@ def _process(line: str) -> None:
     framework = _detect_test(command)
     if framework:
         passed, failed, skipped = _parse_test_results(output, framework, exit_code)
-        base.emit("test_run", {
+        test_meta: dict = {
             "framework": framework, "passed": passed, "failed": failed,
             "skipped": skipped, "duration_ms": duration,
-        })
+        }
+        if cwd:
+            test_meta["cwd"] = cwd
+        base.emit("test_run", test_meta)

{methodproof-0.8.0 → methodproof-0.8.2}/methodproof/agents/watcher.py

@@ -45,9 +45,6 @@ IGNORE_PATTERNS = re.compile(
 )
 
 
-_MAX_DIFF_BYTES = 50_000
-_MAX_HUNK_LINES = 2_000
-
 _HUNK_HEADER_RE = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
 _DIFF_FILE_RE = re.compile(r"^diff --git a/(.+?) b/(.+?)$")
 
@@ -60,7 +57,6 @@ def _parse_hunks(diff_text: str, include_lines: bool) -> list[dict[str, object]]
     """
     hunks: list[dict[str, object]] = []
     current: dict[str, object] | None = None
-    total_lines = 0
     for line in diff_text.splitlines():
         header = _HUNK_HEADER_RE.match(line)
         if header:
@@ -81,10 +77,7 @@ def _parse_hunks(diff_text: str, include_lines: bool) -> list[dict[str, object]]
             continue
         if line.startswith("+++") or line.startswith("---"):
             continue
-        if total_lines >= _MAX_HUNK_LINES:
-            continue
         current["lines"].append(line)  # type: ignore[union-attr]
-        total_lines += 1
     if current is not None:
         hunks.append(current)
     return hunks
@@ -122,7 +115,7 @@ def _git_diff_hunks(repo: str, path: str, include_lines: bool) -> list[dict[str,
             ["git", "-C", repo, "diff", "--unified=0", "--", path],
             capture_output=True, text=True, timeout=5,
         )
-        return _parse_hunks(result.stdout[:_MAX_DIFF_BYTES], include_lines)
+        return _parse_hunks(result.stdout, include_lines)
     except Exception:
         return []
 
@@ -136,7 +129,7 @@ def _git_show_file_hunks(
             ["git", "-C", repo, "show", "--format=", "--unified=0", sha],
             capture_output=True, text=True, timeout=10,
         )
-        return _parse_show_hunks(result.stdout[:_MAX_DIFF_BYTES * 4], include_lines)
+        return _parse_show_hunks(result.stdout, include_lines)
     except Exception:
         return {}
 
@@ -160,25 +153,25 @@ def _git_diff_stats(repo: str, path: str) -> tuple[int, int]:
 
 
 def _git_diff_content(repo: str, path: str) -> str:
-    """Get full diff content for a file, capped at 50KB."""
+    """Get full diff content for a file."""
     try:
         result = subprocess.run(
             ["git", "-C", repo, "diff", "--", path],
             capture_output=True, text=True, timeout=5,
         )
-        return result.stdout[:_MAX_DIFF_BYTES]
+        return result.stdout
     except Exception:
         return ""
 
 
 def _git_show_diff(repo: str, sha: str) -> str:
-    """Get full diff for a commit, capped at 50KB."""
+    """Get full diff for a commit."""
     try:
         result = subprocess.run(
             ["git", "-C", repo, "show", "--format=", sha],
             capture_output=True, text=True, timeout=10,
         )
-        return result.stdout[:_MAX_DIFF_BYTES]
+        return result.stdout
     except Exception:
         return ""
 
@@ -239,14 +232,44 @@ class _Handler(FileSystemEventHandler):
         lang = Path(event.src_path).suffix.lstrip(".")
         base.emit("file_delete", {"path": path, "language": lang})
 
+    def on_moved(self, event: FileSystemEvent) -> None:
+        if event.is_directory:
+            return
+        src = event.src_path
+        dest = getattr(event, "dest_path", "")
+        if IGNORE_PATTERNS.search(src) and IGNORE_PATTERNS.search(dest or src):
+            return
+        old_path = self._relpath(src)
+        new_path = self._relpath(dest) if dest else old_path
+        lang = Path(dest or src).suffix.lstrip(".")
+        old_hash = self._hashes.pop(old_path, None)
+        if old_hash:
+            self._hashes[new_path] = old_hash
+        base.emit("file_rename", {
+            "old_path": old_path, "new_path": new_path, "language": lang,
+        })
+
+
+def _read_branch(head_file: Path) -> str:
+    """Read current branch from .git/HEAD. Returns '' for detached HEAD."""
+    try:
+        content = head_file.read_text().strip()
+        if content.startswith("ref: refs/heads/"):
+            return content[16:]
+        return ""
+    except OSError:
+        return ""
+
 
 def _poll_git(watch_dir: str, stop: threading.Event) -> None:
-    """Poll .git/refs for new commits every 2 seconds."""
+    """Poll .git/refs for new commits and HEAD for branch switches."""
     git_dir = Path(watch_dir) / ".git"
     if not git_dir.exists():
         return
     seen: set[str] = set()
     refs = git_dir / "refs" / "heads"
+    head_file = git_dir / "HEAD"
+    last_branch = _read_branch(head_file)
     while not stop.is_set():
         try:
             for ref in refs.iterdir():
@@ -257,12 +280,17 @@ def _poll_git(watch_dir: str, stop: threading.Event) -> None:
                         _log_commit(watch_dir, sha)
         except OSError:
             pass
+        current_branch = _read_branch(head_file)
+        if current_branch and current_branch != last_branch and last_branch:
+            base.emit("git_branch_switch", {
+                "old_branch": last_branch, "new_branch": current_branch,
+            })
+        last_branch = current_branch
         stop.wait(2)
 
 
 def _log_commit(watch_dir: str, sha: str) -> None:
     try:
-        # Single git call: subject\x00author\x00email\x00iso_date\x00parent_hash\x00full_body
         fmt = subprocess.run(
             ["git", "-C", watch_dir, "log", "-1",
              "--format=%s%x00%an%x00%ae%x00%ai%x00%P%x00%B", sha],
@@ -275,12 +303,22 @@ def _log_commit(watch_dir: str, sha: str) -> None:
         committed_at = parts[3].strip() if len(parts) > 3 else ""
         parent_hash = parts[4].strip()[:7] if len(parts) > 4 else ""
         body = parts[5].strip() if len(parts) > 5 else ""
-        files = subprocess.run(
-            ["git", "-C", watch_dir, "diff-tree", "--no-commit-id", "-r", "--name-only", sha],
+        status_lines = subprocess.run(
+            ["git", "-C", watch_dir, "diff-tree", "--no-commit-id", "-r", "--name-status", sha],
             capture_output=True, text=True, timeout=5,
         ).stdout.strip().splitlines()
+        files: list[str] = []
+        file_statuses: dict[str, str] = {}
+        for sl in status_lines:
+            sl_parts = sl.split("\t", 1)
+            if len(sl_parts) == 2:
+                file_statuses[sl_parts[1]] = sl_parts[0]
+                files.append(sl_parts[1])
+            elif sl.strip():
+                files.append(sl.strip())
     except Exception:
-        subject, author, author_email, committed_at, parent_hash, body, files = "", "", "", "", "", "", []
+        subject, author, author_email, committed_at, parent_hash, body = "", "", "", "", "", ""
+        files, file_statuses = [], {}
     meta: dict[str, object] = {
         "hash": sha[:7], "message": subject, "files_changed": files,
         "author": author, "author_email": author_email, "committed_at": committed_at,
@@ -288,7 +326,12 @@ def _log_commit(watch_dir: str, sha: str) -> None:
     if parent_hash:
         meta["parent_hash"] = parent_hash
     if body and body != subject:
-        meta["body"] = body[:2000]
+        meta["body"] = body
+    if file_statuses:
+        meta["file_statuses"] = file_statuses
+    branch = _read_branch(Path(watch_dir) / ".git" / "HEAD")
+    if branch:
+        meta["branch"] = branch
     include_lines = base.is_content_captured()
     file_hunks = _git_show_file_hunks(watch_dir, sha, include_lines)
     if file_hunks:

{methodproof-0.8.0 → methodproof-0.8.2}/methodproof/cli.py

@@ -1577,8 +1577,6 @@ def cmd_log(args: argparse.Namespace) -> None:
             fake = _ap.Namespace(session_id=sid, local=False)
             if action == "push":
                 cmd_push(fake)
-            elif action == "view":
-                cmd_view(fake)
         return
     sessions = store.list_sessions()
     if not sessions:

{methodproof-0.8.0 → methodproof-0.8.2}/methodproof/graph.py

@@ -36,20 +36,19 @@ def build(session_id: str) -> dict[str, int]:
     db.execute(
         "DELETE FROM causal_links WHERE source_id IN "
         "(SELECT id FROM events WHERE session_id = ?)", (session_id,))
-    stats["causal"] += _link(db, session_id, "llm_prompt", "llm_completion",
-                              "RECEIVED", 60, match_model=True)
-    stats["causal"] += _link(db, session_id, "llm_completion", "file_edit",
-                              "INFORMED", 60)
-    stats["causal"] += _link(db, session_id, "web_search", "web_visit",
-                              "LED_TO", 120)
-    stats["causal"] += _link(db, session_id, "browser_search", "browser_visit",
-                              "LED_TO", 120)
+    stats["causal"] += _link_nearest(db, session_id, "llm_prompt",
+                                      "llm_completion", "RECEIVED", "model")
+    stats["causal"] += _link_until_next(db, session_id, "llm_completion",
+                                         "file_edit", "INFORMED")
+    stats["causal"] += _link_until_next(db, session_id, "web_search",
+                                         "web_visit", "LED_TO")
+    stats["causal"] += _link_until_next(db, session_id, "browser_search",
+                                         "browser_visit", "LED_TO")
     stats["causal"] += _link_pasted(db, session_id)
-    # Agent causal links (OpenClaw / agent gateways)
-    stats["causal"] += _link(db, session_id, "agent_prompt", "agent_completion",
-                              "RECEIVED", 120, match_model=True)
-    stats["causal"] += _link(db, session_id, "agent_completion", "file_edit",
-                              "INFORMED", 60)
+    stats["causal"] += _link_nearest(db, session_id, "agent_prompt",
+                                      "agent_completion", "RECEIVED", "model")
+    stats["causal"] += _link_until_next(db, session_id, "agent_completion",
+                                         "file_edit", "INFORMED")
 
     # Resources
     for e in events:
@@ -95,39 +94,87 @@ def build(session_id: str) -> dict[str, int]:
     return stats
 
 
-def _link(
+def _link_nearest(
     db: object, sid: str, src_type: str, tgt_type: str,
-    rel: str, window_sec: int, match_model: bool = False,
+    rel: str, match_field: str | None = None,
 ) -> int:
-    model_clause = (
-        "AND json_extract(mp_json(s.metadata), '$.model') = json_extract(mp_json(t.metadata), '$.model')"
-        if match_model else ""
-    )
-    sql = f"""
-    INSERT OR IGNORE INTO causal_links (source_id, target_id, type)
-    SELECT s.id, t.id, ?
-    FROM events s JOIN events t ON t.session_id = s.session_id
-    WHERE s.session_id = ? AND s.type = ? AND t.type = ?
-      AND t.timestamp > s.timestamp
-      AND (t.timestamp - s.timestamp) <= ?
-      {model_clause}
-    """
-    return db.execute(sql, (rel, sid, src_type, tgt_type, window_sec)).rowcount
+    """1:1 nearest-neighbor pairing. No time window."""
+    rows = db.execute(
+        "SELECT id, type, timestamp, metadata FROM events "
+        "WHERE session_id = ? AND type IN (?, ?) ORDER BY timestamp",
+        (sid, src_type, tgt_type),
+    ).fetchall()
+    claimed: set[str] = set()
+    pairs: list[tuple[str, str, str]] = []
+    for src in rows:
+        if src["type"] != src_type:
+            continue
+        src_val = _decompress_meta(src["metadata"]).get(match_field) if match_field else None
+        for tgt in rows:
+            if tgt["type"] != tgt_type or tgt["id"] in claimed or tgt["timestamp"] <= src["timestamp"]:
+                continue
+            if match_field and _decompress_meta(tgt["metadata"]).get(match_field) != src_val:
+                continue
+            pairs.append((src["id"], tgt["id"], rel))
+            claimed.add(tgt["id"])
+            break
+    if pairs:
+        db.executemany(
+            "INSERT OR IGNORE INTO causal_links (source_id, target_id, type) "
+            "VALUES (?, ?, ?)", pairs)
+    return len(pairs)
+
+
+def _link_until_next(
+    db: object, sid: str, src_type: str, tgt_type: str, rel: str,
+) -> int:
+    """Link source to all targets until the next source event."""
+    rows = db.execute(
+        "SELECT id, type FROM events "
+        "WHERE session_id = ? AND type IN (?, ?) ORDER BY timestamp",
+        (sid, src_type, tgt_type),
+    ).fetchall()
+    pairs: list[tuple[str, str, str]] = []
+    current_src: str | None = None
+    for ev in rows:
+        if ev["type"] == src_type:
+            current_src = ev["id"]
+        elif current_src:
+            pairs.append((current_src, ev["id"], rel))
+    if pairs:
+        db.executemany(
+            "INSERT OR IGNORE INTO causal_links (source_id, target_id, type) "
+            "VALUES (?, ?, ?)", pairs)
+    return len(pairs)
 
 
 def _link_pasted(db: object, sid: str) -> int:
-    """browser_copy → file_edit: ≤30s, content length within 20%."""
-    sql = """
-    INSERT OR IGNORE INTO causal_links (source_id, target_id, type, confidence)
-    SELECT s.id, t.id, 'PASTED_FROM', 0.7
-    FROM events s JOIN events t ON t.session_id = s.session_id
-    WHERE s.session_id = ? AND s.type = 'browser_copy' AND t.type = 'file_edit'
-      AND t.timestamp > s.timestamp AND (t.timestamp - s.timestamp) <= 30
-      AND abs(json_extract(mp_json(t.metadata), '$.lines_added') * 40.0
-            - json_extract(mp_json(s.metadata), '$.text_length'))
-          < json_extract(mp_json(s.metadata), '$.text_length') * 0.2
-    """
-    return db.execute(sql, (sid,)).rowcount
+    """browser_copy → nearest file_edit with content length within 20%."""
+    rows = db.execute(
+        "SELECT id, type, timestamp, metadata FROM events "
+        "WHERE session_id = ? AND type IN ('browser_copy', 'file_edit') "
+        "ORDER BY timestamp", (sid,),
+    ).fetchall()
+    claimed: set[str] = set()
+    pairs: list[tuple[str, str]] = []
+    for src in rows:
+        if src["type"] != "browser_copy":
+            continue
+        src_len = _decompress_meta(src["metadata"]).get("text_length", 0)
+        if not src_len:
+            continue
+        for tgt in rows:
+            if tgt["type"] != "file_edit" or tgt["id"] in claimed or tgt["timestamp"] <= src["timestamp"]:
+                continue
+            if abs(_decompress_meta(tgt["metadata"]).get("lines_added", 0) * 40 - src_len) < src_len * 0.2:
+                pairs.append((src["id"], tgt["id"]))
+                claimed.add(tgt["id"])
+                break
+    if pairs:
+        db.executemany(
+            "INSERT OR IGNORE INTO causal_links (source_id, target_id, type, confidence) "
+            "VALUES (?, ?, 'PASTED_FROM', 0.7)", pairs)
+    return len(pairs)
 
 
 def _link_action_resources(db: object, sid: str) -> None:

{methodproof-0.8.0 → methodproof-0.8.2}/methodproof/hooks/claude_code.py

@@ -76,6 +76,8 @@ _TYPE_MAP = {
     # Worktree
     "WorktreeCreate": "worktree_create",
     "WorktreeRemove": "worktree_remove",
+    # Notifications
+    "Notification": "notification",
 }
 
 _TOOL = "claude_code"
@@ -113,20 +115,19 @@ _META_EXTRACTORS = {
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"),
         "success": False, "is_interrupt": d.get("is_interrupt", False),
         "tool_input": d.get("tool_input") or {},
-        "error": str(d.get("error", ""))[:200],
+        "error": d.get("error", ""),
     },
     "SubagentStart": lambda d: {"tool": _TOOL, "agent_type": d.get("agent_type", "unknown"), "agent_id": d.get("agent_id", "")},
     "SubagentStop": lambda d: {
         "tool": _TOOL, "agent_type": d.get("agent_type", "unknown"), "agent_id": d.get("agent_id", ""),
         "last_assistant_message": d.get("last_assistant_message", ""),
-        "last_message_preview": str(d.get("last_assistant_message", ""))[:200],
     },
     "TaskCreated": lambda d: {"tool": _TOOL, "task_id": d.get("task_id", ""), "subject": d.get("task_subject", "")},
     "TaskCompleted": lambda d: {"tool": _TOOL, "task_id": d.get("task_id", "")},
     "SessionStart": lambda d: {"tool": _TOOL, "session_id": d.get("session_id", ""), "cwd": d.get("cwd", "")},
     "SessionEnd": lambda d: {"tool": _TOOL, "session_id": d.get("session_id", "")},
     "Stop": lambda d: {"tool": _TOOL},
-    "StopFailure": lambda d: {"tool": _TOOL, "error": str(d.get("error", ""))[:200]},
+    "StopFailure": lambda d: {"tool": _TOOL, "error": d.get("error", "")},
     "CwdChanged": lambda d: {
         "tool": _TOOL, "cwd": d.get("cwd", ""),
         # NOTE: fires for both human `cd` and Claude tool use — caller is ambiguous
@@ -140,6 +141,12 @@ _META_EXTRACTORS = {
     "ElicitationResult": lambda d: {"tool": _TOOL},
     "WorktreeCreate": lambda d: {"tool": _TOOL, "worktree_path": d.get("worktree_path", "")},
     "WorktreeRemove": lambda d: {"tool": _TOOL, "worktree_path": d.get("worktree_path", "")},
+    "Notification": lambda d: {
+        "tool": _TOOL,
+        "title": d.get("title", ""),
+        "message": d.get("message", d.get("text", ""))[:1000],
+        "notification_type": d.get("type", d.get("notification_type", "")),
+    },
 }
 
 

{methodproof-0.8.0 → methodproof-0.8.2}/methodproof/hooks/claude_code.sh

@@ -162,6 +162,10 @@ if command -v jq >/dev/null 2>&1; then
       TYPE=$(echo "$EVENT" | sed 's/Elicitation$/mcp_elicitation/;s/ElicitationResult/mcp_elicitation_result/')
       META='{"tool":"claude_code"}'
       ;;
+    Notification)
+      TYPE="notification"
+      META=$(echo "$INPUT" | jq -c '{tool: "claude_code", title: (.title // ""), message: ((.message // .text // "")[:1000]), notification_type: (.type // .notification_type // "")}' 2>/dev/null || echo '{"tool":"claude_code"}')
+      ;;
     *)
       TYPE="claude_code_event"
       META="{\"event\":\"$EVENT\"}"

{methodproof-0.8.0 → methodproof-0.8.2}/methodproof/hooks/install.py

@@ -38,6 +38,7 @@ HOOK_EVENTS = [
     "ElicitationResult",         # user responded to MCP
     "WorktreeCreate",            # git worktree created (parallel agent)
     "WorktreeRemove",            # git worktree removed
+    "Notification",              # system notifications (recap, compaction summary, etc.)
 ]
 
 # --- Codex CLI ---