hive-rank 3.2.0 → 3.4.0

package/README.md

@@ -4,7 +4,7 @@ Crowdsourced SEO intelligence for AI agents.
 
 ## What is this?
 
-Hive Rank aggregates anonymized search data from Claude Code agents into a shared ranking dataset. Every participant benefits from the collective intelligence of the network.
+Hive Rank aggregates anonymized search data from AI coding agents into a shared ranking dataset. Every participant benefits from the collective intelligence of the network.
 
 **AI agents are searching for your product right now. Do you know where you rank?**
 
@@ -14,27 +14,62 @@ Hive Rank aggregates anonymized search data from Claude Code agents into a share
 npx hive-rank
 ```
 
+The installer auto-detects Claude Code, OpenCode, and Codex CLI and configures all detected platforms.
+
 Or add the MCP server directly:
 
+**Claude Code:**
 ```bash
 claude mcp add --transport http hive-rank https://mcp.hive-rank.com/mcp
 ```
 
+**OpenCode** — add to `~/.config/opencode/opencode.json`:
+```json
+{
+  "mcp": {
+    "hive-rank": {
+      "type": "remote",
+      "url": "https://mcp.hive-rank.com/mcp",
+      "enabled": true
+    }
+  }
+}
+```
+
+**Codex CLI** — add to `~/.codex/config.toml`:
+```toml
+[features]
+experimental_use_rmcp_client = true
+
+[mcp_servers.hive_rank]
+url = "https://mcp.hive-rank.com/mcp"
+```
+
+## Platform Capabilities
+
+| Feature | Claude Code | OpenCode | Codex CLI |
+|---------|------------|----------|-----------|
+| MCP query tools | Yes | Yes | Yes |
+| Data capture (hooks) | Yes | No | No |
+| Slash commands (21) | Yes | No | No |
+| Auto-install | Yes | Yes | Yes |
+
 ## What you get
 
-### 7 MCP Tools
+### 8 MCP Tools
 
 | Tool | Description |
 |------|-------------|
 | `hive_rankings` | Aggregated rankings from the network for a query |
 | `hive_trending` | Trending queries across the network |
 | `hive_domain` | Network intelligence for a domain |
+| `hive_score` | Domain hive score (0-100) |
 | `hive_stats` | Network-wide statistics |
 | `hive_contributors` | Contributor activity stats |
 | `hive_search` | Full-text search across network queries |
 | `hive_contribute` | Contribute search/page observations to the network |
 
-### 20 Slash Commands
+### 21 Slash Commands
 
 Research commands:
 
@@ -53,6 +88,7 @@ Network intelligence commands:
 - `/hive:rankings [query]` — Check network ranking data
 - `/hive:trends` — See what's trending
 - `/hive:status` — Network status and your contribution stats
+- `/hive:score [domain]` — Domain hive score (0-100)
 - `/hive:report [domain]` — Generate SEO report from network data
 - `/hive:audit` — Check network contribution status
 - `/hive:glossary [term]` — Look up any SEO term

package/bin/install.js

@@ -29,6 +29,12 @@ const CLAUDE_DIR = path.join(HOME, '.claude');
 const COMMANDS_DIR = path.join(CLAUDE_DIR, 'commands', 'hive');
 const PKG_ROOT = path.resolve(new URL('..', import.meta.url).pathname);
 
+const OPENCODE_CONFIG_DIR = path.join(HOME, '.config', 'opencode');
+const OPENCODE_CONFIG_FILE = path.join(OPENCODE_CONFIG_DIR, 'opencode.json');
+
+const CODEX_DIR = path.join(HOME, '.codex');
+const CODEX_CONFIG_FILE = path.join(CODEX_DIR, 'config.toml');
+
 const MCP_NAME = 'hive-rank';
 const MCP_URL = 'https://mcp.hive-rank.com/mcp';
 const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
@@ -58,6 +64,118 @@ function writeJsonAtomic(p, obj) {
   fs.renameSync(tmp, p);
 }
 
+// ── TOML helpers (minimal, no deps) ──────────────────────────────────────────
+
+function parseToml(text) {
+  const result = {};
+  let currentSection = null;
+
+  for (const raw of text.split('\n')) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#')) continue;
+
+    // Section header: [foo] or [foo.bar]
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      const parts = sectionMatch[1].split('.');
+      let target = result;
+      for (const part of parts) {
+        if (!target[part] || typeof target[part] !== 'object') target[part] = {};
+        target = target[part];
+      }
+      currentSection = parts;
+      continue;
+    }
+
+    // Key = value
+    const kvMatch = line.match(/^(\w+)\s*=\s*(.+)$/);
+    if (kvMatch) {
+      const key = kvMatch[1];
+      let val = kvMatch[2].trim();
+      // Parse value type
+      if (val === 'true') val = true;
+      else if (val === 'false') val = false;
+      else if (/^-?\d+(\.\d+)?$/.test(val)) val = Number(val);
+      else if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'")))
+        val = val.slice(1, -1);
+
+      if (currentSection) {
+        let target = result;
+        for (const part of currentSection) target = target[part];
+        target[key] = val;
+      } else {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+}
+
+function serializeToml(obj, prefix = '') {
+  let lines = [];
+  const simple = {};
+  const sections = {};
+
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
+      sections[k] = v;
+    } else {
+      simple[k] = v;
+    }
+  }
+
+  // Write simple key-value pairs
+  for (const [k, v] of Object.entries(simple)) {
+    if (typeof v === 'string') lines.push(`${k} = "${v}"`);
+    else lines.push(`${k} = ${v}`);
+  }
+
+  // Write sections
+  for (const [k, v] of Object.entries(sections)) {
+    const sectionKey = prefix ? `${prefix}.${k}` : k;
+    // Check if this section has only simple values (leaf section)
+    const hasNestedObjects = Object.values(v).some(val => val !== null && typeof val === 'object' && !Array.isArray(val));
+
+    if (!hasNestedObjects) {
+      if (lines.length > 0) lines.push('');
+      lines.push(`[${sectionKey}]`);
+      for (const [sk, sv] of Object.entries(v)) {
+        if (typeof sv === 'string') lines.push(`${sk} = "${sv}"`);
+        else lines.push(`${sk} = ${sv}`);
+      }
+    } else {
+      // Recurse for nested sections, writing any simple values first
+      const nestedSimple = {};
+      const nestedSections = {};
+      for (const [sk, sv] of Object.entries(v)) {
+        if (sv !== null && typeof sv === 'object' && !Array.isArray(sv)) {
+          nestedSections[sk] = sv;
+        } else {
+          nestedSimple[sk] = sv;
+        }
+      }
+      if (Object.keys(nestedSimple).length > 0) {
+        if (lines.length > 0) lines.push('');
+        lines.push(`[${sectionKey}]`);
+        for (const [sk, sv] of Object.entries(nestedSimple)) {
+          if (typeof sv === 'string') lines.push(`${sk} = "${sv}"`);
+          else lines.push(`${sk} = ${sv}`);
+        }
+      }
+      const nested = serializeToml(nestedSections, sectionKey);
+      if (nested) lines.push('', nested);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function writeTomlAtomic(p, obj) {
+  const tmp = p + '.tmp.' + crypto.randomBytes(4).toString('hex');
+  fs.writeFileSync(tmp, serializeToml(obj) + '\n', 'utf-8');
+  fs.renameSync(tmp, p);
+}
+
 function copyRecursive(src, dest) {
   if (!fileExists(src)) return;
   const stat = fs.statSync(src);
@@ -92,6 +210,118 @@ function hasClaudeCli() {
   }
 }
 
+function hasOpenCode() {
+  // Check for opencode CLI in PATH
+  try {
+    const result = spawnSync('opencode', ['--version'], { stdio: 'pipe', timeout: 5000 });
+    if (result.status === 0) return true;
+  } catch { /* not in PATH */ }
+  // Check for config directory existence
+  return fileExists(OPENCODE_CONFIG_DIR);
+}
+
+function hasCodexCli() {
+  try {
+    const result = spawnSync('codex', ['--version'], { stdio: 'pipe', timeout: 5000 });
+    if (result.status === 0) return true;
+  } catch { /* not in PATH */ }
+  return fileExists(CODEX_DIR);
+}
+
+function registerCodexMcp() {
+  fs.mkdirSync(CODEX_DIR, { recursive: true });
+
+  let config = {};
+  if (fileExists(CODEX_CONFIG_FILE)) {
+    try {
+      config = parseToml(fs.readFileSync(CODEX_CONFIG_FILE, 'utf-8'));
+    } catch {
+      warn('~/.codex/config.toml exists but could not be parsed. Skipping Codex MCP registration.');
+      return 'skipped';
+    }
+  }
+
+  // Clean up legacy entries
+  if (config.mcp_servers) {
+    for (const oldName of ['gys_local', 'hive_seo', 'grow_your_shit', 'hive_rank']) {
+      delete config.mcp_servers[oldName];
+    }
+  }
+
+  // Ensure feature flag is set
+  if (!config.features) config.features = {};
+  config.features.experimental_use_rmcp_client = true;
+
+  // Register MCP server
+  if (!config.mcp_servers) config.mcp_servers = {};
+  config.mcp_servers.hive_rank = {
+    url: MCP_URL,
+  };
+
+  writeTomlAtomic(CODEX_CONFIG_FILE, config);
+  return 'direct';
+}
+
+function removeCodexMcp() {
+  if (!fileExists(CODEX_CONFIG_FILE)) return;
+  try {
+    const config = parseToml(fs.readFileSync(CODEX_CONFIG_FILE, 'utf-8'));
+    let changed = false;
+    if (config.mcp_servers) {
+      for (const oldName of ['hive_rank', 'gys_local', 'hive_seo', 'grow_your_shit']) {
+        if (config.mcp_servers[oldName]) { delete config.mcp_servers[oldName]; changed = true; }
+      }
+      if (Object.keys(config.mcp_servers).length === 0) delete config.mcp_servers;
+    }
+    if (changed) writeTomlAtomic(CODEX_CONFIG_FILE, config);
+  } catch { /* ignore */ }
+}
+
+function registerOpenCodeMcp() {
+  fs.mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
+
+  let config = {};
+  if (fileExists(OPENCODE_CONFIG_FILE)) {
+    try {
+      config = readJson(OPENCODE_CONFIG_FILE);
+    } catch {
+      warn('~/.config/opencode/opencode.json exists but is not valid JSON. Skipping OpenCode MCP registration.');
+      return 'skipped';
+    }
+  }
+
+  // Clean up old entries
+  if (config.mcp) {
+    for (const oldName of ['gys-local', 'hive-seo', 'grow-your-shit', MCP_NAME]) {
+      delete config.mcp[oldName];
+    }
+  }
+
+  if (!config.mcp) config.mcp = {};
+  config.mcp[MCP_NAME] = {
+    type: 'remote',
+    url: MCP_URL,
+    enabled: true
+  };
+
+  writeJsonAtomic(OPENCODE_CONFIG_FILE, config);
+  return 'direct';
+}
+
+function removeOpenCodeMcp() {
+  if (!fileExists(OPENCODE_CONFIG_FILE)) return;
+  try {
+    const config = readJson(OPENCODE_CONFIG_FILE);
+    let changed = false;
+    if (config.mcp) {
+      for (const oldName of [MCP_NAME, 'gys-local', 'hive-seo', 'grow-your-shit']) {
+        if (config.mcp[oldName]) { delete config.mcp[oldName]; changed = true; }
+      }
+    }
+    if (changed) writeJsonAtomic(OPENCODE_CONFIG_FILE, config);
+  } catch { /* ignore */ }
+}
+
 function registerMcpServer() {
   if (hasClaudeCli()) {
     // Remove old entries from all scopes
@@ -208,7 +438,7 @@ function configureHooks() {
 
   // Hook A: activate session on hive MCP tool usage
   settings.hooks.PostToolUse.push({
-    matcher: 'mcp__hive-rank__hive_rankings|mcp__hive-rank__hive_trending|mcp__hive-rank__hive_domain|mcp__hive-rank__hive_stats|mcp__hive-rank__hive_contributors|mcp__hive-rank__hive_search',
+    matcher: 'mcp__hive-rank__hive_rankings|mcp__hive-rank__hive_trending|mcp__hive-rank__hive_domain|mcp__hive-rank__hive_score|mcp__hive-rank__hive_stats|mcp__hive-rank__hive_contributors|mcp__hive-rank__hive_search',
     hooks: [{ type: 'command', command: ACTIVATE_HOOK_CMD }]
   });
 
@@ -269,14 +499,19 @@ if (FLAG_HELP) {
   What it does:
     1. Copies dist + commands + docs to ~/.hive-rank/
     2. Registers hooks in ~/.claude/settings.json
-    3. Registers remote MCP server via \`claude mcp add\` (HTTP transport)
+    3. Registers remote MCP server for detected platforms:
+       - Claude Code: via \`claude mcp add\` or ~/.claude.json
+       - OpenCode:    via ~/.config/opencode/opencode.json
+       - Codex CLI:   via ~/.codex/config.toml
     4. Installs slash commands to ~/.claude/commands/hive/
 
   Config locations:
-    Hooks:      ~/.claude/settings.json
-    MCP server: ~/.claude.json (via \`claude mcp add --scope user\`)
-    Commands:   ~/.claude/commands/hive/*.md
-    Privacy:    ~/.hive-rank/PRIVACY.md
+    Hooks:          ~/.claude/settings.json
+    MCP (Claude):   ~/.claude.json (via \`claude mcp add --scope user\`)
+    MCP (OpenCode): ~/.config/opencode/opencode.json
+    MCP (Codex):    ~/.codex/config.toml
+    Commands:       ~/.claude/commands/hive/*.md
+    Privacy:        ~/.hive-rank/PRIVACY.md
 `);
   process.exit(0);
 }
@@ -287,7 +522,9 @@ if (FLAG_UNINSTALL) {
   if (FLAG_DRY_RUN) {
     console.log('\n  Uninstalling Hive Rank — DRY RUN (no changes will be made)\n');
     dryLog('Would remove hooks from ' + SETTINGS_FILE);
-    dryLog('Would remove MCP server');
+    dryLog('Would remove Claude Code MCP server');
+    if (fileExists(OPENCODE_CONFIG_FILE)) dryLog('Would remove OpenCode MCP server from ' + OPENCODE_CONFIG_FILE);
+    if (fileExists(CODEX_CONFIG_FILE)) dryLog('Would remove Codex CLI MCP server from ' + CODEX_CONFIG_FILE);
     if (fileExists(COMMANDS_DIR)) dryLog('Would remove slash commands: ' + COMMANDS_DIR);
     if (fileExists(INSTALL_DIR)) dryLog('Would remove ' + INSTALL_DIR + '/');
     console.log('\n  Dry run complete — no changes were made.\n');
@@ -300,7 +537,13 @@ if (FLAG_UNINSTALL) {
   success('Removed hooks from settings.json');
 
   removeMcpServer();
-  success('Removed MCP server');
+  success('Removed Claude Code MCP server');
+
+  removeOpenCodeMcp();
+  success('Removed OpenCode MCP server');
+
+  removeCodexMcp();
+  success('Removed Codex CLI MCP server');
 
   // Remove old gys commands too
   const oldCommandsDir = path.join(CLAUDE_DIR, 'commands', 'gys');
@@ -328,7 +571,7 @@ if (FLAG_UNINSTALL) {
     }
   }
 
-  console.log('\n  Hive Rank has been uninstalled. Restart Claude Code to apply.\n');
+  console.log('\n  Hive Rank has been uninstalled. Restart your agent to apply.\n');
   process.exit(0);
 }
 
@@ -435,8 +678,12 @@ async function install() {
     dryLog('Would copy PRIVACY.md and AGENT.md to ~/.hive-rank/');
   }
 
-  // ── Step 3: Register MCP server ──
+  // ── Step 3: Register MCP servers ──
+
+  // Track which platforms were configured (for summary)
+  const platforms = { claudeCode: false, openCode: false, codexCli: false };
 
+  // Claude Code
   if (FLAG_DRY_RUN) {
     if (hasClaudeCli()) {
       dryLog(`Would run: claude mcp add --scope user --transport http ${MCP_NAME} ${MCP_URL}`);
@@ -444,14 +691,48 @@ async function install() {
       dryLog('Would register MCP server in ~/.claude.json');
     }
   } else {
-    log('Registering remote MCP server...');
+    log('Registering MCP server for Claude Code...');
     const mcpMethod = registerMcpServer();
     if (mcpMethod === 'cli') {
-      success('MCP server registered via `claude mcp add` (HTTP transport)');
+      success('Claude Code: MCP server registered via `claude mcp add`');
+      platforms.claudeCode = true;
     } else if (mcpMethod === 'direct') {
-      success('MCP server registered in ~/.claude.json');
+      success('Claude Code: MCP server registered in ~/.claude.json');
+      platforms.claudeCode = true;
     } else {
-      warn('MCP server registration skipped — run manually after install');
+      warn('Claude Code: MCP registration skipped');
+    }
+  }
+
+  // OpenCode
+  if (hasOpenCode()) {
+    if (FLAG_DRY_RUN) {
+      dryLog(`Would register MCP server in ${OPENCODE_CONFIG_FILE}`);
+    } else {
+      log('Registering MCP server for OpenCode...');
+      const ocMethod = registerOpenCodeMcp();
+      if (ocMethod === 'direct') {
+        success('OpenCode: MCP server registered in ~/.config/opencode/opencode.json');
+        platforms.openCode = true;
+      } else {
+        warn('OpenCode: MCP registration skipped');
+      }
+    }
+  }
+
+  // Codex CLI
+  if (hasCodexCli()) {
+    if (FLAG_DRY_RUN) {
+      dryLog(`Would register MCP server in ${CODEX_CONFIG_FILE}`);
+    } else {
+      log('Registering MCP server for Codex CLI...');
+      const cxMethod = registerCodexMcp();
+      if (cxMethod === 'direct') {
+        success('Codex CLI: MCP server registered in ~/.codex/config.toml');
+        platforms.codexCli = true;
+      } else {
+        warn('Codex CLI: MCP registration skipped');
+      }
     }
   }
 
@@ -510,12 +791,20 @@ async function install() {
     node ${path.join(PKG_ROOT, 'bin', 'install.js')}${FLAG_FORCE ? ' --force' : ''}
   `);
   } else {
+    const platformLines = [];
+    platformLines.push(`    Claude Code:  ${platforms.claudeCode ? '+ MCP server + capture hooks' : '- not detected'}`);
+    platformLines.push(`    OpenCode:     ${platforms.openCode ? '+ MCP server (query tools)' : '- not detected'}`);
+    platformLines.push(`    Codex CLI:    ${platforms.codexCli ? '+ MCP server (query tools)' : '- not detected'}`);
+
     console.log(`
   ────────────────────────────────────────────────
   Hive Rank installed successfully!
   ────────────────────────────────────────────────
 
-  Restart Claude Code, then try:
+  Platforms:
+${platformLines.join('\n')}
+
+  Restart your agent, then try:
 
     /hive:help       — See all commands
     /hive:kickstart  — Bootstrap your SEO research
@@ -523,11 +812,11 @@ async function install() {
     /hive:trends     — See what's trending
 
   Config:
-    Hooks:      ${SETTINGS_FILE}
-    MCP server: ${MCP_URL} (via HTTP)
-    Commands:   ${COMMANDS_DIR}/
-    Privacy:    ~/.hive-rank/PRIVACY.md
-    Controls:   /hive:privacy, /hive:delete-data
+    Hooks:          ${SETTINGS_FILE}
+    MCP (Claude):   ${MCP_URL} (via HTTP)
+    ${platforms.openCode ? `MCP (OpenCode): ${OPENCODE_CONFIG_FILE}\n    ` : ''}${platforms.codexCli ? `MCP (Codex):    ${CODEX_CONFIG_FILE}\n    ` : ''}Commands:       ${COMMANDS_DIR}/
+    Privacy:        ~/.hive-rank/PRIVACY.md
+    Controls:       /hive:privacy, /hive:delete-data
 
   To uninstall: node ~/.hive-rank/bin/install.js --uninstall
   `);

package/commands/grow.md

@@ -8,6 +8,7 @@ allowed-tools:
       - hive_trending
       - hive_rankings
       - hive_search
+      - hive_score
 ---
 
 Run a weekly SEO growth check for $ARGUMENTS.
@@ -31,6 +32,7 @@ If no domain is specified, ask which domain to analyze.
 - WebFetch any new competitor pages discovered
 
 **Step 4 — Present Summary:**
+- Current Hive Score (use `hive_score` for the 0-100 score and breakdown)
 - What's the domain's current visibility?
 - Any notable trends from the network?
 - New competitors or threats identified?

package/commands/help.md

@@ -35,13 +35,14 @@ These commands query the hive network for aggregated insights.
 | `/hive:competitors [domain]` | Find competitors via network intelligence |
 | `/hive:keywords [domain]` | Find keyword opportunities |
 | `/hive:report [domain]` | Generate an SEO report from network data |
+| `/hive:score [domain]` | Get a 0-100 hive score for any domain |
 | `/hive:audit` | Check network contribution status |
 | `/hive:status` | Hive network status and your contribution stats |
 | `/hive:privacy` | View contribution status and privacy controls |
 | `/hive:delete-data` | Request deletion of your data |
 | `/hive:help` | This help guide |
 
-**MCP Tools (7 network tools via hive-rank server):**
+**MCP Tools (8 network tools via hive-rank server):**
 
 | Tool | What it does |
 |------|-------------|
@@ -51,6 +52,7 @@ These commands query the hive network for aggregated insights.
 | `hive_domain(domain)` | Domain intelligence from network observations |
 | `hive_contributors` | Contributor activity and leaderboard |
 | `hive_search(term)` | Full-text search across network data |
+| `hive_score(domain)` | Domain hive score (0-100) based on network observations |
 | `hive_contribute` | Contribute search/page observations (used by hooks automatically) |
 
 **How it works:**

package/commands/report.md

@@ -9,6 +9,7 @@ allowed-tools:
       - hive_trending
       - hive_search
       - hive_stats
+      - hive_score
 ---
 
 Generate a comprehensive SEO report for the specified domain (or ask me which domain to analyze).
@@ -28,12 +29,13 @@ Generate a comprehensive SEO report for the specified domain (or ask me which do
 Present a markdown report with these sections:
 
 1. **Domain Overview** — What the site does, key pages, apparent focus
-2. **Network Presence** — How the domain appears across hive network data
-3. **Ranking Snapshot** — Current positions for key queries (from hive_rankings + fresh searches)
-4. **Trends** — What's moving up or down (from hive_trending)
-5. **Competitive Context** — Who else appears for similar queries
-6. **Opportunities** — Gaps and quick wins identified
-7. **Next Steps** — Specific recommendations
+2. **Hive Score** — 0-100 domain authority score with sub-score breakdown (use `hive_score`)
+3. **Network Presence** — How the domain appears across hive network data
+4. **Ranking Snapshot** — Current positions for key queries (from hive_rankings + fresh searches)
+5. **Trends** — What's moving up or down (from hive_trending)
+6. **Competitive Context** — Who else appears for similar queries
+7. **Opportunities** — Gaps and quick wins identified
+8. **Next Steps** — Specific recommendations
 
 If network data is sparse for this domain, note this and rely more on fresh WebSearch/WebFetch research.
 

package/commands/score.md

@@ -0,0 +1,55 @@
+---
+name: score
+description: Get a 0-100 hive score for any domain — researches first, then computes
+allowed-tools:
+  - mcp: hive-rank
+    tools:
+      - hive_score
+      - hive_domain
+      - hive_stats
+---
+
+Compute a Hive Score for: $ARGUMENTS
+
+If no domain is specified, ask which domain to score.
+
+**Step 1 — Activate Session:**
+- Call `hive_stats` to activate the network session
+
+**Step 2 — Research the Domain:**
+- WebSearch the domain's brand name
+- WebSearch 3-5 key niche keywords related to the domain
+- WebSearch "[domain] vs" and "[domain] alternatives" queries
+- WebFetch the homepage
+- WebFetch 1-2 key pages (pricing, features, or top content)
+
+All of this contributes fresh data to the hive network via contribution hooks.
+
+**Step 3 — Compute Score:**
+- Call `hive_score` with the domain to get the 0-100 score and breakdown
+
+**Step 4 — Present Score Card:**
+
+Format the results as a clear score card:
+
+```
+## Hive Score: [domain]
+
+**Score: XX/100** (confidence: low/medium/high)
+
+### Breakdown
+| Factor | Score | Weight |
+|--------|-------|--------|
+| Visibility | XX | 40% |
+| Breadth | XX | 25% |
+| Consensus | XX | 25% |
+| Freshness | XX | 10% |
+
+### Signals
+- Ranks for X queries (avg position: X.X)
+- X #1 rankings, X top-3, X top-10
+- Observed by X contributors (X total observations)
+- Latest data: YYYY-MM-DD
+```
+
+If the score is null (no data), explain that the domain has no hive network data yet and suggest running `/hive:grow` to build up observations over time.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hive-rank",
-  "version": "3.2.0",
-  "description": "Crowdsourced SEO intelligence for AI agents. Network-powered hooks contribute data to the hive. 7 hive_* tools via remote MCP server.",
+  "version": "3.4.0",
+  "description": "Crowdsourced SEO intelligence for AI agents. Network-powered hooks contribute data to the hive. 8 hive_* tools via remote MCP server.",
   "author": "hive-rank",
   "license": "MIT",
   "homepage": "https://hive-rank.com",