@overdeck/desktop 0.45.12 → 0.45.15

package/sync-sources/hooks/heartbeat-hook

@@ -0,0 +1,113 @@
+#!/bin/bash
+# ~/.overdeck/bin/heartbeat-hook  (PAN-800)
+#
+# Fires on Claude Code PostToolUse. POSTs agent.activity_changed(working, tool)
+# to the dashboard, then records the cost event.
+#
+# Rewritten from the ~200-line jq read-modify-write version to a pure POST
+# emitter. runtime.json and heartbeats/<id>.json are no longer written —
+# AgentStateService's SubscriptionRef + projection_cache is canonical.
+# activity.jsonl is retained as a forensic grep-able artifact (cheap to keep).
+# The sessions.json append-only list is retained because it's a bookkeeping
+# record of Claude session UUIDs, not runtime state.
+# Cost-event recording stays on its own flock-serialized path.
+
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=pan-hook-lib.sh
+. "$SCRIPT_DIR/pan-hook-lib.sh" 2>/dev/null || exit 0
+
+pan_resolve_agent_id || exit 0
+
+TOOL_INFO=$(cat 2>/dev/null || echo '{}')
+
+HAVE_JQ=0
+if command -v jq >/dev/null 2>&1; then HAVE_JQ=1; fi
+
+TOOL_NAME="unknown"
+TOOL_INPUT=""
+CLAUDE_SESSION_ID=""
+if [ "$HAVE_JQ" = "1" ]; then
+  TOOL_NAME=$(echo "$TOOL_INFO" | jq -r '.tool_name // "unknown"' 2>/dev/null || echo "unknown")
+  TOOL_INPUT=$(echo "$TOOL_INFO" | jq -r '.tool_input | tostring | .[0:100] // ""' 2>/dev/null || echo "")
+  CLAUDE_SESSION_ID=$(echo "$TOOL_INFO" | jq -r '.session_id // ""' 2>/dev/null || echo "")
+fi
+
+TS=$(date -Iseconds)
+
+# ── Emit agent.activity_changed(working, tool) ─────────────────────────────
+if [ "$HAVE_JQ" = "1" ]; then
+  BODY=$(jq -n --arg tool "$TOOL_NAME" --arg ts "$TS" \
+    '{kind: "activity", activity: "working", tool: $tool, timestamp: $ts}')
+else
+  BODY="{\"kind\":\"activity\",\"activity\":\"working\",\"tool\":\"$TOOL_NAME\",\"timestamp\":\"$TS\"}"
+fi
+pan_emit_event "$AGENT_ID" "$BODY"
+
+# ── Activity log (retained for forensics) ─────────────────────────────────
+AGENT_DIR="$HOME/.overdeck/agents/$AGENT_ID"
+mkdir -p "$AGENT_DIR" 2>/dev/null
+if [ "$HAVE_JQ" = "1" ]; then
+  ENTRY=$(jq -n --arg ts "$TS" --arg tool "$TOOL_NAME" --arg action "$TOOL_INPUT" \
+    '{ts: $ts, tool: $tool, action: $action}' 2>/dev/null || echo "")
+  if [ -n "$ENTRY" ]; then
+    echo "$ENTRY" >> "$AGENT_DIR/activity.jsonl" 2>/dev/null || true
+    # Prune to last 100 entries.
+    if [ -f "$AGENT_DIR/activity.jsonl" ]; then
+      TMP="$AGENT_DIR/activity.jsonl.tmp"
+      tail -n 100 "$AGENT_DIR/activity.jsonl" > "$TMP" 2>/dev/null \
+        && mv "$TMP" "$AGENT_DIR/activity.jsonl" 2>/dev/null || true
+    fi
+  fi
+fi
+
+# ── Claude session history (append-only bookkeeping) ──────────────────────
+if [ "$HAVE_JQ" = "1" ] && [ -n "$CLAUDE_SESSION_ID" ]; then
+  SESSIONS_FILE="$AGENT_DIR/sessions.json"
+  if [ -f "$SESSIONS_FILE" ]; then
+    if ! jq -e --arg sid "$CLAUDE_SESSION_ID" 'any(.[]; . == $sid)' "$SESSIONS_FILE" >/dev/null 2>&1; then
+      TMP="$SESSIONS_FILE.tmp"
+      jq --arg sid "$CLAUDE_SESSION_ID" '. + [$sid]' "$SESSIONS_FILE" > "$TMP" 2>/dev/null \
+        && mv "$TMP" "$SESSIONS_FILE" 2>/dev/null || true
+    fi
+  else
+    echo "[\"$CLAUDE_SESSION_ID\"]" > "$SESSIONS_FILE" 2>/dev/null || true
+  fi
+fi
+
+# ── Cost-event recording (unchanged, its own flock-serialized path) ──────
+COST_SCRIPT=""
+if [ -f "$HOME/.overdeck/bin/record-cost-event.js" ]; then
+  COST_SCRIPT="$HOME/.overdeck/bin/record-cost-event.js"
+elif [ -f "$SCRIPT_DIR/record-cost-event.js" ]; then
+  COST_SCRIPT="$SCRIPT_DIR/record-cost-event.js"
+fi
+
+if [ -n "$COST_SCRIPT" ] && [ -n "$CLAUDE_SESSION_ID" ]; then
+  GIT_BRANCH=$(git branch --show-current 2>/dev/null || echo "")
+  WORKSPACE=$(pwd)
+
+  if [ -z "$OVERDECK_ISSUE_ID" ]; then
+    if [[ "$GIT_BRANCH" =~ (pan|min|aud|krux|cli|PAN|MIN|AUD|KRUX|CLI)[-]([0-9]+) ]]; then
+      OVERDECK_ISSUE_ID="${BASH_REMATCH[1]^^}-${BASH_REMATCH[2]}"
+    fi
+  fi
+  if [ -z "$OVERDECK_ISSUE_ID" ]; then
+    if [[ "$WORKSPACE" =~ (pan|min|aud|krux|cli|PAN|MIN|AUD|KRUX|CLI)[-]([0-9]+) ]]; then
+      OVERDECK_ISSUE_ID="${BASH_REMATCH[1]^^}-${BASH_REMATCH[2]}"
+    fi
+  fi
+  export OVERDECK_ISSUE_ID="${OVERDECK_ISSUE_ID:-UNKNOWN}"
+  export OVERDECK_SESSION_TYPE="${OVERDECK_SESSION_TYPE:-implementation}"
+
+  STATE_DIR="$HOME/.overdeck/costs/state"
+  mkdir -p "$STATE_DIR" 2>/dev/null
+  LOCK_FILE="$STATE_DIR/${CLAUDE_SESSION_ID}.lock"
+  {
+    flock -x -w 30 200
+    echo "$TOOL_INFO" | node "$COST_SCRIPT" 2>/dev/null || true
+  } 200>"$LOCK_FILE"
+fi
+
+exit 0

package/sync-sources/hooks/notification-hook

@@ -0,0 +1,70 @@
+#!/bin/bash
+# ~/.overdeck/bin/notification-hook  (PAN-800)
+#
+# Fires on Claude Code Notification events. If the notification looks like a
+# permission prompt or a request for human input, emits
+# agent.waiting_started(reason=...). Logs the raw payload for future analysis.
+#
+# PAN-709 note: the Notification event fires for system/desktop notifications
+# from Claude Code, NOT for in-terminal tool approval dialogs. In-terminal
+# prompts are detected separately by the deacon tmux-tail scanner (still
+# active during the PAN-800 migration; scheduled for replacement in Phase 5).
+
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=pan-hook-lib.sh
+. "$SCRIPT_DIR/pan-hook-lib.sh" 2>/dev/null || exit 0
+
+pan_resolve_agent_id || exit 0
+
+NOTIF_INFO=$(cat 2>/dev/null || echo '{}')
+
+HAVE_JQ=0
+if command -v jq >/dev/null 2>&1; then HAVE_JQ=1; fi
+
+NOTIF_MSG=""
+if [ "$HAVE_JQ" = "1" ]; then
+  NOTIF_MSG=$(echo "$NOTIF_INFO" | jq -r '.message // ""' 2>/dev/null || echo "")
+fi
+
+TS=$(date -Iseconds)
+
+# Log the raw notification for forensics. Kept at 500 entries.
+LOG_DIR="$HOME/.overdeck/logs"
+mkdir -p "$LOG_DIR" 2>/dev/null
+LOG_FILE="$LOG_DIR/notifications.jsonl"
+if [ "$HAVE_JQ" = "1" ]; then
+  jq -n --arg ts "$TS" --arg agent "$AGENT_ID" --argjson payload "$NOTIF_INFO" \
+    '{ts: $ts, agent: $agent, payload: $payload}' >> "$LOG_FILE" 2>/dev/null || true
+  if [ -f "$LOG_FILE" ]; then
+    TMP="$LOG_FILE.tmp"
+    tail -n 500 "$LOG_FILE" > "$TMP" 2>/dev/null && mv "$TMP" "$LOG_FILE" 2>/dev/null || true
+  fi
+fi
+
+# Classify the notification. The message strings come from Claude Code's own
+# notification payloads; we're pattern-matching the keywords that indicate the
+# agent is stalled waiting for the human.
+REASON=""
+if echo "$NOTIF_MSG" | grep -qiE '(permission|approval|allow.*tool|confirm.*tool)'; then
+  REASON="tool_permission"
+elif echo "$NOTIF_MSG" | grep -qiE '(question|needs.*input|waiting.*for|needs your)'; then
+  REASON="user_question"
+elif echo "$NOTIF_MSG" | grep -qiE '(disambiguat|choose|select|which)'; then
+  REASON="disambiguation"
+fi
+
+if [ -n "$REASON" ]; then
+  if [ "$HAVE_JQ" = "1" ]; then
+    BODY=$(jq -n --arg reason "$REASON" --arg msg "$NOTIF_MSG" --arg ts "$TS" \
+      '{kind: "waiting_start", reason: $reason, message: $msg, timestamp: $ts}')
+  else
+    # Fallback: minimal body, no message field. Escaping arbitrary NOTIF_MSG
+    # into JSON by hand is error-prone.
+    BODY="{\"kind\":\"waiting_start\",\"reason\":\"$REASON\",\"timestamp\":\"$TS\"}"
+  fi
+  pan_emit_event "$AGENT_ID" "$BODY"
+fi
+
+exit 0

package/sync-sources/hooks/notify-complete

@@ -0,0 +1,79 @@
+#!/bin/bash
+# notify-complete: Send desktop notification when agent completes work
+# Part of Overdeck - works on WSL2/Windows, Linux, and macOS
+#
+# Usage: notify-complete <issue-id> <title> [mr-url]
+#
+# Examples:
+#   notify-complete MIN-665 "Fixed login button"
+#   notify-complete PAN-96 "Implemented templates" "https://gitlab.com/mr/123"
+
+ISSUE_ID="${1:-UNKNOWN}"
+TITLE="${2:-Agent completed work}"
+MR_URL="${3:-}"
+
+# Log to completion file
+COMPLETION_LOG="$HOME/.overdeck/agent-completed.log"
+mkdir -p "$(dirname "$COMPLETION_LOG")"
+echo "$(date '+%Y-%m-%d %H:%M:%S') | ${ISSUE_ID} | ${TITLE} | ${MR_URL}" >> "$COMPLETION_LOG"
+
+# Detect platform and send notification
+send_notification() {
+  local title="$1"
+  local message="$2"
+
+  # WSL2/Windows - use PowerShell toast notifications
+  if command -v powershell.exe &>/dev/null; then
+    powershell.exe -Command "
+\$xml = @\"
+<toast>
+  <visual>
+    <binding template=\"ToastText02\">
+      <text id=\"1\">${title}</text>
+      <text id=\"2\">${message}</text>
+    </binding>
+  </visual>
+  <audio src=\"ms-winsoundevent:Notification.Default\"/>
+</toast>
+\"@
+
+[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
+
+\$template = New-Object Windows.Data.Xml.Dom.XmlDocument
+\$template.LoadXml(\$xml)
+\$toast = New-Object Windows.UI.Notifications.ToastNotification \$template
+[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Overdeck').Show(\$toast)
+" 2>/dev/null && return 0
+
+    # Fallback: MessageBox
+    powershell.exe -Command "[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('${message}', '${title}', 'OK', 'Information')" 2>/dev/null &
+    return 0
+  fi
+
+  # macOS - use osascript
+  if command -v osascript &>/dev/null; then
+    osascript -e "display notification \"${message}\" with title \"${title}\"" 2>/dev/null
+    return 0
+  fi
+
+  # Linux - use notify-send
+  if command -v notify-send &>/dev/null; then
+    notify-send "${title}" "${message}" 2>/dev/null
+    return 0
+  fi
+
+  # Fallback - just print to console
+  echo "[NOTIFICATION] ${title}: ${message}"
+}
+
+# Build notification message
+if [ -n "$MR_URL" ]; then
+  MESSAGE="${TITLE} - Ready for review"
+else
+  MESSAGE="${TITLE} - Work complete"
+fi
+
+send_notification "Overdeck: ${ISSUE_ID}" "$MESSAGE"
+
+echo "Notification sent for ${ISSUE_ID}"

package/sync-sources/hooks/pan-hook-lib.sh

@@ -0,0 +1,153 @@
+# PAN-800 — shared library sourced by all Overdeck hook scripts.
+#
+# Provides:
+#   pan_resolve_agent_id     — sets AGENT_ID, returns 1 if cannot attribute
+#   pan_emit_event           — POST a heartbeat body; on failure buffer in pending-events.jsonl
+#
+# Hooks that emit runtime events go through pan_emit_event. No hook directly
+# writes runtime.json — the SubscriptionRef inside AgentStateService is the
+# source of truth (PAN-800).
+#
+# Shell: intended to be sourced, not executed. Exports no subprocesses; all
+# helpers are plain bash functions.
+
+PAN_DASHBOARD_URL="${OVERDECK_DASHBOARD_URL:-http://localhost:3011}"
+PAN_CURL_TIMEOUT="${OVERDECK_HOOK_TIMEOUT:-0.5}"
+
+# Internal token for authenticated HTTP ingestion (PAN-1596). The
+# /api/agents/:id/heartbeat route is token-gated — without this header every
+# hook POST gets 403 and is dropped on 4xx, so hook-emitted runtime activity
+# (thinking/working/idle/waiting) never reaches the AgentStateService mirror.
+# No launcher exports OVERDECK_INTERNAL_TOKEN, so source it from the on-disk
+# token as the primary path. Empty token => same 403/drop as before (no
+# regression).
+PAN_INTERNAL_TOKEN="${OVERDECK_INTERNAL_TOKEN:-}"
+if [ -z "$PAN_INTERNAL_TOKEN" ]; then
+  _pan_token_path="${OVERDECK_HOME:-$HOME/.overdeck}/internal-token"
+  [ -f "$_pan_token_path" ] && PAN_INTERNAL_TOKEN=$(cat "$_pan_token_path" 2>/dev/null || true)
+fi
+
+# Resolve the current agent ID without a "main-cli" fallback (PAN-69).
+# Returns 0 and sets AGENT_ID on success; returns 1 on failure so the caller
+# can exit cleanly. We refuse to emit events that can't be authoritatively
+# attributed — the whole point of HTTP ingestion is explicit identity.
+pan_resolve_agent_id() {
+  if [ -n "$OVERDECK_AGENT_ID" ]; then
+    AGENT_ID="$OVERDECK_AGENT_ID"
+  elif [ -n "$TMUX" ]; then
+    AGENT_ID=$(tmux display-message -p '#S' 2>/dev/null)
+  else
+    return 1
+  fi
+  [ -z "$AGENT_ID" ] && return 1
+  # Scrub to the same character class the legacy hooks accepted.
+  AGENT_ID=$(printf '%s' "$AGENT_ID" | tr -cd 'A-Za-z0-9._-')
+  [ -z "$AGENT_ID" ] && return 1
+  return 0
+}
+
+# Emit a runtime event body to the dashboard.
+#
+# Order of operations:
+#   1. If pending-events.jsonl has buffered events from prior failures, drain
+#      them FIRST so server sequence numbers line up with wall-clock order.
+#      (Posting the new event first would give it a lower sequence than the
+#      older buffered events — the reducer would then pick the older event
+#      as the most recent snapshot, which is wrong.)
+#   2. POST the new event.
+#   3. If that POST fails, append it to the buffer.
+#
+# Args:
+#   $1 = agent id
+#   $2 = JSON body
+pan_emit_event() {
+  local agent_id="$1"
+  local body="$2"
+  [ -z "$agent_id" ] || [ -z "$body" ] && return 0
+
+  local dir="$HOME/.overdeck/agents/$agent_id"
+  mkdir -p "$dir" 2>/dev/null || return 0
+
+  local url="$PAN_DASHBOARD_URL/api/agents/$agent_id/heartbeat"
+  local pending="$dir/pending-events.jsonl"
+  local lockfile="$dir/pending.lock"
+
+  # Drain any previously-buffered events before emitting the new one.
+  if [ -s "$pending" ]; then
+    pan__drain_pending "$agent_id" "$url" "$pending" "$lockfile"
+  fi
+
+  local http_code
+  http_code=$(curl -s -m "$PAN_CURL_TIMEOUT" -o /dev/null -w '%{http_code}' \
+    -X POST "$url" -H 'Content-Type: application/json' \
+    -H "x-overdeck-internal-token: $PAN_INTERNAL_TOKEN" --data "$body" 2>/dev/null || echo '000')
+
+  if [[ "$http_code" =~ ^2 ]]; then
+    return 0
+  fi
+
+  # Drop on 4xx — server told us this body is invalid.
+  if [[ "$http_code" =~ ^4 ]]; then
+    return 0
+  fi
+
+  # Network failure / 5xx — buffer with flock.
+  {
+    flock -x -w 5 200 || return 0
+    printf '%s\n' "$body" >> "$pending" 2>/dev/null || true
+  } 200>"$lockfile"
+  return 0
+}
+
+# Drain pending-events.jsonl one line at a time. Each line is POSTed with the
+# same timeout; failures put the remaining lines (including the failed one)
+# back into the file so we try again next time the dashboard is up.
+#
+# Internal — do not call directly.
+pan__drain_pending() {
+  local agent_id="$1"
+  local url="$2"
+  local pending="$3"
+  local lockfile="$4"
+
+  {
+    flock -x -w 5 200 || return 0
+    # Re-check size after acquiring the lock — a concurrent hook may have
+    # already drained the file.
+    [ ! -s "$pending" ] && return 0
+
+    local tempfile="$pending.draining.$$"
+    mv "$pending" "$tempfile" 2>/dev/null || return 0
+
+    local failed="$pending.failed.$$"
+    : > "$failed"
+    local stop_on_failure=0
+    while IFS= read -r line; do
+      [ -z "$line" ] && continue
+      if [ "$stop_on_failure" = "1" ]; then
+        printf '%s\n' "$line" >> "$failed"
+        continue
+      fi
+      local code
+      code=$(curl -s -m "$PAN_CURL_TIMEOUT" -o /dev/null -w '%{http_code}' \
+        -X POST "$url" -H 'Content-Type: application/json' \
+        -H "x-overdeck-internal-token: $PAN_INTERNAL_TOKEN" --data "$line" 2>/dev/null || echo '000')
+      if [[ "$code" =~ ^2 ]]; then
+        : # drained successfully
+      elif [[ "$code" =~ ^4 ]]; then
+        : # server-side rejection — drop
+      else
+        # Network failure — put this and the rest back, stop draining.
+        printf '%s\n' "$line" >> "$failed"
+        stop_on_failure=1
+      fi
+    done < "$tempfile"
+
+    if [ -s "$failed" ]; then
+      mv "$failed" "$pending" 2>/dev/null || true
+    else
+      rm -f "$failed" 2>/dev/null || true
+    fi
+    rm -f "$tempfile" 2>/dev/null || true
+  } 200>"$lockfile"
+}

package/sync-sources/hooks/permission-event-hook

@@ -0,0 +1,24 @@
+#!/bin/bash
+# ~/.overdeck/bin/permission-event-hook
+#
+# Fires on Claude Code PermissionRequest, PostToolUse, and Stop hooks.
+# POSTs the raw payload (stdin) to the dashboard's /api/hooks/permission-event
+# endpoint so the dashboard can show/clear a "waiting for permission" indicator.
+#
+# Works for both conversation sessions (looked up by session_id) and agent
+# sessions — the dashboard server handles routing internally.
+
+set +e
+
+PAN_DASHBOARD_URL="${OVERDECK_DASHBOARD_URL:-http://localhost:3011}"
+PAYLOAD=$(cat 2>/dev/null || echo '{}')
+
+curl -sf \
+  --max-time 1 \
+  -X POST \
+  -H "Content-Type: application/json" \
+  -d "$PAYLOAD" \
+  "${PAN_DASHBOARD_URL}/api/hooks/permission-event" \
+  >/dev/null 2>&1 || true
+
+exit 0

package/sync-sources/hooks/post-compact-hook

@@ -0,0 +1,25 @@
+#!/bin/bash
+# ~/.overdeck/bin/post-compact-hook
+#
+# Fires on Claude Code PostCompact. Emits agent.activity_changed(idle) to clear
+# the compacting indicator and return the agent to normal idle state.
+
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=pan-hook-lib.sh
+. "$SCRIPT_DIR/pan-hook-lib.sh" 2>/dev/null || exit 0
+
+pan_resolve_agent_id || exit 0
+
+TS=$(date -Iseconds)
+
+if command -v jq >/dev/null 2>&1; then
+  BODY=$(jq -n --arg ts "$TS" \
+    '{kind: "activity", activity: "idle", timestamp: $ts}')
+else
+  BODY="{\"kind\":\"activity\",\"activity\":\"idle\",\"timestamp\":\"$TS\"}"
+fi
+
+pan_emit_event "$AGENT_ID" "$BODY"
+exit 0

package/sync-sources/hooks/pre-compact-hook

@@ -0,0 +1,26 @@
+#!/bin/bash
+# ~/.overdeck/bin/pre-compact-hook
+#
+# Fires on Claude Code PreCompact. Emits agent.activity_changed(working, tool=compact)
+# so the dashboard shows a "compacting" indicator while context is being summarised.
+# PostCompact hook clears this back to idle.
+
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=pan-hook-lib.sh
+. "$SCRIPT_DIR/pan-hook-lib.sh" 2>/dev/null || exit 0
+
+pan_resolve_agent_id || exit 0
+
+TS=$(date -Iseconds)
+
+if command -v jq >/dev/null 2>&1; then
+  BODY=$(jq -n --arg ts "$TS" \
+    '{kind: "activity", activity: "working", tool: "compact", timestamp: $ts}')
+else
+  BODY="{\"kind\":\"activity\",\"activity\":\"working\",\"tool\":\"compact\",\"timestamp\":\"$TS\"}"
+fi
+
+pan_emit_event "$AGENT_ID" "$BODY"
+exit 0

package/sync-sources/hooks/pre-tool-hook

@@ -0,0 +1,35 @@
+#!/bin/bash
+# ~/.overdeck/bin/pre-tool-hook  (PAN-800)
+#
+# Fires on Claude Code PreToolUse. POSTs agent.activity_changed(working, tool)
+# to the dashboard. No runtime.json writes — AgentStateService's
+# SubscriptionRef is the source of truth now.
+#
+# Never blocks Claude Code: strict timeout, silent failure, pending-events
+# buffering via pan-hook-lib.
+
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=pan-hook-lib.sh
+. "$SCRIPT_DIR/pan-hook-lib.sh" 2>/dev/null || exit 0
+
+pan_resolve_agent_id || exit 0
+
+TOOL_INFO=$(cat 2>/dev/null || echo '{}')
+TOOL_NAME="unknown"
+if command -v jq >/dev/null 2>&1; then
+  TOOL_NAME=$(echo "$TOOL_INFO" | jq -r '.tool_name // "unknown"' 2>/dev/null || echo "unknown")
+fi
+
+TS=$(date -Iseconds)
+# jq -n produces correctly-escaped JSON even if TOOL_NAME contains quotes.
+if command -v jq >/dev/null 2>&1; then
+  BODY=$(jq -n --arg tool "$TOOL_NAME" --arg ts "$TS" \
+    '{kind: "activity", activity: "working", tool: $tool, timestamp: $ts}')
+else
+  BODY="{\"kind\":\"activity\",\"activity\":\"working\",\"tool\":\"$TOOL_NAME\",\"timestamp\":\"$TS\"}"
+fi
+
+pan_emit_event "$AGENT_ID" "$BODY"
+exit 0

package/sync-sources/hooks/record-cost-event.d.ts

@@ -0,0 +1 @@
+export { };