methodproof 0.8.6__tar.gz → 0.8.8__tar.gz

{methodproof-0.8.6 → methodproof-0.8.8}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.8.8] — 2026-05-30
+
+### Fixed
+- **Git telemetry inside worktrees** — the watcher and sub-repo enumeration both assumed `.git` is a directory, but in a `git worktree` it is a file pointing at the shared git dir. As a result, running `mp start` from a worktree captured zero `git_commit`/`git_branch_switch` events (the poller raised `NotADirectoryError` reading `.git/refs` and `.git/HEAD`, swallowed silently) and `mp push`/`mp resync` skipped the worktree's repo entirely. The poller now resolves the per-worktree git dir (HEAD) and shared common dir (refs) via `git rev-parse --absolute-git-dir --git-common-dir` (`methodproof/agents/watcher.py`), and sub-repo enumeration detects worktrees via `os.path.exists` rather than `os.path.isdir` (`methodproof/repos.py`).
+
+## [0.8.7] — 2026-05-15
+
+### Fixed
+- **`SubagentStop` events now emit `last_message_preview`** (`methodproof/hooks/claude_code.py`) — the Python hook only emitted full `last_assistant_message`, so the dashboard's structural-only view of `agent_complete` events showed nothing for accounts without journal mode. Hook now emits both: full content (server gates by tier) plus a 200-char preview (always survives).
+
 ## [0.8.6] — 2026-04-24
 
 ### Fixed

{methodproof-0.8.6 → methodproof-0.8.8}/PKG-INFO

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

{methodproof-0.8.6 → methodproof-0.8.8}/methodproof/agents/watcher.py

@@ -268,13 +268,39 @@ def _read_branch(head_file: Path) -> str:
         return ""
 
 
+def _resolve_git_dirs(watch_dir: str) -> tuple[Path, Path] | None:
+    """Resolve (git_dir, common_dir) for `watch_dir`, or None if not a git repo.
+
+    HEAD lives in git_dir; shared refs live in common_dir. The two diverge
+    inside a git worktree, where `.git` is a file rather than a directory.
+    """
+    try:
+        out = subprocess.run(
+            ["git", "-C", watch_dir, "rev-parse", "--absolute-git-dir", "--git-common-dir"],
+            capture_output=True, text=True, timeout=5,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return None
+    if out.returncode != 0:
+        return None
+    lines = out.stdout.splitlines()
+    if len(lines) < 2:
+        return None
+    git_dir = Path(lines[0].strip())
+    common_dir = Path(lines[1].strip())
+    if not common_dir.is_absolute():
+        common_dir = (Path(watch_dir) / common_dir).resolve()
+    return git_dir, common_dir
+
+
 def _poll_git(watch_dir: str, stop: threading.Event) -> None:
-    """Poll .git/refs for new commits and HEAD for branch switches."""
-    git_dir = Path(watch_dir) / ".git"
-    if not git_dir.exists():
+    """Poll shared refs for new commits and HEAD for branch switches."""
+    dirs = _resolve_git_dirs(watch_dir)
+    if dirs is None:
         return
+    git_dir, common_dir = dirs
     seen: set[str] = set()
-    refs = git_dir / "refs" / "heads"
+    refs = common_dir / "refs" / "heads"
     head_file = git_dir / "HEAD"
     last_branch = _read_branch(head_file)
     while not stop.is_set():
@@ -284,7 +310,7 @@ def _poll_git(watch_dir: str, stop: threading.Event) -> None:
                 if sha not in seen:
                     seen.add(sha)
                     if len(seen) > 1:
-                        _log_commit(watch_dir, sha)
+                        _log_commit(watch_dir, sha, head_file)
         except OSError:
             pass
         current_branch = _read_branch(head_file)
@@ -296,7 +322,7 @@ def _poll_git(watch_dir: str, stop: threading.Event) -> None:
         stop.wait(2)
 
 
-def _log_commit(watch_dir: str, sha: str) -> None:
+def _log_commit(watch_dir: str, sha: str, head_file: Path) -> None:
     try:
         fmt = subprocess.run(
             ["git", "-C", watch_dir, "log", "-1",
@@ -336,7 +362,7 @@ def _log_commit(watch_dir: str, sha: str) -> None:
         meta["body"] = body
     if file_statuses:
         meta["file_statuses"] = file_statuses
-    branch = _read_branch(Path(watch_dir) / ".git" / "HEAD")
+    branch = _read_branch(head_file)
     if branch:
         meta["branch"] = branch
     include_lines = base.is_content_captured()

{methodproof-0.8.6 → methodproof-0.8.8}/methodproof/cli.py

@@ -1929,6 +1929,54 @@ def _push_one(sid: str, cfg: dict, force: bool = False) -> None:
     print(f"  Publish: mp publish {sid[:8]}")
 
 
+def cmd_resync(args: argparse.Namespace) -> None:
+    """Re-push already-synced sessions to overwrite server ciphertext with
+    plaintext. Use when a past migration encrypted sensitive fields with a
+    key the server can't read."""
+    local = getattr(args, "local", False)
+    cfg = config.load(local=local)
+    if not cfg.get("token"):
+        print("Run `methodproof login` first.")
+        sys.exit(1)
+    if cfg.get("e2e_mode"):
+        print("E2E mode is ON — resync would preserve ciphertext. Turn off with `mp e2e off` first.")
+        sys.exit(1)
+
+    from methodproof.sync import resync_events
+
+    sessions = store.list_sessions()
+    candidates = [s for s in sessions if s.get("synced") and s.get("remote_id")]
+
+    if args.session_id:
+        pref = args.session_id
+        candidates = [s for s in candidates
+                      if s["id"].startswith(pref) or (s.get("remote_id") or "").startswith(pref)]
+        if not candidates:
+            print(f"No synced session matches {args.session_id}")
+            sys.exit(1)
+    elif args.since:
+        from datetime import datetime
+        cutoff = datetime.fromisoformat(args.since).timestamp()
+        candidates = [s for s in candidates
+                      if (s.get("completed_at") or s.get("created_at") or 0) >= cutoff]
+
+    if not candidates:
+        print("No synced sessions to resync.")
+        return
+
+    total_events = 0
+    print(f"Resyncing {len(candidates)} sessions (decrypting sensitive fields on push)...")
+    for s in candidates:
+        try:
+            n = resync_events(s, cfg["token"], cfg["api_url"])
+            total_events += n
+            date = datetime.fromtimestamp(s["created_at"]).strftime("%Y-%m-%d") if s.get("created_at") else "?"
+            print(f"  {s['id'][:8]}  {date}  {n:5} events resynced")
+        except SystemExit as exc:
+            print(f"  {s['id'][:8]}  FAILED: {exc}")
+    print(f"\nDone. {total_events} events resynced across {len(candidates)} sessions.")
+
+
 def cmd_tag(args: argparse.Namespace) -> None:
     session = _resolve_session(args.session_id)
     tags = [t.strip() for t in args.tags.split(",") if t.strip()]
@@ -2356,6 +2404,10 @@ def main() -> None:
     pu.add_argument("session_id", nargs="?")
     pu.add_argument("--force", "-f", action="store_true", help="Re-upload all events (replaces previous push)")
     pu.add_argument("--local", action="store_true", help="Push to local dev API (localhost:8000)")
+    rs_ev = sub.add_parser("resync", help="Re-push already-synced sessions to decrypt sensitive fields server-side")
+    rs_ev.add_argument("session_id", nargs="?", help="Session ID prefix (default: all synced)")
+    rs_ev.add_argument("--since", help="Only resync sessions started on or after this date (YYYY-MM-DD)")
+    rs_ev.add_argument("--local", action="store_true", help="Resync against local dev API")
     tg = sub.add_parser("tag", help="Tag a session")
     tg.add_argument("session_id", help="Session ID (prefix ok)")
     tg.add_argument("tags", help="Comma-separated tags")
@@ -2422,7 +2474,7 @@ def main() -> None:
         "init": cmd_init, "start": cmd_start, "stop": cmd_stop, "connect": cmd_connect,
         "view": cmd_view, "log": cmd_log, "status": cmd_status,
         "login": cmd_login, "logout": cmd_logout, "accounts": cmd_accounts, "switch": cmd_switch,
-        "push": cmd_push, "tag": cmd_tag, "publish": cmd_publish,
+        "push": cmd_push, "resync": cmd_resync, "tag": cmd_tag, "publish": cmd_publish,
         "delete": cmd_delete, "review": cmd_review, "consent": cmd_consent,
         "update": cmd_update, "lock": cmd_lock, "reset": cmd_reset, "uninstall": cmd_uninstall,
         "extension": cmd_extension,

{methodproof-0.8.6 → methodproof-0.8.8}/methodproof/hooks/claude_code.py

@@ -146,6 +146,7 @@ _META_EXTRACTORS = {
     "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": (d.get("last_assistant_message") or "")[: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", "")},

{methodproof-0.8.6 → methodproof-0.8.8}/methodproof/repos.py

@@ -26,7 +26,8 @@ def enumerate_sub_repos(watch_dir: str, max_depth: int = 2) -> list[dict[str, st
     def visit(path: str, depth: int) -> None:
         if not os.path.isdir(path):
             return
-        if os.path.isdir(os.path.join(path, ".git")):
+        # `.git` is a directory in a normal clone, a file in a worktree.
+        if os.path.exists(os.path.join(path, ".git")):
             url = _remote_url(path)
             if url and url not in seen_urls:
                 rel = os.path.relpath(path, watch_dir)

{methodproof-0.8.6 → methodproof-0.8.8}/methodproof/sync.py

@@ -9,6 +9,34 @@ from typing import Any
 from methodproof import store
 
 
+def _prepare_events_for_push(session_id: str) -> list[dict[str, Any]]:
+    """Return events for outbound sync. Sensitive fields encrypted with the
+    local master-derived db_key are decrypted here so the server receives
+    plaintext. Users who opt into true E2E (`mp e2e on`) keep ciphertext
+    verbatim — they explicitly chose platform-unreadable storage.
+
+    Local-DB at-rest encryption and E2E share the `e2e:v1:` wire format,
+    so without this step the server can't tell them apart and shows
+    ciphertext for normal (non-E2E) users."""
+    raw = store.get_events(session_id, decrypt=False)
+    from methodproof import config
+    cfg = config.load()
+    if cfg.get("e2e_mode"):
+        return raw
+    key = store._try_load_db_key()
+    if key is None:
+        return raw
+    from methodproof.crypto import decrypt_metadata_safe
+    prepared = []
+    for e in raw:
+        meta = json.loads(e["metadata"])
+        decrypt_metadata_safe(meta, key)
+        e2 = dict(e)
+        e2["metadata"] = json.dumps(meta)
+        prepared.append(e2)
+    return prepared
+
+
 def sync_metadata(session: dict[str, Any], token: str, api_url: str) -> None:
     """Sync repo, tags, and visibility for an already-pushed session."""
     remote_id = session.get("remote_id")
@@ -127,7 +155,7 @@ def push(session_id: str, token: str, api_url: str, force: bool = False) -> str:
     print(f"done ({remote_id[:8]})")
 
     # Upload events in batches (with hash chain if available)
-    events = store.get_events(session_id)
+    events = _prepare_events_for_push(session_id)
     event_hashes = store.get_event_hashes(session_id)
     hash_lookup = {h["event_id"]: h["hash"] for h in event_hashes}
     total = len(events)
@@ -214,6 +242,34 @@ def _iso(ts: float) -> str:
     return datetime.fromtimestamp(ts, tz=UTC).isoformat()
 
 
+def resync_events(session: dict[str, Any], token: str, api_url: str) -> int:
+    """Re-push events for an already-synced session so server metadata reflects
+    the current local state. Uses the dedicated `/events/resync` endpoint
+    (accepts completed sessions; updates existing Action nodes in place).
+    Returns the number of events submitted."""
+    remote_id = session.get("remote_id")
+    if not remote_id:
+        raise SystemExit(f"Session {session['id'][:8]} has no remote_id — push it first.")
+    events = _prepare_events_for_push(session["id"])
+    total = len(events)
+    batch_size = 500
+    for i in range(0, total, batch_size):
+        batch = events[i:i + batch_size]
+        payload = [{"id": e["id"], "metadata": json.loads(e["metadata"])} for e in batch]
+        for attempt in range(5):
+            try:
+                _request("POST", f"/personal/sessions/{remote_id}/events/resync",
+                         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
+    return total
+
+
 def sync_research_consent(token: str, api_url: str) -> None:
     """Sync research consent between CLI (cache) and platform (source of truth)."""
     from methodproof import config

{methodproof-0.8.6 → methodproof-0.8.8}/pyproject.toml

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

{methodproof-0.8.6 → methodproof-0.8.8}/tests/test_repos.py

@@ -12,6 +12,9 @@ from methodproof import repos
 def _git_init(path: Path, remote: str) -> None:
     path.mkdir(parents=True, exist_ok=True)
     subprocess.run(["git", "init", "-q"], cwd=path, check=True)
+    # CI runners have no global git identity; commits need a local one.
+    subprocess.run(["git", "config", "user.email", "test@methodproof.com"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.name", "test"], cwd=path, check=True)
     subprocess.run(["git", "remote", "add", "origin", remote], cwd=path, check=True)
 
 
@@ -71,3 +74,18 @@ def test_enumerate_sub_repos_skips_non_repo_dirs(tmp_path: Path) -> None:
     assert "node_modules" not in rels
     assert "not-a-repo" not in rels
     assert "real" in rels
+
+
+def test_enumerate_sub_repos_detects_worktree(tmp_path: Path) -> None:
+    main = tmp_path / "main"
+    _git_init(main, "https://github.com/me/wt")
+    subprocess.run(["git", "commit", "-q", "--allow-empty", "-m", "init"],
+                   cwd=main, check=True)
+    wt = tmp_path / "wt-feature"
+    subprocess.run(["git", "worktree", "add", "-q", str(wt), "-b", "feature"],
+                   cwd=main, check=True)
+
+    # `.git` is a file in the worktree, not a directory.
+    assert (wt / ".git").is_file()
+    found = repos.enumerate_sub_repos(str(wt), max_depth=1)
+    assert found == [{"remote_url": "https://github.com/me/wt", "rel_path": ""}]

methodproof-0.8.8/tests/test_watcher_git.py

@@ -0,0 +1,41 @@
+"""Tests for git dir resolution — normal clones vs worktrees."""
+
+import subprocess
+from pathlib import Path
+
+from methodproof.agents import watcher
+
+
+def _git_init(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+    subprocess.run(["git", "init", "-q"], cwd=path, check=True)
+    # CI runners have no global git identity; commits need a local one.
+    subprocess.run(["git", "config", "user.email", "test@methodproof.com"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.name", "test"], cwd=path, check=True)
+    subprocess.run(["git", "commit", "-q", "--allow-empty", "-m", "init"],
+                   cwd=path, check=True)
+
+
+def test_resolve_git_dirs_normal_repo(tmp_path: Path) -> None:
+    _git_init(tmp_path)
+    git_dir, common_dir = watcher._resolve_git_dirs(str(tmp_path))
+    assert git_dir == common_dir
+    assert (git_dir / "HEAD").is_file()
+
+
+def test_resolve_git_dirs_worktree(tmp_path: Path) -> None:
+    main = tmp_path / "main"
+    _git_init(main)
+    wt = tmp_path / "wt-feature"
+    subprocess.run(["git", "worktree", "add", "-q", str(wt), "-b", "feature"],
+                   cwd=main, check=True)
+
+    git_dir, common_dir = watcher._resolve_git_dirs(str(wt))
+    # Worktree HEAD is per-worktree; shared refs live in the common dir.
+    assert git_dir != common_dir
+    assert watcher._read_branch(git_dir / "HEAD") == "feature"
+    assert (common_dir / "refs" / "heads" / "feature").is_file()
+
+
+def test_resolve_git_dirs_non_repo(tmp_path: Path) -> None:
+    assert watcher._resolve_git_dirs(str(tmp_path)) is None

{methodproof-0.8.6 → methodproof-0.8.8}/uv.lock

@@ -708,7 +708,7 @@ wheels = [
 
 [[package]]
 name = "methodproof"
-version = "0.8.5"
+version = "0.8.7"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },