fathom-mcp 0.6.4 → 2.0.0

package/index.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * Fathom MCP server — generic adapter that reads tools from the API.
+ *
+ * Connects to any Fathom instance (self-hosted or cloud). Discovers
+ * available tools from GET /v1/tools, filtered by the token's scopes.
+ *
+ * Environment:
+ *   FATHOM_API_URL  — base URL (default: http://localhost:8201)
+ *   FATHOM_API_KEY  — bearer token from Settings → API Keys
+ *
+ * Usage:
+ *   npx fathom-mcp
+ *   FATHOM_API_URL=https://api.hifathom.com FATHOM_API_KEY=fth_... npx fathom-mcp
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+const API_URL = (process.env.FATHOM_API_URL || "http://localhost:8201").replace(/\/$/, "");
+const API_KEY = process.env.FATHOM_API_KEY || "";
+
+// ── HTTP helpers ─────────────────────────────────
+
+function authHeaders(json = true) {
+  const h = {};
+  if (json) h["Content-Type"] = "application/json";
+  if (API_KEY) h["Authorization"] = `Bearer ${API_KEY}`;
+  return h;
+}
+
+// ── Result formatting ────────────────────────────
+
+function formatResults(data) {
+  const items = data.results || data.deltas || (Array.isArray(data) ? data : []);
+  if (!items.length) return "No results.";
+
+  const lines = [`${items.length} results:\n`];
+  for (const raw of items) {
+    const d = raw.delta || raw;
+    const ts = (d.timestamp || "").slice(0, 16);
+    const tags = (d.tags || []).slice(0, 4).join(", ");
+    const src = d.source || "";
+    const content = (d.content || "").slice(0, 400);
+    const media = d.media_hash ? ` [image: ${d.media_hash}]` : "";
+    lines.push(`[${ts} · ${src} · ${tags}]${media}\n${content}\n`);
+  }
+  return lines.join("\n");
+}
+
+function formatResponse(path, method, data) {
+  if (path === "/v1/search") return formatResults(data);
+  if (path === "/v1/deltas" && method === "POST") return `Written. ID: ${data.id || "?"}`;
+  if (path === "/v1/deltas" && method === "GET") return formatResults(data);
+  if (path === "/v1/stats") {
+    return `Lake: ${data.total ?? "?"} deltas, ${data.embedded ?? "?"} embedded (${data.percent ?? "?"}% coverage)`;
+  }
+  if (path === "/v1/chat/completions") {
+    const choices = data.choices || [];
+    return choices.length ? choices[0].message?.content || "" : JSON.stringify(data).slice(0, 2000);
+  }
+  return JSON.stringify(data, null, 2).slice(0, 2000);
+}
+
+// ── Tool execution ───────────────────────────────
+
+async function executeTool(toolDef, args) {
+  const { method, path } = toolDef.endpoint;
+  const requestMap = toolDef.request_map || {};
+
+  const mapped = {};
+  for (const [k, v] of Object.entries(args)) {
+    if (v == null) continue;
+    mapped[requestMap[k] || k] = v;
+  }
+
+  let data;
+  if (method === "POST") {
+    const r = await fetch(`${API_URL}${path}`, {
+      method: "POST",
+      headers: authHeaders(true),
+      body: JSON.stringify(mapped),
+    });
+    if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+    data = await r.json();
+  } else {
+    const params = {};
+    for (const [k, v] of Object.entries(mapped)) {
+      params[k] = Array.isArray(v) ? v.join(",") : String(v);
+    }
+    const qs = Object.keys(params).length ? "?" + new URLSearchParams(params) : "";
+    const r = await fetch(`${API_URL}${path}${qs}`, { headers: authHeaders(false) });
+    if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+    data = await r.json();
+  }
+
+  return formatResponse(path, method, data);
+}
+
+// ── MCP server ───────────────────────────────────
+
+async function main() {
+  // Load tool definitions from the API
+  let tools = [];
+  try {
+    const r = await fetch(`${API_URL}/v1/tools`, { headers: authHeaders(false) });
+    if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+    const data = await r.json();
+    tools = data.tools || [];
+  } catch (e) {
+    console.error(`Could not load tools from ${API_URL}: ${e.message}`);
+    process.exit(1);
+  }
+
+  // Build lookup
+  const toolMap = {};
+  for (const t of tools) toolMap[t.name] = t;
+
+  const server = new Server(
+    { name: "Fathom", version: "0.1.0" },
+    { capabilities: { tools: {} } },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: tools.map(t => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.parameters || { type: "object", properties: {} },
+    })),
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const toolDef = toolMap[name];
+    if (!toolDef) {
+      return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+    }
+    try {
+      const text = await executeTool(toolDef, args || {});
+      return { content: [{ type: "text", text }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch(e => {
+  console.error(e);
+  process.exit(1);
+});

package/package.json

@@ -1,50 +1,18 @@
 {
   "name": "fathom-mcp",
-  "version": "0.6.4",
-  "description": "MCP server for Fathom — vault operations, search, rooms, and cross-workspace communication",
-  "type": "module",
+  "version": "2.0.0",
+  "description": "Connect any MCP host to your Fathom memory lake",
   "bin": {
-    "fathom-mcp": "src/cli.js"
-  },
-  "main": "src/index.js",
-  "files": [
-    "src/",
-    "scripts/*.sh",
-    "scripts/*.py",
-    "scripts/*.js",
-    "fathom-agents.md",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "start": "node src/index.js",
-    "test": "node --test 'test/*.test.js'",
-    "lint": "eslint src/ test/",
-    "lint:fix": "eslint --fix src/ test/"
+    "fathom-mcp": "./index.js"
   },
+  "type": "module",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "js-yaml": "^4.1.0",
-    "ws": "^8.18.0"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.39.3",
-    "eslint": "^9.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
+    "@modelcontextprotocol/sdk": "^1.12.0"
   },
+  "keywords": ["mcp", "fathom", "memory", "delta-lake", "claude"],
   "license": "MIT",
-  "keywords": [
-    "mcp",
-    "vault",
-    "fathom",
-    "claude",
-    "codex",
-    "gemini",
-    "opencode",
-    "ai-agent",
-    "memory"
-  ]
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fathom-ai/fathom-mcp"
+  }
 }

package/CHANGELOG.md

@@ -1,39 +0,0 @@
-# Changelog
-
-## 0.5.11 (2026-03-05)
-
-- Remove legacy `mcp/` directory (replaced by `fathom-mcp/`)
-- Rename config dir `~/.config/fathom` → `~/.config/fathom-mcp`
-- Update CLI installer, agents registry, start script, all path references
-
-## 0.4.0 (2026-02-26)
-
-- **Breaking:** removed `architecture` field everywhere — `agents` array is the only field
-- Cleaned up all backward compatibility shims across config, server, API, and frontend
-- Renamed `_get_architecture` → `_get_agent` in persistent session manager
-
-## 0.3.0 (2026-02-26)
-
-Multi-agent support.
-
-- **Multi-agent init wizard** — auto-detects installed agents and generates per-agent MCP configs
-- **Supported agents:** Claude Code, OpenAI Codex, Gemini CLI, OpenCode
-- **Per-agent config writers** — `.mcp.json`, `.codex/config.toml`, `.gemini/settings.json`, `opencode.json`
-- **Agent instructions boilerplate** — `fathom-agents.md` template for memory discipline, vault conventions, cross-workspace communication
-- **Conditional hooks** — hook setup only for Claude Code (other agents don't support hooks)
-- **`agents` array** in `.fathom.json` — workspace config stores which agents are configured
-- **Server-side agent dispatch** — persistent sessions launch the correct agent CLI per workspace
-- **Agent type registration** — init wizard sends primary agent type when registering workspace
-- **Status command** — shows configured agents per workspace
-
-## 0.1.0 (2026-02-25)
-
-Initial release.
-
-- 16 MCP tools: vault read/write/append, image ops, search (BM25/vector/hybrid), rooms, workspaces
-- CLI: `npx fathom-mcp init` setup wizard, `npx fathom-mcp status`
-- Config resolution: `.fathom.json` → env vars → defaults
-- Hook scripts: SessionStart context injection, PreCompact vault snapshot
-- Direct file I/O for vault operations (no server needed for reads/writes)
-- HTTP client for fathom-server API (search, rooms, workspaces)
-- API key auth support (Bearer token)

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Myra Krusemark
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,133 +0,0 @@
-# fathom-mcp
-
-```
-▐▘  ▗ ▌
-▜▘▀▌▜▘▛▌▛▌▛▛▌▄▖▛▛▌▛▘▛▌
-▐ █▌▐▖▌▌▙▌▌▌▌  ▌▌▌▙▖▙▌
-                    ▌
-
-  hifathom.com  ·  fathom@myrakrusemark.com
-```
-
-MCP server for [Fathom](https://hifathom.com) — vault operations, search, rooms, and cross-workspace communication. Works with any MCP-compatible agent.
-
-## Supported Agents
-
-| Agent | Config file | Auto-detected by |
-|-------|------------|------------------|
-| **Claude Code** | `.mcp.json` | `.claude/` directory |
-| **OpenAI Codex** | `.codex/config.toml` | `.codex/` directory |
-| **Gemini CLI** | `.gemini/settings.json` | `.gemini/` directory |
-| **OpenCode** | `opencode.json` | `opencode.json` file |
-
-The init wizard auto-detects which agents you have and generates the right config for each.
-
-## Quick Start
-
-```bash
-npx fathom-mcp init
-```
-
-The wizard will:
-1. Detect installed agents (Claude Code, Codex, Gemini, etc.)
-2. Let you pick which ones to configure
-3. Write per-agent MCP config files
-4. Set up hooks (Claude Code only)
-5. Register the workspace with your fathom-server
-
-Restart your agent and fathom tools will be available.
-
-## Prerequisites
-
-- **Node.js 18+**
-- **[fathom-server](https://github.com/myrakrusemark/fathom-vault)** running (for search, rooms, and workspace features)
-
-## Commands
-
-```bash
-npx fathom-mcp              # Start MCP server (stdio — used by agent configs)
-npx fathom-mcp init          # Interactive setup wizard
-npx fathom-mcp status        # Check server connection + workspace status
-```
-
-## Tools
-
-### Local (direct file I/O)
-| Tool | Description |
-|------|-------------|
-| `fathom_vault_read` | Read a vault file with parsed frontmatter |
-| `fathom_vault_write` | Create or overwrite a vault file (validates frontmatter) |
-| `fathom_vault_append` | Append to a vault file (auto-creates with frontmatter if new) |
-| `fathom_vault_image` | Read a vault image as base64 |
-| `fathom_vault_write_asset` | Save a base64 image to a vault folder's assets/ |
-
-### Server (via fathom-server API)
-| Tool | Description |
-|------|-------------|
-| `fathom_vault_list` | List vault folders with activity signals |
-| `fathom_vault_folder` | List files in a folder with metadata and previews |
-| `fathom_vault_search` | BM25 keyword search |
-| `fathom_vault_vsearch` | Semantic/vector search |
-| `fathom_vault_query` | Hybrid search (BM25 + vectors + reranking) |
-| `fathom_room_post` | Post to a shared room (supports @mentions) |
-| `fathom_room_read` | Read room messages (windowed, anchored to latest; `minutes`/`start` for pagination) |
-| `fathom_room_list` | List all rooms |
-| `fathom_room_describe` | Set a room's description/topic |
-| `fathom_workspaces` | List all configured workspaces |
-| `fathom_send` | Send a message to another workspace's agent instance |
-
-## Configuration
-
-### `.fathom.json`
-
-```json
-{
-  "workspace": "my-project",
-  "vault": "vault",
-  "server": "http://localhost:4243",
-  "apiKey": "fv_abc123...",
-  "agents": ["claude-code", "gemini"],
-  "hooks": {
-    "vault-recall": { "enabled": true },
-    "precompact-snapshot": { "enabled": true }
-  }
-}
-```
-
-### Resolution order (highest priority first)
-
-1. Environment variables: `FATHOM_SERVER_URL`, `FATHOM_API_KEY`, `FATHOM_WORKSPACE`, `FATHOM_VAULT_DIR`
-2. `.fathom.json` (walked up from cwd to filesystem root)
-3. Built-in defaults
-
-## Hooks (Claude Code only)
-
-Hooks are only available in Claude Code and are configured in `.claude/settings.local.json`.
-
-**UserPromptSubmit** (`fathom-recall.sh`): Runs vault recall on every message — injects relevant context.
-
-**PreCompact** (`fathom-precompact.sh`): Records which vault files were active before context compaction.
-
-Other agents don't support hooks — they get the same MCP tools but without automatic context injection.
-
-## Vault Frontmatter Schema
-
-Files can optionally include YAML frontmatter:
-
-```yaml
----
-title: My Note          # required (string)
-date: 2026-02-25        # required (string, YYYY-MM-DD)
-tags:                    # optional (list)
-  - research
-  - identity
-status: draft            # optional: draft | published | archived
-project: my-project      # optional (string)
-aliases:                 # optional (list)
-  - alt-name
----
-```
-
-## License
-
-MIT

package/fathom-agents.md

@@ -1,45 +0,0 @@
-# {{WORKSPACE_NAME}}
-
-{{DESCRIPTION}}
-
-## Vault
-
-Local files live in `{{VAULT_DIR}}/`. Read, write, and edit vault files using your native file tools (`Read`, `Write`, `Edit`, `Glob`). A PostToolUse hook validates frontmatter automatically on every write.
-
-**Folder conventions:**
-- `research/` — reading notes, paper annotations, deep dives
-- `thinking/` — speculative connections, insights, one file per idea
-- `daily/` — session heartbeats and progress logs
-
-**Frontmatter required** on `.md` files in the vault:
-```yaml
----
-title: My Note          # required (string)
-date: 2026-02-26        # required (YYYY-MM-DD)
-tags: [research, topic] # optional
-status: draft           # optional: draft | published | archived
----
-```
-
-**Search** across vault files using MCP tools:
-- `fathom_vault_search` — keyword/BM25 (fast, exact match)
-- `fathom_vault_vsearch` — semantic/vector (conceptual similarity)
-- `fathom_vault_query` — hybrid (most thorough, slowest)
-
-## Cross-Workspace Communication
-
-This workspace is part of a multi-workspace system. Other workspaces exist — you can talk to them.
-
-- **Send a direct message:** `fathom_send workspace="other-ws" message="..."`
-- **Post to a shared room:** `fathom_room_post room="general" message="..."`
-- **Read room history:** `fathom_room_read room="general"`
-- **Discover workspaces:** `fathom_workspaces`
-
-Your sender identity is automatic — messages are tagged with `{{WORKSPACE_NAME}}`.
-
-## Workflow
-
-1. Research and reading notes → `vault/research/`
-2. Speculative connections and insights → `vault/thinking/`
-3. Session heartbeats → `vault/daily/`
-4. When done — write what you found and what questions remain

package/scripts/fathom-instructions.sh

@@ -1,84 +0,0 @@
-#!/bin/bash
-# SessionStart hook (Fathom) — inject MCP tool reference + notification instructions.
-# Independent of version check — always runs.
-# Output: JSON with hookSpecificOutput.additionalContext.
-
-# Consume stdin (SessionStart sends JSON we don't need)
-cat > /dev/null
-
-read -r -d '' INSTRUCTIONS << 'FATHOM_EOF'
-# Fathom MCP (`mcp__fathom__*` + `mcp__fathom-vault__*`)
-
-**Load tools:** `ToolSearch query="+fathom" max_results=20`
-
-One MCP server: `fathom-vault`. Handles search, rooms, workspaces, TTS, and routines. Vault file I/O uses Claude Code's native tools (`Read`, `Write`, `Edit`, `Glob`) — a PostToolUse hook validates frontmatter automatically.
-
-**`mcp__fathom-vault__*` tools:**
-
-| Tool | What it does |
-|------|-------------|
-| **Search** | |
-| `fathom_vault_search` | Keyword search (BM25) across vault files — fast, start here |
-| `fathom_vault_vsearch` | Semantic/vector search — conceptual similarity, slower |
-| `fathom_vault_query` | Hybrid search (BM25 + vector + reranking) — most thorough |
-| **Rooms** | |
-| `fathom_room_post` | Post to a shared room (created on first post). Multilateral — all participants see it. Supports `@workspace` mentions and `@all`. |
-| `fathom_room_read` | Read recent room messages (default 60min window anchored to latest). Supports `minutes`/`start` for pagination. |
-| `fathom_room_list` | List all rooms with message count, last activity, unread counts. |
-| `fathom_room_describe` | Set or clear a room's description/topic. |
-| **Workspaces** | |
-| `fathom_workspaces` | List all workspaces with running status, model, and role. |
-| `fathom_send` | DM another workspace — stored in a shared `dm:a+b` room visible to both participants. |
-| **Voice & TTS** | |
-| `fathom_speak` | Generate speech (Kokoro TTS — am_echo 70% + bf_alice 30%). Returns WAV path. Optional `play=true`. |
-| `fathom_send_voice` | Generate speech and send as a voice bubble to Myra via the app. |
-| **Routines** | |
-| `fathom_routine_list` | List routines with merged runtime state (next_ping_at, last_fire_at). Works cross-workspace. |
-| `fathom_routine_fire` | Fire a routine immediately, bypassing conditions. Non-blocking. Works cross-workspace. |
-| **Admin** | |
-| `fathom_key_rotate` | Rotate this agent's API key. Revokes current key, issues new one, reconnects. |
-| `policy_evaluate` | Evaluate a permission request for a tool call (called automatically by --permission-prompt-tool). |
-
-**Image Generation (fal.ai):** Use `mcp__fal-ai__*` tools. Default model: `fal-ai/fast-sdxl/image-to-image` for img2img, `fal-ai/nano-banana-pro` for text-to-image. **Always use nano-banana-pro unless another model is specifically requested.**
-
-**Browser:** Use `mcp__chrome-devtools__*` tools. The MCP manages Chrome automatically — just call tools directly. **Always close your pages when done** (`close_page`) so other agents can use Chrome. Only one agent can drive Chrome at a time.
-
-**Vault structure:** See `vault/CLAUDE.md` for full folder map and what goes where.
-
-### App Notifications (#notification room)
-
-After posting to #general, also post a structured JSON message to `#notification` for the dashboard feed:
-`fathom_room_post room="notification" message='{"type":"post","title":"...","body":"..."}'`
-Types: `"post"` (findings/content), `"status"` (operational), `"content"` (linked content with `content_id`). Plain text fallback works too.
-
-**The body field supports full HTML with inline CSS.** This is a rich rendering surface — use it. Capabilities:
-- **Layout:** `display:flex`, `gap`, `padding`, `margin`, tables — all work. Flexbox is preferred.
-- **Styling:** `border-radius`, `background`, `color`, `font-size`, `font-weight`, `object-fit` — all inline CSS works.
-- **Images:** `<img src="...">` renders inline. Wrap in `<a href="..." target="_blank">` for clickable links to source. Use real CDN image URLs (grab via Chrome `evaluate_script` from product pages, paper figures, screenshots, etc.).
-- **Links:** `<a href="..." target="_blank">` for clickable links. Link images, titles, and add explicit text links — multiple touchpoints per item.
-- **Badges/chips:** Use inline `<span>` with background color, padding, border-radius for sale tags, status pills, warning chips.
-- **Markdown** also works in the body for simpler notifications.
-
-**Design your notifications to be visually rich and scannable.** Myra reads these on a dashboard — think product cards, not log entries. Each workspace should develop templates appropriate to its content (e.g., wardrobe uses product cards with images, NS uses equation summaries with paper links).
-
-**Attachments:** To attach vault files (images, docs, audio) to a notification, add an `attachments` array. Each entry has `path` (relative to your vault) and optional `label`. The dashboard resolves types from extensions and renders images inline, audio as players, and other files as clickable chips.
-```json
-{"type":"content","content_id":"unique-id","title":"Title","body":"<div style=\"font-family:system-ui\">HTML here</div>","attachments":[
-  {"path":"photos/olive-top.jpg","label":"Olive button-up"},
-  {"path":"research/note-96.md","label":"Note 96: Seregin Analysis"}
-]}
-```
-Supported: images (.png/.jpg/.gif/.webp), audio (.mp3/.wav/.webm), video (.mp4), documents (.pdf/.md/.txt/.csv/.json/.svg). Old `images` format still works (backward compat).
-FATHOM_EOF
-
-python3 -c "
-import json, sys
-print(json.dumps({
-    'hookSpecificOutput': {
-        'hookEventName': 'SessionStart',
-        'additionalContext': sys.argv[1]
-    }
-}))
-" "$INSTRUCTIONS"
-
-exit 0

package/scripts/fathom-precompact.sh

@@ -1,80 +0,0 @@
-#!/usr/bin/env bash
-# Fathom PreCompact hook — snapshots vault state before context compaction.
-#
-# Reads the transcript, extracts any vault file paths mentioned,
-# and records which files were active in this session for continuity.
-
-set -euo pipefail
-
-HOOK_DIR="$(cd "$(dirname "$0")" && pwd)"
-TOAST="$HOOK_DIR/hook-toast.sh"
-
-# 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 "")
-HOOK_ENABLED=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('hooks',{}).get('precompact-snapshot',{}).get('enabled','true'))" 2>/dev/null || echo "true")
-
-if [ "$HOOK_ENABLED" != "True" ] && [ "$HOOK_ENABLED" != "true" ]; then
-  exit 0
-fi
-
-# Toast: progress via queue (one-shot)
-"$TOAST" fathom "⏳ Snapshotting vault..." &>/dev/null
-
-# Read PreCompact input (contains transcript_path)
-INPUT=$(cat)
-TRANSCRIPT_PATH=$(echo "$INPUT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('transcript_path',''))" 2>/dev/null || echo "")
-
-if [ -z "$TRANSCRIPT_PATH" ] || [ ! -f "$TRANSCRIPT_PATH" ]; then
-  "$TOAST" fathom "✗ No transcript found" &>/dev/null
-  exit 0
-fi
-
-# Extract vault file paths from transcript
-VAULT_FILES=$(grep -oP 'vault/[a-zA-Z0-9_/.-]+\.md' "$TRANSCRIPT_PATH" 2>/dev/null | sort -u || echo "")
-
-if [ -z "$VAULT_FILES" ]; then
-  "$TOAST" fathom "✓ No vault files to record" &>/dev/null
-  exit 0
-fi
-
-# Notify server about accessed files (best-effort)
-AUTH_HEADER=""
-if [ -n "$API_KEY" ]; then
-  AUTH_HEADER="Authorization: Bearer $API_KEY"
-fi
-
-for FILE in $VAULT_FILES; do
-  curl -sf -X POST -H "Content-Type: application/json" -H "$AUTH_HEADER" \
-    -d "{\"path\": \"$FILE\"}" \
-    "${SERVER}/api/vault/access?workspace=${WORKSPACE}" >/dev/null 2>&1 || true
-done
-
-# Output summary
-FILE_COUNT=$(echo "$VAULT_FILES" | wc -l)
-
-# Toast: done
-"$TOAST" fathom "✓ Stored ${FILE_COUNT} vault file(s)" &>/dev/null
-
-python3 -c "
-import json, sys
-result = {
-    'systemMessage': 'Fathom: Recorded ${FILE_COUNT} vault file(s) from this session.'
-}
-json.dump(result, sys.stdout)
-"