methodproof 0.5.5__tar.gz → 0.7.0__tar.gz

{methodproof-0.5.5 → 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.5.5 → methodproof-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.5.5
+Version: 0.7.0
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -67,6 +67,87 @@ methodproof view      # explore your session in the browser
 - **Auto-detection** — hooks for shell, Claude Code, OpenClaw, codex, gemini, aider installed automatically
 - **Platform sync** — `methodproof push` uploads sessions. `methodproof publish` makes them public and shareable
 
+## Security Architecture
+
+Every event passes through consent gating, encryption, and hash chaining before touching disk. The platform adds a server co-signature on push, creating two-party evidence.
+
+```mermaid
+flowchart TB
+    subgraph LOCAL["LOCAL MACHINE"]
+        direction TB
+        subgraph AGENTS["Capture Agents"]
+            direction LR
+            W["File Watcher"] & T["Terminal Hook"] & B["Browser Bridge"] & H["AI Tool Hooks"]
+        end
+        W & T & B & H -->|"raw event"| EMIT["emit(type, metadata)"]
+
+        subgraph CONSENT["Consent Layer"]
+            direction TB
+            EMIT --> EG{"Event Gate"}
+            EG -->|"category OFF"| DROP["Dropped"]
+            EG -->|"category ON"| FG["Field Gate: strip opted-out fields"]
+            FG --> JG{"Journal Mode?"}
+            JG -->|"OFF: structural only"| STRIP["Strip content fields"]
+            JG -->|"ON: full content"| KEEP["Keep all fields"]
+        end
+
+        subgraph CRYPTO["Encryption + Integrity"]
+            direction TB
+            STRIP & KEEP --> AES["AES-256-GCM: encrypt sensitive fields"]
+            AES --> LOCK["Thread Lock: atomic hash + buffer"]
+            LOCK --> CHAIN["SHA-256 Hash Chain"]
+            CHAIN --> BUF["Batched Flush"]
+        end
+
+        BUF --> DB[("SQLite WAL")]
+        BUF -.->|"--live"| WS["WebSocket Stream"]
+
+        subgraph KEYS["Key Vault"]
+            direction LR
+            ENT["Entropy"] --> KDF["Key Derivation"]
+            KDF --> DBK["Encryption Key"]
+            KDF --> BINDK["Binding Key"]
+            KDF --> ED25["Signing Key"]
+            ENT -.-> REC["Recovery Phrase"]
+            KDF -.-> KC["OS Keychain"]
+        end
+    end
+
+    subgraph PUSH["PUSH PROTOCOL"]
+        direction TB
+        DB --> BATCH["Batched Upload"]
+        BATCH --> BIND["Session Binding: HMAC over session metadata"]
+        BIND --> SIGN["Ed25519 Sign: session summary"]
+    end
+
+    subgraph PLATFORM["PLATFORM TRUST BOUNDARY"]
+        direction TB
+        SIGN --> VERIFY["Verify Ed25519 against registered public key"]
+        VERIFY --> COSIG["Server Co-Sign: HMAC over attestation receipt"]
+        COSIG --> NEO[("Graph Store")]
+        NEO --> SCORE["Integrity Score: chain + attestation + cosig + git xref + anomaly"]
+    end
+
+    style DROP fill:#d93326,stroke:#d93326,color:#fff
+    style AES fill:#803794,stroke:#803794,color:#fff
+    style CHAIN fill:#803794,stroke:#803794,color:#fff
+    style LOCK fill:#803794,stroke:#803794,color:#fff
+    style EG fill:#109446,stroke:#109446,color:#fff
+    style JG fill:#109446,stroke:#109446,color:#fff
+    style STRIP fill:#109446,stroke:#109446,color:#fff
+    style VERIFY fill:#c9a84c,stroke:#c9a84c,color:#fff
+    style COSIG fill:#c9a84c,stroke:#c9a84c,color:#fff
+    style SCORE fill:#c9a84c,stroke:#c9a84c,color:#fff
+    style SIGN fill:#192a56,stroke:#192a56,color:#fff
+    style BIND fill:#192a56,stroke:#192a56,color:#fff
+    style DB fill:#192a56,stroke:#192a56,color:#fff
+    style NEO fill:#192a56,stroke:#192a56,color:#fff
+    style KC fill:#803794,stroke:#803794,color:#fff
+    style REC fill:#803794,stroke:#803794,color:#fff
+```
+
+<sup>Green = consent gates · Purple = cryptographic operations · Navy = storage + binding · Gold = integrity verification</sup>
+
 ## Commands
 
 | Command | What it does |
@@ -167,13 +248,15 @@ At session end, outcome metrics are computed: first-shot apply rate, follow-up s
 <details>
 <summary>Integrity verification</summary>
 
-Three layers ensure session data hasn't been tampered with:
+Four layers ensure session data hasn't been tampered with (see [architecture diagram](#security-architecture) above):
+
+**Hash-chained events** — every event includes a SHA-256 hash linking to the previous event. Hash computation is thread-safe (atomic with buffer append). Any modification breaks the chain, detectable via `GET /sessions/{id}/chain/verify`.
 
-**Hash-chained events** — every event includes a SHA-256 hash linking to the previous event. Any modification breaks the chain, detectable via `GET /sessions/{id}/chain/verify`.
+**Ed25519 attestation** — on `methodproof push`, the CLI signs a session summary with your private key. Key generated during `methodproof init`, stored in `~/.methodproof/`.
 
-**Ed25519 attestation** — on `methodproof push`, the CLI signs a session summary with your private key. Install with `pip install methodproof[signing]`. Key generated during `methodproof init`, stored in `~/.methodproof/config.json`.
+**Server co-signature** — the platform independently signs the attestation receipt with its own key and timestamp, creating two-party evidence. Sessions pushed without server co-signature receive a lower integrity score.
 
-**Binary hash self-reporting** — the CLI reports its own binary hash on push. The platform compares against known release hashes to detect modified builds.
+**Binary hash self-reporting** — the CLI reports its own source hash on push. The platform compares against known release hashes to detect modified builds.
 
 </details>
 
@@ -222,7 +305,7 @@ methodproof start
 
 **Excluded patterns:** `__pycache__`, `.pyc`, `.git/`, `node_modules`, `.DS_Store`, `.swp`, temp files ending in `~`
 
-**Git commits** are detected by polling `.git/refs/heads/` every 2 seconds — only commits in a git repo rooted at (or above) the watch directory are captured.
+**Git commits** are detected automatically — only commits in a git repo rooted at (or above) the watch directory are captured.
 
 ## Data Directory
 

{methodproof-0.5.5 → methodproof-0.7.0}/README.md

@@ -52,6 +52,87 @@ methodproof view      # explore your session in the browser
 - **Auto-detection** — hooks for shell, Claude Code, OpenClaw, codex, gemini, aider installed automatically
 - **Platform sync** — `methodproof push` uploads sessions. `methodproof publish` makes them public and shareable
 
+## Security Architecture
+
+Every event passes through consent gating, encryption, and hash chaining before touching disk. The platform adds a server co-signature on push, creating two-party evidence.
+
+```mermaid
+flowchart TB
+    subgraph LOCAL["LOCAL MACHINE"]
+        direction TB
+        subgraph AGENTS["Capture Agents"]
+            direction LR
+            W["File Watcher"] & T["Terminal Hook"] & B["Browser Bridge"] & H["AI Tool Hooks"]
+        end
+        W & T & B & H -->|"raw event"| EMIT["emit(type, metadata)"]
+
+        subgraph CONSENT["Consent Layer"]
+            direction TB
+            EMIT --> EG{"Event Gate"}
+            EG -->|"category OFF"| DROP["Dropped"]
+            EG -->|"category ON"| FG["Field Gate: strip opted-out fields"]
+            FG --> JG{"Journal Mode?"}
+            JG -->|"OFF: structural only"| STRIP["Strip content fields"]
+            JG -->|"ON: full content"| KEEP["Keep all fields"]
+        end
+
+        subgraph CRYPTO["Encryption + Integrity"]
+            direction TB
+            STRIP & KEEP --> AES["AES-256-GCM: encrypt sensitive fields"]
+            AES --> LOCK["Thread Lock: atomic hash + buffer"]
+            LOCK --> CHAIN["SHA-256 Hash Chain"]
+            CHAIN --> BUF["Batched Flush"]
+        end
+
+        BUF --> DB[("SQLite WAL")]
+        BUF -.->|"--live"| WS["WebSocket Stream"]
+
+        subgraph KEYS["Key Vault"]
+            direction LR
+            ENT["Entropy"] --> KDF["Key Derivation"]
+            KDF --> DBK["Encryption Key"]
+            KDF --> BINDK["Binding Key"]
+            KDF --> ED25["Signing Key"]
+            ENT -.-> REC["Recovery Phrase"]
+            KDF -.-> KC["OS Keychain"]
+        end
+    end
+
+    subgraph PUSH["PUSH PROTOCOL"]
+        direction TB
+        DB --> BATCH["Batched Upload"]
+        BATCH --> BIND["Session Binding: HMAC over session metadata"]
+        BIND --> SIGN["Ed25519 Sign: session summary"]
+    end
+
+    subgraph PLATFORM["PLATFORM TRUST BOUNDARY"]
+        direction TB
+        SIGN --> VERIFY["Verify Ed25519 against registered public key"]
+        VERIFY --> COSIG["Server Co-Sign: HMAC over attestation receipt"]
+        COSIG --> NEO[("Graph Store")]
+        NEO --> SCORE["Integrity Score: chain + attestation + cosig + git xref + anomaly"]
+    end
+
+    style DROP fill:#d93326,stroke:#d93326,color:#fff
+    style AES fill:#803794,stroke:#803794,color:#fff
+    style CHAIN fill:#803794,stroke:#803794,color:#fff
+    style LOCK fill:#803794,stroke:#803794,color:#fff
+    style EG fill:#109446,stroke:#109446,color:#fff
+    style JG fill:#109446,stroke:#109446,color:#fff
+    style STRIP fill:#109446,stroke:#109446,color:#fff
+    style VERIFY fill:#c9a84c,stroke:#c9a84c,color:#fff
+    style COSIG fill:#c9a84c,stroke:#c9a84c,color:#fff
+    style SCORE fill:#c9a84c,stroke:#c9a84c,color:#fff
+    style SIGN fill:#192a56,stroke:#192a56,color:#fff
+    style BIND fill:#192a56,stroke:#192a56,color:#fff
+    style DB fill:#192a56,stroke:#192a56,color:#fff
+    style NEO fill:#192a56,stroke:#192a56,color:#fff
+    style KC fill:#803794,stroke:#803794,color:#fff
+    style REC fill:#803794,stroke:#803794,color:#fff
+```
+
+<sup>Green = consent gates · Purple = cryptographic operations · Navy = storage + binding · Gold = integrity verification</sup>
+
 ## Commands
 
 | Command | What it does |
@@ -152,13 +233,15 @@ At session end, outcome metrics are computed: first-shot apply rate, follow-up s
 <details>
 <summary>Integrity verification</summary>
 
-Three layers ensure session data hasn't been tampered with:
+Four layers ensure session data hasn't been tampered with (see [architecture diagram](#security-architecture) above):
+
+**Hash-chained events** — every event includes a SHA-256 hash linking to the previous event. Hash computation is thread-safe (atomic with buffer append). Any modification breaks the chain, detectable via `GET /sessions/{id}/chain/verify`.
 
-**Hash-chained events** — every event includes a SHA-256 hash linking to the previous event. Any modification breaks the chain, detectable via `GET /sessions/{id}/chain/verify`.
+**Ed25519 attestation** — on `methodproof push`, the CLI signs a session summary with your private key. Key generated during `methodproof init`, stored in `~/.methodproof/`.
 
-**Ed25519 attestation** — on `methodproof push`, the CLI signs a session summary with your private key. Install with `pip install methodproof[signing]`. Key generated during `methodproof init`, stored in `~/.methodproof/config.json`.
+**Server co-signature** — the platform independently signs the attestation receipt with its own key and timestamp, creating two-party evidence. Sessions pushed without server co-signature receive a lower integrity score.
 
-**Binary hash self-reporting** — the CLI reports its own binary hash on push. The platform compares against known release hashes to detect modified builds.
+**Binary hash self-reporting** — the CLI reports its own source hash on push. The platform compares against known release hashes to detect modified builds.
 
 </details>
 
@@ -207,7 +290,7 @@ methodproof start
 
 **Excluded patterns:** `__pycache__`, `.pyc`, `.git/`, `node_modules`, `.DS_Store`, `.swp`, temp files ending in `~`
 
-**Git commits** are detected by polling `.git/refs/heads/` every 2 seconds — only commits in a git repo rooted at (or above) the watch directory are captured.
+**Git commits** are detected automatically — only commits in a git repo rooted at (or above) the watch directory are captured.
 
 ## Data Directory
 

{methodproof-0.5.5 → methodproof-0.7.0}/methodproof/__init__.py

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

{methodproof-0.5.5 → 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,27 +58,36 @@ 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
         threads.append(threading.Thread(
             target=bridge.start,
             args=(sid, stop_event, 9877,
-                  cfg.get("token", ""), cfg.get("api_url", ""), cfg.get("e2e_key", "")),
+                  cfg.get("token", ""), cfg.get("api_url", ""), cfg.get("e2e_key", ""),
+                  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.5.5 → 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:
@@ -145,17 +153,21 @@ def emit(event_type: str, metadata: dict[str, Any]) -> None:
     if _e2e_key:
         from methodproof.crypto import encrypt_metadata
         entry["metadata"] = encrypt_metadata(dict(entry["metadata"]), _e2e_key)
-    global _prev_hash
-    from methodproof.integrity import compute_event_hash
-    entry["_chain_hash"] = compute_event_hash(entry, _prev_hash, _account_id)
-    _prev_hash = entry["_chain_hash"]
-    if _live_mode:
-        from methodproof import live as live_mod
-        live_mod.send(entry)
     with _lock:
+        global _prev_hash
+        from methodproof.integrity import compute_event_hash
+        entry["_chain_hash"] = compute_event_hash(entry, _prev_hash, _account_id)
+        _prev_hash = entry["_chain_hash"]
         _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)
 
 
 def flush() -> None:
@@ -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.5.5 → 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.5.5 → methodproof-0.7.0}/methodproof/bridge.py

@@ -12,7 +12,8 @@ _session_id = ""
 _api_token = ""
 _api_base = ""
 _e2e_key = ""
-_pairing: dict[str, Any] = {}  # {token: {session_id, api_token, api_base, e2e_key, paired}}
+_journal = False
+_pairing: dict[str, Any] = {}  # {token: {session_id, api_token, api_base, e2e_key, journal, paired}}
 _extension_paired = threading.Event()
 MAX_BODY = 10 * 1024 * 1024  # 10 MB
 
@@ -47,6 +48,7 @@ PAIR_PAGE = """<!DOCTYPE html>
          data-token="{api_token}"
          data-api-base="{api_base}"
          data-e2e-key="{e2e_key}"
+         data-journal="{journal}"
          style="display:none"></div>
   </div>
   <script>
@@ -62,11 +64,12 @@ PAIR_PAGE = """<!DOCTYPE html>
 </html>"""
 
 
-def generate_pair_token(session_id: str, api_token: str, api_base: str, e2e_key: str = "") -> str:
+def generate_pair_token(session_id: str, api_token: str, api_base: str,
+                        e2e_key: str = "", journal: bool = False) -> str:
     token = secrets.token_urlsafe(16)
     _pairing[token] = {
         "session_id": session_id, "api_token": api_token,
-        "api_base": api_base, "e2e_key": e2e_key, "paired": False,
+        "api_base": api_base, "e2e_key": e2e_key, "journal": journal, "paired": False,
     }
     return token
 
@@ -92,6 +95,7 @@ class _Handler(BaseHTTPRequestHandler):
                 api_token=data["api_token"],
                 api_base=data["api_base"],
                 e2e_key=data["e2e_key"],
+                journal="true" if data.get("journal") else "false",
                 pair_token=token,
             ).encode()
             self.send_response(200)
@@ -109,6 +113,7 @@ class _Handler(BaseHTTPRequestHandler):
                     "token": _api_token,
                     "api_base": _api_base,
                     "e2e_key": _e2e_key,
+                    "journal": _journal,
                 })
                 _extension_paired.set()
                 base.log("info", "extension.auto_paired", session_id=_session_id)
@@ -149,6 +154,7 @@ class _Handler(BaseHTTPRequestHandler):
                 "api_token": body.get("api_token", ""),
                 "api_base": body.get("api_base", ""),
                 "e2e_key": body.get("e2e_key", ""),
+                "journal": body.get("journal", False),
                 "paired": False,
             }
             self._json({"ok": True, "token": token})
@@ -185,12 +191,14 @@ class _Handler(BaseHTTPRequestHandler):
 
 
 def start(session_id: str, stop: threading.Event, port: int = 9877,
-          api_token: str = "", api_base: str = "", e2e_key: str = "") -> None:
-    global _session_id, _api_token, _api_base, _e2e_key
+          api_token: str = "", api_base: str = "", e2e_key: str = "",
+          journal: bool = False) -> None:
+    global _session_id, _api_token, _api_base, _e2e_key, _journal
     _session_id = session_id
     _api_token = api_token
     _api_base = api_base
     _e2e_key = e2e_key
+    _journal = journal
     _extension_paired.clear()
     HTTPServer.allow_reuse_address = True
     server = HTTPServer(("127.0.0.1", port), _Handler)

{methodproof-0.5.5 → 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,18 +1070,23 @@ 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=(
             sid, stop_event, 9877,
             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()
@@ -1053,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():
@@ -1582,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.5.5 → 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.5.5 → 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.5.5 → 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.5.5 → methodproof-0.7.0}/methodproof/sync.py

@@ -102,9 +102,10 @@ def push(session_id: str, token: str, api_url: str) -> str:
     event_hashes = store.get_event_hashes(session_id)
     hash_lookup = {h["event_id"]: h["hash"] for h in event_hashes}
     total = len(events)
+    batch_size = 500
     try:
-        for i in range(0, total, 100):
-            batch = events[i:i + 100]
+        for i in range(0, total, batch_size):
+            batch = events[i:i + batch_size]
             payload = [{"id": e["id"], "type": e["type"],
                          "timestamp": _iso(e["timestamp"]),
                          "timestamp_raw": e["timestamp"],
@@ -112,9 +113,18 @@ def push(session_id: str, token: str, api_url: str) -> str:
                          "metadata": json.loads(e["metadata"]),
                          "hash": hash_lookup.get(e["id"], "")}
                         for e in batch]
-            _request("POST", f"/sessions/{remote_id}/events", api_url, token,
-                     {"events": payload})
-            done = min(i + 100, total)
+            for attempt in range(5):
+                try:
+                    _request("POST", f"/sessions/{remote_id}/events", api_url, token,
+                             {"events": payload})
+                    break
+                except SystemExit as exc:
+                    if "429" in str(exc) and attempt < 4:
+                        import time
+                        time.sleep(10 * (attempt + 1))
+                    else:
+                        raise
+            done = min(i + batch_size, total)
             print(f"\r  Uploading: {done}/{total} events", end="", flush=True)
         print()
     except SystemExit:

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

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.5.5"
+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.5.5 → methodproof-0.7.0}/uv.lock

@@ -649,7 +649,7 @@ name = "importlib-metadata"
 version = "9.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "zipp" },
+    { name = "zipp", marker = "python_full_version < '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" }
 wheels = [
@@ -862,7 +862,7 @@ wheels = [
 
 [[package]]
 name = "methodproof"
-version = "0.4.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'" },