@adgine/geo-cli 1.2.8

package/skills/adgine-geo-visibility/scripts/get_prompt_metrics.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Per-prompt visibility overview (Visibility Score + Avg Position with
+trend, previous-period delta, and per-platform breakdown).
+
+Usage:
+  python3 scripts/get_prompt_metrics.py --prompt-id <prompt_id>
+  python3 scripts/get_prompt_metrics.py --prompt-id <id> --start 2025-11-01 --end 2025-11-30
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import (
+    get_api_config, get_project_id,
+    api_get,
+    extract_data, print_json, truncate,
+    pad,
+)
+
+
+def _fmt(v):
+    if v is None:
+        return "--"
+    try:
+        return f"{float(v):.2f}"
+    except (TypeError, ValueError):
+        return str(v)[:8]
+
+
+def _fmt_change(c):
+    if c is None:
+        return "--"
+    try:
+        f = float(c)
+        sign = "+" if f >= 0 else ""
+        return f"{sign}{f:.2f}"
+    except (TypeError, ValueError):
+        return str(c)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Per-prompt visibility overview")
+    parser.add_argument("--project-id", help="Project ID (or set GEO_PROJECT_ID env var)")
+    parser.add_argument("--prompt-id", required=True)
+    parser.add_argument("--start", help="Start date YYYY-MM-DD")
+    parser.add_argument("--end", help="End date YYYY-MM-DD")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    args = parser.parse_args()
+
+    key, base = get_api_config()
+    pid = get_project_id(args.project_id)
+
+    params = {}
+    if args.start:
+        params["start_date"] = args.start
+    if args.end:
+        params["end_date"] = args.end
+
+    result = api_get(
+        f"/api/projects/{pid}/analytics/prompts/{args.prompt_id}/overview",
+        key, base, params=params or None,
+    )
+    data = extract_data(result) or {}
+
+    if args.json:
+        print_json(data)
+        return
+
+    vs = data.get("visibility_score") or {}
+    ap = data.get("average_position") or {}
+
+    print(f"Prompt overview — {args.prompt_id}")
+    if data.get("prompt_text"):
+        print(f"  text: {truncate(data['prompt_text'], 80)}")
+    print()
+    print("```")
+    print("┌────────────────────┬──────────────┬──────────────┬──────────────┐")
+    print("│ Metric             │      Current │     Previous │       Change │")
+    print("├────────────────────┼──────────────┼──────────────┼──────────────┤")
+    print(f"│ {pad('Visibility Score', 18)} │ {_fmt(vs.get('current')):>12} │ {_fmt(vs.get('previous')):>12} │ {_fmt_change(vs.get('change')):>12} │")
+    print(f"│ {pad('Average Position', 18)} │ {_fmt(ap.get('current')):>12} │ {_fmt(ap.get('previous')):>12} │ {_fmt_change(ap.get('change')):>12} │")
+    print("└────────────────────┴──────────────┴──────────────┴──────────────┘")
+    print("```")
+
+    by_platform = data.get("by_platform") or data.get("platforms") or []
+    if by_platform:
+        print()
+        print("By platform:")
+        print("```")
+        print("┌────────────────────┬──────────┬──────────┐")
+        print("│ Platform           │   Vis(%) │  AvgPos  │")
+        print("├────────────────────┼──────────┼──────────┤")
+        for p in by_platform:
+            name = truncate(p.get("name") or p.get("platform") or p.get("code"), 18)
+            v = _fmt(p.get("visibility_score") or p.get("visibility"))
+            a = _fmt(p.get("average_position") or p.get("avg_position"))
+            print(f"│ {pad(name, 18)} │ {v:>8} │ {a:>8} │")
+        print("└────────────────────┴──────────┴──────────┘")
+        print("```")
+
+
+if __name__ == "__main__":
+    main()

package/skills/adgine-geo-visibility/scripts/get_topic_metrics.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""Topic-level AI visibility metrics.
+
+Subcommands:
+  list                              — full Topic dimension (Visibility / SoV /
+                                       Avg Position + previous-period delta)
+  visibility                        — lightweight list (id + name + score)
+                                       used for content-creation topic picker
+  prompts --topic-id <id>           — prompts under a topic (full metrics)
+  prompts-visibility --topic-id <id>  — prompts under a topic (lightweight)
+
+Time-window options on `list`:
+  --start <YYYY-MM-DD>  --end <YYYY-MM-DD>
+
+Usage:
+  python3 scripts/get_topic_metrics.py list
+  python3 scripts/get_topic_metrics.py visibility            # for picker UI
+  python3 scripts/get_topic_metrics.py prompts --topic-id <topic_id>
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import (
+    get_api_config, get_project_id,
+    api_get,
+    extract_data, print_json, truncate,
+    pad,
+)
+
+
+def _fmt(v):
+    if v is None:
+        return "--"
+    try:
+        return f"{float(v):.1f}"
+    except (TypeError, ValueError):
+        return str(v)[:6]
+
+
+def _fmt_change(c):
+    if c is None:
+        return "--"
+    try:
+        f = float(c)
+        sign = "+" if f >= 0 else ""
+        return f"{sign}{f:.1f}"
+    except (TypeError, ValueError):
+        return str(c)
+
+
+def cmd_list(args, key, base, pid):
+    params = {}
+    if args.start:
+        params["start_date"] = args.start
+    if args.end:
+        params["end_date"] = args.end
+    result = api_get(f"/api/projects/{pid}/analytics/topics", key, base,
+                     params=params or None)
+    data = extract_data(result)
+    items = data if isinstance(data, list) else (data or {}).get("topics", [])
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print("No topic data.")
+        return
+    print(f"Topic Visibility ({len(items)})")
+    print()
+    print("```")
+    print("┌──────────────────────────────┬──────────┬──────────┬──────────┬──────────┐")
+    print("│ Topic                        │   Vis(%) │   SoV(%) │  AvgPos  │   ΔVis   │")
+    print("├──────────────────────────────┼──────────┼──────────┼──────────┼──────────┤")
+    for t in items:
+        name = truncate(t.get("name") or t.get("topic"), 28)
+        vis = _fmt(t.get("visibility_score") or t.get("visibility"))
+        sov = _fmt(t.get("share_of_voice") or t.get("sov"))
+        ap = _fmt(t.get("average_position") or t.get("avg_position"))
+        ch = _fmt_change(t.get("visibility_change") or t.get("change"))
+        print(f"│ {pad(name, 28)} │ {vis:>8} │ {sov:>8} │ {ap:>8} │ {ch:>8} │")
+    print("└──────────────────────────────┴──────────┴──────────┴──────────┴──────────┘")
+    print("```")
+
+
+def cmd_visibility(args, key, base, pid):
+    result = api_get(f"/api/projects/{pid}/analytics/topics/visibility",
+                     key, base)
+    data = extract_data(result)
+    items = data if isinstance(data, list) else (data or {}).get("topics", [])
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print("No topics.")
+        return
+    print(f"Topics ({len(items)}) — sorted by visibility, last 30 days")
+    print()
+    print("```")
+    print("┌──────────────────────────────────────┬──────────────────────────────┬──────────┐")
+    print("│ Topic ID                             │ Name                         │   Vis(%) │")
+    print("├──────────────────────────────────────┼──────────────────────────────┼──────────┤")
+    for t in items:
+        tid = truncate(t.get("id") or t.get("topic_id"), 36)
+        name = truncate(t.get("name") or t.get("topic"), 28)
+        vis = _fmt(t.get("visibility_score") or t.get("score") or t.get("visibility"))
+        print(f"│ {pad(tid, 36)} │ {pad(name, 28)} │ {vis:>8} │")
+    print("└──────────────────────────────────────┴──────────────────────────────┴──────────┘")
+    print("```")
+
+
+def cmd_prompts(args, key, base, pid):
+    result = api_get(
+        f"/api/projects/{pid}/analytics/topics/{args.topic_id}/prompts",
+        key, base,
+    )
+    data = extract_data(result)
+    items = data if isinstance(data, list) else (data or {}).get("prompts", [])
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print(f"No prompts under topic {args.topic_id}.")
+        return
+    print(f"Prompt Visibility — topic {args.topic_id} ({len(items)})")
+    print()
+    print("```")
+    print("┌──────────────────────────────────────────┬──────────┬──────────┬──────────┐")
+    print("│ Prompt                                   │   Vis(%) │   SoV(%) │  AvgPos  │")
+    print("├──────────────────────────────────────────┼──────────┼──────────┼──────────┤")
+    for p in items:
+        text = truncate(p.get("text") or p.get("prompt") or p.get("name"), 40)
+        vis = _fmt(p.get("visibility_score") or p.get("visibility"))
+        sov = _fmt(p.get("share_of_voice") or p.get("sov"))
+        ap = _fmt(p.get("average_position") or p.get("avg_position"))
+        print(f"│ {pad(text, 40)} │ {vis:>8} │ {sov:>8} │ {ap:>8} │")
+    print("└──────────────────────────────────────────┴──────────┴──────────┴──────────┘")
+    print("```")
+
+
+def cmd_prompts_visibility(args, key, base, pid):
+    result = api_get(
+        f"/api/projects/{pid}/analytics/topics/{args.topic_id}/prompts/visibility",
+        key, base,
+    )
+    data = extract_data(result)
+    items = data if isinstance(data, list) else (data or {}).get("prompts", [])
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print(f"No prompts under topic {args.topic_id}.")
+        return
+    print(f"Prompts under topic {args.topic_id} — sorted by visibility")
+    print()
+    print("```")
+    print("┌──────────────────────────────────────┬──────────────────────────────┬──────────┐")
+    print("│ Prompt ID                            │ Text                         │   Vis(%) │")
+    print("├──────────────────────────────────────┼──────────────────────────────┼──────────┤")
+    for p in items:
+        pid_ = truncate(p.get("id") or p.get("prompt_id"), 36)
+        text = truncate(p.get("text") or p.get("prompt"), 28)
+        vis = _fmt(p.get("visibility_score") or p.get("score") or p.get("visibility"))
+        print(f"│ {pad(pid_, 36)} │ {pad(text, 28)} │ {vis:>8} │")
+    print("└──────────────────────────────────────┴──────────────────────────────┴──────────┘")
+    print("```")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Topic-level AI visibility metrics")
+    parser.add_argument("--project-id", help="Project ID (or set GEO_PROJECT_ID env var)")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_l = sub.add_parser("list", help="Full Topic dimension metrics")
+    p_l.add_argument("--start", help="Start date YYYY-MM-DD")
+    p_l.add_argument("--end", help="End date YYYY-MM-DD")
+
+    sub.add_parser("visibility", help="Lightweight topic list for pickers")
+
+    p_p = sub.add_parser("prompts", help="Prompts under topic (full)")
+    p_p.add_argument("--topic-id", required=True)
+
+    p_pv = sub.add_parser("prompts-visibility", help="Prompts under topic (light)")
+    p_pv.add_argument("--topic-id", required=True)
+
+    args = parser.parse_args()
+    key, base = get_api_config()
+    pid = get_project_id(args.project_id)
+
+    handlers = {
+        "list": cmd_list,
+        "visibility": cmd_visibility,
+        "prompts": cmd_prompts,
+        "prompts-visibility": cmd_prompts_visibility,
+    }
+    handlers[args.command](args, key, base, pid)
+
+
+if __name__ == "__main__":
+    main()

package/skills/adgine-geo-visibility/scripts/get_visibility.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Single-metric visibility queries (granular, for AI-agent fine-grained Q&A).
+
+Three subcommands map 1:1 to the analytics single-metric endpoints. Each
+returns the metric value plus 30/14/7-day trend points and previous-period
+delta (when supported by the API).
+
+Subcommands:
+  score              — Visibility Score
+  share-of-voice     — Share of Voice
+  average-position   — Average Position
+
+Common options:
+  --start <YYYY-MM-DD>  --end <YYYY-MM-DD>     time window
+  --platform <code>    openai | google_aio | perplexity | gemini
+
+Usage:
+  python3 scripts/get_visibility.py score
+  python3 scripts/get_visibility.py share-of-voice --platform openai
+  python3 scripts/get_visibility.py average-position --start 2025-11-01 --end 2025-11-30
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import (
+    get_api_config, get_project_id,
+    api_get,
+    extract_data, print_json,
+    pad,
+)
+
+
+def _fmt_metric(v):
+    if v is None:
+        return "--"
+    try:
+        f = float(v)
+        return f"{f:.2f}" if abs(f) < 1000 else f"{f:,.0f}"
+    except (TypeError, ValueError):
+        return str(v)
+
+
+def _fmt_change(c):
+    if c is None:
+        return "--"
+    try:
+        f = float(c)
+        sign = "+" if f >= 0 else ""
+        return f"{sign}{f:.2f}"
+    except (TypeError, ValueError):
+        return str(c)
+
+
+def _common_params(args):
+    p = {}
+    if args.start:
+        p["start_date"] = args.start
+    if args.end:
+        p["end_date"] = args.end
+    if args.platform:
+        p["platform"] = args.platform
+    return p or None
+
+
+def _print_metric(label, unit, data, suffix=""):
+    cur = data.get("current") if isinstance(data, dict) else None
+    if cur is None and isinstance(data, dict):
+        cur = data.get("value") or data.get(label.lower().replace(" ", "_"))
+    prev = data.get("previous") if isinstance(data, dict) else None
+    change = data.get("change") if isinstance(data, dict) else None
+    print(f"{label}")
+    print()
+    print("```")
+    print("┌────────────────────┬──────────────┐")
+    print("│ Field              │        Value │")
+    print("├────────────────────┼──────────────┤")
+    print(f"│ {pad('current', 18)} │ {(_fmt_metric(cur) + unit):>12} │")
+    if prev is not None:
+        print(f"│ {pad('previous', 18)} │ {(_fmt_metric(prev) + unit):>12} │")
+    if change is not None:
+        print(f"│ {pad('change', 18)} │ {_fmt_change(change):>12} │")
+    print("└────────────────────┴──────────────┘")
+    print("```")
+    if suffix:
+        print()
+        print(suffix)
+
+
+def _show_trend(data, unit):
+    trend = data.get("trend") or data.get("series")
+    if isinstance(trend, list) and trend:
+        print()
+        print(f"Trend ({len(trend)} points):")
+        for pt in trend[-10:]:
+            d = pt.get("date") or pt.get("day") or ""
+            v = pt.get("value") or pt.get("score") or pt.get("metric")
+            print(f"  {d}  {_fmt_metric(v)}{unit}")
+
+
+def cmd_score(args, key, base, pid):
+    result = api_get(
+        f"/api/projects/{pid}/analytics/visibility/score",
+        key, base, params=_common_params(args),
+    )
+    data = extract_data(result) or {}
+    if args.json:
+        print_json(data)
+        return
+    _print_metric("Visibility Score", "%", data)
+    _show_trend(data, "%")
+
+
+def cmd_sov(args, key, base, pid):
+    result = api_get(
+        f"/api/projects/{pid}/analytics/visibility/share-of-voice",
+        key, base, params=_common_params(args),
+    )
+    data = extract_data(result) or {}
+    if args.json:
+        print_json(data)
+        return
+    _print_metric("Share of Voice", "%", data)
+    _show_trend(data, "%")
+
+
+def cmd_avg(args, key, base, pid):
+    result = api_get(
+        f"/api/projects/{pid}/analytics/visibility/average-position",
+        key, base, params=_common_params(args),
+    )
+    data = extract_data(result) or {}
+    if args.json:
+        print_json(data)
+        return
+    _print_metric("Average Position", "", data)
+    _show_trend(data, "")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Single-metric visibility queries")
+    parser.add_argument("--project-id", help="Project ID (or set GEO_PROJECT_ID env var)")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    for name in ("score", "share-of-voice", "average-position"):
+        p = sub.add_parser(name)
+        p.add_argument("--start", help="Start date YYYY-MM-DD")
+        p.add_argument("--end", help="End date YYYY-MM-DD")
+        p.add_argument("--platform", choices=["openai", "google_aio", "perplexity", "gemini"])
+
+    args = parser.parse_args()
+    key, base = get_api_config()
+    pid = get_project_id(args.project_id)
+
+    handlers = {
+        "score": cmd_score,
+        "share-of-voice": cmd_sov,
+        "average-position": cmd_avg,
+    }
+    handlers[args.command](args, key, base, pid)
+
+
+if __name__ == "__main__":
+    main()

package/skills/adgine-geo-wordpress/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: adgine/geo-wordpress
+description: Connects a GEO project to a WordPress site (站点凭证管理 — site URL + username + application password), lists WP categories, publishes generated articles to WordPress (one-click or direct markdown), tracks publish history, and updates an existing WP post with the latest content version. Use when the user wants to publish GEO articles to WordPress (发布到 WordPress, push to WP, publish article), manage WP credentials (连接 WordPress, 绑定 WP, save WordPress credentials, application password), update an already-published post with the newest content (更新 WordPress 文章, sync to WP), check publish history (发布历史), or list WordPress categories.
+---
+
+# GEO WordPress
+
+End-to-end WordPress publishing for GEO-generated content. Three steps:
+
+1. **Connect** your WordPress site (save URL + username + application password).
+2. **Publish** an article — either by `content_id` from the GEO content
+   library, or directly with a title + markdown body.
+3. **Update** an existing WP post when the GEO article is revised.
+
+Use the **adgine-geo-content** skill to generate articles before publishing them.
+
+## Output rules — IDs (apply to every reply)
+
+These rules apply to **every list, table, and confirmation message** in this skill. Their goal: keep user-facing output friendly while preserving the IDs the agent needs internally.
+
+1. **Lists & tables — never show raw UUIDs in cells.** Use a 1-based `#` index column instead. Keep a private mental mapping of `#N → actual UUID` so that follow-up commands like *"delete #3"*, *"run citation test on #1 #2"*, *"show details of the 2nd one"* resolve to the right entity.
+   - Index numbers restart from 1 in each new list — they are not stable across calls.
+   - If the user references *"the topic about X"* / *"that Poki vs CrazyGames prompt"*, match by visible content (name / title / domain / prompt text), not by ID.
+
+2. **Single-item operations — prefer a human name over an ID.**
+   - ✅ *"Project **Poki vs Competitors** deleted."*
+   - ✅ *"Topic **Brand mentions in 2024** updated — name → 'Brand mentions 2025'."*
+   - ❌ *"Project `a4305b57-1c79-4cec-a17c-16eb1d959ea6` deleted."*
+   - If the entity has **no human-readable name** (e.g. an anonymous prompt or a job), use a short 8-character prefix: *"Prompt `2a2a8f4f…` deleted."* Never paste the full UUID.
+
+3. **Always exception: `--json` mode.** When the user passes `--json` to a script or explicitly asks for raw JSON / debug output, print the script output verbatim — do not strip IDs.
+
+4. **Internally, the agent still uses full UUIDs** for every API call (`--project-id`, `--topic-id`, `--prompt-id`, etc.). The display rules only affect what is shown back to the user.
+
+---
+
+## Step 1: Make sure GEO_API_KEY is configured
+
+Scripts auto-load `GEO_API_KEY` from `<skills-root>/.env` on import — **no `export` needed, no shell restart needed**. To check the configuration, run any script (it prints the exact `.env` path if the key is missing).
+
+- ✅ Key already in `<skills-root>/.env` → proceed.
+- ❌ Key missing, or user just gave you a new key → go to the **adgine-geo-projects** skill, **Step 0**, which runs `python3 <skills-root>/setup.py <KEY>` to write the key into the correct `.env` file. **Never** write the key to `~/.zshrc`, `~/.bashrc`, Hermes global config, or any user-secrets store.
+
+> ⚠️ **IMPORTANT:** In all shell/exec commands, always reference the key as `$GEO_API_KEY` (the environment variable). Never hardcode the literal value.
+
+## Project selection
+
+```bash
+export GEO_PROJECT_ID=<project-id>
+```
+
+## Scripts
+
+### 1) Credentials & categories
+
+```bash
+python3 scripts/manage_credentials.py status                     # connection state
+python3 scripts/manage_credentials.py categories                 # live WP categories
+python3 scripts/manage_credentials.py connect \
+    --site-url https://example.com \
+    --username admin \
+    --password "abcd efgh ijkl mnop"
+python3 scripts/manage_credentials.py disconnect --yes           # DESTRUCTIVE
+```
+
+> **WordPress application password** must be created in WP Admin → Users →
+> Profile → Application Passwords. Plain user passwords will **not** work.
+
+### 2) Publish an article
+
+First find publishable content:
+```bash
+python3 scripts/list_publishable.py
+```
+
+Then publish:
+```bash
+# Mode A: by GEO content ID
+python3 scripts/publish.py --content-id <uuid> [--category-ids 2,5] [--status publish|draft]
+
+# Mode B: raw title + markdown body
+python3 scripts/publish.py --title "My Post" --content-body "# Hello..."
+```
+
+### 3) Manage existing publishes
+
+```bash
+python3 scripts/manage_publishes.py list                          # publish history
+python3 scripts/manage_publishes.py update --record-id <id>       # push latest content
+python3 scripts/manage_publishes.py update --record-id <id> --status draft
+```
+
+## Output Format
+
+ASCII tables only. Status vocabulary: `Connected` / `Disconnected` /
+`publish` / `draft`. Width ≤80 chars max for tables with WP IDs / URLs.
+
+```
+┌────────────────────┬──────────────────────────────┐
+│ Field              │ Value                        │
+├────────────────────┼──────────────────────────────┤
+│ Status             │ Connected                    │
+│ site_url           │ https://example.com          │
+│ username           │ admin                        │
+└────────────────────┴──────────────────────────────┘
+```
+
+## Workflow narrative
+
+> 1. **Connect**: `manage_credentials.py connect ...` (one-time).
+> 2. **Verify**: `manage_credentials.py status` returns `Connected`.
+> 3. **Discover**: `manage_credentials.py categories` to know which IDs to assign.
+> 4. **List candidates**: `list_publishable.py`.
+> 5. **Publish**: `publish.py --content-id <uuid> --category-ids 2,5`.
+> 6. **Iterate**: if the article is revised in GEO, run
+>    `manage_publishes.py update --record-id <id>` to push the new version
+>    to the same WP post.
+
+## Related endpoints
+
+| Method | Path |
+|---|---|
+| GET    | `/api/projects/{id}/integrations/wordpress/credentials` |
+| PUT    | `/api/projects/{id}/integrations/wordpress/credentials` |
+| DELETE | `/api/projects/{id}/integrations/wordpress/credentials` |
+| GET    | `/api/projects/{id}/integrations/wordpress/categories` |
+| GET    | `/api/projects/{id}/integrations/wordpress/publishable-content` |
+| POST   | `/api/projects/{id}/integrations/wordpress/publish` |
+| GET    | `/api/projects/{id}/integrations/wordpress/publishes` |
+| PUT    | `/api/projects/{id}/integrations/wordpress/publishes/{record_id}` |
+
+---
+
+## Post-task recommendations
+
+After WordPress operations, suggest the next content or analysis step:
+
+| You just… | → use skill (agent-internal) |
+|---|---|
+| Connected WordPress | 生成 GEO 文章（现在可以直接发布） *(→ adgine-geo-content)*|
+| Published an article | 检查已发布页面的 AI 优化健康度 *(→ adgine-geo-performance)*|
+| Updated a published post | 运行引用测试，验证更新后 AI 引用是否提升 *(→ adgine-geo-citation)*|
+| Listed publishable content | 选择一篇发布到 WordPress *(→ adgine-geo-wordpress)*|
+| Checked publish history | 生成更多文章扩展内容库 *(→ adgine-geo-content)*|
+| Disconnected WordPress | 管理其他集成（GA4 / Cloudflare） *(→ adgine-geo-integrations)*|
+
+**⚠️ Output rule:** Do NOT write skill names (e.g. `adgine-geo-xxx`) in user-facing suggestions. Each suggestion must be phrased as a natural-language prompt the user can copy and send directly to the agent.
+
+> 💡 **建议下一步：**
+> 1. **[行动标题]** — *"[可直接发送给 AI 的自然语言提示词]"*
+> 2. **[行动标题]** — *"[可直接发送给 AI 的自然语言提示词]"*