methodproof 0.8.5__tar.gz → 0.8.7__tar.gz

{methodproof-0.8.5 → methodproof-0.8.7}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [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
+- **`mp push` sends real capture-time boundaries** — `POST /personal/sessions` now includes `started_at` from the local `sessions.created_at`, and `PUT /complete` now includes `ended_at` from `sessions.completed_at` (when available). Previously the server stamped both boundaries at push time, so the dashboard's `/personal/sessions` showed a duration equal to how long the push transaction took instead of the real session window. Requires platform ≥ 2026-04-24; older platforms silently ignore the new fields.
+
 ## [0.8.1] — 2026-04-17
 
 ### Added

{methodproof-0.8.5 → methodproof-0.8.7}/PKG-INFO

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

{methodproof-0.8.5 → methodproof-0.8.7}/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.5 → methodproof-0.8.7}/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.5 → methodproof-0.8.7}/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")
@@ -117,13 +145,17 @@ def push(session_id: str, token: str, api_url: str, force: bool = False) -> str:
         create_body["session_binding"] = session["session_binding"]
     if session.get("device_id"):
         create_body["device_id"] = session["device_id"]
+    # Send the original capture start so the remote session's duration reflects
+    # the actual session, not the push transaction.
+    if session.get("created_at"):
+        create_body["started_at"] = _iso(session["created_at"])
     result = _request("POST", "/personal/sessions", api_url, token,
                       create_body or None)
     remote_id = result["session_id"]
     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)
@@ -190,7 +222,11 @@ def push(session_id: str, token: str, api_url: str, force: bool = False) -> str:
             pass  # cryptography not installed
 
     # Complete (server drains ingest queue + materializes stats — needs longer timeout)
-    _request("PUT", f"/personal/sessions/{remote_id}/complete", api_url, token, timeout=90)
+    complete_body: dict[str, Any] | None = None
+    if session.get("completed_at"):
+        complete_body = {"ended_at": _iso(session["completed_at"])}
+    _request("PUT", f"/personal/sessions/{remote_id}/complete", api_url, token,
+             complete_body, timeout=90)
     store.mark_synced(session_id, remote_id)
 
     # Sync metadata (repo, tags, visibility)
@@ -206,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.5 → methodproof-0.8.7}/pyproject.toml

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

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