@overdeck/desktop 0.45.12 → 0.45.13

package/sync-sources/hooks/statusline.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+# Claude Code status line — all available info + plan usage limits
+# JSON is piped via stdin on each update
+
+input=$(cat)
+
+# Single jq call to extract all fields at once
+eval "$(echo "$input" | jq -r '
+  @sh "model=\(.model.display_name // "")",
+  @sh "model_id=\(.model.id // "")",
+  @sh "current_dir=\(.workspace.current_dir // "")",
+  @sh "project_dir=\(.workspace.project_dir // "")",
+  @sh "cost=\(.cost.total_cost_usd // 0)",
+  @sh "lines_added=\(.cost.total_lines_added // 0)",
+  @sh "lines_removed=\(.cost.total_lines_removed // 0)",
+  @sh "ctx_used_pct=\(.context_window.used_percentage // 0)",
+  @sh "ctx_size=\(.context_window.context_window_size // 0)",
+  @sh "ctx_in=\(.context_window.current_usage.input_tokens // 0)",
+  @sh "ctx_out=\(.context_window.current_usage.output_tokens // 0)"
+' 2>/dev/null)"
+
+# ANSI colors
+RST='\033[0m'; DIM='\033[2m'
+CYN='\033[36m'; GRN='\033[32m'; YLW='\033[33m'
+MAG='\033[35m'; RED='\033[31m'; WHT='\033[37m'
+
+# Helper: format token count
+fmt() {
+  local n=${1:-0}
+  if (( n >= 1000000 )); then printf "%.1fM" "$(echo "scale=1;$n/1000000" | bc)"
+  elif (( n >= 1000 )); then printf "%.1fk" "$(echo "scale=1;$n/1000" | bc)"
+  else echo "$n"; fi
+}
+
+# Helper: color a percentage (green < 50, yellow < 80, red >= 80)
+pct_color() {
+  local pct_int=${1%.*}
+  if (( ${pct_int:-0} >= 80 )); then echo "$RED"
+  elif (( ${pct_int:-0} >= 50 )); then echo "$YLW"
+  else echo "$GRN"; fi
+}
+
+# Helper: format time remaining from ISO timestamp
+time_remaining() {
+  local reset_at="$1"
+  [ -z "$reset_at" ] || [ "$reset_at" = "null" ] && return
+  local reset_epoch now_epoch diff_s hours mins
+  reset_epoch=$(date -d "$reset_at" +%s 2>/dev/null) || return
+  now_epoch=$(date +%s)
+  diff_s=$(( reset_epoch - now_epoch ))
+  (( diff_s <= 0 )) && { echo "now"; return; }
+  hours=$(( diff_s / 3600 ))
+  mins=$(( (diff_s % 3600) / 60 ))
+  if (( hours > 0 )); then echo "${hours}h${mins}m"
+  else echo "${mins}m"; fi
+}
+
+# --- Usage limits (cached for 60s) ---
+CACHE_FILE="/tmp/.claude-usage-cache-$(id -u)"
+CACHE_TTL=60
+usage_5h="" usage_7d="" reset_5h="" reset_7d=""
+
+fetch_usage() {
+  local creds_file="$HOME/.claude/.credentials.json"
+  [ -f "$creds_file" ] || return
+  local token
+  token=$(jq -r '.claudeAiOauth.accessToken // empty' "$creds_file" 2>/dev/null)
+  [ -z "$token" ] && return
+  local response
+  response=$(curl -sf --max-time 3 \
+    -H "Accept: application/json" \
+    -H "Content-Type: application/json" \
+    -H "Authorization: Bearer $token" \
+    -H "anthropic-beta: oauth-2025-04-20" \
+    "https://api.anthropic.com/api/oauth/usage" 2>/dev/null) || return
+  echo "$response" > "$CACHE_FILE"
+}
+
+# Use cache if fresh, otherwise fetch in background
+if [ -f "$CACHE_FILE" ]; then
+  cache_age=$(( $(date +%s) - $(stat -c %Y "$CACHE_FILE" 2>/dev/null || echo 0) ))
+  if (( cache_age > CACHE_TTL )); then
+    # Fetch in background so we don't block the statusline
+    fetch_usage &
+  fi
+else
+  # First run — fetch synchronously (one-time cost)
+  fetch_usage
+fi
+
+# Read cached data
+if [ -f "$CACHE_FILE" ]; then
+  eval "$(jq -r '
+    @sh "usage_5h=\(.five_hour.utilization // "")",
+    @sh "reset_5h=\(.five_hour.resets_at // "")",
+    @sh "usage_7d=\(.seven_day.utilization // "")",
+    @sh "reset_7d=\(.seven_day.resets_at // "")"
+  ' "$CACHE_FILE" 2>/dev/null)"
+fi
+
+# Git branch (fast — reads file directly, no subprocess)
+git_branch=""
+dir="${current_dir:-.}"
+while [ "$dir" != "/" ]; do
+  if [ -f "$dir/.git/HEAD" ]; then
+    ref=$(< "$dir/.git/HEAD")
+    git_branch="${ref#ref: refs/heads/}"
+    break
+  fi
+  dir=$(dirname "$dir")
+done
+
+# Context % color
+ctx_color=$(pct_color "$ctx_used_pct")
+
+# Cost formatting
+cost_fmt=$(printf '$%.4f' "${cost:-0}")
+
+# Line 1: model | dir | git branch
+line1=""
+[ -n "$model" ] && line1+=$(printf "%b%s%b" "$MAG" "$model" "$RST")
+[ -n "$model_id" ] && line1+=$(printf " %b(%s)%b" "$DIM" "$model_id" "$RST")
+if [ -n "$current_dir" ]; then
+  short_dir="${current_dir/#$HOME/~}"
+  line1+=$(printf "  %b%s%b" "$CYN" "$short_dir" "$RST")
+fi
+[ -n "$git_branch" ] && line1+=$(printf "  %b%b%s%b" "$DIM" "$GRN" "$git_branch" "$RST")
+
+# Line 2: context usage | cost | lines changed
+line2=""
+line2+=$(printf "%bctx%b %b%.0f%%%b" "$DIM" "$RST" "$ctx_color" "$ctx_used_pct" "$RST")
+line2+=$(printf "  %b%s%b/%b%s%b" "$WHT" "$(fmt "$ctx_in")" "$RST" "$DIM" "$(fmt "$ctx_size")" "$RST")
+line2+=$(printf "  %bout%b %s" "$DIM" "$RST" "$(fmt "$ctx_out")")
+line2+=$(printf "  %bcost%b %b%s%b" "$DIM" "$RST" "$YLW" "$cost_fmt" "$RST")
+if (( lines_added > 0 || lines_removed > 0 )); then
+  line2+=$(printf "  %b+%d%b/%b-%d%b" "$GRN" "$lines_added" "$RST" "$RED" "$lines_removed" "$RST")
+fi
+
+# Line 3: plan usage limits (5h + 7d)
+line3=""
+if [ -n "$usage_5h" ]; then
+  u5_color=$(pct_color "$usage_5h")
+  u5_reset=$(time_remaining "$reset_5h")
+  line3+=$(printf "%b5h%b %b%.0f%%%b" "$DIM" "$RST" "$u5_color" "$usage_5h" "$RST")
+  [ -n "$u5_reset" ] && line3+=$(printf " %b(%s)%b" "$DIM" "$u5_reset" "$RST")
+fi
+if [ -n "$usage_7d" ]; then
+  u7_color=$(pct_color "$usage_7d")
+  u7_reset=$(time_remaining "$reset_7d")
+  [ -n "$line3" ] && line3+="  "
+  line3+=$(printf "%b7d%b %b%.0f%%%b" "$DIM" "$RST" "$u7_color" "$usage_7d" "$RST")
+  [ -n "$u7_reset" ] && line3+=$(printf " %b(%s)%b" "$DIM" "$u7_reset" "$RST")
+fi
+
+# Write context % to agent dir for dashboard monitoring (non-blocking)
+if [ -n "$OVERDECK_AGENT_ID" ] && [ -n "$ctx_used_pct" ]; then
+  CTX_DIR="$HOME/.overdeck/agents/$OVERDECK_AGENT_ID"
+  if [ -d "$CTX_DIR" ]; then
+    printf '%.0f' "$ctx_used_pct" > "$CTX_DIR/context-pct" 2>/dev/null || true
+    # Capture initial context % (first time only)
+    if [ ! -f "$CTX_DIR/initial-context-pct" ]; then
+      printf '%.0f' "$ctx_used_pct" > "$CTX_DIR/initial-context-pct" 2>/dev/null || true
+    fi
+  fi
+fi
+
+printf "%b\n" "$line1"
+printf "%b\n" "$line2"
+[ -n "$line3" ] && printf "%b\n" "$line3"

package/sync-sources/hooks/stop-hook

@@ -0,0 +1,217 @@
+#!/bin/bash
+# ~/.overdeck/bin/stop-hook  (PAN-800)
+#
+# Fires on Claude Code Stop. Emits agent.activity_changed(idle) — the reducer
+# clears currentTool / thinking / waiting on that transition, so no separate
+# waiting_cleared is needed. Still chains to specialist-stop-hook and
+# work-agent-stop-hook, and still fires the planning auto-completion call.
+
+set +e
+
+# Capture stdin once, early, so later background work cannot consume it and the
+# hook can forward the session_id to the turn-complete title-refinement endpoint.
+INPUT=$(cat 2>/dev/null || echo '{}')
+
+# Log first-thing so we have empirical evidence the hook fired, regardless of
+# whether anything downstream succeeded. Silent failures in pan_resolve_agent_id
+# used to leave zero trace, making "did the Stop hook even fire?" impossible to
+# answer post-hoc.
+LOG_DIR="$HOME/.overdeck/logs"
+mkdir -p "$LOG_DIR" 2>/dev/null || true
+echo "[$(date -Iseconds)] stop-hook: invoked CLAUDE_SESSION_ID=${CLAUDE_SESSION_ID:-unset} OVERDECK_AGENT_ID=${OVERDECK_AGENT_ID:-unset} cwd=$(pwd)" \
+  >> "$LOG_DIR/hooks.log" 2>/dev/null || true
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=pan-hook-lib.sh
+. "$SCRIPT_DIR/pan-hook-lib.sh" 2>/dev/null || {
+  echo "[$(date -Iseconds)] stop-hook: pan-hook-lib.sh source failed — exiting" \
+    >> "$LOG_DIR/hooks.log" 2>/dev/null || true
+  exit 0
+}
+
+if ! pan_resolve_agent_id; then
+  echo "[$(date -Iseconds)] stop-hook: pan_resolve_agent_id failed (CLAUDE_SESSION_ID=${CLAUDE_SESSION_ID:-unset} cwd=$(pwd)) — exiting" \
+    >> "$LOG_DIR/hooks.log" 2>/dev/null || true
+  exit 0
+fi
+
+echo "[$(date -Iseconds)] stop-hook: resolved AGENT_ID=$AGENT_ID — proceeding" \
+  >> "$LOG_DIR/hooks.log" 2>/dev/null || true
+
+TS=$(date -Iseconds)
+BODY="{\"kind\":\"activity\",\"activity\":\"idle\",\"timestamp\":\"$TS\"}"
+pan_emit_event "$AGENT_ID" "$BODY"
+
+# ── API error detection (all agent types) ────────────────────────────────
+# Run before the turn-complete notification so a Stop caused by a transient
+# API error is not treated as a completed assistant turn.
+LOG_DIR="$HOME/.overdeck/logs"
+mkdir -p "$LOG_DIR"
+API_ERROR_DETECTED=false
+API_ERROR_NUDGE_FILE="$HOME/.overdeck/agents/$AGENT_ID/.last-api-error-nudge"
+
+OUTPUT=$(tmux capture-pane -t "$AGENT_ID" -p -S -100 2>/dev/null || echo "")
+if [ -n "$OUTPUT" ]; then
+  for pattern in \
+    "API Error: The server had an error while processing your request" \
+    "API Error: Overloaded" \
+    "API Error: Rate limit" \
+    "API Error: Request was aborted" \
+    "API Error: Timed out" \
+    "529 Overloaded" \
+    "502 Bad Gateway" \
+    "503 Service Unavailable"; do
+    if echo "$OUTPUT" | grep -qF "$pattern"; then
+      API_ERROR_DETECTED=true
+      break
+    fi
+  done
+fi
+
+# PAN-1644: notify the dashboard that a turn completed, so it can progressively
+# refine the conversation title. Skip this when an API error caused the Stop.
+# Fire-and-forget: the dashboard may be down or busy; the stop-hook must still
+# exit 0 and chain to downstream hooks.
+if [ "$API_ERROR_DETECTED" != "true" ]; then
+  INTERNAL_TOKEN="${OVERDECK_INTERNAL_TOKEN:-}"
+  if [ -z "$INTERNAL_TOKEN" ]; then
+    TOKEN_PATH="${OVERDECK_HOME:-$HOME/.overdeck}/internal-token"
+    if [ -f "$TOKEN_PATH" ]; then
+      INTERNAL_TOKEN=$(cat "$TOKEN_PATH" 2>/dev/null || true)
+    fi
+  fi
+
+  if command -v jq >/dev/null 2>&1; then
+    SESSION_ID=$(printf '%s' "$INPUT" | jq -r '(.session_id // "")' 2>/dev/null)
+    if [ -z "$SESSION_ID" ]; then
+      SESSION_ID="${CLAUDE_SESSION_ID:-}"
+    fi
+    if [ -n "$SESSION_ID" ]; then
+      TURN_COMPLETE_BODY=$(jq -n --arg session_id "$SESSION_ID" '{session_id: $session_id}' 2>/dev/null)
+      if [ -n "$TURN_COMPLETE_BODY" ]; then
+        curl -s -m 1 -X POST -H 'Content-Type: application/json' -H "x-overdeck-internal-token: $INTERNAL_TOKEN" --data "$TURN_COMPLETE_BODY" "$PAN_DASHBOARD_URL/api/hooks/turn-complete" >/dev/null 2>&1 || true
+      fi
+    fi
+  fi
+fi
+
+# If the agent stopped because of a transient API error, nudge it to retry.
+# This runs before chaining to specialist/work-agent hooks because it
+# applies universally. 5-minute cooldown per agent.
+if [ "$API_ERROR_DETECTED" = "true" ]; then
+  SHOULD_NUDGE=true
+  if [ -f "$API_ERROR_NUDGE_FILE" ]; then
+    LAST_API_NUDGE=$(cat "$API_ERROR_NUDGE_FILE" 2>/dev/null || echo "0")
+    NOW=$(date +%s)
+    if [ $(( NOW - LAST_API_NUDGE )) -lt 300 ]; then
+      SHOULD_NUDGE=false
+    fi
+  fi
+
+  if [ "$SHOULD_NUDGE" = "true" ]; then
+    mkdir -p "$(dirname "$API_ERROR_NUDGE_FILE")"
+    date +%s > "$API_ERROR_NUDGE_FILE" 2>/dev/null || true
+
+    echo "[$(date -Iseconds)] stop-hook: $AGENT_ID api_error detected — nudging retry" \
+      >> "$LOG_DIR/hooks.log" 2>/dev/null || true
+
+    tmpfile=$(mktemp)
+    echo "You stopped due to a transient API error. This is a temporary server issue, not a problem with your work. Continue from where you left off. Do NOT start over — pick up exactly where you stopped." > "$tmpfile"
+    tmux load-buffer "$tmpfile" 2>/dev/null
+    tmux paste-buffer -t "$AGENT_ID" 2>/dev/null
+    sleep 0.3
+    tmux send-keys -t "$AGENT_ID" C-m 2>/dev/null
+    rm -f "$tmpfile"
+  fi
+fi
+
+# Chain to specialist-specific hook (auto-completion detection).
+SPECIALIST_HOOK="$HOME/.overdeck/bin/specialist-stop-hook"
+if [ -x "$SPECIALIST_HOOK" ]; then
+  "$SPECIALIST_HOOK" &
+fi
+
+# Chain to work-agent completion detection (nudges agents that forgot `pan work done`).
+WORK_AGENT_HOOK="$HOME/.overdeck/bin/work-agent-stop-hook"
+if [ -x "$WORK_AGENT_HOOK" ]; then
+  "$WORK_AGENT_HOOK" &
+fi
+
+# Auto-mark planning complete when a planning agent finishes.
+if [[ "$AGENT_ID" == planning-* ]]; then
+  ISSUE_ID=$(echo "$AGENT_ID" | sed 's/^planning-//' | tr '[:lower:]' '[:upper:]')
+  if [ -n "$ISSUE_ID" ]; then
+    curl -s -m 1.0 -X POST "$PAN_DASHBOARD_URL/api/issues/$ISSUE_ID/complete-planning" \
+      -H "Content-Type: application/json" \
+      -d '{"skipKill":true}' > /dev/null 2>&1 &
+  fi
+fi
+
+# PAN-1557: interactive convoy reviewer finished a turn. If it wrote its report
+# and hasn't signaled yet, deliver REVIEWER_READY to the synthesis agent.
+# Interactive reviewers (no `claude --print`) don't exit, so the launcher can't
+# own this signal the way it did for headless reviewers — the Stop-hook does.
+# A bare idle stop with no report is left alone: Deacon's REVIEWER_TIMEOUT is
+# the failure path, so we never emit a premature REVIEWER_FAILED.
+# Pattern: agent-<issueId>-review-<subRole>
+if [[ "$AGENT_ID" =~ ^agent-.+-review-(security|correctness|performance|requirements)$ ]]; then
+  R_STATE="$HOME/.overdeck/agents/$AGENT_ID/state.json"
+  R_MARKER="$HOME/.overdeck/agents/$AGENT_ID/reviewer-signaled"
+  if [ -f "$R_STATE" ] && [ ! -f "$R_MARKER" ]; then
+    # state.json is pretty-printed ("key": "value" with whitespace after the
+    # colon), so the extraction must tolerate optional whitespace.
+    R_OUT=$(sed -nE 's/.*"reviewOutputPath"[[:space:]]*:[[:space:]]*"([^"]*)".*/\1/p' "$R_STATE" | head -1)
+    R_SUB=$(sed -nE 's/.*"reviewSubRole"[[:space:]]*:[[:space:]]*"([^"]*)".*/\1/p' "$R_STATE" | head -1)
+    R_SYNTH=$(sed -nE 's/.*"reviewSynthesisAgentId"[[:space:]]*:[[:space:]]*"([^"]*)".*/\1/p' "$R_STATE" | head -1)
+    if [ -n "$R_OUT" ] && [ -n "$R_SUB" ] && [ -n "$R_SYNTH" ] && [ -s "$R_OUT" ]; then
+      # Deliver via the load-buffer + paste-buffer + Enter pattern on the
+      # overdeck socket (matches the API-error nudge above and the project's
+      # tmux-delivery rule). The synthesis session is always an interactive
+      # tmux session, so the paste reaches its prompt.
+      R_TMP=$(mktemp)
+      printf 'REVIEWER_READY %s %s' "$R_SUB" "$R_OUT" > "$R_TMP"
+      tmux -L overdeck load-buffer "$R_TMP" 2>/dev/null
+      tmux -L overdeck paste-buffer -t "$R_SYNTH" 2>/dev/null
+      sleep 0.3
+      tmux -L overdeck send-keys -t "$R_SYNTH" C-m 2>/dev/null
+      rm -f "$R_TMP"
+      touch "$R_MARKER"
+      echo "[$(date -Iseconds)] stop-hook: $AGENT_ID signaled REVIEWER_READY $R_SUB to $R_SYNTH" \
+        >> "$LOG_DIR/hooks.log" 2>/dev/null || true
+    fi
+  fi
+fi
+
+# PAN-1059 session-reaper: when the review synthesis session ends, kill any
+# convoy sub-reviewer sessions (agent-<id>-review-{security,correctness,...}).
+# Pattern: agent-<issueId>-review   (no trailing sub-role suffix → synthesis)
+if [[ "$AGENT_ID" =~ ^agent-(.+)-review$ ]]; then
+  REVIEW_ISSUE="${BASH_REMATCH[1]}"
+  KILLED_ANY=false
+  for SUBROLE in security correctness performance requirements; do
+    CONVOY_SESSION="agent-${REVIEW_ISSUE}-review-${SUBROLE}"
+    # PAN-1557: only reap a convoy reviewer that has SIGNALED (its
+    # `reviewer-signaled` marker is present). The marker is cleared at spawn
+    # (review-agent.ts) and touched when the reviewer signals REVIEWER_READY
+    # — headless launchers and the interactive Stop-hook both honor it — so a
+    # present marker means "this cycle's reviewer is done; safe to reap." A
+    # reviewer with NO marker is either still running OR belongs to a newer
+    # review cycle that reused this session name; reaping it would be the
+    # cross-cycle race that left running reviewers terminal-less. Skip it.
+    CONVOY_MARKER="$HOME/.overdeck/agents/$CONVOY_SESSION/reviewer-signaled"
+    if [ ! -f "$CONVOY_MARKER" ]; then
+      continue
+    fi
+    if tmux -L overdeck kill-session -t "$CONVOY_SESSION" 2>/dev/null; then
+      KILLED_ANY=true
+      echo "[$(date -Iseconds)] stop-hook: $AGENT_ID killed convoy $CONVOY_SESSION (signaled)" \
+        >> "$LOG_DIR/hooks.log" 2>/dev/null || true
+    fi
+  done
+  if [ "$KILLED_ANY" = "true" ]; then
+    echo "[$(date -Iseconds)] stop-hook: $AGENT_ID synthesis ended — convoy reaped for $REVIEW_ISSUE" \
+      >> "$LOG_DIR/hooks.log" 2>/dev/null || true
+  fi
+fi
+
+exit 0

package/sync-sources/hooks/tldr-post-edit

@@ -0,0 +1,72 @@
+#!/bin/bash
+# ~/.overdeck/bin/tldr-post-edit
+# PostToolUse hook on Edit/Write — notifies TLDR to re-warm after code changes.
+#
+# Tracks dirty files in a lightweight file. When the dirty count exceeds a
+# threshold, triggers a background re-warm so the index stays fresh.
+
+# Don't use set -e — never break Claude Code execution
+INPUT=$(cat 2>/dev/null || echo '{}')
+
+# Only act on Edit and Write tools
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""' 2>/dev/null)
+if [ "$TOOL_NAME" != "Edit" ] && [ "$TOOL_NAME" != "Write" ]; then
+  exit 0
+fi
+
+# Extract file path
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""' 2>/dev/null)
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+# Only track code files
+EXT="${FILE_PATH##*.}"
+EXT_LOWER=$(echo "$EXT" | tr '[:upper:]' '[:lower:]')
+case "$EXT_LOWER" in
+  ts|tsx|js|jsx|py|java|go|rs|cpp|c|h|hpp|rb|php|kt|swift|cs|scala|lua|ex|exs)
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+
+# Find project root (where .venv lives)
+PROJECT_DIR=""
+DIR="$(dirname "$FILE_PATH")"
+while [ "$DIR" != "/" ]; do
+  if [ -d "$DIR/.venv" ]; then
+    PROJECT_DIR="$DIR"
+    break
+  fi
+  DIR=$(dirname "$DIR")
+done
+
+if [ -z "$PROJECT_DIR" ]; then
+  exit 0
+fi
+
+# Track dirty files
+DIRTY_FILE="$PROJECT_DIR/.tldr/dirty-files"
+mkdir -p "$PROJECT_DIR/.tldr" 2>/dev/null || true
+
+# Append the changed file (deduplicated on warm)
+REL_PATH="${FILE_PATH#$PROJECT_DIR/}"
+echo "$REL_PATH" >> "$DIRTY_FILE" 2>/dev/null || true
+
+# Count dirty files (fast line count)
+DIRTY_COUNT=$(wc -l < "$DIRTY_FILE" 2>/dev/null || echo 0)
+
+# Trigger background re-warm after 10 edits (keeps index reasonably fresh)
+WARM_THRESHOLD=10
+if [ "$DIRTY_COUNT" -ge "$WARM_THRESHOLD" ]; then
+  TLDR_BIN="$PROJECT_DIR/.venv/bin/tldr"
+  if [ -x "$TLDR_BIN" ]; then
+    # Clear dirty tracking before warm
+    : > "$DIRTY_FILE" 2>/dev/null || true
+    # Background warm — non-blocking
+    (cd "$PROJECT_DIR" && "$TLDR_BIN" warm . --background) >/dev/null 2>&1 &
+  fi
+fi
+
+exit 0