@overdeck/desktop 0.45.12 → 0.45.13

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

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+/**
+ * Record cost events from Claude Code transcript data
+ * Called by heartbeat-hook with PostToolUse JSON on stdin
+ *
+ * Claude Code's PostToolUse events do NOT include token usage.
+ * Instead, we read usage from the transcript JSONL file
+ * (available via the transcript_path field in the event).
+ *
+ * Uses byte-offset tracking to efficiently process only new
+ * transcript entries on each invocation.
+ */
+
+import { readFileSync, existsSync, writeFileSync, mkdirSync, openSync, readSync, fstatSync, closeSync } from 'fs';
+import { execFileSync } from 'child_process';
+import { join } from 'path';
+import { homedir } from 'os';
+import { calculateCostSync, getPricingSync, AIProvider } from '../../src/lib/cost.js';
+import { appendCostEventSync } from '../../src/lib/costs/events.js';
+import { captureTldrMetricsSync, type TldrSessionMetrics } from '../../src/lib/tldr-daemon.js';
+
+// ============== Types ==============
+
+interface PostToolUseEvent {
+  session_id?: string;
+  transcript_path?: string;
+  tool_name?: string;
+  tool_use_id?: string;
+}
+
+interface TranscriptUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+}
+
+interface TranscriptEntry {
+  type?: string;
+  message?: {
+    model?: string;
+    usage?: TranscriptUsage;
+  };
+  requestId?: string;
+}
+
+// ============== Main ==============
+
+// Read PostToolUse event from stdin
+let event: PostToolUseEvent;
+try {
+  const input = readFileSync(0, 'utf-8');
+  event = JSON.parse(input) as PostToolUseEvent;
+} catch {
+  process.exit(0);
+}
+
+// Need transcript path to read usage data
+const transcriptPath = event?.transcript_path;
+if (!transcriptPath || !existsSync(transcriptPath)) {
+  process.exit(0);
+}
+
+const sessionId = event?.session_id || 'unknown';
+
+// State tracking: byte offset per session to avoid re-processing
+const stateDir = join(process.env.HOME || homedir(), '.overdeck', 'costs', 'state');
+mkdirSync(stateDir, { recursive: true });
+const stateFile = join(stateDir, `${sessionId}.offset`);
+
+let lastOffset = 0;
+if (existsSync(stateFile)) {
+  try {
+    lastOffset = parseInt(readFileSync(stateFile, 'utf-8').trim(), 10) || 0;
+  } catch { /* start from 0 */ }
+}
+
+// Load persisted seen requestIds to guard against crash-before-write duplicates (PAN-238)
+// Claude Code's transcript can have multiple entries per requestId — we emit exactly one event per requestId.
+const seenFile = join(stateDir, `${sessionId}.seen`);
+const seenRequestIds = new Set<string>();
+if (existsSync(seenFile)) {
+  try {
+    const seenContent = readFileSync(seenFile, 'utf-8').trim();
+    if (seenContent) {
+      for (const id of seenContent.split('\n')) {
+        if (id.trim()) seenRequestIds.add(id.trim());
+      }
+    }
+  } catch { /* start fresh */ }
+}
+
+// Read only NEW content from the transcript (efficient for large files)
+let fd: number;
+try {
+  fd = openSync(transcriptPath, 'r');
+} catch {
+  process.exit(0);
+}
+
+const stat = fstatSync(fd);
+if (stat.size <= lastOffset) {
+  closeSync(fd);
+  // Save current size even if no new content (handles file truncation)
+  writeFileSync(stateFile, String(stat.size), 'utf-8');
+  process.exit(0);
+}
+
+const bytesToRead = stat.size - lastOffset;
+const buffer = Buffer.alloc(bytesToRead);
+readSync(fd, buffer, 0, bytesToRead, lastOffset);
+closeSync(fd);
+
+const newContent = buffer.toString('utf-8');
+const lines = newContent.split('\n');
+
+// Get agent/issue context from environment, with git branch fallback
+const agentId: string = process.env.OVERDECK_AGENT_ID || 'unattributed';
+let issueId: string = process.env.OVERDECK_ISSUE_ID || '';
+const sessionType: string = process.env.OVERDECK_SESSION_TYPE || 'implementation';
+// Caveman A/B test variant — set by agent launcher when agents.caveman.ab_test is active (PAN-611)
+const cavemanVariant = process.env.OVERDECK_CAVEMAN_VARIANT as 'enabled' | 'disabled' | 'off' | undefined;
+
+// Infer issue ID from git branch if not set (covers ad-hoc Claude sessions)
+if (!issueId || issueId === 'UNKNOWN') {
+  try {
+    const branch = execFileSync('git', ['branch', '--show-current'], {
+      encoding: 'utf-8',
+      timeout: 2000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    const branchMatch = branch.match(/(pan|min|aud|krux|cli)[-](\d+)/i);
+    if (branchMatch) {
+      issueId = `${branchMatch[1].toUpperCase()}-${branchMatch[2]}`;
+    }
+  } catch {
+    // Git not available or not in a repo — that's fine
+  }
+}
+
+// Final fallback
+if (!issueId) {
+  issueId = 'UNKNOWN';
+}
+
+// Capture TLDR metrics for this batch (PAN-236)
+// Find workspace root via git (same process already used for branch detection above)
+let tldrMetrics: TldrSessionMetrics | null = null;
+try {
+  const workspaceRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+    encoding: 'utf-8',
+    timeout: 2000,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+  if (workspaceRoot) {
+    tldrMetrics = captureTldrMetricsSync(workspaceRoot);
+  }
+} catch { /* git not available or no workspace — skip TLDR metrics */ }
+
+// Process new transcript lines looking for assistant messages with usage
+let tldrAttachedToFirstEvent = false;
+for (const line of lines) {
+  if (!line.trim()) continue;
+
+  try {
+    const entry = JSON.parse(line) as TranscriptEntry;
+
+    // Only process assistant messages that have usage data
+    if (entry.type !== 'assistant' || !entry.message?.usage) {
+      continue;
+    }
+
+    // Skip already-seen requestIds — transcript has multiple entries per API request (PAN-238)
+    const requestId = entry.requestId;
+    if (requestId) {
+      if (seenRequestIds.has(requestId)) {
+        continue; // Duplicate entry for this request — already emitted a cost event
+      }
+      seenRequestIds.add(requestId);
+    }
+
+    const usage = entry.message.usage;
+    const model: string = entry.message.model || 'claude-sonnet-4';
+
+    const inputTokens = usage.input_tokens || 0;
+    const outputTokens = usage.output_tokens || 0;
+    const cacheReadTokens = usage.cache_read_input_tokens || 0;
+    const cacheWriteTokens = usage.cache_creation_input_tokens || 0;
+
+    // Skip entries with zero tokens
+    if (inputTokens === 0 && outputTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0) {
+      continue;
+    }
+
+    // Determine provider from model name
+    let provider: AIProvider = 'anthropic';
+    if (model.includes('gpt')) {
+      provider = 'openai';
+    } else if (model.includes('gemini')) {
+      provider = 'google';
+    } else if (model.includes('kimi') || model.toLowerCase().startsWith('minimax')) {
+      provider = 'custom';
+    }
+
+    // Get pricing and calculate cost (Sync variants — the Effect-returning
+    // getPricing/calculateCost are lazy and silently broke recording, PAN-1570)
+    const pricing = getPricingSync(provider, model);
+    if (!pricing) continue;
+
+    const cost = calculateCostSync({
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      cacheTTL: '5m',
+    }, pricing);
+
+    // Attach TLDR metrics to the first event in each batch (delta since last batch)
+    const tldrFields = tldrMetrics && !tldrAttachedToFirstEvent && tldrMetrics.interceptions + tldrMetrics.bypasses > 0
+      ? {
+          tldrInterceptions: tldrMetrics.interceptions,
+          tldrBypasses: tldrMetrics.bypasses,
+          tldrTokensSaved: tldrMetrics.estimatedTokensSaved,
+          tldrBypassReasons: Object.keys(tldrMetrics.bypassReasons).length > 0
+            ? tldrMetrics.bypassReasons
+            : undefined,
+        }
+      : {};
+
+    if (tldrMetrics && !tldrAttachedToFirstEvent) {
+      tldrAttachedToFirstEvent = true;
+    }
+
+    // Record the cost event.
+    // NOTE: appendCostEventSync (not the Effect-returning appendCostEvent) — the
+    // latter is a lazy Effect that does nothing unless run, which silently dropped
+    // every cost event after the PAN-1249 Effect migration (PAN-1570).
+    appendCostEventSync({
+      ts: new Date().toISOString(),
+      type: 'cost',
+      agentId,
+      issueId,
+      sessionType,
+      provider,
+      model,
+      input: inputTokens,
+      output: outputTokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: cacheWriteTokens,
+      cost,
+      ...(requestId ? { requestId } : {}),
+      sessionId,
+      ...tldrFields,
+      ...(cavemanVariant ? { cavemanVariant } : {}),
+    });
+  } catch {
+    // Skip malformed lines silently
+  }
+}
+
+// Save new byte offset and seen requestIds for next invocation
+writeFileSync(stateFile, String(stat.size), 'utf-8');
+if (seenRequestIds.size > 0) {
+  writeFileSync(seenFile, Array.from(seenRequestIds).join('\n') + '\n', 'utf-8');
+}
+
+process.exit(0);

package/sync-sources/hooks/rtk-bash-filter

@@ -0,0 +1,152 @@
+#!/bin/bash
+# ~/.overdeck/bin/rtk-bash-filter
+# PreToolUse hook on Bash — delegates command rewriting to rtk-ai/rtk so
+# expensive command output can be filtered before Claude Code runs the command.
+#
+# Bypasses (allows normal Bash execution):
+#   - Non-Bash tool_name
+#   - jq unavailable or malformed PreToolUse JSON
+#   - OVERDECK_RTK_ENABLED is unset/false and agents.rtk.enabled is absent/false
+#   - ~/.overdeck/bin/rtk is missing or not executable
+#   - rtk exits non-zero, emits no output, or emits an invalid PreToolUse response
+#   - rtk chooses not to rewrite a command, including commands whose output it
+#     expects to be too small to benefit from filtering
+#
+# Don't use set -e — hooks must never break Claude Code execution.
+set +e
+
+rtk_truthy() {
+  case "$(printf '%s' "$1" | tr '[:upper:]' '[:lower:]')" in
+    1|true|yes|on|enabled) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+rtk_project_root() {
+  local current
+  current="$PWD"
+  while [ "$current" != "/" ]; do
+    if [ -e "$current/.git" ]; then
+      printf '%s\n' "$current"
+      return 0
+    fi
+    current=$(dirname "$current")
+  done
+}
+
+rtk_read_config_enabled() {
+  local config_path
+  config_path="$1"
+  [ -z "$config_path" ] && return 0
+  [ ! -f "$config_path" ] && return 0
+
+  awk '
+    function trim(s) { sub(/^[ \t\r\n]+/, "", s); sub(/[ \t\r\n]+$/, "", s); return s }
+    BEGIN { in_agents = 0; in_rtk = 0; agents_indent = -1; rtk_indent = -1 }
+    {
+      line = $0
+      sub(/#.*/, "", line)
+      if (line ~ /^[[:space:]]*$/) next
+      match(line, /^[ ]*/)
+      indent = RLENGTH
+      key = line
+      sub(/^[[:space:]]*/, "", key)
+
+      if (key ~ /^agents:[[:space:]]*$/) {
+        in_agents = 1
+        in_rtk = 0
+        agents_indent = indent
+        next
+      }
+      if (in_agents && indent <= agents_indent) {
+        in_agents = 0
+        in_rtk = 0
+      }
+      if (in_agents && key ~ /^rtk:[[:space:]]*$/) {
+        in_rtk = 1
+        rtk_indent = indent
+        next
+      }
+      if (in_rtk && indent <= rtk_indent) {
+        in_rtk = 0
+      }
+      if (in_rtk && key ~ /^enabled:[[:space:]]*/) {
+        sub(/^enabled:[[:space:]]*/, "", key)
+        gsub(/"/, "", key)
+        gsub(/\047/, "", key)
+        print trim(key)
+        exit
+      }
+    }
+  ' "$config_path" 2>/dev/null
+}
+
+rtk_config_enabled_value() {
+  local config_path project_root value result
+
+  if [ -n "${OVERDECK_CONFIG:-}" ]; then
+    value=$(rtk_read_config_enabled "$OVERDECK_CONFIG")
+  else
+    value=$(rtk_read_config_enabled "$HOME/.overdeck/config.yaml")
+  fi
+  [ -n "$value" ] && result="$value"
+
+  project_root=$(rtk_project_root)
+  if [ -n "$project_root" ]; then
+    if [ -f "$project_root/.pan.yaml" ]; then
+      config_path="$project_root/.pan.yaml"
+    elif [ -f "$project_root/.overdeck.yaml" ]; then
+      config_path="$project_root/.overdeck.yaml"
+    else
+      config_path=""
+    fi
+
+    value=$(rtk_read_config_enabled "$config_path")
+    [ -n "$value" ] && result="$value"
+  fi
+
+  printf '%s\n' "$result"
+}
+
+RTK_BIN="$HOME/.overdeck/bin/rtk"
+
+if [ -n "${OVERDECK_RTK_ENABLED+x}" ]; then
+  if ! rtk_truthy "$OVERDECK_RTK_ENABLED"; then
+    exit 0
+  fi
+else
+  CONFIG_VALUE=$(rtk_config_enabled_value)
+  if ! rtk_truthy "$CONFIG_VALUE"; then
+    exit 0
+  fi
+fi
+
+if [ ! -x "$RTK_BIN" ]; then
+  exit 0
+fi
+
+if ! command -v jq >/dev/null 2>&1; then
+  exit 0
+fi
+
+INPUT=$(cat 2>/dev/null || echo '{}')
+TOOL_NAME=$(printf '%s' "$INPUT" | jq -r '.tool_name // ""' 2>/dev/null)
+if [ "$TOOL_NAME" != "Bash" ]; then
+  exit 0
+fi
+
+RTK_OUTPUT=$(printf '%s' "$INPUT" | "$RTK_BIN" hook claude 2>/dev/null)
+RTK_STATUS=$?
+if [ $RTK_STATUS -ne 0 ] || [ -z "$RTK_OUTPUT" ]; then
+  exit 0
+fi
+
+if ! printf '%s' "$RTK_OUTPUT" | jq -e '
+  .hookSpecificOutput.hookEventName == "PreToolUse"
+  and (.hookSpecificOutput.updatedInput.command | type == "string")
+' >/dev/null 2>&1; then
+  exit 0
+fi
+
+printf '%s\n' "$RTK_OUTPUT"
+exit 0

package/sync-sources/hooks/session-start-hook

@@ -0,0 +1,80 @@
+#!/bin/bash
+# ~/.overdeck/bin/session-start-hook  (PAN-800)
+#
+# Fires on Claude Code SessionStart. Emits agent.activity_changed(idle) so the
+# runtime snapshot is current before the first tool fires, and emits
+# agent.model_set when the model is inferable from the payload or env.
+#
+# This hook replaces the waitForReadySignal tmux fallback referenced in
+# PAN-759 — the hook that was supposed to exist from the start but was never
+# registered in ~/.claude/settings.json by the installer.
+
+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
+
+INPUT=$(cat 2>/dev/null || echo '{}')
+
+CLAUDE_SESSION_ID=""
+MODEL=""
+if command -v jq >/dev/null 2>&1; then
+  CLAUDE_SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // ""' 2>/dev/null)
+  MODEL=$(echo "$INPUT" | jq -r '.model // .model_name // ""' 2>/dev/null)
+fi
+[ -z "$MODEL" ] && MODEL="${ANTHROPIC_MODEL:-}"
+
+TS=$(date -Iseconds)
+
+pan_emit_event "$AGENT_ID" "{\"kind\":\"activity\",\"activity\":\"idle\",\"timestamp\":\"$TS\"}"
+
+# PAN-1594: write the ready.json readiness signal that waitForReadySignal()
+# consumes. Claude-side counterpart to the Pi extension's handleSessionStart
+# writer (packages/pi-extension/src/index.ts). Closes the PAN-759 gap where the
+# hook emitted the idle event but never wrote the file, which forced
+# waitForReadySignal onto a tmux pane-scrape fallback coupled to permission-mode
+# footer text. clearReadySignal() removes this file before every (re)launch, so
+# its presence means "this session reached the prompt".
+READY_DIR="${OVERDECK_HOME:-$HOME/.overdeck}/agents/$AGENT_ID"
+mkdir -p "$READY_DIR" 2>/dev/null
+if command -v jq >/dev/null 2>&1; then
+  jq -n --arg agentId "$AGENT_ID" --arg sid "$CLAUDE_SESSION_ID" --arg ts "$TS" \
+    '{ready: true, agentId: $agentId, sessionId: (if $sid == "" then null else $sid end), reason: "session-start", timestamp: $ts}' \
+    > "$READY_DIR/ready.json" 2>/dev/null || true
+else
+  printf '{"ready":true,"agentId":"%s","sessionId":"%s","reason":"session-start","timestamp":"%s"}\n' \
+    "$AGENT_ID" "$CLAUDE_SESSION_ID" "$TS" > "$READY_DIR/ready.json" 2>/dev/null || true
+fi
+
+if [ -n "$MODEL" ]; then
+  if command -v jq >/dev/null 2>&1; then
+    BODY=$(jq -n --arg model "$MODEL" --arg sid "$CLAUDE_SESSION_ID" --arg ts "$TS" \
+      'if $sid == "" then {kind: "model_set", model: $model, timestamp: $ts}
+       else {kind: "model_set", model: $model, claudeSessionId: $sid, timestamp: $ts} end')
+  elif [ -n "$CLAUDE_SESSION_ID" ]; then
+    BODY="{\"kind\":\"model_set\",\"model\":\"$MODEL\",\"claudeSessionId\":\"$CLAUDE_SESSION_ID\",\"timestamp\":\"$TS\"}"
+  else
+    BODY="{\"kind\":\"model_set\",\"model\":\"$MODEL\",\"timestamp\":\"$TS\"}"
+  fi
+  pan_emit_event "$AGENT_ID" "$BODY"
+fi
+
+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_BODY=$(printf '%s' "$INPUT" | jq -c --arg agentId "$AGENT_ID" '. + {agentId: $agentId}' 2>/dev/null)
+  if [ -n "$SESSION_BODY" ]; then
+    curl -s -m 0.5 -o /dev/null -X POST -H 'Content-Type: application/json' -H "x-overdeck-internal-token: $INTERNAL_TOKEN" --data "$SESSION_BODY" "$PAN_DASHBOARD_URL/api/memory/session/start" 2>/dev/null || true
+  fi
+fi
+
+exit 0

package/sync-sources/hooks/specialist-stop-hook

@@ -0,0 +1,106 @@
+#!/bin/bash
+# ~/.overdeck/bin/specialist-stop-hook
+# Called when a specialist agent goes idle - detects completion patterns
+#
+# This hook is chained from stop-hook and only runs for specialist agents.
+# It captures the last 50 lines of terminal output and looks for completion
+# patterns to auto-trigger status updates.
+
+# Don't use set -e - we want the hook to be resilient to failures
+# and never break Claude Code execution
+
+# Get agent ID from env or tmux session name
+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
+  exit 0  # Not in a tracked session
+fi
+
+# Check if this is a specialist agent
+case "$AGENT_ID" in
+  specialist-review-agent|specialist-test-agent|specialist-merge-agent)
+    ;;
+  *)
+    exit 0  # Not a specialist, skip
+    ;;
+esac
+
+# Get the specialist type from agent ID
+SPECIALIST_TYPE="${AGENT_ID#specialist-}"
+
+# Capture the last 50 lines of terminal output
+OUTPUT=$(tmux capture-pane -t "$AGENT_ID" -p -S -50 2>/dev/null || echo "")
+
+if [ -z "$OUTPUT" ]; then
+  exit 0  # No output to analyze
+fi
+
+# Define completion patterns for each specialist (case-insensitive grep -E patterns)
+case "$SPECIALIST_TYPE" in
+  review-agent)
+    # Patterns that indicate review passed
+    PASS_PATTERN="[Rr]eview (passed|complete|PASSED|COMPLETE)|LGTM|[Nn]o issues found|[Cc]ode review complete|✓.*[Pp]assed"
+    # Patterns that indicate review failed/blocked
+    FAIL_PATTERN="[Rr]eview (failed|blocked|FAILED|BLOCKED)|[Ii]ssues found|[Nn]eeds changes|[Bb]locked"
+    STATUS_FIELD="reviewStatus"
+    ;;
+  test-agent)
+    # Patterns that indicate tests passed
+    PASS_PATTERN="(all )?[Tt]ests? passed|test suite passed|0 failed|✓.*[Pp]assed|Tests PASSED"
+    # Patterns that indicate tests failed
+    FAIL_PATTERN="[Tt]ests? failed|test failures|[0-9]+ failed|✗.*[Ff]ailed|Tests FAILED"
+    STATUS_FIELD="testStatus"
+    ;;
+  merge-agent)
+    # Patterns that indicate merge complete
+    PASS_PATTERN="[Mm]erge (complete|successful)|[Pp]ushed to|[Mm]erged to main|[Mm]erged successfully"
+    # Patterns that indicate merge failed
+    FAIL_PATTERN="[Mm]erge conflict|[Cc]annot merge|[Mm]erge failed"
+    STATUS_FIELD="mergeStatus"
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+
+# Check for completion patterns (look at output)
+STATUS=""
+if echo "$OUTPUT" | grep -qE "$PASS_PATTERN"; then
+  STATUS="passed"
+elif echo "$OUTPUT" | grep -qE "$FAIL_PATTERN"; then
+  STATUS="failed"
+fi
+
+if [ -z "$STATUS" ]; then
+  exit 0  # No recognized completion pattern - specialist is just idle
+fi
+
+# Get current issue from specialist state file
+STATE_FILE="$HOME/.overdeck/agents/$AGENT_ID/state.json"
+ISSUE_ID=""
+
+if [ -f "$STATE_FILE" ] && command -v jq &> /dev/null; then
+  ISSUE_ID=$(jq -r '.currentIssue // ""' "$STATE_FILE" 2>/dev/null || echo "")
+fi
+
+if [ -z "$ISSUE_ID" ] || [ "$ISSUE_ID" = "null" ]; then
+  # No issue ID - cannot report completion
+  exit 0
+fi
+
+# Report completion to dashboard API (non-blocking background process)
+# Only if dashboard is running
+if curl -s -f --max-time 0.5 "http://localhost:3011/health" > /dev/null 2>&1; then
+  curl -s -X POST "http://localhost:3011/api/specialists/$SPECIALIST_TYPE/auto-complete" \
+    -H "Content-Type: application/json" \
+    -d "{\"issueId\":\"$ISSUE_ID\",\"status\":\"$STATUS\"}" \
+    > /dev/null 2>&1 &
+
+  # Log the completion detection
+  echo "[specialist-stop-hook] Detected completion: $SPECIALIST_TYPE -> $ISSUE_ID -> $STATUS" \
+    >> "$HOME/.overdeck/logs/hooks.log" 2>/dev/null || true
+fi
+
+exit 0