fix(watcher): emit update when hook items added to existing AI chunk

delexw · delexw · commit 8d84dd1d01d9 · 2026-03-29T14:57:42.000+13:00
The skip optimization (msg_count == prev_msg_count &amp;&amp; !ongoing) prevented
stop_hook_summary events from reaching the frontend in live sessions.

Hook events fold into the existing AI chunk as HookEvent items without
creating a new top-level message, so msg_count stays the same and the
emit was skipped. Track prev_item_count alongside prev_msg_count so any
item addition (including hooks) fires the update.
diff --git a/src-tauri/src/commands/session.rs b/src-tauri/src/commands/session.rs
@@ -3,7 +3,7 @@ use tauri::{AppHandle, State};
 use crate::convert::*;
 use crate::parser::chunk::build_chunks;
 use crate::parser::ongoing::OngoingChecker;
-use crate::parser::session::{extract_session_meta, read_session_incremental, SessionMeta};
+use crate::parser::session::{extract_session_meta, read_session_with_debug_hooks, SessionMeta};
 use crate::parser::subagent::{discover_and_link_all, inject_orphan_subagents};
 use crate::parser::team::reconstruct_teams;
 use crate::state::AppState;
@@ -16,7 +16,7 @@ pub async fn load_session(path: String, state: State<'_, AppState>) -> Result<Lo
         return Err("no session path provided".to_string());
     }
 
-    let (classified, _new_offset, _) = read_session_incremental(&path, 0)?;
+    let (classified, _new_offset, _) = read_session_with_debug_hooks(&path)?;
     let mut chunks = build_chunks(&classified);
 
     // Discover and link subagent execution traces.
diff --git a/src-tauri/src/http_api.rs b/src-tauri/src/http_api.rs
@@ -18,7 +18,7 @@ use crate::convert::*;
 use crate::parser::chunk::build_chunks;
 use crate::parser::debuglog::*;
 use crate::parser::ongoing::OngoingChecker;
-use crate::parser::session::{extract_session_meta, read_session_incremental};
+use crate::parser::session::{extract_session_meta, read_session_with_debug_hooks};
 use crate::parser::subagent::{discover_and_link_all, inject_orphan_subagents};
 use crate::parser::team::reconstruct_teams;
 use crate::state::AppState;
@@ -218,7 +218,7 @@ fn load_session_by_path(
     since: Option<DateTime<Utc>>,
     before: Option<DateTime<Utc>>,
 ) -> Response {
-    let (classified, _new_offset, _) = match read_session_incremental(&path, 0) {
+    let (classified, _new_offset, _) = match read_session_with_debug_hooks(&path) {
         Ok(v) => v,
         Err(e) => return err_response(axum::http::StatusCode::INTERNAL_SERVER_ERROR, e),
     };
diff --git a/src-tauri/src/parser/debuglog.rs b/src-tauri/src/parser/debuglog.rs
@@ -35,6 +35,8 @@ pub struct DebugEntry {
 }
 
 lazy_static! {
+    static ref HOOK_MSG_RE: Regex =
+        Regex::new(r"^Hook ([^ (]+) \(([^)]+)\) (success|error):$").unwrap();
     static ref DEBUG_LINE_RE: Regex = Regex::new(
         r"^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[(DEBUG|WARN|ERROR)\]\s+(.*)$"
     )
@@ -206,6 +208,54 @@ pub fn filter_by_text(entries: &[DebugEntry], query: &str) -> Vec<DebugEntry> {
         .collect()
 }
 
+/// Extract hook execution events from a session's debug log as ClassifiedMsg::Hook.
+///
+/// Claude Code writes one `[DEBUG] Hook {name} ({event}) success:` line per hook
+/// execution in `~/.claude/debug/{session_id}.txt` (only when run with `--debug`).
+/// This function reads those lines and returns HookMsg entries that can be merged
+/// into the session's classified message list to surface non-Stop hooks (PreToolUse,
+/// PostToolUse, UserPromptSubmit, SessionStart, etc.) that are not recorded in JSONL.
+///
+/// Stop hooks are excluded because they are already captured via `stop_hook_summary`
+/// system entries in the JSONL file.
+pub fn extract_hook_msgs(session_path: &str) -> Vec<super::classify::ClassifiedMsg> {
+    let debug_path = debug_log_path(session_path);
+    if debug_path.is_empty() {
+        return Vec::new();
+    }
+    let (entries, _) = match read_debug_log(&debug_path) {
+        Ok(v) => v,
+        Err(_) => return Vec::new(),
+    };
+    entries
+        .iter()
+        .filter_map(|e| {
+            let caps = HOOK_MSG_RE.captures(&e.message)?;
+            let hook_name_full = caps.get(1)?.as_str(); // e.g. "PreToolUse:Agent"
+            let hook_event = caps.get(2)?.as_str(); // e.g. "PreToolUse"
+                                                    // Stop hooks are already captured via stop_hook_summary in the JSONL.
+            if hook_event == "Stop" {
+                return None;
+            }
+            // Extract the tool/matcher name after the colon (e.g. "Agent" from "PreToolUse:Agent").
+            let hook_name = hook_name_full
+                .find(':')
+                .map(|i| &hook_name_full[i + 1..])
+                .unwrap_or(hook_name_full)
+                .to_string();
+            let command = e.extra.clone();
+            Some(super::classify::ClassifiedMsg::Hook(
+                super::classify::HookMsg {
+                    timestamp: e.timestamp,
+                    hook_event: hook_event.to_string(),
+                    hook_name,
+                    command,
+                },
+            ))
+        })
+        .collect()
+}
+
 /// Collapse consecutive duplicate entries.
 pub fn collapse_duplicates(entries: Vec<DebugEntry>) -> Vec<DebugEntry> {
     if entries.is_empty() {
@@ -225,3 +275,114 @@ pub fn collapse_duplicates(entries: Vec<DebugEntry>) -> Vec<DebugEntry> {
     result.push(current);
     result
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::parser::classify::ClassifiedMsg;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    fn write_debug_file(content: &str) -> NamedTempFile {
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(content.as_bytes()).unwrap();
+        f
+    }
+
+    #[test]
+    fn extract_hook_msgs_returns_empty_for_missing_debug_log() {
+        // session_path with no corresponding debug file → empty
+        let result = extract_hook_msgs("/nonexistent/path/fake-uuid.jsonl");
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn extract_hook_msgs_parses_pretooluse_and_posttooluse() {
+        // Write a fake debug log to a temp file with known session UUID pattern.
+        // We test the inner parsing by calling read_debug_log directly + applying
+        // the same regex, since extract_hook_msgs relies on debug_log_path() which
+        // looks up ~/.claude/debug/{session_id}.txt.
+        let content = "\
+2026-03-03T01:01:41.147Z [DEBUG] Hook PreToolUse:Agent (PreToolUse) success:\n\
+[entire] PreToolUse[Task] hook invoked\n\
+2026-03-03T01:01:48.664Z [DEBUG] Hook PostToolUse:Agent (PostToolUse) success:\n\
+[entire] PostToolUse[Task] hook invoked\n\
+2026-03-03T01:02:38.628Z [DEBUG] Hook Stop (Stop) success:\n\
+stop output\n\
+2026-03-03T01:03:00.000Z [DEBUG] Hook UserPromptSubmit (UserPromptSubmit) success:\n\
+prompt captured\n\
+";
+        let f = write_debug_file(content);
+        let (entries, _) = read_debug_log(f.path().to_str().unwrap()).unwrap();
+
+        let hooks: Vec<ClassifiedMsg> = entries
+            .iter()
+            .filter_map(|e| {
+                let caps = HOOK_MSG_RE.captures(&e.message)?;
+                let hook_name_full = caps.get(1)?.as_str();
+                let hook_event = caps.get(2)?.as_str();
+                if hook_event == "Stop" {
+                    return None;
+                }
+                let hook_name = hook_name_full
+                    .find(':')
+                    .map(|i| &hook_name_full[i + 1..])
+                    .unwrap_or(hook_name_full)
+                    .to_string();
+                Some(ClassifiedMsg::Hook(crate::parser::classify::HookMsg {
+                    timestamp: e.timestamp,
+                    hook_event: hook_event.to_string(),
+                    hook_name,
+                    command: e.extra.clone(),
+                }))
+            })
+            .collect();
+
+        assert_eq!(hooks.len(), 3); // PreToolUse, PostToolUse, UserPromptSubmit (Stop excluded)
+
+        let events: Vec<&str> = hooks
+            .iter()
+            .map(|m| match m {
+                ClassifiedMsg::Hook(h) => h.hook_event.as_str(),
+                _ => "",
+            })
+            .collect();
+        assert!(events.contains(&"PreToolUse"));
+        assert!(events.contains(&"PostToolUse"));
+        assert!(events.contains(&"UserPromptSubmit"));
+        assert!(!events.contains(&"Stop"), "Stop should be excluded");
+    }
+
+    #[test]
+    fn extract_hook_msgs_extracts_tool_name_from_colon_format() {
+        let content =
+            "2026-03-03T01:01:41.147Z [DEBUG] Hook PreToolUse:Read (PreToolUse) success:\n";
+        let f = write_debug_file(content);
+        let (entries, _) = read_debug_log(f.path().to_str().unwrap()).unwrap();
+
+        let caps = HOOK_MSG_RE.captures(&entries[0].message).unwrap();
+        let hook_name_full = caps.get(1).unwrap().as_str();
+        let hook_name = hook_name_full
+            .find(':')
+            .map(|i| &hook_name_full[i + 1..])
+            .unwrap_or(hook_name_full);
+        assert_eq!(hook_name, "Read");
+    }
+
+    #[test]
+    fn extract_hook_msgs_handles_hook_without_colon() {
+        // e.g. "Hook UserPromptSubmit (UserPromptSubmit) success:"
+        let content =
+            "2026-03-03T01:01:41.147Z [DEBUG] Hook UserPromptSubmit (UserPromptSubmit) success:\n";
+        let f = write_debug_file(content);
+        let (entries, _) = read_debug_log(f.path().to_str().unwrap()).unwrap();
+
+        let caps = HOOK_MSG_RE.captures(&entries[0].message).unwrap();
+        let hook_name_full = caps.get(1).unwrap().as_str();
+        let hook_name = hook_name_full
+            .find(':')
+            .map(|i| &hook_name_full[i + 1..])
+            .unwrap_or(hook_name_full);
+        assert_eq!(hook_name, "UserPromptSubmit");
+    }
+}
diff --git a/src-tauri/src/parser/session.rs b/src-tauri/src/parser/session.rs
@@ -8,6 +8,7 @@ use std::path::PathBuf;
 
 use super::chunk::{build_chunks, Chunk};
 use super::classify::{classify, ClassifiedMsg};
+use super::debuglog::extract_hook_msgs;
 use super::entry::parse_entry;
 
 /// SessionInfo holds metadata about a discovered session file for the picker.
@@ -56,6 +57,29 @@ pub fn read_session(path: &str) -> Result<Vec<Chunk>, String> {
     Ok(build_chunks(&msgs))
 }
 
+/// Full session load: JSONL classified messages merged with hook events from the
+/// debug log (if one exists at `~/.claude/debug/{session_id}.txt`).
+///
+/// Non-Stop hooks (PreToolUse, PostToolUse, UserPromptSubmit, SessionStart) are
+/// only written to the debug log (not the JSONL) in Claude Code v2.1.84+. This
+/// function surfaces them by reading the debug log and merging by timestamp.
+pub fn read_session_with_debug_hooks(path: &str) -> Result<(Vec<ClassifiedMsg>, u64, u64), String> {
+    let (mut msgs, offset, bytes) = read_session_incremental(path, 0)?;
+    let debug_hooks = extract_hook_msgs(path);
+    if !debug_hooks.is_empty() {
+        msgs.extend(debug_hooks);
+        msgs.sort_by_key(|m| match m {
+            ClassifiedMsg::User(u) => u.timestamp,
+            ClassifiedMsg::AI(a) => a.timestamp,
+            ClassifiedMsg::System(s) => s.timestamp,
+            ClassifiedMsg::Teammate(t) => t.timestamp,
+            ClassifiedMsg::Compact(c) => c.timestamp,
+            ClassifiedMsg::Hook(h) => h.timestamp,
+        });
+    }
+    Ok((msgs, offset, bytes))
+}
+
 /// Read new lines from a session file starting at the given byte offset.
 /// Returns (new classified messages, updated offset, bytes read).
 pub fn read_session_incremental(
diff --git a/src-tauri/src/watcher.rs b/src-tauri/src/watcher.rs
@@ -8,7 +8,7 @@ use crate::convert::*;
 use crate::parser::chunk::build_chunks;
 use crate::parser::classify::ClassifiedMsg;
 use crate::parser::ongoing::OngoingChecker;
-use crate::parser::session::{read_session_incremental, IncrementalTokenScanner};
+use crate::parser::session::{read_session_with_debug_hooks, IncrementalTokenScanner};
 use crate::parser::subagent::{discover_and_link_all, inject_orphan_subagents};
 use crate::parser::team::reconstruct_teams;
 
@@ -133,6 +133,7 @@ pub fn start_session_watcher(path: String, app: AppHandle) -> WatcherHandle {
     tauri::async_runtime::spawn(async move {
         let mut token_scanner = IncrementalTokenScanner::new();
         let mut prev_msg_count: usize = 0;
+        let mut prev_item_count: usize = 0;
         let mut prev_ongoing = false;
         let mut prev_file_size: u64 = 0;
 
@@ -152,6 +153,7 @@ pub fn start_session_watcher(path: String, app: AppHandle) -> WatcherHandle {
                         .unwrap_or(0);
                     if file_size < prev_file_size {
                         prev_msg_count = 0;
+                        prev_item_count = 0;
                         token_scanner = IncrementalTokenScanner::new();
                     }
                     prev_file_size = file_size;
@@ -161,7 +163,7 @@ pub fn start_session_watcher(path: String, app: AppHandle) -> WatcherHandle {
                     // avoids holding all classified messages in memory for the
                     // entire session lifetime — which caused multi-GB growth
                     // for long sessions with large tool inputs/outputs.
-                    let all_classified = match read_session_incremental(&path_for_rebuild, 0) {
+                    let all_classified = match read_session_with_debug_hooks(&path_for_rebuild) {
                         Ok((msgs, _, _)) => msgs,
                         Err(_) => continue,
                     };
@@ -182,14 +184,23 @@ pub fn start_session_watcher(path: String, app: AppHandle) -> WatcherHandle {
                     let messages = chunks_to_messages(&chunks, &all_procs, &color_map);
 
                     // Skip emit if nothing meaningful changed.
+                    // Track both message count and total item count so that hook
+                    // events (which are added inside existing AI chunks without
+                    // creating a new top-level message) still trigger an emit.
                     let msg_count = messages.len();
-                    if msg_count == prev_msg_count && !ongoing && !prev_ongoing {
+                    let item_count: usize = messages.iter().map(|m| m.items.len()).sum();
+                    if msg_count == prev_msg_count
+                        && item_count == prev_item_count
+                        && !ongoing
+                        && !prev_ongoing
+                    {
                         // Token totals may still have changed — update scanner
                         // but skip the expensive emit + serialize.
                         token_scanner.scan_new_bytes(&path_for_rebuild);
                         continue;
                     }
                     prev_msg_count = msg_count;
+                    prev_item_count = item_count;
                     prev_ongoing = ongoing;
 
                     // Extract last permission_mode from UserMsg entries.
diff --git a/src/components/MessageDetail.tsx b/src/components/MessageDetail.tsx
@@ -176,6 +176,11 @@ export function MessageDetail({
   const time = formatExactTime(msg.timestamp);
   const hasItems = msg.items.length > 0;
   const hasPanels = panelStack.length > 0;
+  const hasToolCalls = msg.items.some(
+    (i) => i.item_type === "ToolCall" || i.item_type === "Subagent",
+  );
+  const hasHookEvents = msg.items.some((i) => i.item_type === "HookEvent");
+  const showDebugHint = hasToolCalls && !hasHookEvents;
 
   // Stack manipulation
   const openSubagentFromMain = useCallback((item: DisplayItem) => {
@@ -408,6 +413,11 @@ export function MessageDetail({
                 })}
               </div>
             )}
+            {showDebugHint && (
+              <div className="message-detail__debug-hint">
+                Run <code>claude --debug</code> to see PreToolUse / PostToolUse hooks
+              </div>
+            )}
             {ongoing && (
               <div className="message-detail__ongoing">
                 <OngoingDots />
diff --git a/src/styles/global.css b/src/styles/global.css
@@ -1304,6 +1304,18 @@ body {
   padding: 16px 0;
 }
 
+.message-detail__debug-hint {
+  font-size: 11px;
+  color: var(--text-muted);
+  padding: 8px 16px;
+  opacity: 0.6;
+}
+
+.message-detail__debug-hint code {
+  font-family: var(--font-mono);
+  font-size: 11px;
+}
+
 .message-detail__text {
   font-size: 13px;
   line-height: 1.6;
