methodproof 0.6.0__tar.gz → 0.7.0__tar.gz

{methodproof-0.6.0 → methodproof-0.7.0}/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.7.0] — 2026-04-07
+
+### Fixed
+- **Runaway event logging** — watcher ignored only 7 patterns, tracking 35K+ files including `.venv/` (20K), `dist/build/` (23K). Expanded to 30+ ignore patterns covering Python, JS/TS, Rust, Go, Java, Ruby, PHP, .NET, Swift, and build artifacts. **138K → 1,442 files (99% reduction)**
+- **Claude Code hook errors** — hook script pointed to deleted pyenv site-packages path; added pidfile guard (`exit 0` when no session active) to prevent bridge connection failures
+
+### Added
+- `mp start --streaming` — blocking foreground mode, streams every captured event to stdout in real-time with human-readable formatting
+- `mp start --verbose` / `-v` — structured debug logging at each step (config, auth, session, anchor, daemon spawn); daemon log includes agent init and buffer/flush stats
+- Step-by-step progress output on default `mp start` (`→ Loading config`, `→ Checking hooks`, etc.) so failures are immediately locatable
+
 ## [0.5.1] — 2026-04-06
 
 ### Fixed

{methodproof-0.6.0 → methodproof-0.7.0}/PKG-INFO

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

{methodproof-0.6.0 → methodproof-0.7.0}/methodproof/_daemon.py

@@ -18,6 +18,7 @@ PIDFILE = config.DIR / "methodproof.pid"
 def main() -> None:
     sid = sys.argv[1]
     watch_dir = sys.argv[2]
+    verbose = "--verbose" in sys.argv
 
     cfg = config.load()
     capture = cfg.get("capture", {})
@@ -28,10 +29,15 @@ def main() -> None:
         del cfg["_live_url"]
         config.save(cfg)
 
-    base.init(sid, live=bool(live_url))
+    base.init(sid, live=bool(live_url), verbose=verbose)
+
+    if verbose:
+        active = [k for k, v in capture.items() if v]
+        base.log("info", "daemon.config", capture=active, live=bool(live_url),
+                 journal=cfg.get("journal_mode", False))
 
-    # Environment profile (was done pre-fork in old code, now done in daemon)
     if capture.get("environment_analysis", True):
+        base.log("info", "daemon.agent.environment_scan") if verbose else None
         try:
             from methodproof.analysis import scan_environment
             env_profile = scan_environment(watch_dir)
@@ -52,12 +58,16 @@ def main() -> None:
         threads.append(threading.Thread(
             target=watcher.start, args=(watch_dir, stop_event), daemon=True,
         ))
+        if verbose:
+            base.log("info", "daemon.agent.watcher", dir=watch_dir)
 
     if capture.get("terminal_commands", True) or capture.get("test_results", True):
         from methodproof.agents import terminal
         threads.append(threading.Thread(
             target=terminal.start, args=(stop_event,), daemon=True,
         ))
+        if verbose:
+            base.log("info", "daemon.agent.terminal", log=str(config.CMD_LOG))
 
     if capture.get("browser", True):
         from methodproof import bridge
@@ -68,12 +78,16 @@ def main() -> None:
                   cfg.get("journal_mode", False)),
             daemon=True,
         ))
+        if verbose:
+            base.log("info", "daemon.agent.bridge", port=9877)
 
     if capture.get("music", True):
         from methodproof.agents import music
         threads.append(threading.Thread(
             target=music.start, args=(stop_event,), daemon=True,
         ))
+        if verbose:
+            base.log("info", "daemon.agent.music")
 
     def _shutdown(sig_num: int, frame: object) -> None:
         stop_event.set()

{methodproof-0.6.0 → methodproof-0.7.0}/methodproof/agents/base.py

@@ -21,6 +21,8 @@ _MAX_RETRIES = 3
 _prev_hash = "genesis"
 _account_id = ""
 _journal_mode = False
+_verbose = False
+_streaming = False
 
 # Maps event types to the capture category that gates them
 _EVENT_GATES: dict[str, str] = {
@@ -91,11 +93,13 @@ def _load_encryption_key(cfg: dict) -> bytes | None:
     return bytes.fromhex(raw) if raw else None
 
 
-def init(session_id: str, live: bool = False) -> None:
-    global _session_id, _initialized, _e2e_key, _capture, _live_mode, _prev_hash, _journal_mode, _account_id
+def init(session_id: str, live: bool = False, verbose: bool = False, streaming: bool = False) -> None:
+    global _session_id, _initialized, _e2e_key, _capture, _live_mode, _prev_hash, _journal_mode, _account_id, _verbose, _streaming
     _session_id = session_id
     _initialized = True
     _live_mode = live
+    _verbose = verbose
+    _streaming = streaming
     _prev_hash = "genesis"
     from methodproof import config
     cfg = config.load()
@@ -103,6 +107,10 @@ def init(session_id: str, live: bool = False) -> None:
     _capture = cfg.get("capture", {})
     _journal_mode = cfg.get("journal_mode", False)
     _account_id = cfg.get("account_id", "")
+    if _verbose or _streaming:
+        active = [k for k, v in _capture.items() if v]
+        log("info", "base.init", encryption=bool(_e2e_key), journal=_journal_mode,
+            live=_live_mode, capture=active)
 
 
 def log(level: str, event: str, **kw: object) -> None:
@@ -153,6 +161,10 @@ def emit(event_type: str, metadata: dict[str, Any]) -> None:
         _buffer.append(entry)
         if len(_buffer) >= _FLUSH_SIZE:
             _flush_locked()
+    if _verbose:
+        log("debug", "emit.buffered", type=event_type, buffer=len(_buffer))
+    if _streaming:
+        _stream_event(entry)
     if _live_mode:
         from methodproof import live as live_mod
         live_mod.send(entry)
@@ -168,15 +180,55 @@ def _flush_locked() -> None:
         return
     batch = list(_buffer)
     hashes = [(e["id"], e.pop("_chain_hash")) for e in batch if "_chain_hash" in e]
+    if _verbose or _streaming:
+        types = [e["type"] for e in batch]
+        log("info", "flush.start", count=len(batch), types=types)
     for attempt in range(_MAX_RETRIES):
         try:
             store.insert_events(_session_id, batch)
             if hashes:
                 store.insert_event_hashes(hashes)
+            if _verbose or _streaming:
+                log("info", "flush.ok", count=len(batch))
             _buffer.clear()
             return
         except Exception as exc:
             log("warning", "flush.retry", attempt=attempt + 1, error=str(exc))
             time.sleep(0.1 * (attempt + 1))
-    # Final attempt failed — keep events in buffer for next flush cycle
     log("error", "flush.failed", count=len(batch), retries=_MAX_RETRIES)
+
+
+def _stream_event(entry: dict[str, Any]) -> None:
+    """Print a human-readable event line to stdout for --streaming mode."""
+    ts = time.strftime("%H:%M:%S", time.localtime(entry["timestamp"]))
+    etype = entry["type"]
+    meta = entry.get("metadata", {})
+    # Build a compact summary per event type
+    detail = ""
+    if etype == "file_edit":
+        detail = f'{meta.get("path", "?")} +{meta.get("lines_added", 0)}-{meta.get("lines_removed", 0)}'
+    elif etype == "file_create":
+        detail = f'{meta.get("path", "?")} ({meta.get("size", 0)}B)'
+    elif etype == "file_delete":
+        detail = meta.get("path", "?")
+    elif etype == "terminal_cmd":
+        detail = f'{meta.get("command", "?")[:60]} → exit {meta.get("exit_code", "?")}'
+    elif etype == "test_run":
+        detail = f'{meta.get("framework", "?")} {meta.get("passed", 0)}✓ {meta.get("failed", 0)}✗'
+    elif etype == "git_commit":
+        detail = f'{meta.get("hash", "?")} {meta.get("message", "")[:50]}'
+    elif etype in ("llm_prompt", "agent_prompt", "user_prompt"):
+        detail = f'len={meta.get("prompt_length", meta.get("message_length", "?"))}'
+    elif etype in ("llm_completion", "agent_completion"):
+        detail = f'len={meta.get("response_length", "?")}'
+    elif etype == "music_playing":
+        detail = f'{meta.get("artist", "?")} — {meta.get("track", "?")}'
+    elif etype.startswith("browser_"):
+        detail = meta.get("url", meta.get("query", ""))[:60]
+    elif etype == "environment_profile":
+        detail = f'{meta.get("tool_count", "?")} tools'
+    else:
+        keys = list(meta.keys())[:4]
+        detail = ", ".join(f"{k}={meta[k]}" for k in keys) if keys else ""
+    sys.stdout.write(f"  [{ts}] {etype:30s} {detail}\n")
+    sys.stdout.flush()

{methodproof-0.6.0 → methodproof-0.7.0}/methodproof/agents/watcher.py

@@ -13,7 +13,35 @@ from watchdog.observers import Observer
 from methodproof.agents import base
 
 IGNORE_PATTERNS = re.compile(
-    r"(__pycache__|\.pyc|\.git/|node_modules|\.DS_Store|\.swp|~$)"
+    # Version control
+    r"(\.git/|\.hg/|\.svn/"
+    # OS / editor artifacts
+    r"|\.DS_Store|Thumbs\.db|\.swp|\.swo|~$|\.idea/|\.vscode/"
+    # Python
+    r"|__pycache__|\.pyc|\.pyo|\.egg-info/|\.eggs/|\.tox/"
+    r"|\.venv/|venv/|\.env/|env/|\.mypy_cache/|\.pytest_cache/|\.ruff_cache/"
+    r"|\.coverage|htmlcov/|\.nox/"
+    # JavaScript / TypeScript
+    r"|node_modules/|\.next/|\.nuxt/|\.expo/|\.turbo/|\.parcel-cache/"
+    r"|\.svelte-kit/|\.angular/|\.cache/"
+    # Rust
+    r"|/target/|\.cargo/"
+    # Go
+    r"|vendor/"
+    # Java / Kotlin / JVM
+    r"|\.gradle/|\.m2/|/out/"
+    # Ruby
+    r"|\.bundle/|\.gem/"
+    # PHP
+    r"|/vendor/|\.phpunit/"
+    # .NET / C#
+    r"|/bin/|/obj/|\.nuget/"
+    # Swift / Xcode
+    r"|\.build/|DerivedData/|Pods/"
+    # Build output / artifacts
+    r"|dist/|build/|\.output/"
+    # Logs and locks
+    r"|\.lock$|\.log$)"
 )
 
 

{methodproof-0.6.0 → methodproof-0.7.0}/methodproof/cli.py

@@ -845,28 +845,54 @@ def _is_daemon_alive() -> bool:
         return False
 
 
+def _log_step(msg: str, verbose: bool = False) -> None:
+    """Print a step-by-step progress line. Always shown."""
+    print(f"  → {msg}")
+
+
+def _log_debug(msg: str, **kw: object) -> None:
+    """Print structured debug line (--verbose only). Writes to stderr."""
+    import json as _json
+    entry = {"ts": time.time(), "level": "debug", "event": msg, **kw}
+    sys.stderr.write(_json.dumps(entry, default=str) + "\n")
+
+
 def cmd_start(args: argparse.Namespace) -> None:
+    verbose = getattr(args, "verbose", False)
+    streaming = getattr(args, "streaming", False)
+
+    _log_step("Loading config")
     cfg = config.load()
+    if verbose:
+        _log_debug("config.loaded", api_url=cfg.get("api_url"), account_id=cfg.get("account_id", "")[:8],
+                    active_session=cfg.get("active_session"), journal=cfg.get("journal_mode"))
+
     if cfg.get("auto_update"):
+        _log_step("Checking for updates")
         _auto_update()
+
     if cfg.get("active_session"):
         if _is_daemon_alive():
             print(f"Session active: {cfg['active_session'][:8]}")
             print("Run `methodproof stop` first.")
             sys.exit(1)
-        # Daemon is dead — clean up the stale session
         stale_sid = cfg["active_session"]
+        _log_step(f"Cleaning stale session {stale_sid[:8]}")
         store.complete_session(stale_sid)
         graph.build(stale_sid)
         PIDFILE.unlink(missing_ok=True)
         cfg["active_session"] = None
         config.save(cfg)
-        print(f"Cleaned up stale session {stale_sid[:8]} (daemon was not running).")
+
+    _log_step("Checking hooks")
     if not hook.is_installed():
-        print("Run `methodproof init` first.")
+        print("ERROR: Run `methodproof init` first.")
         sys.exit(1)
 
+    _log_step("Authenticating")
     account_id = _require_auth(cfg)
+    if verbose:
+        _log_debug("auth.ok", account_id=account_id[:8] if account_id else "none")
 
     # Check for new consent categories before recording
     capture = cfg.get("capture", {})
@@ -878,6 +904,7 @@ def cmd_start(args: argparse.Namespace) -> None:
         config.save(cfg)
         print()
 
+    _log_step("Creating session")
     sid = uuid.uuid4().hex
     watch_dir = os.path.abspath(args.dir or ".")
     repo_url = args.repo or repos.detect_repo(watch_dir)
@@ -885,7 +912,6 @@ def cmd_start(args: argparse.Namespace) -> None:
     visibility = "public" if args.public else "private"
     from methodproof.binding import compute_binding, compute_device_id
     device_id = compute_device_id()
-    # Compute session binding if master key is available
     binding = ""
     if cfg.get("master_key_fingerprint") and account_id:
         from methodproof.keychain import load_secret
@@ -895,38 +921,45 @@ def cmd_start(args: argparse.Namespace) -> None:
             master = derive_master(entropy)
             bind_key = derive_bind_key(master, account_id)
             binding = compute_binding(bind_key, sid, account_id, device_id, time.time())
+            if verbose:
+                _log_debug("binding.computed", device_id=device_id[:8])
     store.create_session(sid, watch_dir, repo_url, json.dumps(tags), visibility,
                          account_id, binding, device_id)
     cfg["active_session"] = sid
     config.save(cfg)
     PIDFILE.write_text(str(os.getpid()))
+    if verbose:
+        _log_debug("session.created", sid=sid[:8], watch_dir=watch_dir, visibility=visibility,
+                    device_id=device_id[:8], bound=bool(binding))
 
-    # Temporal anchor — server-signed timestamp (best-effort, skip if offline)
+    # Temporal anchor
     if cfg.get("token"):
+        _log_step("Requesting temporal anchor")
         try:
             from methodproof.sync import _request
             anchor = _request("POST", f"/sessions/{sid}/anchor", cfg["api_url"], cfg["token"])
             store.update_anchor(sid, anchor["anchor_ts"], anchor["signature"])
+            if verbose:
+                _log_debug("anchor.ok", anchor_ts=anchor["anchor_ts"])
         except Exception as exc:
-            print(f"Anchor: skipped ({exc})")
+            _log_step(f"Anchor: skipped ({exc})")
 
     from methodproof.agents import base
-    live_ok = False
     capture = cfg.get("capture", {})
 
+    # Live streaming
     live_url = ""
     want_live = args.live or getattr(args, "live_public", False)
     live_visibility = "public" if getattr(args, "live_public", False) else "private"
     if want_live:
+        _log_step("Connecting live stream")
         if not cfg.get("token"):
             print("Live mode requires login. Run `methodproof login` first.")
             sys.exit(1)
-        # Create remote session first
         from methodproof.sync import _request
         result = _request("POST", "/personal/sessions", cfg["api_url"], cfg["token"])
         remote_id = result["session_id"]
         store.mark_synced(sid, remote_id)
-        # Connect live WebSocket
         from methodproof import live as live_mod
         live_url = live_mod.start(cfg["api_url"], cfg["token"], remote_id, capture, live_visibility) or ""
         if not live_url:
@@ -939,7 +972,7 @@ def cmd_start(args: argparse.Namespace) -> None:
             print(f"Live (public): {live_url}")
             print("  Anyone with this link can watch your session build in real time.")
 
-    # Journal mode — per-session override or persistent config
+    # Journal mode
     if getattr(args, "journal", False):
         cfg["journal_mode"] = True
         credits = cfg.get("journal_credits", 0)
@@ -966,25 +999,35 @@ def cmd_start(args: argparse.Namespace) -> None:
         print(f"Bridge:    http://localhost:9877")
     if live_url:
         print(f"Live:      {live_url}")
+    if verbose:
+        print(f"Mode:      verbose (debug → daemon.log)")
+    if streaming:
+        print(f"Mode:      streaming (blocking, events → stdout)")
+
+    # --streaming: blocking foreground mode with real-time event output
+    if streaming:
+        _run_foreground(sid, watch_dir, cfg, capture, live_url, verbose=True, streaming=True)
+        return
 
-    # Daemonize: spawn a subprocess (safe on macOS — avoids CoreFoundation segfault from os.fork)
+    # Daemonize (macOS/Linux) — pass --verbose to daemon if set
     if sys.platform != "win32":
         import subprocess as _sp
         daemon_log = config.DIR / "daemon.log"
         log_fh = open(daemon_log, "a")
-        proc = _sp.Popen(
-            [sys.executable, "-m", "methodproof._daemon", sid, watch_dir],
-            start_new_session=True,
-            stdout=log_fh, stderr=log_fh, stdin=_sp.DEVNULL,
-        )
+        cmd = [sys.executable, "-m", "methodproof._daemon", sid, watch_dir]
+        if verbose:
+            cmd.append("--verbose")
+        _log_step(f"Spawning daemon (log: {daemon_log})")
+        proc = _sp.Popen(cmd, start_new_session=True, stdout=log_fh, stderr=log_fh, stdin=_sp.DEVNULL)
         PIDFILE.write_text(str(proc.pid))
-        # Verify daemon is alive after brief startup
+        if verbose:
+            _log_debug("daemon.spawned", pid=proc.pid, cmd=cmd)
         time.sleep(1)
         if proc.poll() is not None:
             print(f"ERROR: Daemon exited immediately (code {proc.returncode}). Check {daemon_log}")
             PIDFILE.unlink(missing_ok=True)
             sys.exit(1)
-        # Check extension auto-discovery (extension polls every ~6s)
+        _log_step(f"Daemon alive (pid {proc.pid})")
         if capture.get("browser", True):
             import urllib.request as _ur
             time.sleep(7)
@@ -1001,9 +1044,16 @@ def cmd_start(args: argparse.Namespace) -> None:
         return
 
     # Windows: foreground mode (no subprocess daemonization)
+    _run_foreground(sid, watch_dir, cfg, capture, live_url, verbose=verbose, streaming=False)
+
+
+def _run_foreground(sid: str, watch_dir: str, cfg: dict, capture: dict,
+                    live_url: str, verbose: bool, streaming: bool) -> None:
+    """Run capture agents in the foreground (blocking). Used by --streaming and Windows."""
     from methodproof.agents import base as _base
-    _base.init(sid, live=bool(live_url))
+    _base.init(sid, live=bool(live_url), verbose=verbose, streaming=streaming)
     if capture.get("environment_analysis", True):
+        _log_step("Scanning environment")
         try:
             from methodproof.analysis import scan_environment
             env_profile = scan_environment(watch_dir)
@@ -1020,9 +1070,11 @@ def cmd_start(args: argparse.Namespace) -> None:
     if files_enabled:
         from methodproof.agents import watcher
         threads.append(threading.Thread(target=watcher.start, args=(watch_dir, stop_event), daemon=True))
+        _log_step("Agent: watcher")
     if capture.get("terminal_commands", True) or capture.get("test_results", True):
         from methodproof.agents import terminal
         threads.append(threading.Thread(target=terminal.start, args=(stop_event,), daemon=True))
+        _log_step("Agent: terminal")
     if capture.get("browser", True):
         from methodproof import bridge
         threads.append(threading.Thread(target=bridge.start, args=(
@@ -1030,9 +1082,11 @@ def cmd_start(args: argparse.Namespace) -> None:
             cfg.get("token", ""), cfg.get("api_url", ""), cfg.get("e2e_key", ""),
             cfg.get("journal_mode", False),
         ), daemon=True))
+        _log_step("Agent: bridge")
     if capture.get("music", True):
         from methodproof.agents import music
         threads.append(threading.Thread(target=music.start, args=(stop_event,), daemon=True))
+        _log_step("Agent: music")
 
     def _shutdown(sig: int, frame: object) -> None:
         stop_event.set()
@@ -1054,10 +1108,14 @@ def cmd_start(args: argparse.Namespace) -> None:
         PIDFILE.unlink(missing_ok=True)
         sys.exit(0)
 
+    _log_step(f"Starting {len(threads)} agent(s)")
     for t in threads:
         t.start()
     signal.signal(signal.SIGINT, _shutdown)
-    print("Press Ctrl+C or run `mp stop` to finish.")
+    if streaming:
+        print("\n  Streaming events (Ctrl+C to stop):\n")
+    else:
+        print("Press Ctrl+C or run `mp stop` to finish.")
     stopfile = config.DIR / "methodproof.stop"
     while not stop_event.is_set():
         if stopfile.exists():
@@ -1583,6 +1641,8 @@ def main() -> None:
     s.add_argument("--live", action="store_true", help="Stream graph live to your private profile")
     s.add_argument("--live-public", action="store_true", help="Stream graph live — visible to anyone with the link")
     s.add_argument("--journal", action="store_true", help="Journal mode — full content capture (2 free credits, then Pro)")
+    s.add_argument("--verbose", "-v", action="store_true", help="Debug logging at each step (still daemonizes)")
+    s.add_argument("--streaming", action="store_true", help="Blocking foreground — stream every captured event to stdout")
     sub.add_parser("stop", help="Stop recording")
     v = sub.add_parser("view", help="Inspect captured session data")
     v.add_argument("session_id", nargs="?")

{methodproof-0.6.0 → methodproof-0.7.0}/methodproof/hooks/claude_code.py

@@ -24,14 +24,36 @@ def _build_prompt_meta(text: str) -> dict:
 
 
 _TYPE_MAP = {
+    # Human-initiated
     "UserPromptSubmit": "user_prompt",
+    # Tool lifecycle
     "PreToolUse": "tool_call",
     "PostToolUse": "tool_result",
+    "PostToolUseFailure": "tool_failure",
+    # Agent lifecycle
     "SubagentStart": "agent_launch",
     "SubagentStop": "agent_complete",
+    # Task lifecycle
     "TaskCreated": "task_start",
     "TaskCompleted": "task_end",
+    # Session lifecycle
     "SessionStart": "claude_session_start",
+    "SessionEnd": "claude_session_end",
+    "Stop": "agent_turn_end",
+    "StopFailure": "agent_turn_error",
+    # Context
+    "CwdChanged": "cwd_changed",
+    "PreCompact": "context_compact_start",
+    "PostCompact": "context_compact_end",
+    # Permissions
+    "PermissionRequest": "permission_request",
+    "PermissionDenied": "permission_denied",
+    # MCP
+    "Elicitation": "mcp_elicitation",
+    "ElicitationResult": "mcp_elicitation_result",
+    # Worktree
+    "WorktreeCreate": "worktree_create",
+    "WorktreeRemove": "worktree_remove",
 }
 
 _TOOL = "claude_code"
@@ -43,11 +65,35 @@ _META_EXTRACTORS = {
     },
     "PreToolUse": lambda d: {"tool": _TOOL, "tool_name": d.get("tool_name", "unknown")},
     "PostToolUse": lambda d: {"tool": _TOOL, "tool_name": d.get("tool_name", "unknown"), "success": True},
+    "PostToolUseFailure": lambda d: {
+        "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"),
+        "success": False, "is_interrupt": d.get("is_interrupt", False),
+        "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", "")},
+    "SubagentStop": lambda d: {
+        "tool": _TOOL, "agent_type": d.get("agent_type", "unknown"), "agent_id": d.get("agent_id", ""),
+        "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]},
+    "CwdChanged": lambda d: {
+        "tool": _TOOL, "cwd": d.get("cwd", ""),
+        # NOTE: fires for both human `cd` and Claude tool use — caller is ambiguous
+        "source": "ambiguous",
+    },
+    "PreCompact": lambda d: {"tool": _TOOL},
+    "PostCompact": lambda d: {"tool": _TOOL},
+    "PermissionRequest": lambda d: {"tool": _TOOL, "tool_name": d.get("tool_name", "unknown")},
+    "PermissionDenied": lambda d: {"tool": _TOOL, "tool_name": d.get("tool_name", "unknown")},
+    "Elicitation": lambda d: {"tool": _TOOL},
+    "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", "")},
 }
 
 

{methodproof-0.6.0 → methodproof-0.7.0}/methodproof/hooks/claude_code.sh

@@ -3,7 +3,9 @@
 # Receives JSON on stdin. Posts to local bridge. Fails silently.
 # Must complete in <1s to avoid blocking Claude Code.
 
-# Require jq — without it, fall back to a minimal Python parser
+# 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
@@ -47,7 +49,7 @@ if command -v jq >/dev/null 2>&1; then
       ;;
     SubagentStop)
       TYPE="agent_complete"
-      META=$(echo "$INPUT" | jq -c '{agent_type: (.agent_type // "unknown"), agent_id: (.agent_id // "")}' 2>/dev/null || echo '{}')
+      META=$(echo "$INPUT" | jq -c '{agent_type: (.agent_type // "unknown"), agent_id: (.agent_id // ""), last_message_preview: (.last_assistant_message // "" | .[0:200])}' 2>/dev/null || echo '{}')
       ;;
     TaskCreated)
       TYPE="task_created"
@@ -61,6 +63,54 @@ if command -v jq >/dev/null 2>&1; then
       TYPE="claude_session_start"
       META=$(echo "$INPUT" | jq -c '{claude_session_id: (.session_id // ""), cwd: (.cwd // "")}' 2>/dev/null || echo '{}')
       ;;
+    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 '{}')
+      ;;
+    SessionEnd)
+      TYPE="claude_session_end"
+      META=$(echo "$INPUT" | jq -c '{claude_session_id: (.session_id // "")}' 2>/dev/null || echo '{}')
+      ;;
+    Stop)
+      TYPE="agent_turn_end"
+      META='{"tool":"claude_code"}'
+      ;;
+    StopFailure)
+      TYPE="agent_turn_error"
+      META=$(echo "$INPUT" | jq -c '{error: (.error // "" | .[0:200])}' 2>/dev/null || echo '{}')
+      ;;
+    CwdChanged)
+      TYPE="cwd_changed"
+      META=$(echo "$INPUT" | jq -c '{cwd: (.cwd // ""), source: "ambiguous"}' 2>/dev/null || echo '{}')
+      ;;
+    PreCompact)
+      TYPE="context_compact_start"
+      META='{"tool":"claude_code"}'
+      ;;
+    PostCompact)
+      TYPE="context_compact_end"
+      META='{"tool":"claude_code"}'
+      ;;
+    PermissionRequest)
+      TYPE="permission_request"
+      META=$(echo "$INPUT" | jq -c '{tool_name: (.tool_name // "unknown")}' 2>/dev/null || echo '{}')
+      ;;
+    PermissionDenied)
+      TYPE="permission_denied"
+      META=$(echo "$INPUT" | jq -c '{tool_name: (.tool_name // "unknown")}' 2>/dev/null || echo '{}')
+      ;;
+    WorktreeCreate)
+      TYPE="worktree_create"
+      META=$(echo "$INPUT" | jq -c '{worktree_path: (.worktree_path // "")}' 2>/dev/null || echo '{}')
+      ;;
+    WorktreeRemove)
+      TYPE="worktree_remove"
+      META=$(echo "$INPUT" | jq -c '{worktree_path: (.worktree_path // "")}' 2>/dev/null || echo '{}')
+      ;;
+    Elicitation|ElicitationResult)
+      TYPE=$(echo "$EVENT" | sed 's/Elicitation$/mcp_elicitation/;s/ElicitationResult/mcp_elicitation_result/')
+      META='{"tool":"claude_code"}'
+      ;;
     *)
       TYPE="claude_code_event"
       META="{\"event\":\"$EVENT\"}"

{methodproof-0.6.0 → methodproof-0.7.0}/methodproof/hooks/install.py

@@ -21,9 +21,23 @@ _HOOK_PY = _HOOKS_DIR / "claude_code.py"
 HOOK_SCRIPT = _HOOK_PY if sys.platform == "win32" else _HOOK_SH
 
 HOOK_EVENTS = [
+    # Core (already captured)
     "UserPromptSubmit", "PreToolUse", "PostToolUse",
     "SubagentStart", "SubagentStop",
     "TaskCreated", "TaskCompleted", "SessionStart",
+    # New: interruptions, lifecycle, context
+    "PostToolUseFailure",        # tool failure + is_interrupt flag
+    "SessionEnd",                # session terminated
+    "Stop",                      # Claude finished responding (normal or interrupted)
+    "StopFailure",               # turn ended due to API error
+    "CwdChanged",                # working directory changed (ambiguous: human or Claude)
+    "PreCompact", "PostCompact", # context window compaction
+    "PermissionRequest",         # permission dialog shown
+    "PermissionDenied",          # auto mode denied a tool
+    "Elicitation",               # MCP requested user input
+    "ElicitationResult",         # user responded to MCP
+    "WorktreeCreate",            # git worktree created (parallel agent)
+    "WorktreeRemove",            # git worktree removed
 ]
 
 # --- Codex CLI ---

{methodproof-0.6.0 → methodproof-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.6.0"
+version = "0.7.0"
 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"]

{methodproof-0.6.0 → methodproof-0.7.0}/uv.lock

@@ -862,7 +862,7 @@ wheels = [
 
 [[package]]
 name = "methodproof"
-version = "0.5.5"
+version = "0.6.0"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography", version = "44.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },