methodproof 0.7.35__tar.gz → 0.7.37__tar.gz

{methodproof-0.7.35 → methodproof-0.7.37}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.7.37] — 2026-04-12
+
+### Changed
+- **Full tool metadata capture** — shell hook now stores complete `tool_input` and `tool_response` objects alongside display previews. Previously only extracted preview strings; raw data was discarded. Enables upstream graph analysis, causal edge building, and artifact tracking from tool events.
+- **Enriched shell hook** — `PreToolUse` captures `tool_input_preview` per tool type (Bash→command, Read/Edit/Write→file_path, Grep→pattern+path, Glob→pattern, Agent→description). `PostToolUse` captures `result_preview` (Bash→stdout/stderr, Read→line count, Grep→file+line count, Glob→file count) plus `tool_input_preview` so results show what was done.
+- **Journal gating removed** — all captured metadata is now persisted regardless of journal mode. No more field stripping in `emit()`. `JOURNAL_CONTENT_FIELDS` retained as a reference for TUI enrichment display.
+- **`tool_result` TUI shows input + result** — e.g. `Grep ✓ def main /src 3 files, 15 lines` instead of just `Grep ✓`.
+
+## [0.7.36] — 2026-04-12
+
+### Added
+- **`mp connect [session_id]`** — attach TUI to an active recording session. Defaults to the current active session. `mp start` with an active session now auto-connects instead of erroring.
+- **Source tracking in TUI** — events display which AI tool session generated them (e.g. `claude`, `codex`). Session bar shows source name and conversation number (`claude #2`). Tracks across multiple AI sessions within one `mp start`.
+- **End session from TUI (`x`)** — confirmation prompt (`y`/`n`) to stop the session and finalize from within the TUI. `q` now exits the TUI without stopping the daemon — reconnect later with `mp connect`.
+
+### Fixed
+- **Tree indentation invisible** — `gold_ember` (`#3d3118`) was near-invisible on dark background; switched to `gold_aged` (`#9a7b3a`).
+- **Orphan tool_call events showed no tree** — `tool_call` after `agent_turn_end`/`agent_complete` fell through to flat rendering. Now implicitly opens a new chain.
+- **`tool_name` field empty in TUI** — hook events store the tool name in `tool` not `tool_name`; formatters now check both fields.
+
 ## [0.7.35] — 2026-04-12
 
 ### Added

{methodproof-0.7.35 → methodproof-0.7.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.7.35
+Version: 0.7.37
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -88,9 +88,10 @@ methodproof view      # explore your session in the browser
 | `enter` | Event detail | Modal overlay with all metadata fields |
 | `m` | Quiet mode | Hide dim events (music, environment, MCP, context compaction) |
 | `p` | Pause | Pause/resume event polling |
-| `q` | Stop | Stop the session |
+| `q` | Exit TUI | Detach — daemon keeps recording. Reconnect with `mp connect` |
+| `x` | End session | Stop recording with confirmation prompt |
 
-Active modes display as badges in the session bar: `J` (journal), `⏸` (scroll locked), `Q` (quiet), `T` (tree collapsed), filter name when not "all".
+Active modes display as badges in the session bar: `J` (journal), `⏸` (scroll locked), `Q` (quiet), `T` (tree collapsed), filter name when not "all". Source tracking shows which AI tool session (`claude #1`, `codex #2`) generated each event.
 
 ## Security Architecture
 
@@ -178,8 +179,9 @@ flowchart TB
 | Command | What it does |
 |---------|-------------|
 | `init` | Interactive consent selector, install hooks, create data directory |
-| `start [--dir .] [--tags t1,t2] [--public] [--live] [--journal] [--e2e]` | Start recording |
+| `start [--dir .] [--tags t1,t2] [--public] [--live] [--journal] [--e2e]` | Start recording (auto-connects if session already active) |
 | `stop` | Stop recording, build process graph |
+| `connect [session_id]` | Attach TUI to an active session (defaults to current) |
 | `view [session_id]` | Open session graph in browser |
 | `log` | List sessions with sync status, visibility, tags |
 | `login [--api-url URL]` | Authenticate with the platform |

{methodproof-0.7.35 → methodproof-0.7.37}/README.md

@@ -71,9 +71,10 @@ methodproof view      # explore your session in the browser
 | `enter` | Event detail | Modal overlay with all metadata fields |
 | `m` | Quiet mode | Hide dim events (music, environment, MCP, context compaction) |
 | `p` | Pause | Pause/resume event polling |
-| `q` | Stop | Stop the session |
+| `q` | Exit TUI | Detach — daemon keeps recording. Reconnect with `mp connect` |
+| `x` | End session | Stop recording with confirmation prompt |
 
-Active modes display as badges in the session bar: `J` (journal), `⏸` (scroll locked), `Q` (quiet), `T` (tree collapsed), filter name when not "all".
+Active modes display as badges in the session bar: `J` (journal), `⏸` (scroll locked), `Q` (quiet), `T` (tree collapsed), filter name when not "all". Source tracking shows which AI tool session (`claude #1`, `codex #2`) generated each event.
 
 ## Security Architecture
 
@@ -161,8 +162,9 @@ flowchart TB
 | Command | What it does |
 |---------|-------------|
 | `init` | Interactive consent selector, install hooks, create data directory |
-| `start [--dir .] [--tags t1,t2] [--public] [--live] [--journal] [--e2e]` | Start recording |
+| `start [--dir .] [--tags t1,t2] [--public] [--live] [--journal] [--e2e]` | Start recording (auto-connects if session already active) |
 | `stop` | Stop recording, build process graph |
+| `connect [session_id]` | Attach TUI to an active session (defaults to current) |
 | `view [session_id]` | Open session graph in browser |
 | `log` | List sessions with sync status, visibility, tags |
 | `login [--api-url URL]` | Authenticate with the platform |

{methodproof-0.7.35 → methodproof-0.7.37}/methodproof/agents/base.py

@@ -140,15 +140,6 @@ 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.7.35 → methodproof-0.7.37}/methodproof/cli.py

@@ -1098,9 +1098,11 @@ def cmd_start(args: argparse.Namespace) -> None:
 
     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)
+            sid = cfg["active_session"]
+            print(f"  Session {sid[:8]} already active. Connecting...")
+            args.session_id = None  # connect resolves from config
+            cmd_connect(args)
+            return
         stale_sid = cfg["active_session"]
         _log_step(f"Cleaning stale session {stale_sid[:8]}")
         store.complete_session(stale_sid)
@@ -1301,7 +1303,9 @@ def cmd_start(args: argparse.Namespace) -> None:
         if _resolve_ui(args, cfg):
             session = store.get_session(sid)
             from methodproof.tui.start import run as tui_start
-            tui_start(sid, session)
+            result = tui_start(sid, session)
+            if result == "end_session":
+                cmd_stop(args)
             return
         print("Run `mp stop` to finish.")
         return
@@ -1444,6 +1448,33 @@ def cmd_stop(args: argparse.Namespace) -> None:
     _print_summary(session, stats, cfg)
 
 
+def cmd_connect(args: argparse.Namespace) -> None:
+    """Attach TUI to an active recording session."""
+    cfg = config.load()
+    sid = getattr(args, "session_id", None)
+    if sid:
+        # Resolve prefix
+        sessions = store.list_sessions()
+        match = [s for s in sessions if s["id"].startswith(sid)]
+        if not match:
+            print(f"No session matching '{sid}'")
+            sys.exit(1)
+        sid = match[0]["id"]
+    else:
+        sid = cfg.get("active_session")
+    if not sid:
+        print("No active session. Run `mp start` first.")
+        sys.exit(1)
+    session = store.get_session(sid)
+    if not session:
+        print(f"Session {sid[:8]} not found.")
+        sys.exit(1)
+    from methodproof.tui.start import run as tui_start
+    result = tui_start(sid, session)
+    if result == "end_session":
+        cmd_stop(args)
+
+
 def cmd_view(args: argparse.Namespace) -> None:
     session = _resolve_session(args.session_id)
     from methodproof.viewer import view
@@ -1782,18 +1813,51 @@ def cmd_push(args: argparse.Namespace) -> None:
     local = getattr(args, "local", False)
     cfg = config.load(local=local)
     if not cfg.get("token"):
-        target = "local API" if local else "platform"
         print(f"Run `methodproof login{' --api-url http://localhost:8000' if local else ''}` first.")
         sys.exit(1)
     from methodproof.sync import sync_research_consent
     sync_research_consent(cfg["token"], cfg["api_url"])
     cfg = config.load(local=local)
-    sid = args.session_id or _latest()
-    if not sid:
-        print("No sessions to push.")
-        sys.exit(1)
-    from methodproof.sync import push
     force = getattr(args, "force", False)
+
+    if args.session_id:
+        _push_one(args.session_id, cfg, force=force)
+        return
+
+    # No session_id — check for unsynced completed sessions
+    unsynced = [s for s in store.list_sessions()
+                if not s["synced"] and s.get("completed_at")]
+    if not unsynced:
+        # Fall back to latest session
+        sid = _latest()
+        if not sid:
+            print("No sessions to push.")
+            sys.exit(1)
+        _push_one(sid, cfg, force=force)
+        return
+
+    if len(unsynced) == 1:
+        _push_one(unsynced[0]["id"], cfg, force=force)
+        return
+
+    # Multiple unsynced — offer to push all
+    print(f"Found {len(unsynced)} unsynced sessions:\n")
+    for s in unsynced:
+        events = len(store.get_events(s["id"]))
+        date = s["created_at"][:10] if s.get("created_at") else "?"
+        print(f"  {s['id'][:8]}  {date}  {events} events")
+    print()
+    answer = input(f"Push all {len(unsynced)}? [Y/n] ").strip().lower()
+    if answer in ("", "y", "yes"):
+        for s in unsynced:
+            _push_one(s["id"], cfg, force=force)
+            print()
+    else:
+        print("Cancelled. Push individually with `mp push <session_id>`.")
+
+
+def _push_one(sid: str, cfg: dict, force: bool = False) -> None:
+    from methodproof.sync import push
     remote_id = push(sid, cfg["token"], cfg["api_url"], force=force)
     app = _app_url(cfg["api_url"])
     print(f"Pushed {sid[:8]} → {cfg['api_url']} (private).")
@@ -2205,6 +2269,9 @@ def main() -> None:
     s.add_argument("--streaming", action="store_true", help="Blocking foreground — stream every captured event to stdout")
     _add_ui_flags(s)
     sub.add_parser("stop", help="Stop recording")
+    cn = sub.add_parser("connect", help="Attach TUI to active session")
+    cn.add_argument("session_id", nargs="?", help="Session ID prefix (defaults to active)")
+    _add_ui_flags(cn)
     v = sub.add_parser("view", help="Inspect captured session data")
     v.add_argument("session_id", nargs="?")
     l_log = sub.add_parser("log", help="List sessions")
@@ -2287,7 +2354,7 @@ def main() -> None:
 
     args = p.parse_args()
     cmds = {
-        "init": cmd_init, "start": cmd_start, "stop": cmd_stop,
+        "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,

{methodproof-0.7.35 → methodproof-0.7.37}/methodproof/config.py

@@ -79,47 +79,37 @@ 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 — no longer gated. All captured metadata is persisted.
+# This list is retained as a reference for the TUI journal enrichment layer,
+# which uses it to identify fields worth displaying as secondary content lines.
 JOURNAL_CONTENT_FIELDS: list[tuple[str, str]] = [
-    # AI prompts — full prompt text
     ("llm_prompt", "prompt_text"),
     ("agent_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 (command itself is structural, not gated)
     ("terminal_cmd", "output_snippet"),
-    # Code — full diffs and commit messages
     ("file_edit", "diff"),
     ("git_commit", "diff"),
     ("git_commit", "message"),
-    # Web — full search queries, URLs, page titles
+    ("git_commit", "body"),
     ("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"),
-    # Tasks — subject reveals intent
     ("task_created", "subject"),
-    # Claude Code hooks — tool input/output and raw user prompt
     ("user_prompt", "prompt_text"),
     ("tool_call", "tool_input_preview"),
     ("tool_result", "result_preview"),
-    # Agent final message and commit body reveal content
     ("agent_complete", "last_message_preview"),
-    ("git_commit", "body"),
 ]
 
 

{methodproof-0.7.35 → methodproof-0.7.37}/methodproof/hooks/claude_code.py

@@ -99,20 +99,26 @@ _META_EXTRACTORS = {
     },
     "PreToolUse": lambda d: {
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"),
+        "tool_input": d.get("tool_input") or {},
         "tool_input_preview": _tool_input_preview(d),
     },
     "PostToolUse": lambda d: {
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"), "success": True,
+        "tool_input": d.get("tool_input") or {},
+        "tool_response": d.get("tool_response") or {},
+        "tool_input_preview": _tool_input_preview(d),
         "result_preview": _extract_result_text(d.get("tool_response")),
     },
     "PostToolUseFailure": lambda d: {
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"),
         "success": False, "is_interrupt": d.get("is_interrupt", False),
+        "tool_input": d.get("tool_input") or {},
         "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", ""),
+        "last_assistant_message": d.get("last_assistant_message", ""),
         "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", "")},

{methodproof-0.7.35 → methodproof-0.7.37}/methodproof/hooks/claude_code.sh

@@ -37,11 +37,62 @@ if command -v jq >/dev/null 2>&1; then
       ;;
     PreToolUse)
       TYPE="tool_call"
-      META=$(echo "$INPUT" | jq -c '{tool: (.tool_name // "unknown"), tool_use_id: (.tool_use_id // "")}' 2>/dev/null || echo '{}')
+      META=$(echo "$INPUT" | jq -c '{
+        tool: (.tool_name // "unknown"),
+        tool_use_id: (.tool_use_id // ""),
+        tool_input: (.tool_input // {}),
+        tool_input_preview: (
+          (.tool_input // {}) as $ti |
+          (.tool_name // "unknown") as $tn |
+          (if $tn == "Bash" then ($ti.command // "")
+           elif $tn == "Read" then ($ti.file_path // "")
+           elif $tn == "Write" then ($ti.file_path // "")
+           elif $tn == "Edit" then ($ti.file_path // "")
+           elif $tn == "Grep" then (($ti.pattern // "") + " " + ($ti.path // ""))
+           elif $tn == "Glob" then ($ti.pattern // "")
+           elif $tn == "Agent" then ($ti.description // $ti.prompt // "" | .[0:200])
+           else ($ti.command // $ti.file_path // $ti.path // $ti.query // $ti.pattern // $ti.url // $ti.description // $ti.prompt // ($ti | tostring)) end
+          ) | tostring | .[0:200]
+        )
+      }' 2>/dev/null || echo '{}')
       ;;
     PostToolUse)
       TYPE="tool_result"
-      META=$(echo "$INPUT" | jq -c '{tool: (.tool_name // "unknown"), tool_use_id: (.tool_use_id // "")}' 2>/dev/null || echo '{}')
+      META=$(echo "$INPUT" | jq -c '{
+        tool: (.tool_name // "unknown"),
+        tool_use_id: (.tool_use_id // ""),
+        success: true,
+        tool_input: (.tool_input // {}),
+        tool_response: (.tool_response // {}),
+        tool_input_preview: (
+          (.tool_input // {}) as $ti |
+          (.tool_name // "unknown") as $tn |
+          (if $tn == "Bash" then ($ti.command // "")
+           elif $tn == "Read" then ($ti.file_path // "")
+           elif $tn == "Write" then ($ti.file_path // "")
+           elif $tn == "Edit" then ($ti.file_path // "")
+           elif $tn == "Grep" then (($ti.pattern // "") + " " + ($ti.path // ""))
+           elif $tn == "Glob" then ($ti.pattern // "")
+           elif $tn == "Agent" then ($ti.description // $ti.prompt // "" | .[0:200])
+           else ($ti.command // $ti.file_path // $ti.path // $ti.query // $ti.pattern // $ti.url // $ti.description // $ti.prompt // ($ti | tostring)) end
+          ) | tostring | .[0:200]
+        ),
+        result_preview: (
+          (.tool_response // {}) as $tr |
+          (.tool_name // "unknown") as $tn |
+          (if $tn == "Bash" then
+             (if ($tr.stderr // "") != "" then ("stderr: " + $tr.stderr) else ($tr.stdout // "") end | .[0:200])
+           elif $tn == "Read" then
+             (($tr.file.numLines // $tr.numLines // 0) | tostring) + " lines"
+           elif $tn == "Grep" then
+             (($tr.numFiles // 0) | tostring) + " files, " + (($tr.numLines // 0) | tostring) + " lines"
+           elif $tn == "Glob" then
+             (($tr.numFiles // 0) | tostring) + " files"
+           elif ($tr | type) == "string" then ($tr | .[0:200])
+           else ($tr | tostring | .[0:200]) end
+          )
+        )
+      }' 2>/dev/null || echo '{}')
       ;;
     SubagentStart)
       TYPE="agent_launch"
@@ -65,7 +116,7 @@ if command -v jq >/dev/null 2>&1; then
       ;;
     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 '{}')
+      META=$(echo "$INPUT" | jq -c '{tool: (.tool_name // "unknown"), is_interrupt: (.is_interrupt // false), success: false, error: (.error // "" | .[0:200])}' 2>/dev/null || echo '{}')
       ;;
     SessionEnd)
       TYPE="claude_session_end"

{methodproof-0.7.35 → methodproof-0.7.37}/methodproof/tui/start.py

@@ -197,6 +197,11 @@ class _TreeTracker:
                 return "├ ", True
             self._in_chain = False
             return "  ", True
+        # Not in chain — tool_call starts one implicitly (orphan after closer)
+        if etype in self._INNERS:
+            self._in_chain = True
+            self._collapse_count = 0
+            return "├ ", True
         return "  ", True
 
 
@@ -255,15 +260,17 @@ def _fmt_meta(ev: dict) -> str:
 
     # Hook lifecycle — tool call / result
     if etype == "tool_call":
-        name = meta.get("tool_name", "")
+        name = meta.get("tool_name") or meta.get("tool", "")
         preview = (meta.get("tool_input_preview") or "")[:60]
         return f"{name}  {preview}".strip()
     if etype == "tool_result":
-        name = meta.get("tool_name", "")
+        name = meta.get("tool_name") or meta.get("tool", "")
         ok = "✓" if meta.get("success", True) else "✗"
-        return f"{name}  {ok}"
+        inp = (meta.get("tool_input_preview") or "")[:40]
+        result = (meta.get("result_preview") or "")[:40]
+        return f"{name}  {ok}  {inp}  {result}".strip()
     if etype == "tool_failure":
-        name = meta.get("tool_name", "")
+        name = meta.get("tool_name") or meta.get("tool", "")
         err = (meta.get("error") or "")[:40]
         return f"{name}  ✗  {err}".strip()
 
@@ -392,14 +399,40 @@ class _DetailScreen(Screen[None]):
         self.app.pop_screen()
 
 
+class _ConfirmEndScreen(Screen[bool]):
+    """Confirm session end."""
+
+    BINDINGS = [
+        Binding("y", "confirm", "yes"),
+        Binding("n", "cancel", "no"),
+        Binding("escape", "cancel", "cancel"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        P = ACTIVE
+        yield Static(
+            f"\n  [{P.red}]End this session?[/{P.red}]\n\n"
+            f"  [{P.dim}]This will stop all capture agents and finalize the session.[/{P.dim}]\n\n"
+            f"  [{P.gold}]y[/{P.gold}] [{P.dim}]confirm[/{P.dim}]    "
+            f"[{P.gold}]n[/{P.gold}] [{P.dim}]cancel[/{P.dim}]",
+        )
+
+    def action_confirm(self) -> None:
+        self.dismiss(True)
+
+    def action_cancel(self) -> None:
+        self.dismiss(False)
+
+
 # ── App ──────────────────────────────────────────────────────────────
-class StartApp(App[None]):
+class StartApp(App[str | None]):
     """Live session view — tails the active session's events."""
 
     TITLE = "methodproof — mp start"
     CSS = _CSS
     BINDINGS = [
-        Binding("q", "stop_session", "stop"),
+        Binding("q", "exit_tui", "exit"),
+        Binding("x", "end_session", "end session"),
         Binding("p", "pause", "pause"),
         Binding("j", "toggle_journal", "journal"),
         Binding("f", "cycle_filter", "filter"),
@@ -438,6 +471,10 @@ class StartApp(App[None]):
         self._last_event_ts: float = 0.0
         self._recent_files: list[str] = []
         self._recent_tools: list[str] = []
+        # Source tracking: which AI tool session is active
+        self._active_source: str = ""  # e.g. "claude", "codex", "gemini"
+        self._source_session_id: str = ""  # short id of the AI session
+        self._source_count: int = 0  # how many AI sessions so far
 
     def compose(self) -> ComposeResult:
         yield Header(show_clock=False)
@@ -518,10 +555,13 @@ class StartApp(App[None]):
             badge_str = f"  {badge_str}"
 
         ev = f"  {self._event_count} ev" if self._event_count else ""
+        src = ""
+        if self._active_source:
+            src = f"  ·  [{P.purple_muted}]{self._active_source} #{self._source_count}[/{P.purple_muted}]"
         self.query_one("#session-bar", Static).update(
             f"  session: [{P.gold}]{sid}[/{P.gold}]  ·  {watch_dir}"
             f"  ·  [{P.green}]●[/{P.green}]  {h:02d}:{m:02d}:{s:02d}"
-            f"{ev}{badge_str}  ·  [{P.purple}]{self._account_type}[/{P.purple}]"
+            f"{ev}{src}{badge_str}  ·  [{P.purple}]{self._account_type}[/{P.purple}]"
         )
 
     # ── Event poll: Layers B + E + A ─────────────────────────────
@@ -544,6 +584,17 @@ class StartApp(App[None]):
             self._last_event = ev
             ev_ts = ev.get("ts", time.time())
 
+            # Source tracking: detect AI session boundaries
+            if etype.endswith("_session_start"):
+                self._active_source = etype.replace("_session_start", "")
+                ev_meta_src = ev.get("metadata") or {}
+                sid_field = ev_meta_src.get("session_id") or ev_meta_src.get("claude_session_id", "")
+                self._source_session_id = str(sid_field)[:8]
+                self._source_count += 1
+            elif etype.endswith("_session_end"):
+                self._active_source = ""
+                self._source_session_id = ""
+
             # Quiet mode: skip dim events
             if self._quiet_mode and etype in _DIM_TYPES:
                 self._stats[etype] = self._stats.get(etype, 0) + 1
@@ -572,7 +623,7 @@ class StartApp(App[None]):
                         self._recent_files.append(path)
                     if len(self._recent_files) > 10:
                         self._recent_files.pop(0)
-                tool = ev_meta.get("tool_name")
+                tool = ev_meta.get("tool_name") or ev_meta.get("tool")
                 if tool and etype in ("tool_call", "tool_result"):
                     if tool not in self._recent_tools:
                         self._recent_tools.append(tool)
@@ -585,16 +636,20 @@ class StartApp(App[None]):
                 self._event_count += 1
                 continue
 
+            # Source tag
+            src_tag = ""
+            if self._active_source:
+                src_tag = f"[{P.purple_muted}]{self._active_source}[/{P.purple_muted}] "
+
             # Search highlight
             line_plain = f"{etype} {meta}"
             if self._search_query and self._search_query.lower() not in line_plain.lower():
-                # Still render but dimmed
                 feed.write(f"[{P.dim}]{ts}  {prefix}{etype:<18} {meta}[/{P.dim}]")
             else:
-                # Layer B + E: structural line with tree prefix
                 feed.write(
                     f"[{P.dim}]{ts}[/{P.dim}] "
-                    f"[{P.gold_ember}]{prefix}[/{P.gold_ember}]"
+                    f"{src_tag}"
+                    f"[{P.gold_aged}]{prefix}[/{P.gold_aged}]"
                     f"[{color}]{etype:<18}[/{color}] "
                     f"[{P.dim}]{meta}[/{P.dim}]"
                 )
@@ -602,7 +657,7 @@ class StartApp(App[None]):
             # Layer A: journal content enrichment
             for jline in _journal_lines(ev, self._journal_mode):
                 feed.write(
-                    f"           [{P.gold_ember}]│[/{P.gold_ember}] "
+                    f"           [{P.gold_aged}]│[/{P.gold_aged}] "
                     f"[{P.dim}]{jline}[/{P.dim}]"
                 )
 
@@ -655,9 +710,19 @@ class StartApp(App[None]):
         self.set_timer(4.0, lambda: alert.remove_class("visible"))
 
     # ── Actions ──────────────────────────────────────────────────
-    def action_stop_session(self) -> None:
+    def action_exit_tui(self) -> None:
+        """Detach TUI — daemon keeps recording."""
         self.exit(None)
 
+    def action_end_session(self) -> None:
+        """End the session (with confirmation)."""
+        self.push_screen(_ConfirmEndScreen(), self._on_confirm_end)
+
+    def _on_confirm_end(self, confirmed: bool) -> None:
+        if not confirmed:
+            return
+        self.exit("end_session")
+
     def action_pause(self) -> None:
         self._paused = not self._paused
 
@@ -743,6 +808,7 @@ class StartApp(App[None]):
         self._tick_timer()
 
 
-def run(session_id: str, session: dict) -> None:
-    """Launch the live session view for the given session."""
-    StartApp(session_id, session).run()
+def run(session_id: str, session: dict) -> str | None:
+    """Launch the live session view. Returns 'end_session' if user chose to end."""
+    app = StartApp(session_id, session)
+    return app.run()

{methodproof-0.7.35 → methodproof-0.7.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.7.35"
+version = "0.7.37"
 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", "textual>=0.59", "rich>=13.7"]

{methodproof-0.7.35 → methodproof-0.7.37}/tests/test_cli_start.py

@@ -38,14 +38,17 @@ def test_start_auth_fails(mock_auth, mock_hook, cli_args):
 
 @patch("methodproof.cli._is_daemon_alive", return_value=True)
 @patch("methodproof.hook.is_installed", return_value=True)
-def test_start_session_already_active(mock_hook, mock_alive, logged_in_cfg, cli_args, make_session):
+def test_start_session_already_active(mock_hook, mock_alive, logged_in_cfg, cli_args, make_session, capsys):
     logged_in_cfg()
     sid, _ = make_session()
     cfg = config.load()
     cfg["active_session"] = sid
     config.save(cfg)
-    with pytest.raises(SystemExit):
+    with patch("methodproof.cli.cmd_connect") as mock_connect:
         cli.cmd_start(cli_args())
+        mock_connect.assert_called_once()
+    out = capsys.readouterr().out
+    assert "already active" in out
 
 
 @patch("methodproof.cli._is_daemon_alive", return_value=False)