fathom-mcp 0.6.3 → 2.0.0

package/scripts/fathom-recall.sh

@@ -1,194 +0,0 @@
-#!/bin/bash
-# Fathom Vault recall — BM25 keyword + cached semantic search on every user message.
-# JSON output: systemMessage (user sees count) + additionalContext (model sees details).
-#
-# Search strategy:
-# - BM25 keyword search runs synchronously (<2s) for immediate results
-# - Vector semantic search runs asynchronously in the background
-# - Cached vsearch results from the previous query are shown alongside BM25
-# - This gives us the best of both: fast keywords + deep semantics (one message behind)
-
-set -o pipefail
-
-HOOK_DIR="$(cd "$(dirname "$0")" && pwd)"
-TOAST="$HOOK_DIR/hook-toast.sh"
-VSEARCH_CACHE="/tmp/fathom-vsearch-cache.json"
-VSEARCH_LOCK="/tmp/fathom-vsearch.lock"
-STALE_LOCK_SECONDS=180   # 3 minutes — lock older than this is considered stale
-CACHE_TTL_SECONDS=300    # 5 minutes — cached results older than this are ignored
-
-# Walk up to find .fathom.json
-find_config() {
-  local dir="$PWD"
-  while [ "$dir" != "/" ]; do
-    if [ -f "$dir/.fathom.json" ]; then
-      echo "$dir/.fathom.json"
-      return 0
-    fi
-    dir="$(dirname "$dir")"
-  done
-  return 1
-}
-
-CONFIG_FILE=$(find_config 2>/dev/null) || exit 0
-
-WORKSPACE=$(python3 -c "import json; print(json.load(open('$CONFIG_FILE')).get('workspace',''))" 2>/dev/null || echo "")
-SERVER=$(python3 -c "import json; print(json.load(open('$CONFIG_FILE')).get('server','http://localhost:4243'))" 2>/dev/null || echo "http://localhost:4243")
-API_KEY=$(python3 -c "import json; print(json.load(open('$CONFIG_FILE')).get('apiKey',''))" 2>/dev/null || echo "")
-
-AUTH_HEADER=""
-if [ -n "$API_KEY" ]; then
-  AUTH_HEADER="Authorization: Bearer $API_KEY"
-fi
-
-# Compact parser: converts verbose qmd output to one-line-per-result format
-compact_results() {
-    python3 -c "
-import sys, re
-lines = sys.stdin.read().strip().split('\n')
-current = {}
-for line in lines:
-    m = re.match(r'qmd://[^/]+/(.+?)(?::\d+)?\s+#\w+', line)
-    if m:
-        if current and current.get('path'):
-            score = current.get('score', '?')
-            title = current.get('title', '(untitled)')
-            print(f\"  {current['path']} ({score}) — {title}\")
-        current = {'path': m.group(1)}
-    elif line.startswith('Title: '):
-        current['title'] = line[7:]
-    elif line.startswith('Score:'):
-        parts = line.split()
-        current['score'] = parts[-1] if parts else '?'
-if current and current.get('path'):
-    score = current.get('score', '?')
-    title = current.get('title', '(untitled)')
-    print(f\"  {current['path']} ({score}) — {title}\")
-" 2>/dev/null
-}
-
-INPUT=$(cat)
-USER_MESSAGE=$(echo "$INPUT" | jq -r '.prompt // empty' 2>/dev/null)
-
-if [ -z "$USER_MESSAGE" ] || [ ${#USER_MESSAGE} -lt 10 ]; then
-    exit 0
-fi
-
-QUERY="${USER_MESSAGE:0:500}"
-
-# Toast: start retrieving
-"$TOAST" fathom "⏳ Retrieving docs..." &>/dev/null
-
-# --- Phase 1: Read cached vsearch results from previous query ---
-CACHED_VSEARCH=""
-if [ -f "$VSEARCH_CACHE" ]; then
-    CACHE_AGE=$(( $(date +%s) - $(stat -c %Y "$VSEARCH_CACHE" 2>/dev/null || echo 0) ))
-    if [ "$CACHE_AGE" -lt "$CACHE_TTL_SECONDS" ]; then
-        RAW_VSEARCH=$(python3 -c "
-import json, sys
-try:
-    with open(sys.argv[1]) as f:
-        data = json.load(f)
-    if data.get('results'):
-        print(data['results'])
-except Exception:
-    pass
-" "$VSEARCH_CACHE" 2>/dev/null)
-        if [ -n "$RAW_VSEARCH" ]; then
-            CACHED_VSEARCH=$(echo "$RAW_VSEARCH" | compact_results)
-        fi
-    fi
-fi
-
-# --- Phase 2: Run search via API ---
-ENCODED_Q=$(python3 -c "import urllib.parse, sys; print(urllib.parse.quote(sys.argv[1]))" "$QUERY")
-
-CURL_ARGS=(-sf)
-[ -n "$AUTH_HEADER" ] && CURL_ARGS+=(-H "$AUTH_HEADER")
-
-API_RESPONSE=$(timeout 5 curl "${CURL_ARGS[@]}" "${SERVER}/api/search?q=${ENCODED_Q}&n=5&mode=bm25&workspace=${WORKSPACE}" 2>/dev/null)
-BM25_RESULTS=""
-
-if [ -n "$API_RESPONSE" ]; then
-    BM25_RESULTS=$(echo "$API_RESPONSE" | python3 -c "
-import json, sys
-try:
-    data = json.load(sys.stdin)
-    for r in data.get('results', []):
-        score = str(r.get('score', '?')) + '%'
-        title = r.get('title', '(untitled)')
-        path = r.get('file', '')
-        print(f'  {path} ({score}) — {title}')
-except Exception:
-    pass
-" 2>/dev/null)
-fi
-
-# Combine vault results
-ALL_RESULTS=""
-[ -n "$BM25_RESULTS" ] && ALL_RESULTS="$BM25_RESULTS"
-if [ -n "$CACHED_VSEARCH" ]; then
-    if [ -n "$ALL_RESULTS" ]; then
-        ALL_RESULTS="$ALL_RESULTS"$'\n'"$CACHED_VSEARCH"
-    else
-        ALL_RESULTS="$CACHED_VSEARCH"
-    fi
-fi
-
-# --- Output ---
-if [ -n "$BM25_RESULTS" ] || [ -n "$CACHED_VSEARCH" ]; then
-    VAULT_COUNT=0
-    [ -n "$BM25_RESULTS" ] && VAULT_COUNT=$(echo "$BM25_RESULTS" | grep -c '^\s' || true)
-    [ -n "$CACHED_VSEARCH" ] && VAULT_COUNT=$((VAULT_COUNT + $(echo "$CACHED_VSEARCH" | grep -c '^\s' || true)))
-
-    DETAIL_TEXT="Fathom Vault: ${VAULT_COUNT} results"
-    DETAIL_TEXT="$DETAIL_TEXT"$'\n'
-    if [ -n "$BM25_RESULTS" ] && [ -n "$CACHED_VSEARCH" ]; then
-        DETAIL_TEXT="$DETAIL_TEXT"$'\n'"Vault (keyword):"
-        DETAIL_TEXT="$DETAIL_TEXT"$'\n'"$BM25_RESULTS"
-        DETAIL_TEXT="$DETAIL_TEXT"$'\n'$'\n'"Vault (semantic, previous query):"
-        DETAIL_TEXT="$DETAIL_TEXT"$'\n'"$CACHED_VSEARCH"
-    elif [ -n "$BM25_RESULTS" ]; then
-        DETAIL_TEXT="$DETAIL_TEXT"$'\n'"$BM25_RESULTS"
-    elif [ -n "$CACHED_VSEARCH" ]; then
-        DETAIL_TEXT="$DETAIL_TEXT"$'\n'"$CACHED_VSEARCH"
-    fi
-
-    SUMMARY="Fathom Vault: ${VAULT_COUNT} memories"
-
-    # Toast: result
-    "$TOAST" fathom "✓ ${VAULT_COUNT} docs recalled" &>/dev/null
-
-    python3 -c "
-import json, sys
-summary = sys.argv[1]
-detail = sys.argv[2]
-print(json.dumps({
-    'systemMessage': summary,
-    'hookSpecificOutput': {
-        'hookEventName': 'UserPromptSubmit',
-        'additionalContext': detail
-    }
-}))
-" "$SUMMARY" "$DETAIL_TEXT"
-else
-    # Toast: no results
-    "$TOAST" fathom "✓ No docs matched" &>/dev/null
-fi
-
-# --- Phase 3: Launch background vsearch for current query ---
-SHOULD_LAUNCH=true
-
-if [ -f "$VSEARCH_LOCK" ]; then
-    LOCK_AGE=$(( $(date +%s) - $(stat -c %Y "$VSEARCH_LOCK" 2>/dev/null || echo 0) ))
-    if [ "$LOCK_AGE" -lt "$STALE_LOCK_SECONDS" ]; then
-        SHOULD_LAUNCH=false
-    else
-        rm -f "$VSEARCH_LOCK"
-    fi
-fi
-
-if [ "$SHOULD_LAUNCH" = true ]; then
-    nohup "$HOOK_DIR/fathom-vsearch-background.sh" "$QUERY" "$WORKSPACE" >/dev/null 2>&1 &
-    disown
-fi

package/scripts/fathom-sessionstart.sh

@@ -1,72 +0,0 @@
-#!/bin/bash
-# Fathom SessionStart hook — version check on session startup.
-# Compares local .fathom/version against npm registry and injects update notice.
-#
-# Output: JSON with hookSpecificOutput.additionalContext (update notice or empty).
-# Graceful failure: if npm unreachable or version file missing, skip silently.
-
-set -o pipefail
-
-HOOK_DIR="$(cd "$(dirname "$0")" && pwd)"
-TOAST="$HOOK_DIR/hook-toast.sh"
-
-# Consume stdin (SessionStart sends JSON we don't need)
-cat > /dev/null
-
-# Walk up to find .fathom.json
-find_config() {
-  local dir="$PWD"
-  while [ "$dir" != "/" ]; do
-    if [ -f "$dir/.fathom.json" ]; then
-      echo "$dir"
-      return 0
-    fi
-    dir="$(dirname "$dir")"
-  done
-  return 1
-}
-
-PROJECT_DIR=$(find_config 2>/dev/null) || exit 0
-
-VERSION_FILE="$PROJECT_DIR/.fathom/version"
-
-# If no version file, skip silently — init hasn't been run with this version yet
-if [ ! -f "$VERSION_FILE" ]; then
-    exit 0
-fi
-
-LOCAL_VERSION=$(cat "$VERSION_FILE" 2>/dev/null | tr -d '[:space:]')
-if [ -z "$LOCAL_VERSION" ]; then
-    exit 0
-fi
-
-# Check npm registry for latest version (2s timeout)
-LATEST_VERSION=$(curl -s --max-time 2 "https://registry.npmjs.org/fathom-mcp/latest" 2>/dev/null \
-    | python3 -c "import json,sys; print(json.load(sys.stdin).get('version',''))" 2>/dev/null || echo "")
-
-# If npm check failed, skip silently
-if [ -z "$LATEST_VERSION" ]; then
-    "$TOAST" fathom "✓ Fathom v${LOCAL_VERSION}" &>/dev/null
-    exit 0
-fi
-
-# Compare versions
-if [ "$LOCAL_VERSION" != "$LATEST_VERSION" ]; then
-    # Update available — inject notice and show toast
-    "$TOAST" fathom "⬆ Fathom v${LATEST_VERSION} available" &>/dev/null
-
-    python3 -c "
-import json
-print(json.dumps({
-    'hookSpecificOutput': {
-        'hookEventName': 'SessionStart',
-        'additionalContext': 'Fathom update available: v${LOCAL_VERSION} → v${LATEST_VERSION}. Run: npx fathom-mcp update'
-    }
-}))
-"
-else
-    # Up to date — toast only, no context injection
-    "$TOAST" fathom "✓ Fathom v${LOCAL_VERSION}" &>/dev/null
-fi
-
-exit 0

package/scripts/fathom-start.sh

@@ -1,366 +0,0 @@
-#!/usr/bin/env bash
-#
-# fathom-start.sh — Launch an agent session.
-#
-# Reads .fathom.json for workspace name and agent. For interactive agents
-# (claude-code, codex, gemini, opencode), wraps in a tmux session. For
-# headless agents (claude-sdk), spawns a direct process with PID tracking.
-#
-# Claude agents require an explicit mode flag:
-#   fathom-start.sh --claude-code-w-tmux   Interactive Claude Code in tmux
-#   fathom-start.sh --claude-sdk           Headless Claude SDK, no tmux
-#
-# Other usage:
-#   fathom-start.sh              Start agent (non-claude agents auto-detect)
-#   fathom-start.sh --detach     Start agent, don't attach to tmux
-#   fathom-start.sh --agent X    Override agent
-#   fathom-start.sh --kill       Kill existing session
-#   fathom-start.sh --status     Show session status
-
-set -euo pipefail
-
-# ── Defaults ──────────────────────────────────────────────────────────────────
-
-ATTACH=true
-AGENT_OVERRIDE=""
-ACTION="start"
-MODE_FLAG=""
-USE_TMUX=true
-
-# ── Parse flags ───────────────────────────────────────────────────────────────
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --claude-code-w-tmux) MODE_FLAG="claude-code-w-tmux"; shift ;;
-    --claude-sdk)         MODE_FLAG="claude-sdk"; shift ;;
-    --detach)   ATTACH=false; shift ;;
-    --attach)   ATTACH=true; shift ;;
-    --agent)    AGENT_OVERRIDE="$2"; shift 2 ;;
-    --kill)     ACTION="kill"; shift ;;
-    --status)   ACTION="status"; shift ;;
-    -h|--help)
-      echo "Usage: fathom-start.sh [FLAGS]"
-      echo ""
-      echo "Mode flags (required for Claude agents):"
-      echo "  --claude-code-w-tmux   Interactive Claude Code in tmux"
-      echo "  --claude-sdk           Headless Claude SDK, no tmux"
-      echo ""
-      echo "Other flags:"
-      echo "  --detach     Start but don't attach to tmux"
-      echo "  --agent X    Override agent: claude-code, claude-sdk, codex, gemini, opencode"
-      echo "  --kill       Kill existing session"
-      echo "  --status     Show if session is running"
-      exit 0
-      ;;
-    *)
-      echo "Unknown flag: $1" >&2
-      exit 1
-      ;;
-  esac
-done
-
-# ── Find .fathom.json ────────────────────────────────────────────────────────
-
-find_config() {
-  local dir="$PWD"
-  while [[ "$dir" != "/" ]]; do
-    if [[ -f "$dir/.fathom.json" ]]; then
-      echo "$dir/.fathom.json"
-      return 0
-    fi
-    dir="$(dirname "$dir")"
-  done
-  return 1
-}
-
-CONFIG_FILE=$(find_config) || {
-  echo "Error: No .fathom.json found (searched from $PWD to /)" >&2
-  echo "Run 'npx fathom-mcp init' first." >&2
-  exit 1
-}
-
-PROJECT_DIR="$(dirname "$CONFIG_FILE")"
-
-# ── Parse config ──────────────────────────────────────────────────────────────
-
-read_json_field() {
-  local file="$1" field="$2"
-  if command -v jq &>/dev/null; then
-    jq -r ".$field // empty" "$file" 2>/dev/null
-  else
-    # Fallback: simple grep/sed for flat string fields
-    sed -n "s/.*\"$field\"[[:space:]]*:[[:space:]]*\"\([^\"]*\)\".*/\1/p" "$file" | head -1
-  fi
-}
-
-read_json_array_first() {
-  local file="$1" field="$2"
-  if command -v jq &>/dev/null; then
-    jq -r ".$field[0] // empty" "$file" 2>/dev/null
-  else
-    # Fallback: grab first quoted string after the array field
-    sed -n "/\"$field\"/,/\]/{ s/.*\"\([^\"]*\)\".*/\1/p; }" "$file" | head -1
-  fi
-}
-
-WORKSPACE=$(read_json_field "$CONFIG_FILE" "workspace")
-if [[ -z "$WORKSPACE" ]]; then
-  WORKSPACE="$(basename "$PROJECT_DIR")"
-fi
-
-SESSION="${WORKSPACE}_fathom-session"
-PANE_DIR="$HOME/.config/fathom-mcp"
-PANE_FILE="$PANE_DIR/${WORKSPACE}-pane-id"
-PID_FILE="$PROJECT_DIR/.fathom/agent.pid"
-LOG_FILE="$PROJECT_DIR/.fathom/agent.log"
-
-# ── Resolve agent type ────────────────────────────────────────────────────────
-
-resolve_agent() {
-  local agent="${AGENT_OVERRIDE:-}"
-  if [[ -z "$agent" ]]; then
-    agent=$(read_json_array_first "$CONFIG_FILE" "agents")
-  fi
-  if [[ -z "$agent" ]]; then
-    agent="claude-code"
-  fi
-  echo "$agent"
-}
-
-AGENT=$(resolve_agent)
-
-# ── Determine execution mode (tmux vs headless) ──────────────────────────────
-# Must happen in the main shell, not inside $(...) subshell.
-
-case "$AGENT" in
-  claude-code)
-    if [[ "$MODE_FLAG" == "claude-sdk" ]]; then
-      USE_TMUX=false
-    elif [[ -z "$MODE_FLAG" ]]; then
-      echo "Error: Claude Code requires an explicit mode flag:" >&2
-      echo "  fathom-start.sh --claude-code-w-tmux    Interactive Claude in tmux" >&2
-      echo "  fathom-start.sh --claude-sdk             Headless Claude SDK" >&2
-      echo "" >&2
-      echo "For local agents managed by fathom-server, use the dashboard restart button instead." >&2
-      exit 1
-    fi
-    ;;
-  claude-sdk)
-    if [[ "$MODE_FLAG" == "claude-code-w-tmux" ]]; then
-      USE_TMUX=true
-    else
-      USE_TMUX=false
-    fi
-    ;;
-esac
-
-# ── Resolve agent command ─────────────────────────────────────────────────────
-
-resolve_agent_cmd() {
-  case "$AGENT" in
-    claude-code)
-      if [[ "$USE_TMUX" == false ]]; then
-        echo "claude -p --permission-mode bypassPermissions --output-format stream-json"
-      else
-        echo "claude --model opus --permission-mode bypassPermissions"
-      fi
-      ;;
-    claude-sdk)
-      if [[ "$USE_TMUX" == true ]]; then
-        echo "claude --model opus --permission-mode bypassPermissions"
-      else
-        echo "claude -p --permission-mode bypassPermissions --output-format stream-json"
-      fi
-      ;;
-    codex)
-      echo "codex"
-      ;;
-    gemini)
-      echo "gemini"
-      ;;
-    opencode)
-      echo "opencode"
-      ;;
-    *)
-      echo "Warning: Unknown agent '$AGENT', falling back to claude" >&2
-      echo "claude"
-      ;;
-  esac
-}
-
-# ── Save pane ID ──────────────────────────────────────────────────────────────
-
-save_pane_id() {
-  local pane_id
-  pane_id=$(tmux list-panes -t "$SESSION" -F '#{pane_id}' 2>/dev/null | head -1)
-  if [[ -n "$pane_id" ]]; then
-    mkdir -p "$PANE_DIR"
-    echo "$pane_id" > "$PANE_FILE"
-    echo "Pane ID: $pane_id → $PANE_FILE"
-  fi
-}
-
-# ── Session/process check ────────────────────────────────────────────────────
-
-session_exists() {
-  tmux has-session -t "$SESSION" 2>/dev/null
-}
-
-headless_is_running() {
-  if [[ -f "$PID_FILE" ]]; then
-    local pid
-    pid=$(cat "$PID_FILE" 2>/dev/null)
-    if [[ -n "$pid" ]] && kill -0 "$pid" 2>/dev/null; then
-      return 0
-    fi
-  fi
-  return 1
-}
-
-# ── Actions ───────────────────────────────────────────────────────────────────
-
-do_status() {
-  echo "Workspace: $WORKSPACE"
-  echo "Session:   $SESSION"
-  if session_exists; then
-    echo "Status:    running (tmux)"
-    if [[ -f "$PANE_FILE" ]]; then
-      echo "Pane ID:   $(cat "$PANE_FILE")"
-    fi
-  elif headless_is_running; then
-    echo "Status:    running (headless)"
-    echo "PID:       $(cat "$PID_FILE")"
-    echo "Log:       $LOG_FILE"
-    if [[ -p "$PROJECT_DIR/.fathom/agent.pipe" ]]; then
-      echo "Pipe:      $PROJECT_DIR/.fathom/agent.pipe"
-    fi
-  else
-    echo "Status:    not running"
-  fi
-}
-
-do_kill() {
-  local killed=false
-  if session_exists; then
-    tmux kill-session -t "$SESSION"
-    rm -f "$PANE_FILE"
-    echo "Killed tmux session: $SESSION"
-    killed=true
-  fi
-  if headless_is_running; then
-    local pid
-    pid=$(cat "$PID_FILE")
-    kill "$pid" 2>/dev/null || true
-    rm -f "$PID_FILE"
-    echo "Killed headless process: PID $pid"
-    killed=true
-  fi
-  # Clean up keeper process and FIFO
-  local keeper_pid_file="$PROJECT_DIR/.fathom/agent-keeper.pid"
-  if [[ -f "$keeper_pid_file" ]]; then
-    local keeper_pid
-    keeper_pid=$(cat "$keeper_pid_file")
-    kill "$keeper_pid" 2>/dev/null || true
-    rm -f "$keeper_pid_file"
-  fi
-  rm -f "$PROJECT_DIR/.fathom/agent.pipe"
-  if [[ "$killed" == false ]]; then
-    echo "No running session found for: $WORKSPACE"
-  fi
-}
-
-do_start() {
-  local agent_cmd
-  agent_cmd=$(resolve_agent_cmd)
-
-  if [[ "$USE_TMUX" == false ]]; then
-    # ── Headless mode — FIFO-based stdin ──
-    if headless_is_running; then
-      echo "Headless agent already running (PID $(cat "$PID_FILE"))"
-      echo "Log: $LOG_FILE"
-      return 0
-    fi
-
-    echo "Starting headless: $agent_cmd"
-    echo "Dir: $PROJECT_DIR"
-    echo "Logs: $LOG_FILE"
-
-    cd "$PROJECT_DIR"
-    unset CLAUDECODE 2>/dev/null || true
-    # Ensure common binary locations are on PATH for backgrounded processes
-    export PATH="$HOME/.local/bin:$HOME/.claude/local/bin:$PATH"
-    mkdir -p .fathom
-
-    local pipe_file="$PROJECT_DIR/.fathom/agent.pipe"
-
-    # Clean up stale pipe
-    rm -f "$pipe_file"
-    mkfifo "$pipe_file"
-
-    # Keep a writer FD open so the pipe never sends EOF to the reader.
-    # Without this, the agent reads EOF and exits when no writer is connected.
-    sleep infinity > "$pipe_file" &
-    local keeper_pid=$!
-
-    # Start agent reading from the FIFO, logging stdout/stderr
-    $agent_cmd < "$pipe_file" >> "$LOG_FILE" 2>&1 &
-    local pid=$!
-
-    echo "$pid" > "$PID_FILE"
-    echo "$keeper_pid" > "$PROJECT_DIR/.fathom/agent-keeper.pid"
-
-    echo "PID: $pid"
-    echo "Pipe: $pipe_file"
-    echo "Started. View logs: tail -f $LOG_FILE"
-    echo "Inject: echo 'your message' > $pipe_file"
-    return 0
-  fi
-
-  # ── Interactive mode — tmux session ──
-  if ! command -v tmux &>/dev/null; then
-    echo "Error: tmux is not installed. Install it first:" >&2
-    echo "  apt install tmux  |  brew install tmux  |  dnf install tmux" >&2
-    exit 1
-  fi
-
-  if session_exists; then
-    echo "Session already running: $SESSION"
-    save_pane_id
-    if [[ "$ATTACH" == true ]]; then
-      exec tmux attach-session -t "$SESSION"
-    fi
-    return 0
-  fi
-
-  echo "Starting: $SESSION"
-  echo "Agent:    $agent_cmd"
-  echo "Dir:      $PROJECT_DIR"
-
-  # Unset CLAUDECODE to avoid nested session detection
-  unset CLAUDECODE 2>/dev/null || true
-
-  # Create detached tmux session running the agent
-  tmux new-session -d -s "$SESSION" -c "$PROJECT_DIR" $agent_cmd
-
-  # Wait briefly for session to stabilize
-  sleep 2
-
-  if session_exists; then
-    save_pane_id
-    echo "Session started."
-    if [[ "$ATTACH" == true ]]; then
-      exec tmux attach-session -t "$SESSION"
-    fi
-  else
-    echo "Error: Session failed to start" >&2
-    exit 1
-  fi
-}
-
-# ── Main ──────────────────────────────────────────────────────────────────────
-
-case "$ACTION" in
-  status) do_status ;;
-  kill)   do_kill ;;
-  start)  do_start ;;
-esac

package/scripts/fathom-vsearch-background.sh

@@ -1,46 +0,0 @@
-#!/bin/bash
-# Background vector search worker for fathom-recall hook.
-# Launched via nohup/disown — runs asynchronously after the hook returns.
-#
-# Takes a search query as $1 and workspace as $2, runs qmd vsearch,
-# and writes results as JSON to /tmp/fathom-vsearch-cache.json.
-
-set -o pipefail
-
-LOCK_FILE="/tmp/fathom-vsearch.lock"
-CACHE_FILE="/tmp/fathom-vsearch-cache.json"
-
-cleanup() {
-    rm -f "$LOCK_FILE"
-}
-trap cleanup EXIT
-
-if [ -z "$1" ]; then
-    exit 1
-fi
-
-WORKSPACE="${2:-fathom}"
-
-echo $$ > "$LOCK_FILE"
-
-VSEARCH_QUERY="${1:0:200}"
-
-# Run vsearch with 180-second hard timeout
-RESULTS=$(timeout 180 qmd vsearch "$VSEARCH_QUERY" -n 5 -c "$WORKSPACE" --min-score 0.5 2>/dev/null)
-
-TMPFILE=$(mktemp /tmp/fathom-vsearch-cache.XXXXXX)
-
-python3 -c "
-import json, sys, time
-query = sys.argv[1][:200]
-results = sys.stdin.read().strip()
-has_results = bool(results) and 'No results found' not in results
-with open(sys.argv[2], 'w') as f:
-    json.dump({
-        'query': query,
-        'timestamp': int(time.time()),
-        'results': results if has_results else None
-    }, f)
-" "$VSEARCH_QUERY" "$TMPFILE" <<< "$RESULTS"
-
-mv "$TMPFILE" "$CACHE_FILE"