methodproof 0.7.36__tar.gz → 0.7.38__tar.gz

{methodproof-0.7.36 → methodproof-0.7.38}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.7.38] — 2026-04-12
+
+### Added
+- **Structural hunk capture on `file_edit` and `git_commit`** — watcher parses `@@ -old,count +new,count @@` headers from `git diff --unified=0` and `git show --format= --unified=0 <sha>` and emits them as `hunks: [{old_start, old_count, new_start, new_count}, ...]` on `file_edit` metadata and `file_hunks: {path: [hunks, ...]}` on `git_commit` metadata. Pure range data — no code content, no identifiers. Stays inside the structural-capture boundary alongside `lines_added` / `lines_removed`.
+- **Journal-mode hunk content** — when `code_capture` consent is on (Pro tier, journal mode), each hunk additionally carries a `lines: ["+foo", "-bar", ...]` field with the actual diff lines for that hunk, capped at 2000 lines per event. Gated by the same consent flag that gates the raw `diff` field.
+- **`base.is_content_captured()`** — public helper in `methodproof/agents/base.py` exposing the `code_capture` capture-flag check so agents can decide what content to include without reaching into private module state.
+
+### Why
+Enables the platform's post-processing pipeline to distinguish `SUPERSEDES` (later commit replaces 100% of an earlier commit's added lines on each shared path) from `EXTENSION_TO` (anything less — the default) without ever needing the raw diff content. See `methodproof` changelog v0.6.30.
+
+## [0.7.37] — 2026-04-12
+
+### Changed
+- **Full tool metadata capture** — shell hook now stores complete `tool_input` and `tool_response` objects alongside display previews. Previously only extracted preview strings; raw data was discarded. Enables upstream graph analysis, causal edge building, and artifact tracking from tool events.
+- **Enriched shell hook** — `PreToolUse` captures `tool_input_preview` per tool type (Bash→command, Read/Edit/Write→file_path, Grep→pattern+path, Glob→pattern, Agent→description). `PostToolUse` captures `result_preview` (Bash→stdout/stderr, Read→line count, Grep→file+line count, Glob→file count) plus `tool_input_preview` so results show what was done.
+- **Journal gating removed** — all captured metadata is now persisted regardless of journal mode. No more field stripping in `emit()`. `JOURNAL_CONTENT_FIELDS` retained as a reference for TUI enrichment display.
+- **`tool_result` TUI shows input + result** — e.g. `Grep ✓ def main /src 3 files, 15 lines` instead of just `Grep ✓`.
+
 ## [0.7.36] — 2026-04-12
 
 ### Added

{methodproof-0.7.36 → methodproof-0.7.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.7.36
+Version: 0.7.38
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -88,9 +88,10 @@ methodproof view      # explore your session in the browser
 | `enter` | Event detail | Modal overlay with all metadata fields |
 | `m` | Quiet mode | Hide dim events (music, environment, MCP, context compaction) |
 | `p` | Pause | Pause/resume event polling |
-| `q` | Stop | Stop the session |
+| `q` | Exit TUI | Detach — daemon keeps recording. Reconnect with `mp connect` |
+| `x` | End session | Stop recording with confirmation prompt |
 
-Active modes display as badges in the session bar: `J` (journal), `⏸` (scroll locked), `Q` (quiet), `T` (tree collapsed), filter name when not "all".
+Active modes display as badges in the session bar: `J` (journal), `⏸` (scroll locked), `Q` (quiet), `T` (tree collapsed), filter name when not "all". Source tracking shows which AI tool session (`claude #1`, `codex #2`) generated each event.
 
 ## Security Architecture
 
@@ -178,8 +179,9 @@ flowchart TB
 | Command | What it does |
 |---------|-------------|
 | `init` | Interactive consent selector, install hooks, create data directory |
-| `start [--dir .] [--tags t1,t2] [--public] [--live] [--journal] [--e2e]` | Start recording |
+| `start [--dir .] [--tags t1,t2] [--public] [--live] [--journal] [--e2e]` | Start recording (auto-connects if session already active) |
 | `stop` | Stop recording, build process graph |
+| `connect [session_id]` | Attach TUI to an active session (defaults to current) |
 | `view [session_id]` | Open session graph in browser |
 | `log` | List sessions with sync status, visibility, tags |
 | `login [--api-url URL]` | Authenticate with the platform |

{methodproof-0.7.36 → methodproof-0.7.38}/README.md

@@ -71,9 +71,10 @@ methodproof view      # explore your session in the browser
 | `enter` | Event detail | Modal overlay with all metadata fields |
 | `m` | Quiet mode | Hide dim events (music, environment, MCP, context compaction) |
 | `p` | Pause | Pause/resume event polling |
-| `q` | Stop | Stop the session |
+| `q` | Exit TUI | Detach — daemon keeps recording. Reconnect with `mp connect` |
+| `x` | End session | Stop recording with confirmation prompt |
 
-Active modes display as badges in the session bar: `J` (journal), `⏸` (scroll locked), `Q` (quiet), `T` (tree collapsed), filter name when not "all".
+Active modes display as badges in the session bar: `J` (journal), `⏸` (scroll locked), `Q` (quiet), `T` (tree collapsed), filter name when not "all". Source tracking shows which AI tool session (`claude #1`, `codex #2`) generated each event.
 
 ## Security Architecture
 
@@ -161,8 +162,9 @@ flowchart TB
 | Command | What it does |
 |---------|-------------|
 | `init` | Interactive consent selector, install hooks, create data directory |
-| `start [--dir .] [--tags t1,t2] [--public] [--live] [--journal] [--e2e]` | Start recording |
+| `start [--dir .] [--tags t1,t2] [--public] [--live] [--journal] [--e2e]` | Start recording (auto-connects if session already active) |
 | `stop` | Stop recording, build process graph |
+| `connect [session_id]` | Attach TUI to an active session (defaults to current) |
 | `view [session_id]` | Open session graph in browser |
 | `log` | List sessions with sync status, visibility, tags |
 | `login [--api-url URL]` | Authenticate with the platform |

{methodproof-0.7.36 → methodproof-0.7.38}/methodproof/agents/base.py

@@ -125,6 +125,13 @@ def log(level: str, event: str, **kw: object) -> None:
     sys.stderr.write(json.dumps(entry, default=str) + "\n")
 
 
+def is_content_captured() -> bool:
+    """True when code_capture consent is on (journal/Pro mode). Agents use this
+    to decide whether to include line-level diff content alongside structural
+    metadata."""
+    return bool(_capture.get("code_capture", False))
+
+
 def emit(event_type: str, metadata: dict[str, Any]) -> None:
     if not _initialized:
         log("warning", "emit.before_init", type=event_type)
@@ -140,15 +147,6 @@ def emit(event_type: str, metadata: dict[str, Any]) -> None:
             if event_type == etype and not _capture.get(category, True):
                 metadata.pop(field, None)
 
-    # Journal mode gate — strip content fields when journal is OFF (default).
-    # Structural equivalents (prompt_length, etc.) are always kept.
-    # Journal ON = complete explicit record. Journal OFF = structural only.
-    if not _journal_mode:
-        from methodproof.config import JOURNAL_CONTENT_FIELDS
-        for etype, field in JOURNAL_CONTENT_FIELDS:
-            if event_type == etype and field in metadata:
-                metadata.pop(field, None)
-
     entry = {
         "id": uuid.uuid4().hex,
         "session_id": _session_id,

{methodproof-0.7.36 → methodproof-0.7.38}/methodproof/agents/watcher.py

@@ -46,6 +46,99 @@ 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/(.+?)$")
+
+
+def _parse_hunks(diff_text: str, include_lines: bool) -> list[dict[str, object]]:
+    """Parse unified diff text into structured hunks.
+
+    Each hunk: {old_start, old_count, new_start, new_count, [lines]}.
+    Lines are only included when `include_lines` is True (journal / code_capture).
+    """
+    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:
+            if current is not None:
+                hunks.append(current)
+            current = {
+                "old_start": int(header.group(1)),
+                "old_count": int(header.group(2) or 1),
+                "new_start": int(header.group(3)),
+                "new_count": int(header.group(4) or 1),
+            }
+            if include_lines:
+                current["lines"] = []
+            continue
+        if current is None or not include_lines:
+            continue
+        if not (line.startswith("+") or line.startswith("-")):
+            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
+
+
+def _parse_show_hunks(
+    show_text: str, include_lines: bool,
+) -> dict[str, list[dict[str, object]]]:
+    """Split `git show --unified=0` output by file and parse hunks per file."""
+    file_hunks: dict[str, list[dict[str, object]]] = {}
+    current_path: str | None = None
+    buffer: list[str] = []
+
+    def _flush() -> None:
+        if current_path and buffer:
+            file_hunks[current_path] = _parse_hunks("\n".join(buffer), include_lines)
+
+    for line in show_text.splitlines():
+        m = _DIFF_FILE_RE.match(line)
+        if m:
+            _flush()
+            current_path = m.group(2)
+            buffer = []
+            continue
+        if current_path is not None:
+            buffer.append(line)
+    _flush()
+    return file_hunks
+
+
+def _git_diff_hunks(repo: str, path: str, include_lines: bool) -> list[dict[str, object]]:
+    """Structured hunks for a pending file_edit. Ranges always; line content when allowed."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", repo, "diff", "--unified=0", "--", path],
+            capture_output=True, text=True, timeout=5,
+        )
+        return _parse_hunks(result.stdout[:_MAX_DIFF_BYTES], include_lines)
+    except Exception:
+        return []
+
+
+def _git_show_file_hunks(
+    repo: str, sha: str, include_lines: bool,
+) -> dict[str, list[dict[str, object]]]:
+    """Per-file structured hunks for a commit."""
+    try:
+        result = subprocess.run(
+            ["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)
+    except Exception:
+        return {}
 
 
 def _git_diff_stats(repo: str, path: str) -> tuple[int, int]:
@@ -125,10 +218,14 @@ class _Handler(FileSystemEventHandler):
 
         added, removed = _git_diff_stats(self._root, path)
         lang = Path(event.src_path).suffix.lstrip(".")
+        include_lines = base.is_content_captured()
+        hunks = _git_diff_hunks(self._root, path, include_lines)
         meta: dict[str, object] = {
             "path": path, "language": lang,
             "lines_added": added, "lines_removed": removed,
         }
+        if hunks:
+            meta["hunks"] = hunks
         diff = _git_diff_content(self._root, path)
         if diff:
             meta["diff"] = diff
@@ -192,6 +289,10 @@ def _log_commit(watch_dir: str, sha: str) -> None:
         meta["parent_hash"] = parent_hash
     if body and body != subject:
         meta["body"] = body[:2000]
+    include_lines = base.is_content_captured()
+    file_hunks = _git_show_file_hunks(watch_dir, sha, include_lines)
+    if file_hunks:
+        meta["file_hunks"] = file_hunks
     diff = _git_show_diff(watch_dir, sha)
     if diff:
         meta["diff"] = diff

{methodproof-0.7.36 → methodproof-0.7.38}/methodproof/config.py

@@ -79,47 +79,37 @@ CAPTURE_DESCRIPTIONS: dict[str, str] = {
     "code_capture": "Full file diffs and git patches (Pro only, encrypted, private by default)",
 }
 
-# Content fields that Journal Mode unlocks. When journal_mode is OFF (default),
-# these fields are stripped — only structural equivalents remain (lengths, counts, types).
-# When journal_mode is ON (Pro+), EVERYTHING is persisted and encrypted.
-# Journal = the complete, explicit record of the session.
+# Journal content fields — no longer gated. All captured metadata is persisted.
+# This list is retained as a reference for the TUI journal enrichment layer,
+# which uses it to identify fields worth displaying as secondary content lines.
 JOURNAL_CONTENT_FIELDS: list[tuple[str, str]] = [
-    # AI prompts — full prompt text
     ("llm_prompt", "prompt_text"),
     ("agent_prompt", "prompt_preview"),
-    # AI responses — full completion text
     ("llm_completion", "response_text"),
     ("agent_completion", "response_preview"),
     ("agent_tool_dispatch", "tool_input_preview"),
     ("agent_tool_result", "result_preview"),
     ("agent_skill_invoke", "skill_input_preview"),
-    # Terminal — full command output (command itself is structural, not gated)
     ("terminal_cmd", "output_snippet"),
-    # Code — full diffs and commit messages
     ("file_edit", "diff"),
     ("git_commit", "diff"),
     ("git_commit", "message"),
-    # Web — full search queries, URLs, page titles
+    ("git_commit", "body"),
     ("web_search", "query"),
     ("web_search", "clicked_results"),
     ("web_visit", "url"),
     ("web_visit", "title"),
-    # Browser — full search queries, URLs, copy content, AI chat input
     ("browser_search", "query"),
     ("browser_visit", "url"),
     ("browser_visit", "title"),
     ("browser_copy", "text_snippet"),
     ("browser_ai_chat", "detected_input"),
     ("browser_ai_chat", "url"),
-    # Tasks — subject reveals intent
     ("task_created", "subject"),
-    # Claude Code hooks — tool input/output and raw user prompt
     ("user_prompt", "prompt_text"),
     ("tool_call", "tool_input_preview"),
     ("tool_result", "result_preview"),
-    # Agent final message and commit body reveal content
     ("agent_complete", "last_message_preview"),
-    ("git_commit", "body"),
 ]
 
 

{methodproof-0.7.36 → methodproof-0.7.38}/methodproof/hooks/claude_code.py

@@ -99,20 +99,26 @@ _META_EXTRACTORS = {
     },
     "PreToolUse": lambda d: {
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"),
+        "tool_input": d.get("tool_input") or {},
         "tool_input_preview": _tool_input_preview(d),
     },
     "PostToolUse": lambda d: {
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"), "success": True,
+        "tool_input": d.get("tool_input") or {},
+        "tool_response": d.get("tool_response") or {},
+        "tool_input_preview": _tool_input_preview(d),
         "result_preview": _extract_result_text(d.get("tool_response")),
     },
     "PostToolUseFailure": lambda d: {
         "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],
     },
     "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", "")},

{methodproof-0.7.36 → methodproof-0.7.38}/methodproof/hooks/claude_code.sh

@@ -37,11 +37,62 @@ if command -v jq >/dev/null 2>&1; then
       ;;
     PreToolUse)
       TYPE="tool_call"
-      META=$(echo "$INPUT" | jq -c '{tool: (.tool_name // "unknown"), tool_use_id: (.tool_use_id // "")}' 2>/dev/null || echo '{}')
+      META=$(echo "$INPUT" | jq -c '{
+        tool: (.tool_name // "unknown"),
+        tool_use_id: (.tool_use_id // ""),
+        tool_input: (.tool_input // {}),
+        tool_input_preview: (
+          (.tool_input // {}) as $ti |
+          (.tool_name // "unknown") as $tn |
+          (if $tn == "Bash" then ($ti.command // "")
+           elif $tn == "Read" then ($ti.file_path // "")
+           elif $tn == "Write" then ($ti.file_path // "")
+           elif $tn == "Edit" then ($ti.file_path // "")
+           elif $tn == "Grep" then (($ti.pattern // "") + " " + ($ti.path // ""))
+           elif $tn == "Glob" then ($ti.pattern // "")
+           elif $tn == "Agent" then ($ti.description // $ti.prompt // "" | .[0:200])
+           else ($ti.command // $ti.file_path // $ti.path // $ti.query // $ti.pattern // $ti.url // $ti.description // $ti.prompt // ($ti | tostring)) end
+          ) | tostring | .[0:200]
+        )
+      }' 2>/dev/null || echo '{}')
       ;;
     PostToolUse)
       TYPE="tool_result"
-      META=$(echo "$INPUT" | jq -c '{tool: (.tool_name // "unknown"), tool_use_id: (.tool_use_id // "")}' 2>/dev/null || echo '{}')
+      META=$(echo "$INPUT" | jq -c '{
+        tool: (.tool_name // "unknown"),
+        tool_use_id: (.tool_use_id // ""),
+        success: true,
+        tool_input: (.tool_input // {}),
+        tool_response: (.tool_response // {}),
+        tool_input_preview: (
+          (.tool_input // {}) as $ti |
+          (.tool_name // "unknown") as $tn |
+          (if $tn == "Bash" then ($ti.command // "")
+           elif $tn == "Read" then ($ti.file_path // "")
+           elif $tn == "Write" then ($ti.file_path // "")
+           elif $tn == "Edit" then ($ti.file_path // "")
+           elif $tn == "Grep" then (($ti.pattern // "") + " " + ($ti.path // ""))
+           elif $tn == "Glob" then ($ti.pattern // "")
+           elif $tn == "Agent" then ($ti.description // $ti.prompt // "" | .[0:200])
+           else ($ti.command // $ti.file_path // $ti.path // $ti.query // $ti.pattern // $ti.url // $ti.description // $ti.prompt // ($ti | tostring)) end
+          ) | tostring | .[0:200]
+        ),
+        result_preview: (
+          (.tool_response // {}) as $tr |
+          (.tool_name // "unknown") as $tn |
+          (if $tn == "Bash" then
+             (if ($tr.stderr // "") != "" then ("stderr: " + $tr.stderr) else ($tr.stdout // "") end | .[0:200])
+           elif $tn == "Read" then
+             (($tr.file.numLines // $tr.numLines // 0) | tostring) + " lines"
+           elif $tn == "Grep" then
+             (($tr.numFiles // 0) | tostring) + " files, " + (($tr.numLines // 0) | tostring) + " lines"
+           elif $tn == "Glob" then
+             (($tr.numFiles // 0) | tostring) + " files"
+           elif ($tr | type) == "string" then ($tr | .[0:200])
+           else ($tr | tostring | .[0:200]) end
+          )
+        )
+      }' 2>/dev/null || echo '{}')
       ;;
     SubagentStart)
       TYPE="agent_launch"
@@ -65,7 +116,7 @@ if command -v jq >/dev/null 2>&1; then
       ;;
     PostToolUseFailure)
       TYPE="tool_failure"
-      META=$(echo "$INPUT" | jq -c '{tool_name: (.tool_name // "unknown"), is_interrupt: (.is_interrupt // false), error: (.error // "" | .[0:200])}' 2>/dev/null || echo '{}')
+      META=$(echo "$INPUT" | jq -c '{tool: (.tool_name // "unknown"), is_interrupt: (.is_interrupt // false), success: false, error: (.error // "" | .[0:200])}' 2>/dev/null || echo '{}')
       ;;
     SessionEnd)
       TYPE="claude_session_end"

methodproof-0.7.38/methodproof/hooks/gemini_hook.sh

@@ -0,0 +1,123 @@
+#!/bin/sh
+# MethodProof hook for Gemini CLI — captures prompts, tools, model calls, sessions.
+# Receives JSON on stdin. Posts to local bridge. Fails silently.
+# Must complete in <1s to avoid blocking Gemini.
+
+# Skip if no session is running (no pidfile = no daemon = no bridge)
+[ -f "${HOME}/.methodproof/methodproof.pid" ] || exit 0
+
+INPUT=$(cat)
+
+if command -v jq >/dev/null 2>&1; then
+  EVENT=$(echo "$INPUT" | jq -r '.hook_event_name // "unknown"' 2>/dev/null || echo "unknown")
+else
+  EVENT=$(echo "$INPUT" | grep -o '"hook_event_name":"[^"]*"' | head -1 | cut -d'"' -f4)
+  EVENT=${EVENT:-unknown}
+fi
+
+if date +%s.%N >/dev/null 2>&1 && [ "$(date +%N)" != "%N" ]; then
+  TS=$(date +%s.%N)
+else
+  TS=$(date +%s).000
+fi
+
+if command -v jq >/dev/null 2>&1; then
+  case "$EVENT" in
+    BeforeAgent)
+      TYPE="user_prompt"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        prompt_preview: (.prompt // "" | .[0:200]),
+        prompt_length: (.prompt // "" | length)
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    AfterAgent)
+      TYPE="agent_completion"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        prompt_preview: (.prompt // "" | .[0:200]),
+        response_preview: (.prompt_response // "" | .[0:200]),
+        response_length: (.prompt_response // "" | length)
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    BeforeTool)
+      TYPE="tool_call"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        tool_name: (.tool_name // "unknown"),
+        tool_input_preview: (.tool_input // {} | tostring | .[0:200])
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    AfterTool)
+      TYPE="tool_result"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        tool_name: (.tool_name // "unknown"),
+        tool_input_preview: (.tool_input // {} | tostring | .[0:200]),
+        result_preview: (.tool_response // {} | tostring | .[0:200])
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    BeforeModel)
+      TYPE="llm_prompt"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        model: "gemini"
+      }' 2>/dev/null || echo '{"tool":"gemini","model":"gemini"}')
+      ;;
+    AfterModel)
+      TYPE="llm_completion"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        model: "gemini"
+      }' 2>/dev/null || echo '{"tool":"gemini","model":"gemini"}')
+      ;;
+    SessionStart)
+      TYPE="gemini_session_start"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        gemini_session_id: (.session_id // ""),
+        cwd: (.cwd // ""),
+        source: (.source // "")
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    SessionEnd)
+      TYPE="gemini_session_end"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        gemini_session_id: (.session_id // ""),
+        reason: (.reason // "")
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    PreCompress)
+      TYPE="context_compact_start"
+      META='{"tool":"gemini"}'
+      ;;
+    Notification)
+      TYPE="gemini_event"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        event: "notification",
+        notification_type: (.notification_type // ""),
+        message: (.message // "" | .[0:200])
+      }' 2>/dev/null || echo '{"tool":"gemini","event":"notification"}')
+      ;;
+    *)
+      TYPE="gemini_event"
+      META="{\"tool\":\"gemini\",\"event\":\"$EVENT\"}"
+      ;;
+  esac
+else
+  TYPE="gemini_event"
+  META="{\"tool\":\"gemini\",\"event\":\"$EVENT\"}"
+fi
+
+PAYLOAD="{\"events\":[{\"type\":\"$TYPE\",\"timestamp\":$TS,\"metadata\":$META}]}"
+RESPONSE=$(curl -s -w "\n%{http_code}" --max-time 1 --connect-timeout 0.5 \
+  -X POST http://localhost:9877/events \
+  -H "Content-Type: application/json" \
+  -d "$PAYLOAD" 2>/dev/null) || true
+HTTP_CODE=$(echo "$RESPONSE" | tail -1)
+if [ -n "$HTTP_CODE" ] && [ "$HTTP_CODE" != "200" ]; then
+  echo "{\"ts\":$TS,\"level\":\"warning\",\"event\":\"hook.post_failed\",\"http_code\":\"$HTTP_CODE\",\"type\":\"$TYPE\",\"payload\":$PAYLOAD}" \
+    >> "${HOME}/.methodproof/hook_errors.log" 2>/dev/null || true
+fi

{methodproof-0.7.36 → methodproof-0.7.38}/methodproof/hooks/install.py

@@ -48,7 +48,11 @@ _CODEX_EVENTS = ["PreToolUse", "PostToolUse", "UserPromptSubmit", "SessionStart"
 # --- Gemini CLI ---
 _GEMINI_DIR = Path.home() / ".gemini"
 _GEMINI_HOOK = _HOOKS_DIR / "gemini_hook.sh"
-_GEMINI_EVENTS = ["BeforeTool", "AfterTool", "SessionStart", "SessionEnd"]
+_GEMINI_EVENTS = [
+    "BeforeTool", "AfterTool", "BeforeAgent", "AfterAgent",
+    "BeforeModel", "AfterModel", "SessionStart", "SessionEnd",
+    "PreCompress", "Notification",
+]
 
 # --- Kiro ---
 _KIRO_DIR = Path.home() / ".kiro"

{methodproof-0.7.36 → methodproof-0.7.38}/methodproof/tui/start.py

@@ -266,7 +266,9 @@ def _fmt_meta(ev: dict) -> str:
     if etype == "tool_result":
         name = meta.get("tool_name") or meta.get("tool", "")
         ok = "✓" if meta.get("success", True) else "✗"
-        return f"{name}  {ok}"
+        inp = (meta.get("tool_input_preview") or "")[:40]
+        result = (meta.get("result_preview") or "")[:40]
+        return f"{name}  {ok}  {inp}  {result}".strip()
     if etype == "tool_failure":
         name = meta.get("tool_name") or meta.get("tool", "")
         err = (meta.get("error") or "")[:40]

{methodproof-0.7.36 → methodproof-0.7.38}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.7.36"
+version = "0.7.38"
 description = "See how you code. Capture and visualize your engineering process."
 requires-python = ">=3.11"
 dependencies = ["watchdog>=4.0", "websocket-client>=1.7", "cryptography>=43.0", "keyring>=25.0", "textual>=0.59", "rich>=13.7"]

methodproof-0.7.36/methodproof/hooks/gemini_hook.sh

@@ -1,58 +0,0 @@
-#!/bin/sh
-# MethodProof hook for Gemini CLI — captures tool calls and sessions.
-# Receives JSON on stdin. Posts to local bridge. Fails silently.
-# Must complete in <1s to avoid blocking Gemini.
-
-INPUT=$(cat)
-
-if command -v jq >/dev/null 2>&1; then
-  EVENT=$(echo "$INPUT" | jq -r '.hook_event_name // "unknown"' 2>/dev/null || echo "unknown")
-else
-  EVENT=$(echo "$INPUT" | grep -o '"hook_event_name":"[^"]*"' | head -1 | cut -d'"' -f4)
-  EVENT=${EVENT:-unknown}
-fi
-
-if date +%s.%N >/dev/null 2>&1 && [ "$(date +%N)" != "%N" ]; then
-  TS=$(date +%s.%N)
-else
-  TS=$(date +%s).000
-fi
-
-if command -v jq >/dev/null 2>&1; then
-  case "$EVENT" in
-    BeforeTool)
-      TYPE="tool_call"
-      META=$(echo "$INPUT" | jq -c '{tool: "gemini", tool_name: (.tool_name // "unknown")}' 2>/dev/null || echo '{"tool":"gemini"}')
-      ;;
-    AfterTool)
-      TYPE="tool_result"
-      META=$(echo "$INPUT" | jq -c '{tool: "gemini", tool_name: (.tool_name // "unknown")}' 2>/dev/null || echo '{"tool":"gemini"}')
-      ;;
-    SessionStart)
-      TYPE="gemini_session_start"
-      META=$(echo "$INPUT" | jq -c '{tool: "gemini", cwd: (.cwd // "")}' 2>/dev/null || echo '{"tool":"gemini"}')
-      ;;
-    SessionEnd)
-      TYPE="gemini_session_end"
-      META=$(echo "$INPUT" | jq -c '{tool: "gemini", reason: (.reason // "")}' 2>/dev/null || echo '{"tool":"gemini"}')
-      ;;
-    *)
-      TYPE="gemini_event"
-      META="{\"tool\":\"gemini\",\"event\":\"$EVENT\"}"
-      ;;
-  esac
-else
-  TYPE="gemini_event"
-  META="{\"tool\":\"gemini\",\"event\":\"$EVENT\"}"
-fi
-
-PAYLOAD="{\"events\":[{\"type\":\"$TYPE\",\"timestamp\":$TS,\"metadata\":$META}]}"
-RESPONSE=$(curl -s -w "\n%{http_code}" --max-time 1 --connect-timeout 0.5 \
-  -X POST http://localhost:9877/events \
-  -H "Content-Type: application/json" \
-  -d "$PAYLOAD" 2>/dev/null) || true
-HTTP_CODE=$(echo "$RESPONSE" | tail -1)
-if [ -n "$HTTP_CODE" ] && [ "$HTTP_CODE" != "200" ]; then
-  echo "{\"ts\":$TS,\"level\":\"warning\",\"event\":\"hook.post_failed\",\"http_code\":\"$HTTP_CODE\",\"type\":\"$TYPE\",\"payload\":$PAYLOAD}" \
-    >> "${HOME}/.methodproof/hook_errors.log" 2>/dev/null || true
-fi