claude-smart 0.2.29 → 0.2.31

package/plugin/scripts/smart-install.sh

@@ -22,63 +22,81 @@ MARKER_DIR="$HOME/.claude-smart"
 FAILURE_MARKER="$MARKER_DIR/install-failed"
 SUCCESS_MARKER="$MARKER_DIR/install-complete"
 INSTALL_LOCK="$MARKER_DIR/install.lock"
+INSTALL_REAP_LOCK="$MARKER_DIR/install.lock.reap"
 mkdir -p "$MARKER_DIR"
 
+remove_stale_install_lock() {
+  local expected current
+
+  expected="$1"
+  if ! mkdir "$INSTALL_REAP_LOCK" 2>/dev/null; then
+    sleep 1
+    return 0
+  fi
+  current="$(cat "$INSTALL_LOCK" 2>/dev/null || true)"
+  if [ "$current" = "$expected" ]; then
+    rm -f "$INSTALL_LOCK"
+  fi
+  rmdir "$INSTALL_REAP_LOCK" 2>/dev/null || true
+}
+
+acquire_install_lock() {
+  local lock_pid
+
+  if command -v flock >/dev/null 2>&1; then
+    exec 9>"$INSTALL_LOCK"
+    if ! flock 9; then
+      echo "[claude-smart] install lock failed; continuing without serialization" >&2
+      echo '{"continue":true,"suppressOutput":true}'
+      exit 0
+    fi
+    return 0
+  fi
+
+  while ! ( set -C; printf '%s\n' "$$" > "$INSTALL_LOCK" ) 2>/dev/null; do
+    lock_pid="$(cat "$INSTALL_LOCK" 2>/dev/null || true)"
+    case "$lock_pid" in
+      ''|*[!0-9]*)
+        remove_stale_install_lock "$lock_pid"
+        ;;
+      *)
+        if kill -0 "$lock_pid" 2>/dev/null; then
+          sleep 1
+        else
+          remove_stale_install_lock "$lock_pid"
+        fi
+        ;;
+    esac
+  done
+  trap '[ "$(cat "$INSTALL_LOCK" 2>/dev/null || true)" = "$$" ] && rm -f "$INSTALL_LOCK" || true' EXIT
+}
+
 # Serialize concurrent installer runs (SessionStart hook + slash-command
 # self-heal can both invoke this script). Wait for the active installer
 # rather than returning early, otherwise callers can re-check uv before
 # the first install has finished and report a false missing-dependency error.
-if command -v flock >/dev/null 2>&1; then
-  exec 9>"$INSTALL_LOCK"
-  if ! flock 9; then
-    echo "[claude-smart] install lock failed; continuing without serialization" >&2
-    echo '{"continue":true,"suppressOutput":true}'
-    exit 0
-  fi
-fi
+acquire_install_lock
 
 rm -f "$FAILURE_MARKER"
 
 write_failure() {
-  local reason
+  local reason fp_hash
   reason="$1"
-  printf '%s\n' "$reason" > "$FAILURE_MARKER"
+  fp_hash="$(claude_smart_install_fingerprint_hash "$PLUGIN_ROOT" "$HERE" 2>/dev/null || true)"
+  {
+    printf '%s\n' "$reason"
+    if [ -n "$fp_hash" ]; then
+      printf 'fingerprint=%s\n' "$fp_hash"
+    fi
+  } > "$FAILURE_MARKER"
   rm -f "$SUCCESS_MARKER"
   echo "[claude-smart] install failed: $reason" >&2
   echo '{"continue":true,"suppressOutput":true}'
   exit 0
 }
 
-fingerprint_file() {
-  local path
-  path="$1"
-  if [ -f "$path" ]; then
-    cksum "$path" 2>/dev/null | awk '{print $1 ":" $2}'
-  else
-    printf 'missing\n'
-  fi
-}
-
 install_fingerprint() {
-  printf 'plugin_root=%s\n' "$PLUGIN_ROOT"
-  printf 'smart_install=%s\n' "$(fingerprint_file "$HERE/smart-install.sh")"
-  printf 'pyproject=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/pyproject.toml")"
-  printf 'uv_lock=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/uv.lock")"
-  # Resolved python interpreter — catches a system upgrade (3.12.4 → 3.12.5)
-  # that would otherwise let install_complete return true against a venv
-  # built against a now-deleted interpreter.
-  if command -v uv >/dev/null 2>&1; then
-    printf 'python=%s\n' "$(uv python find 3.12 2>/dev/null || echo missing)"
-  else
-    printf 'python=no-uv\n'
-  fi
-  if [ -d "$PLUGIN_ROOT/dashboard" ]; then
-    printf 'dashboard_pkg=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/dashboard/package.json")"
-    printf 'dashboard_lock=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/dashboard/package-lock.json")"
-  else
-    printf 'dashboard_pkg=none\n'
-    printf 'dashboard_lock=none\n'
-  fi
+  claude_smart_install_fingerprint "$PLUGIN_ROOT" "$HERE"
 }
 
 install_complete() {

package/plugin/src/claude_smart/cli.py

@@ -205,7 +205,8 @@ def _bootstrap_claude_code_install() -> tuple[bool, str]:
     if result.returncode != 0:
         return False, f"smart-install.sh failed in {plugin_root}"
     if _INSTALL_FAILURE_MARKER.is_file():
-        reason = _INSTALL_FAILURE_MARKER.read_text().strip() or "unknown error"
+        first_line = _INSTALL_FAILURE_MARKER.read_text().splitlines()
+        reason = (first_line[0].strip() if first_line else "") or "unknown error"
         return False, reason
     return True, str(plugin_root)
 
@@ -1561,6 +1562,104 @@ def cmd_clear_all(args: argparse.Namespace) -> int:
     return start_rc or 0
 
 
+def _resolve_reflexio_url() -> str:
+    """Return the URL endpoint for the local claude-smart reflexio backend.
+
+    Mirrors ``claude_smart.reflexio_adapter`` so the CLI's one-shot
+    ReflexioClient calls hit the same server as the long-lived adapter
+    used by hook handlers.
+
+    Returns:
+        str: The ``REFLEXIO_URL`` env var if set, otherwise the default
+            local backend endpoint.
+    """
+    return os.environ.get("REFLEXIO_URL", "http://localhost:8071/")
+
+
+def _format_deleted_counts(deleted_counts: object) -> str:
+    """Render ``deleted_counts`` from a ``clear_user_data`` response as a summary.
+
+    The backend returns one count per affected table. We surface the
+    total in the headline string (``"removed N row(s)"``) and append a
+    per-table breakdown when at least one bucket is populated, so the
+    operator can tell *what* got cleared at a glance.
+
+    Args:
+        deleted_counts (object): The ``deleted_counts`` field from the
+            backend response. Expected to be a mapping of
+            ``str -> int``; anything else is rendered as ``"unknown"``.
+
+    Returns:
+        str: A short human-readable summary suitable for echoing to
+            stdout (e.g. ``"3 row(s) (interactions=3)"``).
+    """
+    if not isinstance(deleted_counts, dict):
+        return "unknown row(s)"
+    pairs: list[tuple[str, int]] = []
+    for key, value in deleted_counts.items():
+        if isinstance(key, str) and isinstance(value, int):
+            pairs.append((key, value))
+    total = sum(value for _, value in pairs)
+    if not pairs:
+        return f"{total} row(s)"
+    breakdown = ", ".join(f"{name}={count}" for name, count in sorted(pairs))
+    return f"{total} row(s) ({breakdown})"
+
+
+def cmd_clear_user(args: argparse.Namespace) -> int:
+    """Delete one user_id's playbooks, profiles, and interactions via the backend.
+
+    Per-user-scoped counterpart of ``clear-all``. Where ``clear-all`` does
+    a filesystem-level wipe of the entire local storage root, ``clear-user``
+    routes through the running reflexio backend's ``clear_user_data``
+    endpoint so it can scope the deletion to a single ``user_id`` —
+    leaving other users' data and globally-shared ``agent_playbooks``
+    untouched. This is the primitive SWE-bench-style benchmark harnesses
+    need when running many parallel evaluations under distinct synthetic
+    user ids against one shared backend.
+
+    Args:
+        args (argparse.Namespace): Parsed CLI args. Requires
+            ``args.user_id`` (positional) and ``args.yes`` (the
+            destructive-action confirmation flag, matching ``clear-all``).
+
+    Returns:
+        int: 0 on success, 1 if confirmation is missing or the backend
+            call fails.
+    """
+    user_id = args.user_id
+    if not args.yes:
+        sys.stdout.write(
+            f"This will permanently delete all reflexio rows for user '{user_id}' "
+            "(playbooks, profiles, interactions). Other users' data and "
+            "agent_playbooks are not affected.\n"
+            "Re-run with --yes to confirm.\n"
+        )
+        return 1
+
+    try:
+        from reflexio import ReflexioClient  # type: ignore[import-not-found]
+    except ImportError as exc:
+        sys.stderr.write(f"error: reflexio is not installed: {exc}\n")
+        return 1
+
+    try:
+        client = ReflexioClient(url_endpoint=_resolve_reflexio_url())
+        # The companion reflexio PR adds ``clear_user_data``; keep the
+        # CLI buildable until both sides ship together.
+        response = client.clear_user_data(user_id)  # pyright: ignore[reportAttributeAccessIssue]
+    except Exception as exc:  # noqa: BLE001 — surface backend failure verbatim.
+        sys.stderr.write(f"error: clear-user failed: {exc}\n")
+        return 1
+
+    deleted_counts = (
+        response.get("deleted_counts") if isinstance(response, dict) else None
+    )
+    summary = _format_deleted_counts(deleted_counts)
+    sys.stdout.write(f"Cleared user '{user_id}': removed {summary}.\n")
+    return 0
+
+
 def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="claude-smart")
     sub = parser.add_subparsers(dest="command", required=True)
@@ -1625,6 +1724,25 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     ca.set_defaults(func=cmd_clear_all)
 
+    cu = sub.add_parser(
+        "clear-user",
+        help=(
+            "Delete one user_id's playbooks, profiles, and interactions via "
+            "the backend (leaves other users and agent_playbooks intact)"
+        ),
+    )
+    cu.add_argument(
+        "user_id",
+        help="User id whose reflexio rows should be cleared",
+    )
+    cu.add_argument(
+        "--yes",
+        "-y",
+        action="store_true",
+        help="Confirm the destructive clear without prompting",
+    )
+    cu.set_defaults(func=cmd_clear_user)
+
     rs = sub.add_parser(
         "restart",
         help="Restart the reflexio backend and dashboard to pick up changes",

package/plugin/src/claude_smart/events/session_end.py

@@ -1,20 +1,185 @@
-"""SessionEnd hook — flush any remaining interactions; extraction runs async."""
+"""SessionEnd hook — flush any remaining interactions; extraction runs async.
+
+When ``Stop`` never fires during a session (autonomous agentic loops
+that don't reach ``stop_reason=end_turn``), the buffer at SessionEnd
+time can contain orphan ``Assistant_tool`` records with no closing
+``Assistant`` anchor. The ``state.unpublished_slice`` contract folds
+tool records into the *next* Assistant turn's ``tools_used``; without
+that anchor, every buffered tool call is silently dropped at publish
+time and reflexio receives only the original User prompt.
+
+This module synthesises a closing Assistant record from whatever
+assistant text the Claude Code transcript still has, so the publish
+carries the full tool record stream instead of just the User prompt.
+A short placeholder string is used when the transcript is unreadable.
+"""
 
 from __future__ import annotations
 
+import logging
+import time
+from pathlib import Path
 from typing import Any
 
-from claude_smart import ids, publish
+from claude_smart import ids, publish, state
+from claude_smart.events.stop import (
+    _read_transcript_entries,
+    _scan_transcript_for_assistant_text,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+# Fallback Assistant content used when the transcript is missing,
+# unreadable, or has no recoverable assistant text. The string is
+# distinctive so a future audit can grep for it and quantify how often
+# a session ended without any model response.
+_PLACEHOLDER_ASSISTANT_TEXT = "<session ended without final assistant response>"
 
 
-def handle(payload: dict[str, Any]) -> None:
+def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
+    """Flush any remaining buffered turns to reflexio.
+
+    Args:
+        payload (dict[str, Any]): Claude Code hook payload.
+
+    Returns:
+        tuple[PublishStatus, int] | None: The ``(status, count)`` tuple
+            from ``publish.publish_unpublished`` so the dispatcher's
+            forensic hook log captures the publish outcome. ``None``
+            when the payload had no ``session_id``.
+    """
     session_id = payload.get("session_id")
     if not session_id:
-        return
+        return None
     project_id = ids.resolve_project_id(payload.get("cwd"))
-    publish.publish_unpublished(
+
+    _maybe_synthesize_assistant_anchor(
         session_id=session_id,
         project_id=project_id,
-        force_extraction=False,
+        transcript_path=payload.get("transcript_path"),
+    )
+
+    # ``force_extraction=True`` makes the reflexio server run the
+    # extractor synchronously for this publish, so by the time the HTTP
+    # call returns the playbook (if any) is already committed. SessionEnd
+    # is the final flush — the user/agent is already going away — so
+    # adding a few extra seconds here trades nothing for "snapshot_playbooks()
+    # reads after this point see the just-extracted rows." Stop hooks
+    # (the per-turn flushes) stay async so they don't slow interactive
+    # generation.
+    return publish.publish_unpublished(
+        session_id=session_id,
+        project_id=project_id,
+        force_extraction=True,
         skip_aggregation=False,
     )
+
+
+def _maybe_synthesize_assistant_anchor(
+    *,
+    session_id: str,
+    project_id: str,
+    transcript_path: Any,
+) -> None:
+    """Append a closing Assistant record when the unpublished tail
+    holds orphan ``Assistant_tool`` rows.
+
+    Walks the post-watermark slice of the buffer and looks for a tail
+    pattern of ``Assistant_tool`` records that aren't followed by an
+    ``Assistant`` record. If that's the case, scans the Claude Code
+    transcript for whatever final assistant text is recoverable and
+    appends one synthetic ``Assistant`` record so
+    ``state.unpublished_slice`` can fold the tools into its
+    ``tools_used`` field at publish time.
+
+    Args:
+        session_id (str): Claude Code session id for the state buffer.
+        project_id (str): Resolved project_id used as the synthetic
+            record's ``user_id`` (matches Stop's convention).
+        transcript_path (Any): The ``transcript_path`` value from the
+            hook payload — accepted as ``Any`` because Claude Code may
+            send a string, ``None``, or omit the key entirely.
+
+    Returns:
+        None
+    """
+    records = state.read_all(session_id)
+    if not _tail_has_orphan_tools(records):
+        return
+
+    assistant_text = _recover_assistant_text(transcript_path)
+    state.append(
+        session_id,
+        {
+            "ts": int(time.time()),
+            "role": "Assistant",
+            "content": assistant_text,
+            "user_id": project_id,
+            "synthesised_by": "session_end_anchor",
+        },
+    )
+    _LOGGER.info(
+        "session_end: synthesised Assistant anchor for %s (len=%d)",
+        session_id,
+        len(assistant_text),
+    )
+
+
+def _tail_has_orphan_tools(records: list[dict[str, Any]]) -> bool:
+    """Return True when the post-watermark tail ends with one or more
+    ``Assistant_tool`` records with no closing ``Assistant`` record.
+
+    Walks records from the latest ``published_up_to`` marker forward;
+    tracks the most recent record role. The tail is considered "orphan"
+    when at least one ``Assistant_tool`` was seen after the watermark
+    and no ``Assistant`` record was seen *after* the last
+    ``Assistant_tool``.
+
+    Args:
+        records (list[dict[str, Any]]): The full buffered record list
+            as returned by ``state.read_all``.
+
+    Returns:
+        bool: True if a synthetic anchor would unblock publishing tool
+            records that would otherwise be dropped.
+    """
+    # Find the most recent published_up_to watermark.
+    published = 0
+    for rec in records:
+        if "published_up_to" in rec:
+            published = rec["published_up_to"]
+
+    tail = records[published:]
+    saw_orphan_tool = False
+    for rec in tail:
+        role = rec.get("role")
+        if role == "Assistant_tool":
+            saw_orphan_tool = True
+        elif role == "Assistant":
+            saw_orphan_tool = False
+    return saw_orphan_tool
+
+
+def _recover_assistant_text(transcript_path: Any) -> str:
+    """Return whatever assistant text the transcript still has, or a placeholder.
+
+    Args:
+        transcript_path (Any): Raw value from the hook payload.
+
+    Returns:
+        str: Concatenated current-turn assistant text from the
+            transcript, or ``_PLACEHOLDER_ASSISTANT_TEXT`` when the
+            transcript is unset, missing, or yields nothing.
+    """
+    if not isinstance(transcript_path, str) or not transcript_path:
+        return _PLACEHOLDER_ASSISTANT_TEXT
+    path = Path(transcript_path)
+    if not path.is_file():
+        return _PLACEHOLDER_ASSISTANT_TEXT
+    try:
+        entries = _read_transcript_entries(path)
+    except OSError as exc:
+        _LOGGER.debug("session_end transcript read failed: %s", exc)
+        return _PLACEHOLDER_ASSISTANT_TEXT
+    text = _scan_transcript_for_assistant_text(entries)
+    return text or _PLACEHOLDER_ASSISTANT_TEXT

package/plugin/src/claude_smart/events/session_start.py

@@ -15,8 +15,32 @@ from claude_smart.stall_banner import render_banner
 # Claude-smart's preferred extraction cadence — more frequent, smaller windows
 # than reflexio's out-of-box 10/5. Applied idempotently to the reflexio server
 # on every SessionStart via Adapter.apply_extraction_defaults.
-_CLAUDE_SMART_WINDOW_SIZE = 5
-_CLAUDE_SMART_STRIDE_SIZE = 3
+#
+# Env-var overrides let benchmark harnesses (SWE-bench Verified, in particular)
+# run with ``CLAUDE_SMART_STRIDE_SIZE=1`` so a single short autonomous session
+# triggers extraction on its sole publish instead of being silently filtered
+# out by the stride pre-filter (``new < stride_size``). Production users keep
+# the defaults; the values are only read on SessionStart, so a launcher that
+# sets the env var has predictable effect for the entire Claude Code session.
+#
+# Parsing is defensive: a non-integer env value falls back to the default
+# rather than raising at import time. SessionStart is the hook that wires up
+# every subsequent hook, so an import-time crash here would silently disable
+# the whole plugin for the session.
+
+
+def _int_env(name: str, default: int) -> int:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    try:
+        return int(raw)
+    except ValueError:
+        return default
+
+
+_CLAUDE_SMART_WINDOW_SIZE = _int_env("CLAUDE_SMART_WINDOW_SIZE", 5)
+_CLAUDE_SMART_STRIDE_SIZE = _int_env("CLAUDE_SMART_STRIDE_SIZE", 3)
 # Optimizer is on by default. Set this env var to "0" to skip pushing the
 # claude-smart optimizer defaults on SessionStart (kill switch).
 _DISABLE_OPTIMIZER_ENV = "CLAUDE_SMART_ENABLE_OPTIMIZER"

package/plugin/src/claude_smart/events/stop.py

@@ -308,10 +308,23 @@ def _resolve_cited_items(session_id: str, cited_ids: list[str]) -> list[dict[str
     return resolved
 
 
-def handle(payload: dict[str, Any]) -> None:
+def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
+    """Drain the buffered assistant turn to reflexio.
+
+    Args:
+        payload (dict[str, Any]): Claude Code hook payload.
+
+    Returns:
+        tuple[PublishStatus, int] | None: The ``(status, count)`` tuple
+            from ``publish.publish_unpublished`` so the dispatcher can
+            include it in the forensic hook log. ``None`` is returned
+            only when the handler short-circuits before publishing (no
+            ``session_id`` in the payload, or Codex internal-prompt
+            detection skipped the fire).
+    """
     session_id = payload.get("session_id")
     if not session_id:
-        return
+        return None
 
     # Always append an Assistant record, even when the turn emitted only
     # tool calls and no text. ``state.unpublished_slice`` folds any
@@ -332,7 +345,7 @@ def handle(payload: dict[str, Any]) -> None:
     )
     if runtime.is_codex():
         if internal_call.is_codex_internal_prompt(prompt):
-            return
+            return None
 
     last_assistant_message = payload.get("last_assistant_message")
     assistant_text = (
@@ -374,7 +387,7 @@ def handle(payload: dict[str, Any]) -> None:
     if cited_items:
         record["cited_items"] = cited_items
     state.append(session_id, record)
-    publish.publish_unpublished(
+    return publish.publish_unpublished(
         session_id=session_id,
         project_id=project_id,
         force_extraction=False,

package/plugin/src/claude_smart/hook.py

@@ -5,6 +5,13 @@ The plugin's ``hook_entry.sh`` calls either
 ``python -m claude_smart.hook <host> <event>`` once per hook invocation.
 This module reads the hook JSON from stdin, routes to the matching handler,
 and makes sure no unhandled exception ever propagates.
+
+Every fire produces one structured JSON line in
+``~/.claude-smart/hook.log`` via ``hook_log.log_event`` — covers the
+event name, session id, internal-invocation skip, handler outcome
+(``ok`` / ``raised:<Exc>`` / ``unknown_event``), and for Stop/SessionEnd
+the publish status + count. The log is the forensic trail for chasing
+"hook didn't publish" mysteries from a single file.
 """
 
 from __future__ import annotations
@@ -12,15 +19,22 @@ from __future__ import annotations
 import json
 import logging
 import sys
-from typing import Any, Callable
+from collections.abc import Callable
+from contextlib import redirect_stdout
+from io import StringIO
+from typing import Any
 
-from claude_smart import runtime
+from claude_smart import hook_log, ids, runtime
 from claude_smart.internal_call import is_internal_invocation
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def _load_handlers() -> dict[str, Callable[[dict[str, Any]], None]]:
+# Stop and SessionEnd return ``(PublishStatus, int)`` so the dispatcher can
+# log the publish outcome; the other handlers return ``None`` (or nothing).
+# Use ``Any`` here rather than two specialised typedefs — the dispatcher
+# narrows at the call site via ``isinstance(result, tuple)``.
+def _load_handlers() -> dict[str, Callable[[dict[str, Any]], Any]]:
     from claude_smart.events import (
         post_tool,
         pre_tool,
@@ -92,6 +106,15 @@ def main(argv: list[str] | None = None) -> int:
     # handlers so we don't publish the extractor's system prompt back
     # into reflexio. See claude_smart.internal_call for detection logic.
     if is_internal_invocation(payload):
+        hook_log.log_event(
+            event=event,
+            host=host,
+            session_id=payload.get("session_id"),
+            project_id=ids.resolve_project_id(payload.get("cwd")),
+            cwd=payload.get("cwd"),
+            internal_skipped=True,
+            handler_status="ok",
+        )
         emit_continue()
         return 0
 
@@ -99,14 +122,49 @@ def main(argv: list[str] | None = None) -> int:
     handler = handlers.get(event)
     if handler is None:
         _LOGGER.warning("unknown hook event: %s", event)
+        hook_log.log_event(
+            event=event,
+            host=host,
+            session_id=payload.get("session_id"),
+            project_id=ids.resolve_project_id(payload.get("cwd")),
+            cwd=payload.get("cwd"),
+            handler_status="unknown_event",
+        )
         emit_continue()
         return 0
 
+    handler_status = "ok"
+    publish_status: str | None = None
+    publish_count: int | None = None
+    handler_stdout = StringIO()
     try:
-        handler(payload)
+        with redirect_stdout(handler_stdout):
+            result = handler(payload)
+        if isinstance(result, tuple) and len(result) == 2:
+            publish_status, publish_count = result
     except Exception as exc:  # noqa: BLE001 — hooks must never crash the session.
         _LOGGER.exception("hook handler %s raised: %s", event, exc)
+        handler_status = f"raised:{type(exc).__name__}: {exc}"
         emit_continue()
+    else:
+        # Handlers that inject context already emit the full hook JSON. Silent
+        # handlers still need the continue response so the parent session does
+        # not wait on an empty stdout payload.
+        captured = handler_stdout.getvalue()
+        if captured.strip():
+            sys.stdout.write(captured)
+        else:
+            emit_continue()
+    hook_log.log_event(
+        event=event,
+        host=host,
+        session_id=payload.get("session_id"),
+        project_id=ids.resolve_project_id(payload.get("cwd")),
+        cwd=payload.get("cwd"),
+        handler_status=handler_status,
+        publish_status=publish_status,
+        publish_count=publish_count,
+    )
     return 0