antenna-fyi 1.2.1 → 1.2.3

package/bin/antenna.js

@@ -7,7 +7,10 @@ import {
   handleAccept,
   handleCheckin,
   handleMatches,
+  handleDiscover,
+  handleEvent,
   handleBind,
+  handlePass,
   handleSetup,
   handleStatus,
   handleInstallSkill,
@@ -31,8 +34,14 @@ async function main() {
       return handleCheckin(f);
     case "matches":
       return handleMatches(f);
+    case "discover":
+      return handleDiscover(f);
+    case "event":
+      return handleEvent(f);
     case "bind":
       return handleBind(f);
+    case "pass":
+      return handlePass(f);
     case "serve": {
       const { startMcpServer } = await import("../lib/mcp.js");
       return startMcpServer();

package/lib/cli.js

@@ -1,6 +1,6 @@
 // antenna CLI command handlers
 
-import { scan, getProfile, setProfile, accept, checkMatches, checkin, createBindToken } from "./core.js";
+import { scan, getProfile, setProfile, accept, checkMatches, checkin, createBindToken, discover, createEvent, joinEvent, eventScan, pass as passUser } from "./core.js";
 import { createInterface } from "readline";
 import { existsSync, mkdirSync, copyFileSync } from "fs";
 import { join, dirname } from "path";
@@ -24,10 +24,10 @@ export function parseFlags(args) {
 }
 
 export async function handleScan(f) {
-  if (!f.lat || !f.lng) return console.error("Usage: antenna scan --lat 39.99 --lng 116.48 [--radius 500] (max 1000) [--id telegram:123]");
+  if (!f.lat && !f.lng && !f.id) return console.error("Usage: antenna scan --lat 39.99 --lng 116.48 [--radius 500] (max 1000) [--id telegram:123]\n  Or just: antenna scan --id telegram:123 (uses saved location from GPS bind)");
   const result = await scan({
-    lat: +f.lat,
-    lng: +f.lng,
+    lat: f.lat ? +f.lat : undefined,
+    lng: f.lng ? +f.lng : undefined,
     radius_m: +(f.radius || 500),
     device_id: f.id || null,
   });
@@ -110,6 +110,65 @@ export async function handleMatches(f) {
   }
 }
 
+export async function handleDiscover(f) {
+  if (!f.id) return console.error("Usage: antenna discover --id telegram:123");
+  const result = await discover({ device_id: f.id });
+  if (result.count === 0) return console.log(result.message || "🌍 No global recommendation available right now.");
+  console.log(`🌍 Global discover:\n`);
+  result.profiles.forEach((p) => {
+    console.log(`  ${p.emoji} ${p.name}`);
+    if (p.line1) console.log(`    ${p.line1}`);
+    if (p.line2) console.log(`    ${p.line2}`);
+    if (p.line3) console.log(`    ${p.line3}`);
+    if (p.match_reason) console.log(`    → ${p.match_reason}`);
+    console.log(`    ref: ${p.ref}\n`);
+  });
+}
+
+export async function handleEvent(f) {
+  const sub = f._?.[0] || Object.keys(f).find(k => ["create", "join", "scan"].includes(k));
+
+  if (f.create || (!f.join && !f.scan && f.name)) {
+    if (!f.name) return console.error("Usage: antenna event --create --name 'AI Meetup'");
+    const result = await createEvent({ name: f.name, device_id: f.id || null, lat: f.lat ? +f.lat : undefined, lng: f.lng ? +f.lng : undefined });
+    console.log(`\n🎉 Event created!\n`);
+    console.log(`  Name: ${result.name}`);
+    console.log(`  Code: ${result.code}`);
+    console.log(`  URL:  ${result.url}`);
+    console.log(`  Ends: ${result.ends_at}\n`);
+    return;
+  }
+
+  if (f.join) {
+    if (!f.code || !f.id) return console.error("Usage: antenna event --join --code abc123 --id telegram:123");
+    const result = await joinEvent({ code: f.code, device_id: f.id });
+    if (result.joined) {
+      console.log(`\n✅ Joined "${result.name}" (${result.code})\n`);
+    } else {
+      console.log(`\n❌ ${result.error}\n`);
+    }
+    return;
+  }
+
+  if (f.scan) {
+    if (!f.code) return console.error("Usage: antenna event --scan --code abc123 [--id telegram:123]");
+    const result = await eventScan({ code: f.code, device_id: f.id || null });
+    if (result.count === 0) return console.log("\n🏟️ No participants yet.\n");
+    console.log(`\n🏟️ ${result.count} people in this event:\n`);
+    result.profiles.forEach((p) => {
+      console.log(`  ${p.emoji} ${p.name}`);
+      if (p.line1) console.log(`    ${p.line1}`);
+      console.log(`    ref: ${p.ref}\n`);
+    });
+    return;
+  }
+
+  console.log(`Usage:
+  antenna event --create --name 'AI Meetup' [--id telegram:123]
+  antenna event --join --code abc123 --id telegram:123
+  antenna event --scan --code abc123 [--id telegram:123]`);
+}
+
 export async function handleBind(f) {
   if (!f.id) return console.error("Usage: antenna bind --id telegram:123");
   const result = await createBindToken({ device_id: f.id });
@@ -119,6 +178,17 @@ export async function handleBind(f) {
   console.log();
 }
 
+export async function handlePass(f) {
+  if (!f.id) return console.error("Usage: antenna pass --id telegram:123 --target telegram:789");
+  if (!f.target && !f.ref) return console.error("Usage: antenna pass --id telegram:123 --target telegram:789 (or --ref 1)");
+  const result = await passUser({
+    device_id: f.id,
+    target_device_id: f.target,
+    ref: f.ref,
+  });
+  console.log("✅ " + (result.message || "Passed."));
+}
+
 export async function handleSetup(f) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
@@ -288,7 +358,10 @@ Usage:
   antenna checkin    --id telegram:123 --lat 39.99 --lng 116.48
   antenna profile    --id telegram:123 [--name Yi --emoji 🦦 --line1 '...']
   antenna accept     --id telegram:123 --target telegram:789 [--contact 'WeChat: yi']
+  antenna pass       --id telegram:123 --target telegram:789 (or --ref 1)
   antenna matches    --id telegram:123
+  antenna discover   --id telegram:123
+  antenna event      --create --name 'AI Meetup' | --join --code abc123 | --scan --code abc123
   antenna bind       --id telegram:123
   antenna serve      Start MCP server (stdio transport)
   antenna setup      Interactive profile setup [--id telegram:123]

package/lib/core.js

@@ -10,49 +10,39 @@ const DEFAULT_KEY =
 let _client = null;
 let _url = null;
 
-// ─── Embedding ───────────────────────────────────────────────────────
-
-const GEMINI_EMBEDDING_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent";
-const GEMINI_FLASH_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent";
-
-async function generateMatchReason(myLines, theirLines) {
-  const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
-  if (!apiKey) return null;
-
-  const prompt = `You are matching two people. Person A: "${myLines}". Person B: "${theirLines}". Write ONE short sentence (under 20 words) in the SAME LANGUAGE as the profiles explaining why they might click. Be specific, not generic. No fluff.`;
+// ─── Embedding & Match Reason (via Supabase Edge Functions) ───────
 
+async function generateEmbedding(text) {
   try {
-    const res = await fetch(`${GEMINI_FLASH_URL}?key=${apiKey}`, {
+    const sb = getClient();
+    const res = await fetch(`${_url || DEFAULT_URL}/functions/v1/generate-embedding`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        contents: [{ parts: [{ text: prompt }] }],
-        generationConfig: { maxOutputTokens: 60, temperature: 0.7 },
-      }),
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${process.env.ANTENNA_SUPABASE_KEY || process.env.ANTENNA_KEY || DEFAULT_KEY}`,
+      },
+      body: JSON.stringify({ text }),
     });
     if (!res.ok) return null;
     const data = await res.json();
-    return data?.candidates?.[0]?.content?.parts?.[0]?.text?.trim() || null;
+    return data?.embedding || null;
   } catch { return null; }
 }
 
-async function generateEmbedding(text) {
-  const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
-  if (!apiKey) return null; // silently skip if no key
-
-  const res = await fetch(`${GEMINI_EMBEDDING_URL}?key=${apiKey}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      content: { parts: [{ text }] },
-      taskType: "SEMANTIC_SIMILARITY",
-      outputDimensionality: 768,
-    }),
-  });
-
-  if (!res.ok) return null;
-  const data = await res.json();
-  return data?.embedding?.values || null;
+async function generateMatchReason(myLines, theirLines) {
+  try {
+    const res = await fetch(`${_url || DEFAULT_URL}/functions/v1/generate-match-reason`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${process.env.ANTENNA_SUPABASE_KEY || process.env.ANTENNA_KEY || DEFAULT_KEY}`,
+      },
+      body: JSON.stringify({ my_lines: myLines, their_lines: theirLines }),
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data?.reason || null;
+  } catch { return null; }
 }
 
 export function getClient(url, key) {

package/lib/hermes-plugin/__init__.py

@@ -13,14 +13,27 @@ from .tools import (
     handle_checkin,
     handle_check_matches,
     handle_bind,
+    handle_pass,
+    handle_discover,
+    handle_event_create,
+    handle_event_join,
+    handle_event_scan,
     _sb,
     _device_id,
+    _my_device_ids,
+)
+from .schemas import (
     SCAN_SCHEMA,
     PROFILE_SCHEMA,
     ACCEPT_SCHEMA,
     CHECKIN_SCHEMA,
     CHECK_MATCHES_SCHEMA,
     BIND_SCHEMA,
+    PASS_SCHEMA,
+    DISCOVER_SCHEMA,
+    EVENT_CREATE_SCHEMA,
+    EVENT_JOIN_SCHEMA,
+    EVENT_SCAN_SCHEMA,
 )
 import re
 import time
@@ -29,6 +42,11 @@ import time
 _last_event_check = 0
 _EVENT_CHECK_INTERVAL = 30  # seconds
 
+# Track last match check timestamp
+_last_match_check = 0
+_MATCH_CHECK_INTERVAL = 60  # seconds
+_notified_match_keys: set = set()  # "deviceA→deviceB" already notified
+
 
 def register(ctx):
     # ── Tools ─────────────────────────────────────────────────────
@@ -38,13 +56,65 @@ def register(ctx):
     ctx.register_tool("antenna_checkin", CHECKIN_SCHEMA, handle_checkin)
     ctx.register_tool("antenna_check_matches", CHECK_MATCHES_SCHEMA, handle_check_matches)
     ctx.register_tool("antenna_bind", BIND_SCHEMA, handle_bind)
+    ctx.register_tool("antenna_pass", PASS_SCHEMA, handle_pass)
+    ctx.register_tool("antenna_discover", DISCOVER_SCHEMA, handle_discover)
+    ctx.register_tool("antenna_event_create", EVENT_CREATE_SCHEMA, handle_event_create)
+    ctx.register_tool("antenna_event_join", EVENT_JOIN_SCHEMA, handle_event_join)
+    ctx.register_tool("antenna_event_scan", EVENT_SCAN_SCHEMA, handle_event_scan)
 
     # ── Hook: auto-detect location + check web GPS events ─────────
     def on_pre_llm(messages, **kwargs):
-        """Check for location data in messages AND pending web GPS events."""
-        global _last_event_check
+        """Check for location data in messages AND pending web GPS events AND new matches."""
+        global _last_event_check, _last_match_check
         hints = []
 
+        now = time.time()
+
+        # 0. Check for new matches (every 60s)
+        if now - _last_match_check > _MATCH_CHECK_INTERVAL and _my_device_ids:
+            _last_match_check = now
+            try:
+                sb = _sb()
+                for did in list(_my_device_ids):
+                    resp = sb.rpc("get_my_matches", {"p_device_id": did}).execute()
+                    all_matches = resp.data or []
+                    if not all_matches:
+                        continue
+
+                    incoming = [m for m in all_matches if m.get("device_id_b") == did]
+                    my = [m for m in all_matches if m.get("device_id_a") == did]
+
+                    for m in incoming:
+                        key = f"{m['device_id_a']}→{did}"
+                        if key in _notified_match_keys:
+                            continue
+                        _notified_match_keys.add(key)
+
+                        # Get their profile
+                        prof_resp = sb.rpc("get_profile", {"p_device_id": m["device_id_a"]}).execute()
+                        p = prof_resp.data or {}
+                        name = p.get("display_name") or "有人"
+                        emoji = p.get("emoji") or "👤"
+
+                        # Check if mutual
+                        i_accepted = any(
+                            x.get("device_id_b") == m["device_id_a"] for x in my
+                        )
+                        if i_accepted:
+                            contact = m.get("contact_info_a")
+                            contact_msg = f"对方的联系方式：{contact}" if contact else "对方还没有分享联系方式。"
+                            hints.append(
+                                f"[Antenna] 🎉 双向匹配！{emoji} {name} 也接受了你！{contact_msg} "
+                                f"请立即通知用户这个好消息！"
+                            )
+                        else:
+                            hints.append(
+                                f"[Antenna] 📩 {emoji} {name} 想认识你！"
+                                f"请告诉用户有人想认识 TA，并建议用 antenna_check_matches 查看详情。"
+                            )
+            except Exception:
+                pass
+
         # 1. Check location_events table (web GPS updates)
         now = time.time()
         if now - _last_event_check > _EVENT_CHECK_INTERVAL:

package/lib/hermes-plugin/schemas.py

@@ -134,3 +134,89 @@ BIND_SCHEMA = {
         "required": ["sender_id", "channel"],
     },
 }
+
+PASS_SCHEMA = {
+    "name": "antenna_pass",
+    "description": "Pass/skip a person. They won't be recommended again.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "sender_id": {"type": "string", "description": "The sender's user ID"},
+            "channel": {"type": "string", "description": "Platform name"},
+            "ref": {
+                "type": "string",
+                "description": "Ref number from scan/discover results (e.g. '1')",
+            },
+            "target_device_id": {
+                "type": "string",
+                "description": "Device ID (use ref instead when possible)",
+            },
+        },
+        "required": ["sender_id", "channel"],
+    },
+}
+
+DISCOVER_SCHEMA = {
+    "name": "antenna_discover",
+    "description": (
+        "Get today's global recommendation — the person most similar to you "
+        "worldwide. 1 per day, no repeats."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "sender_id": {"type": "string", "description": "The sender's user ID"},
+            "channel": {"type": "string", "description": "Platform name"},
+        },
+        "required": ["sender_id", "channel"],
+    },
+}
+
+EVENT_CREATE_SCHEMA = {
+    "name": "antenna_event_create",
+    "description": (
+        "Create an event. Returns a shareable link (antenna.fyi/e/CODE) "
+        "for participants to join."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string", "description": "Event name"},
+            "sender_id": {"type": "string", "description": "The sender's user ID"},
+            "channel": {"type": "string", "description": "Platform name"},
+            "lat": {"type": "number", "description": "Event latitude"},
+            "lng": {"type": "number", "description": "Event longitude"},
+            "starts_at": {"type": "string", "description": "Start time ISO"},
+            "ends_at": {"type": "string", "description": "End time ISO"},
+        },
+        "required": ["name", "sender_id", "channel"],
+    },
+}
+
+EVENT_JOIN_SCHEMA = {
+    "name": "antenna_event_join",
+    "description": "Join an event by its code from the event URL.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "code": {"type": "string", "description": "Event code"},
+            "sender_id": {"type": "string", "description": "The sender's user ID"},
+            "channel": {"type": "string", "description": "Platform name"},
+        },
+        "required": ["code", "sender_id", "channel"],
+    },
+}
+
+EVENT_SCAN_SCHEMA = {
+    "name": "antenna_event_scan",
+    "description": "Scan people in an event. No distance limit.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "code": {"type": "string", "description": "Event code"},
+            "sender_id": {"type": "string", "description": "The sender's user ID"},
+            "channel": {"type": "string", "description": "Platform name"},
+        },
+        "required": ["code", "sender_id", "channel"],
+    },
+}

package/lib/hermes-plugin/tools.py

@@ -8,6 +8,7 @@ import json
 import math
 import os
 import time
+import urllib.request
 
 try:
     from supabase import create_client
@@ -29,6 +30,7 @@ _client_url = None
 _last_scan: dict[str, float] = {}
 SCAN_DEBOUNCE_S = 30
 _last_ref_map: dict[str, str] = {}  # ref → device_id from last scan
+_my_device_ids: set[str] = set()  # track this user's device_ids for match checking
 
 
 def _get_url():
@@ -53,7 +55,9 @@ def _sb():
 
 
 def _device_id(sender_id: str, channel: str) -> str:
-    return f"{channel}:{sender_id}"
+    did = f"{channel}:{sender_id}"
+    _my_device_ids.add(did)
+    return did
 
 
 def _fuzzy(lat: float, lng: float) -> tuple[float, float]:
@@ -274,6 +278,173 @@ def handle_check_matches(params: dict) -> str:
 BASE_URL = "https://www.antenna.fyi"
 
 
+def handle_pass(params: dict) -> str:
+    sb = _sb()
+    did = _device_id(params["sender_id"], params["channel"])
+
+    ref = params.get("ref")
+    target = params.get("target_device_id")
+    if ref and ref in _last_ref_map:
+        target = _last_ref_map[ref]
+    if not target and ref:
+        # Try resolve via RPC
+        try:
+            resp = sb.rpc("resolve_ref", {"p_device_id": did, "p_ref": ref}).execute()
+            if resp.data:
+                target = resp.data.get("target_device_id")
+        except Exception:
+            pass
+    if not target:
+        return _ok({"error": "No target. Use 'ref' from scan/discover results or 'target_device_id'."})
+
+    sb.rpc("pass_user", {
+        "p_device_id": did,
+        "p_target_device_id": target,
+    }).execute()
+
+    return _ok({"passed": True, "message": "已跳过，不会再推荐这个人了。"})
+
+
+def handle_discover(params: dict) -> str:
+    sb = _sb()
+    did = _device_id(params["sender_id"], params["channel"])
+
+    resp = sb.rpc("global_discover", {"p_device_id": did}).execute()
+    results = resp.data or []
+
+    if not results:
+        return _ok({"count": 0, "message": "今天没有新的全球推荐了，明天再来看看。"})
+
+    global _last_ref_map
+    _last_ref_map = {}
+    profiles = []
+
+    # Get my profile for match reason
+    my_prof = sb.rpc("get_profile", {"p_device_id": did}).execute()
+    my_data = my_prof.data or {}
+    my_lines = [my_data.get("line1", ""), my_data.get("line2", ""), my_data.get("line3", "")]
+
+    for i, p in enumerate(results):
+        ref = str(i + 1)
+        _last_ref_map[ref] = p.get("device_id")
+
+        their_lines = [p.get("line1", ""), p.get("line2", ""), p.get("line3", "")]
+
+        # Generate match reason via Edge Function
+        match_reason = None
+        try:
+            req = urllib.request.Request(
+                f"{BUILTIN_URL}/functions/v1/generate-match-reason",
+                data=json.dumps({"my_lines": my_lines, "their_lines": their_lines}).encode(),
+                headers={"Content-Type": "application/json", "Authorization": f"Bearer {BUILTIN_KEY}"},
+            )
+            res = urllib.request.urlopen(req, timeout=10)
+            body = json.loads(res.read().decode())
+            match_reason = body.get("reason")
+        except Exception:
+            pass
+
+        profile = {
+            "ref": ref,
+            "emoji": p.get("emoji") or "\ud83d\udc64",
+            "name": p.get("display_name") or "匿名",
+            "line1": p.get("line1"),
+            "line2": p.get("line2"),
+            "line3": p.get("line3"),
+        }
+        if match_reason:
+            profile["match_reason"] = match_reason
+        profiles.append(profile)
+
+    return _ok({
+        "count": len(profiles),
+        "profiles": profiles,
+        "instruction": "这是全球推荐。根据你对用户的了解，判断是否值得推荐，写一句个性化的匹配理由。使用 ref 编号引用。",
+    })
+
+
+def handle_event_create(params: dict) -> str:
+    sb = _sb()
+    did = _device_id(params["sender_id"], params["channel"])
+
+    rpc_params = {
+        "p_device_id": did,
+        "p_name": params["name"],
+    }
+    if params.get("lat") is not None:
+        rpc_params["p_lat"] = params["lat"]
+    if params.get("lng") is not None:
+        rpc_params["p_lng"] = params["lng"]
+    if params.get("starts_at"):
+        rpc_params["p_starts_at"] = params["starts_at"]
+    if params.get("ends_at"):
+        rpc_params["p_ends_at"] = params["ends_at"]
+
+    resp = sb.rpc("create_event", rpc_params).execute()
+    data = resp.data or {}
+
+    code = data.get("code", "")
+    return _ok({
+        "created": True,
+        "name": params["name"],
+        "code": code,
+        "url": f"{BASE_URL}/e/{code}",
+        "message": f"活动已创建！分享链接给参加的人：{BASE_URL}/e/{code}",
+    })
+
+
+def handle_event_join(params: dict) -> str:
+    sb = _sb()
+    did = _device_id(params["sender_id"], params["channel"])
+
+    resp = sb.rpc("join_event", {
+        "p_device_id": did,
+        "p_code": params["code"],
+    }).execute()
+    data = resp.data or {}
+
+    if data.get("joined"):
+        return _ok({"joined": True, "name": data.get("name", ""), "message": f"已加入活动 \"{data.get('name', '')}\"！"})
+    return _ok({"joined": False, "error": data.get("error", "加入失败")})
+
+
+def handle_event_scan(params: dict) -> str:
+    sb = _sb()
+    did = _device_id(params["sender_id"], params["channel"])
+
+    resp = sb.rpc("event_participants_list", {
+        "p_code": params["code"],
+    }).execute()
+    results = resp.data or []
+
+    others = [p for p in results if p.get("device_id") != did]
+
+    if not others:
+        return _ok({"count": 0, "profiles": [], "message": "活动里还没有其他人。"})
+
+    global _last_ref_map
+    _last_ref_map = {}
+    profiles = []
+    for i, p in enumerate(others):
+        ref = str(i + 1)
+        _last_ref_map[ref] = p.get("device_id")
+        profiles.append({
+            "ref": ref,
+            "emoji": p.get("emoji") or "\ud83d\udc64",
+            "name": p.get("display_name") or "匿名",
+            "line1": p.get("line1"),
+            "line2": p.get("line2"),
+            "line3": p.get("line3"),
+            "source": "event",
+        })
+
+    return _ok({
+        "count": len(profiles),
+        "profiles": profiles,
+        "instruction": "这些是活动参加者。根据你对用户的了解，推荐值得认识的人。使用 ref 编号引用。",
+    })
+
+
 def handle_bind(params: dict) -> str:
     sb = _sb()
     did = _device_id(params["sender_id"], params["channel"])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antenna-fyi",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Antenna — nearby people discovery. CLI + MCP server + OpenClaw skill & plugin, all in one package.",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -122,6 +122,20 @@ Get today's global recommendation — the person most similar to you worldwide.
 - If all users have been recommended, returns a message saying "wait for new people"
 - Use this in the daily cron job, or when user asks "find someone interesting globally"
 
+### `antenna_pass`
+Pass/skip a person. They won't be recommended again.
+- `sender_id`, `channel`: from context
+- `ref`: ref number from scan/discover results (e.g. '1')
+- `target_device_id`: device ID (use ref instead when possible)
+- Use when the user says "skip", "pass", "not interested", etc.
+
+### `antenna_checkin`
+Check in at a location — update your position so others can find you when they scan.
+- `lat`, `lng`: coordinates (required)
+- `sender_id`, `channel`: from context
+- `place_name`: optional name of the place
+- Use when the user says "I'm at XX" or wants to be discoverable without scanning others
+
 ## Data Transparency — what Antenna sends
 
 Antenna only communicates with Supabase (bcudjloikmpcqwcptuyd.supabase.co) via HTTPS.