methodproof 0.3.4__tar.gz → 0.4.0__tar.gz

{methodproof-0.3.4 → methodproof-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.3.4
+Version: 0.4.0
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -9,6 +9,8 @@ Requires-Dist: watchdog>=4.0
 Requires-Dist: websocket-client>=1.7
 Provides-Extra: e2e
 Requires-Dist: cryptography>=43.0; extra == 'e2e'
+Provides-Extra: proxy
+Requires-Dist: mitmproxy>=10.0; extra == 'proxy'
 Provides-Extra: signing
 Requires-Dist: cryptography>=43.0; extra == 'signing'
 Description-Content-Type: text/markdown

{methodproof-0.3.4 → methodproof-0.4.0}/methodproof/__init__.py

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

{methodproof-0.3.4 → methodproof-0.4.0}/methodproof/agents/base.py

@@ -47,6 +47,23 @@ _EVENT_GATES: dict[str, str] = {
     "music_playing": "music",
     "environment_profile": "environment_analysis",
     "prompt_outcomes": "ai_prompts",
+    "ai_cli_start": "ai_prompts",
+    "ai_cli_end": "ai_responses",
+    # Hook lifecycle events (all AI tools)
+    "user_prompt": "ai_prompts",
+    "tool_call": "ai_responses",
+    "tool_result": "ai_responses",
+    "task_start": "ai_responses",
+    "task_end": "ai_responses",
+    "agent_launch": "ai_responses",
+    "agent_complete": "ai_responses",
+    "claude_session_start": "ai_prompts",
+    "codex_session_start": "ai_prompts",
+    "codex_session_end": "ai_responses",
+    "gemini_session_start": "ai_prompts",
+    "gemini_session_end": "ai_responses",
+    "kiro_session_start": "ai_prompts",
+    "kiro_session_end": "ai_responses",
 }
 
 # Maps capture categories to (event_type, field) pairs for field-level gating.
@@ -57,9 +74,11 @@ _FIELD_GATES: dict[str, list[tuple[str, str]]] = {
     "code_capture": [("file_edit", "diff"), ("git_commit", "diff")],
 }
 
+_journal_mode = False
+
 
 def init(session_id: str, live: bool = False) -> None:
-    global _session_id, _initialized, _e2e_key, _capture, _live_mode, _prev_hash
+    global _session_id, _initialized, _e2e_key, _capture, _live_mode, _prev_hash, _journal_mode
     _session_id = session_id
     _initialized = True
     _live_mode = live
@@ -69,6 +88,7 @@ def init(session_id: str, live: bool = False) -> None:
     raw = cfg.get("e2e_key", "")
     _e2e_key = bytes.fromhex(raw) if raw else None
     _capture = cfg.get("capture", {})
+    _journal_mode = cfg.get("journal_mode", False)
 
 
 def log(level: str, event: str, **kw: object) -> None:
@@ -91,6 +111,15 @@ def emit(event_type: str, metadata: dict[str, Any]) -> None:
             if event_type == etype and not _capture.get(category, True):
                 metadata.pop(field, None)
 
+    # Journal mode gate — strip content fields when journal is OFF (default).
+    # Structural equivalents (prompt_length, etc.) are always kept.
+    # Journal ON = complete explicit record. Journal OFF = structural only.
+    if not _journal_mode:
+        from methodproof.config import JOURNAL_CONTENT_FIELDS
+        for etype, field in JOURNAL_CONTENT_FIELDS:
+            if event_type == etype and field in metadata:
+                metadata.pop(field, None)
+
     entry = {
         "id": uuid.uuid4().hex,
         "session_id": _session_id,

{methodproof-0.3.4 → methodproof-0.4.0}/methodproof/analysis.py

@@ -439,6 +439,71 @@ def analyze_prompt(text: str) -> dict[str, Any]:
     }
 
 
+def compose_summary(meta: dict[str, Any]) -> str:
+    """Compose a readable prompt summary from structural analysis fields.
+
+    Replaces dumb 200-char truncation with a meaningful, searchable summary.
+    Zero API calls — purely local composition from already-extracted sa_* fields.
+
+    Examples:
+      "[instruction/synthesis] refactor app/auth/middleware.py — dependency injection"
+      "[bug_report/execution] fix TypeError in utils.py:parse_config — Python, JSON"
+      "[design_question/analysis] caching strategy — Redis, PostgreSQL, 3 constraints"
+      "[correction] not that approach — references prior turn"
+    """
+    intent = meta.get("sa_intent", "unknown")
+    cognitive = meta.get("sa_cognitive_level", "")
+    files = meta.get("sa_named_files", [])
+    functions = meta.get("sa_named_functions", [])
+    classes = meta.get("sa_named_classes", [])
+    technologies = meta.get("sa_named_technologies", [])
+    languages = meta.get("sa_code_languages", [])
+    collab = meta.get("sa_collaboration_mode", "")
+
+    # Header: [intent/cognitive]
+    header = f"[{intent}"
+    if cognitive and cognitive != "none":
+        header += f"/{cognitive}"
+    header += "]"
+
+    # Entities: files, functions, classes, technologies
+    parts: list[str] = []
+    if files:
+        parts.extend(files[:3])
+    if functions:
+        parts.extend(functions[:2])
+    if classes:
+        parts.extend(classes[:2])
+    if technologies:
+        parts.extend(technologies[:4])
+    elif languages:
+        parts.extend(languages[:2])
+
+    # Qualifiers
+    qualifiers: list[str] = []
+    if meta.get("sa_has_error_trace"):
+        qualifiers.append(f"{meta.get('sa_error_trace_lines', 0)} error lines")
+    if meta.get("sa_has_constraints"):
+        qualifiers.append("constrained")
+    if meta.get("sa_has_acceptance_criteria"):
+        qualifiers.append("with criteria")
+    if meta.get("sa_is_compound"):
+        qualifiers.append("multi-part")
+    if meta.get("sa_references_prior_turn"):
+        qualifiers.append("references prior turn")
+    if meta.get("sa_code_block_count", 0) > 0:
+        qualifiers.append(f"{meta['sa_code_block_count']} code blocks")
+
+    # Compose
+    summary = header
+    if parts:
+        summary += " " + ", ".join(dict.fromkeys(parts))  # dedupe preserving order
+    if qualifiers:
+        summary += " — " + ", ".join(qualifiers[:3])
+
+    return summary
+
+
 def scan_environment(watch_dir: str) -> dict[str, Any]:
     """Scan filesystem for AI instruction files and config. No content stored."""
     home = Path.home()

{methodproof-0.3.4 → methodproof-0.4.0}/methodproof/cli.py

@@ -1,7 +1,7 @@
 """MethodProof CLI. See how you code.
 
 Usage:
-    methodproof init              Install hooks, configure capture + research + redaction
+    methodproof init              Install hooks, configure capture
     methodproof start [--dir .]   Start recording a session
     methodproof stop              Stop recording, build process graph
     methodproof view [id]         View session graph in browser
@@ -60,6 +60,69 @@ def _banner() -> str:
     return f"MethodProof — {_rainbow('Full Spectrum')}"
 
 
+def _app_url(api_url: str) -> str:
+    """Derive dashboard URL from API URL."""
+    if "localhost" in api_url or "127.0.0.1" in api_url:
+        return "http://localhost:5173"
+    return api_url.replace("api.", "app.", 1)
+
+
+def _print_intro() -> None:
+    """Show the 3-layer architecture intro with rainbow borders."""
+    if not sys.stdout.isatty():
+        _print_intro_plain()
+        return
+
+    W = "\033[1;97m"
+    G = "\033[92m"
+    C = "\033[96m"
+    Y = "\033[93m"
+    D = "\033[90m"
+    R = _RESET
+
+    bar = _rainbow("━" * 51)
+
+    print(f"\n  {bar}\n")
+    print(f"       {W}M E T H O D P R O O F{R}")
+    print(f"    {D}See how you code. Prove how you build.{R}")
+    print(f"\n  {bar}\n")
+    print(f"   ┌────────────────────────────────────────────────┐")
+    print(f"   │  {Y}SHARE{R}     push · publish · live stream        │")
+    print(f"   ├────────────────────────────────────────────────┤")
+    print(f"   │  {C}GRAPH{R}     knowledge graph · moments · edges   │")
+    print(f"   ├────────────────────────────────────────────────┤")
+    print(f"   │  {G}CAPTURE{R}   hooks · proxy · plugin              │")
+    print(f"   └────────────────────────────────────────────────┘")
+    print()
+    print(f"   {D}1.{R} {G}mp start{R}       begin recording")
+    print(f"   {D}2.{R} code normally  {D}MethodProof watches silently{R}")
+    print(f"   {D}3.{R} {G}mp stop{R}        build your process graph")
+    print(f"   {D}4.{R} {G}mp push{R}        upload to your profile")
+    print()
+    print(f"   {D}All data stays local until you push.{R}\n")
+
+
+def _print_intro_plain() -> None:
+    print("\n  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n")
+    print("       M E T H O D P R O O F")
+    print("    See how you code. Prove how you build.")
+    print("\n  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n")
+    print("   ┌────────────────────────────────────────────────┐")
+    print("   │  SHARE     push · publish · live stream        │")
+    print("   ├────────────────────────────────────────────────┤")
+    print("   │  GRAPH     knowledge graph · moments · edges   │")
+    print("   ├────────────────────────────────────────────────┤")
+    print("   │  CAPTURE   hooks · proxy · plugin              │")
+    print("   └────────────────────────────────────────────────┘")
+    print()
+    print("   1. mp start       begin recording")
+    print("   2. code normally  MethodProof watches silently")
+    print("   3. mp stop        build your process graph")
+    print("   4. mp push        upload to your profile")
+    print()
+    print("   All data stays local until you push.\n")
+
+
 _ALIAS_MARKER = "# methodproof-alias"
 
 
@@ -75,20 +138,77 @@ def _install_alias() -> None:
         f.write(alias)
 
 
+def _print_journal_intro(credits: int) -> None:
+    """Show journal mode introduction with remaining credits."""
+    print("  ┌─────────────────────────────────────────────────────┐")
+    print("  │  Journal Mode — full content capture                │")
+    print("  └─────────────────────────────────────────────────────┘")
+    print(f"  You have {credits} free journal credit{'s' if credits != 1 else ''} "
+          f"(sessions up to {config.FREE_JOURNAL_MAX_HOURS}h each).")
+    print()
+    print("  By default, MethodProof captures structural metadata only —")
+    print("  file paths, line counts, timing, tool names. Journal mode")
+    print("  preserves the full picture: prompts, AI responses, diffs,")
+    print("  and terminal output. All encrypted (AES-256-GCM).")
+    print()
+    print("  Try it:  mp start --journal")
+    print("  Toggle:  mp journal on / off / status")
+    print()
+
+
 def _run_consent(cfg: dict) -> dict:
-    """Interactive consent flow with three sections: capture, research, redaction."""
+    """Simplified consent flow: accept defaults or customize."""
+    print(f"\n{_banner()}\n")
+    print("  Built by engineers, for engineers.\n")
+    print("  All data stays local in ~/.methodproof/. Nothing leaves your")
+    print("  machine unless you explicitly run `mp push` or `mp publish`.\n")
+    print("  MethodProof records structural metadata about your workflow:")
+    print("  commands, file changes, git commits, AI interactions, and more.")
+    print("  No code content is stored by default.\n")
+
+    choice = input("  Enable recommended capture? [Y/n/c to customize]: ").strip().lower()
+
+    if choice in ("c", "customize"):
+        return _run_consent_detailed(cfg)
+
+    if choice in ("n", "no"):
+        # Minimal: only file changes + git commits
+        capture = {k: False for k in config.STANDARD_CATEGORIES}
+        capture["file_changes"] = True
+        capture["git_commits"] = True
+        capture["code_capture"] = False
+        cfg["capture"] = capture
+        cfg["research_consent"] = False
+        cfg["publish_redact"] = dict(config._DEFAULTS["publish_redact"])
+        cfg["consent_acknowledged"] = True
+        credits = cfg.get("journal_credits", config._DEFAULTS["journal_credits"])
+        print("\n  Minimal capture enabled (file changes + git commits).\n")
+        _print_journal_intro(credits)
+        print("  Customize anytime: `methodproof consent`\n")
+        return cfg
+
+    # Default: all 10 standard on, code_capture off
+    cfg["capture"] = dict(config._DEFAULTS["capture"])
+    cfg["research_consent"] = False
+    cfg["publish_redact"] = dict(config._DEFAULTS["publish_redact"])
+    cfg["consent_acknowledged"] = True
+    credits = cfg.get("journal_credits", config._DEFAULTS["journal_credits"])
+    print(f"\n  {_rainbow('Full Spectrum')} enabled — free live streaming unlocked.\n")
+    _print_journal_intro(credits)
+    print("  Customize anytime: `methodproof consent`\n")
+    return cfg
+
+
+def _run_consent_detailed(cfg: dict) -> dict:
+    """Full interactive consent flow with three sections: capture, research, redaction."""
     capture = cfg.get("capture", dict(config._DEFAULTS["capture"]))
     publish_redact = cfg.get("publish_redact", dict(config._DEFAULTS["publish_redact"]))
     std = config.STANDARD_CATEGORIES
 
-    print(f"\n{_banner()}\n")
-    print("Built by engineers, for engineers.\n")
-    print("All data stays local in ~/.methodproof/. Nothing leaves your")
-    print("machine unless you explicitly run `mp push` or `mp publish`.\n")
-
     # --- Section 1: Capture ---
+    print()
     print("=" * 60)
-    print("  SECTION 1: What gets recorded locally")
+    print("  What gets recorded locally")
     print("=" * 60)
     print()
     print("  These 10 categories are structural metadata only.")
@@ -143,7 +263,7 @@ def _run_consent(cfg: dict) -> dict:
 
     # --- Section 2: Research Data ---
     print("=" * 60)
-    print("  SECTION 2: Contribute to AI research (optional)")
+    print("  Contribute to AI research (optional)")
     print("=" * 60)
     print()
 
@@ -171,7 +291,7 @@ def _run_consent(cfg: dict) -> dict:
 
     # --- Section 3: Publish Redaction ---
     print("=" * 60)
-    print("  SECTION 3: Default redactions for public sessions")
+    print("  Default redactions for public sessions")
     print("=" * 60)
     print()
     print("  `mp push` uploads privately to your account (nothing public).")
@@ -288,9 +408,8 @@ def cmd_init(args: argparse.Namespace) -> None:
     else:
         print("Signing key: exists")
 
-    print(f"\n{_banner()}")
-    print("Restart your shell, then run: methodproof start\n")
-    _print_commands()
+    _print_intro()
+    print("  Restart your shell, then run: mp start\n")
 
 
 def _print_commands() -> None:
@@ -310,7 +429,11 @@ def _print_commands() -> None:
     print(f"  {_W}RECORD{R}")
     print(f"    {_G}mp start{R}              Start recording a session")
     print(f"    {_G}mp stop{R}               Stop recording, build process graph")
-    print(f"    {_G}mp start --live{R}        Stream your graph in real time")
+    print(f"    {_G}mp start --live{R}        Stream your graph privately (only you can view)")
+    print(f"    {_G}mp start --live-public{R} Stream your graph publicly (shareable link)")
+    print(f"    {_G}mp start --journal{R}    Full content capture (2 free credits, then Pro)")
+    print(f"    {_G}mp journal on{R}         Enable persistent journal mode")
+    print(f"    {_G}mp journal status{R}     Check journal mode and remaining credits")
     print()
     print(f"  {_W}REVIEW{R}")
     print(f"    {_C}mp view{R}  {_D}[id]{R}          View session graph in browser")
@@ -449,12 +572,65 @@ def cmd_uninstall(args: argparse.Namespace) -> None:
 def cmd_consent(args: argparse.Namespace) -> None:
     """Review or change capture, research, and redaction settings."""
     cfg = config.load()
-    cfg = _run_consent(cfg)
+    print(f"\n{_banner()}\n")
+    cfg = _run_consent_detailed(cfg)
     config.save(cfg)
     print(f"\n{_banner()} settings saved.\n")
     _print_commands()
 
 
+def cmd_journal(args: argparse.Namespace) -> None:
+    """Journal mode — full content capture."""
+    subcmd = getattr(args, "journal_cmd", None)
+    cfg = config.load()
+    credits = cfg.get("journal_credits", 0)
+
+    if subcmd == "on":
+        print("Journal Mode — Full Content Capture\n")
+        print("When enabled, MethodProof persists full content alongside structural data:")
+        print("  • Full prompt text (not just length)")
+        print("  • Full AI completion text (not just length)")
+        print("  • Full file diffs and git patches")
+        print("  • Terminal output (not just commands)")
+        print("  • Tool call parameters and results\n")
+        print("All content is encrypted (AES-256-GCM) and subject to your consent settings.\n")
+        if credits > 0:
+            print(f"You have {credits} free journal credit{'s' if credits != 1 else ''} "
+                  f"(sessions up to {config.FREE_JOURNAL_MAX_HOURS}h each).")
+            print("After credits are used, journal mode requires a Pro plan.\n")
+        else:
+            print("Journal mode requires a Pro plan (or free credits if available).\n")
+        answer = input("Enable journal mode? [y/N] ").strip().lower()
+        if answer != "y":
+            print("Journal mode not enabled.")
+            return
+        cfg["journal_mode"] = True
+        config.save(cfg)
+        print("\nJournal mode ON. Full content will be captured in your next session.")
+        print("Run `methodproof start` to begin recording.\n")
+
+    elif subcmd == "off":
+        cfg["journal_mode"] = False
+        config.save(cfg)
+        print("Journal mode OFF. Only structural metadata will be captured.")
+
+    elif subcmd == "status":
+        enabled = cfg.get("journal_mode", False)
+        if enabled:
+            print("Journal mode: ON (full content capture)")
+            print("  Prompts, completions, diffs, and output are persisted and encrypted.")
+        else:
+            print("Journal mode: OFF (structural only)")
+            print("  Only metadata captured: lengths, types, timing, file paths.")
+            print("  Enable with: methodproof journal on")
+        if credits > 0:
+            print(f"  Free journal credits: {credits} "
+                  f"(up to {config.FREE_JOURNAL_MAX_HOURS}h per session)")
+
+    else:
+        print("Usage: methodproof journal [on|off|status]")
+
+
 def _is_daemon_alive() -> bool:
     """Check if the recording daemon is still running."""
     if not PIDFILE.exists():
@@ -511,7 +687,9 @@ def cmd_start(args: argparse.Namespace) -> None:
     capture = cfg.get("capture", {})
 
     live_url = ""
-    if args.live:
+    want_live = args.live or getattr(args, "live_public", False)
+    live_visibility = "public" if getattr(args, "live_public", False) else "private"
+    if want_live:
         if not cfg.get("token"):
             print("Live mode requires login. Run `methodproof login` first.")
             sys.exit(1)
@@ -522,10 +700,27 @@ def cmd_start(args: argparse.Namespace) -> None:
         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) or ""
+        live_url = live_mod.start(cfg["api_url"], cfg["token"], remote_id, capture, live_visibility) or ""
         if not live_url:
-            print("Live stream rejected — requires Pro plan or full-spectrum consent.")
+            print("Live stream rejected — requires Pro plan or Full Spectrum.")
             sys.exit(1)
+        if live_visibility == "private":
+            print(f"Live (private): {live_url}")
+            print("  Only you can view this stream while logged in.")
+        else:
+            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
+    if getattr(args, "journal", False):
+        cfg["journal_mode"] = True
+        credits = cfg.get("journal_credits", 0)
+        if credits > 0:
+            cfg["journal_credits"] = credits - 1
+            print(f"Journal mode ON (free credit used — {credits - 1} remaining, {config.FREE_JOURNAL_MAX_HOURS}h cap).")
+        else:
+            print("Journal mode ON for this session (full content capture).")
+        config.save(cfg)
 
     base.init(sid, live=bool(live_url))
 
@@ -774,8 +969,11 @@ def cmd_push(args: argparse.Namespace) -> None:
         print("No sessions to push.")
         sys.exit(1)
     from methodproof.sync import push
-    push(sid, cfg["token"], cfg["api_url"])
-    print(f"Pushed {sid[:8]} (private). Use `mp publish` to make public.")
+    remote_id = push(sid, cfg["token"], cfg["api_url"])
+    app = _app_url(cfg["api_url"])
+    print(f"Pushed {sid[:8]} (private).")
+    print(f"  View: {app}/personal/sessions/{remote_id}")
+    print(f"  Publish: mp publish {sid[:8]}")
 
 
 def cmd_tag(args: argparse.Namespace) -> None:
@@ -805,11 +1003,15 @@ def cmd_publish(args: argparse.Namespace) -> None:
     session["visibility"] = "public"
     if not session["synced"]:
         from methodproof.sync import push
-        push(session["id"], cfg["token"], cfg["api_url"])
+        remote_id = push(session["id"], cfg["token"], cfg["api_url"])
     else:
         from methodproof.sync import sync_metadata
         sync_metadata(session, cfg["token"], cfg["api_url"])
+        remote_id = session.get("remote_id", "")
+    app = _app_url(cfg["api_url"])
     print(f"Published {session['id'][:8]} (public).")
+    if remote_id:
+        print(f"  View: {app}/sessions/{remote_id}/cover")
 
 
 def _resolve_session(session_id: str) -> dict:
@@ -1122,7 +1324,9 @@ def main() -> None:
     s.add_argument("--repo", help="Git remote URL (overrides auto-detect)")
     s.add_argument("--public", action="store_true", help="Set visibility to public")
     s.add_argument("--tags", help="Comma-separated tags")
-    s.add_argument("--live", action="store_true", help="Stream events live to platform")
+    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)")
     sub.add_parser("stop", help="Stop recording")
     v = sub.add_parser("view", help="Inspect captured session data")
     v.add_argument("session_id", nargs="?")
@@ -1150,8 +1354,20 @@ def main() -> None:
     ext_sub.add_parser("pair", help="Pair extension to active session")
     ext_sub.add_parser("status", help="Check extension connection")
     ext_sub.add_parser("install", help="Open Chrome Web Store listing")
+    jr = sub.add_parser("journal", help="Journal mode — full content capture (2 free credits, then Pro)")
+    jr_sub = jr.add_subparsers(dest="journal_cmd")
+    jr_sub.add_parser("on", help="Enable journal mode (persists full content)")
+    jr_sub.add_parser("off", help="Disable journal mode (structural only)")
+    jr_sub.add_parser("status", help="Show journal mode status")
+    sub.add_parser("intro", help="Show the MethodProof intro")
     sub.add_parser("help", help="Show command reference")
     sub.add_parser("mcp-serve", help="Run MCP server (used by Claude Code)")
+    px = sub.add_parser("proxy", help="Local AI API proxy (deep capture)")
+    px_sub = px.add_subparsers(dest="proxy_cmd")
+    px_sub.add_parser("start", help="Start proxy (requires consent)")
+    px_sub.add_parser("stop", help="Stop proxy")
+    px_sub.add_parser("status", help="Show proxy status")
+    px_sub.add_parser("cert", help="CA certificate install instructions")
 
     args = p.parse_args()
     cmds = {
@@ -1161,11 +1377,15 @@ def main() -> None:
         "delete": cmd_delete, "review": cmd_review, "consent": cmd_consent,
         "update": cmd_update, "uninstall": cmd_uninstall,
         "extension": cmd_extension,
+        "journal": cmd_journal,
+        "intro": lambda _: _print_intro(),
         "help": lambda _: _print_commands(),
         "mcp-serve": cmd_mcp_serve,
+        "proxy": lambda a: __import__("methodproof.proxy", fromlist=["cmd_proxy"]).cmd_proxy(a),
     }
     fn = cmds.get(args.cmd)
     if not fn:
+        _print_intro()
         _print_commands()
         sys.exit(1)
 

{methodproof-0.3.4 → methodproof-0.4.0}/methodproof/config.py

@@ -33,6 +33,8 @@ _DEFAULTS: dict[str, Any] = {
         "code_capture": False,
     },
     "research_consent": False,
+    "journal_mode": False,
+    "journal_credits": 2,
     "publish_redact": {
         "command_output": True,
         "ai_prompts": True,
@@ -41,6 +43,8 @@ _DEFAULTS: dict[str, Any] = {
     },
 }
 
+FREE_JOURNAL_MAX_HOURS = 4
+
 # The 10 standard categories (excludes code_capture)
 STANDARD_CATEGORIES = [
     "terminal_commands", "command_output", "test_results", "file_changes",
@@ -63,6 +67,44 @@ CAPTURE_DESCRIPTIONS: dict[str, str] = {
     "code_capture": "Full file diffs and git patches (Pro only, encrypted, private by default)",
 }
 
+# Content fields that Journal Mode unlocks. When journal_mode is OFF (default),
+# these fields are stripped — only structural equivalents remain (lengths, counts, types).
+# When journal_mode is ON (Pro+), EVERYTHING is persisted and encrypted.
+# Journal = the complete, explicit record of the session.
+JOURNAL_CONTENT_FIELDS: list[tuple[str, str]] = [
+    # AI prompts — full prompt text
+    ("llm_prompt", "prompt_text"),
+    ("agent_prompt", "prompt_preview"),
+    ("user_prompt", "prompt_preview"),
+    # AI responses — full completion text
+    ("llm_completion", "response_text"),
+    ("agent_completion", "response_preview"),
+    ("agent_tool_dispatch", "tool_input_preview"),
+    ("agent_tool_result", "result_preview"),
+    ("agent_skill_invoke", "skill_input_preview"),
+    # Terminal — full command output
+    ("terminal_cmd", "output_snippet"),
+    ("terminal_cmd", "command"),
+    # Code — full diffs and commit messages
+    ("file_edit", "diff"),
+    ("git_commit", "diff"),
+    ("git_commit", "message"),
+    # Web — full search queries, URLs, page titles
+    ("web_search", "query"),
+    ("web_search", "clicked_results"),
+    ("web_visit", "url"),
+    ("web_visit", "title"),
+    # Browser — full search queries, URLs, copy content, AI chat input
+    ("browser_search", "query"),
+    ("browser_visit", "url"),
+    ("browser_visit", "title"),
+    ("browser_copy", "text_snippet"),
+    ("browser_ai_chat", "detected_input"),
+    ("browser_ai_chat", "url"),
+    # Inline completions — provider detail
+    ("inline_completion_accepted", "text_length"),
+]
+
 
 def ensure_dirs() -> None:
     DIR.mkdir(exist_ok=True)

{methodproof-0.3.4 → methodproof-0.4.0}/methodproof/hooks/claude_code.py

@@ -11,9 +11,17 @@ import time
 import urllib.request
 
 try:
-    from methodproof.analysis import analyze_prompt
+    from methodproof.analysis import analyze_prompt, compose_summary
 except ImportError:
     analyze_prompt = lambda _: {}
+    compose_summary = lambda _: ""
+
+def _build_prompt_meta(text: str) -> dict:
+    sa = analyze_prompt(text)
+    sa["prompt_length"] = len(text)
+    sa["prompt_summary"] = compose_summary(sa)
+    return sa
+
 
 _TYPE_MAP = {
     "UserPromptSubmit": "user_prompt",
@@ -27,11 +35,7 @@ _TYPE_MAP = {
 }
 
 _META_EXTRACTORS = {
-    "UserPromptSubmit": lambda d: {
-        "prompt_preview": (d.get("prompt") or "")[:200],
-        "prompt_length": len(d.get("prompt") or ""),
-        **analyze_prompt(d.get("prompt") or ""),
-    },
+    "UserPromptSubmit": lambda d: _build_prompt_meta(d.get("prompt") or ""),
     "PreToolUse": lambda d: {"tool": d.get("tool_name", "unknown"), "tool_use_id": d.get("tool_use_id", "")},
     "PostToolUse": lambda d: {"tool": d.get("tool_name", "unknown"), "tool_use_id": d.get("tool_use_id", "")},
     "SubagentStart": lambda d: {"agent_type": d.get("agent_type", "unknown"), "agent_id": d.get("agent_id", "")},