@acedatacloud/skills 2026.704.2 → 2026.704.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/skills",
-  "version": "2026.704.2",
+  "version": "2026.704.4",
   "description": "Agent Skills for AceDataCloud AI services — music, image, video generation, LLM chat, web search. Compatible with Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, and 30+ AI coding agents.",
   "keywords": [
     "agent-skills",

package/skills/_shared/artifacts.md

@@ -0,0 +1,28 @@
+# Recording produced outputs (`publish_artifact`)
+
+Write/publish-capable Skills should record their concrete deliverable so the
+user can later find and aggregate everything the agent produced (in the "My
+Outputs" view at `/chatgpt/artifacts`).
+
+After a publish/send/generate action **succeeds and you have the live result
+URL**, call the built-in `publish_artifact` tool exactly ONCE for that
+deliverable:
+
+```
+publish_artifact(
+  kind="article",          # article | image | video | audio | document | email | message | dataset | link | other
+  channel="<platform>",    # e.g. zhihu, csdn, medium, x, mastodon
+  title="<human title>",
+  url="<the REAL returned URL>",
+  status="delivered"       # delivered | draft | failed
+)
+```
+
+Rules:
+
+- Use the **real URL returned by the publish step** — never fabricate a URL.
+- Call it once per distinct deliverable, right after delivery is confirmed.
+- Do NOT call it for intermediate steps, drafts you didn't submit, or narration.
+- If publishing failed, either skip it or record `status="failed"`.
+
+The tool is non-interactive and works in unattended (scheduled-task) runs.

package/skills/bilibili/SKILL.md

@@ -106,3 +106,17 @@ skips this.
   common `tid` values.
 - **Never print `BILIBILI_COOKIES`** — it is full account access.
 - **ToS**: acts only on the user's own account with their own captured cookie.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="bilibili", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/blogger/SKILL.md

@@ -78,3 +78,17 @@ curl -sS -H "Authorization: Bearer $GOOGLE_BLOGGER_TOKEN" \
   or reconnect with the account that has the blog.
 - `content` must be HTML; passing raw Markdown will render literally.
 - Paginate with `&pageToken=$PAGE_TOKEN` from the previous `.nextPageToken`.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="blogger", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/bluesky/SKILL.md

@@ -112,3 +112,17 @@ extracts the `rkey`. An empty result / `deleted:true` is success.
   there; all XRPC calls target that host, not `bsky.social`.
 - The CLI creates a fresh short-lived session on **every** invocation, so an
   expiring `accessJwt` is never a concern — just run the command again.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="message", channel="bluesky", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/csdn/SKILL.md

@@ -91,3 +91,17 @@ image that fails to upload keeps its original URL (never blocks the post).
 - **Never print `CSDN_COOKIES`** — it is full account access.
 - **ToS**: cookie automation acts only on the user's own account with their own
   captured cookie; the user owns that risk.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="csdn", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/devto/SKILL.md

@@ -76,3 +76,17 @@ curl -sS -H "api-key: $DEVTO_API_KEY" -H "Accept: application/vnd.forem.api-v1+j
   bulk publishes or you'll get `429`.
 - `body_markdown` is the source of truth — if you put a `---` front-matter block
   at the top, its fields override the JSON `article` fields.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="devto", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/hashnode/SKILL.md

@@ -145,3 +145,17 @@ gql 'query GetPost($id: ObjectId!) { post(id: $id) { title url views reactionCou
   via status codes; always surface them.
 - **Idempotency** — re-running `publishPost` creates a *new* post each time; to
   change an existing one use `updatePost` with its `id`.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="hashnode", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/instagram/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: instagram
+description: Publish images, videos, Reels or carousels to your Instagram professional account via the Instagram Content Publishing API, and read your own recent media. Use when the user wants to post to Instagram (photo / video / reel / carousel), cross-post a visual, or review their own Instagram posts. Instagram is image/video-only (no text-only posts). Auth uses an access token (BYOC). 支持 Instagram 图片 / 视频 / Reels / 轮播发布。
+when_to_use: |
+  Trigger when the user wants to publish a photo, video, reel or carousel to
+  their Instagram professional (Business/Creator) account, or review their own
+  recent posts. Instagram only publishes image/video — there are no text-only
+  posts. Publishing posts as their real account — confirm caption + media first.
+connections: [instagram]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+Call the **Instagram Graph API** (`graph.facebook.com`) with `curl + jq`. The
+connector injects `$INSTAGRAM_ACCESS_TOKEN` (a token with
+`instagram_content_publish` + `pages_read_engagement`; a Facebook Page token or
+an Instagram-Login user token) and optionally `$INSTAGRAM_IG_USER_ID`. Never echo them.
+
+Instagram publishes only **images / videos / reels** to a **professional**
+(Business or Creator) account linked to a Facebook Page. There are no text-only posts.
+
+### Resolve the Instagram account id
+
+If `$INSTAGRAM_IG_USER_ID` is set, use it. Otherwise derive it from the linked Page:
+
+```bash
+if [ -n "$INSTAGRAM_IG_USER_ID" ]; then
+  IGID="$INSTAGRAM_IG_USER_ID"
+else
+  PAGE=$(curl -sS "https://graph.facebook.com/v21.0/me/accounts?access_token=$INSTAGRAM_ACCESS_TOKEN" | jq -r '.data[0].id')
+  IGID=$(curl -sS "https://graph.facebook.com/v21.0/$PAGE?fields=instagram_business_account&access_token=$INSTAGRAM_ACCESS_TOKEN" | jq -r '.instagram_business_account.id')
+fi
+echo "ig_user_id=$IGID"
+```
+
+Errors are JSON with `error.message` / `error.code` — show them verbatim.
+`401` / `OAuthException` → token expired or missing scope; a null `IGID` → the
+token isn't linked to a professional IG account / Page (see Gotchas). Reconnect if needed.
+
+## Publish a single image (two-step: create container → publish)
+
+**Confirm the caption + image with the user first.** The `image_url` must be a
+**public JPEG** URL (Instagram server-side cURLs it):
+
+```bash
+CID=$(curl -sS -X POST "https://graph.facebook.com/v21.0/$IGID/media" \
+  -d "image_url=https://cdn.acedata.cloud/xxxx.jpg" \
+  --data-urlencode "caption=One endpoint → posters, cards, mockups. #AI #API" \
+  -d "access_token=$INSTAGRAM_ACCESS_TOKEN" | jq -r .id)
+echo "container=$CID"
+
+curl -sS -X POST "https://graph.facebook.com/v21.0/$IGID/media_publish" \
+  -d "creation_id=$CID" -d "access_token=$INSTAGRAM_ACCESS_TOKEN" | jq .
+# → {"id":"<IG_MEDIA_ID>"}
+```
+
+Get the permalink to hand back to the user:
+
+```bash
+curl -sS "https://graph.facebook.com/v21.0/<IG_MEDIA_ID>?fields=permalink&access_token=$INSTAGRAM_ACCESS_TOKEN" | jq -r .permalink
+```
+
+## Reels / video
+
+Create with `media_type=REELS` + a public `video_url`, then **poll the container
+status until FINISHED** before publishing (video processing takes time):
+
+```bash
+CID=$(curl -sS -X POST "https://graph.facebook.com/v21.0/$IGID/media" \
+  -d "media_type=REELS" -d "video_url=https://cdn.acedata.cloud/xxxx.mp4" \
+  --data-urlencode "caption=..." -d "access_token=$INSTAGRAM_ACCESS_TOKEN" | jq -r .id)
+
+# poll until the video finishes processing (up to ~5 min) BEFORE publishing —
+# publishing an IN_PROGRESS container is rejected:
+for i in $(seq 1 60); do
+  ST=$(curl -sS "https://graph.facebook.com/v21.0/$CID?fields=status_code&access_token=$INSTAGRAM_ACCESS_TOKEN" | jq -r .status_code)
+  echo "status=$ST"; [ "$ST" = "FINISHED" ] && break
+  [ "$ST" = "ERROR" ] || [ "$ST" = "EXPIRED" ] && { echo "container failed: $ST"; break; }
+  sleep 5
+done
+
+curl -sS -X POST "https://graph.facebook.com/v21.0/$IGID/media_publish" \
+  -d "creation_id=$CID" -d "access_token=$INSTAGRAM_ACCESS_TOKEN" | jq .
+```
+
+## Carousel (2–10 items)
+
+Create each child with `is_carousel_item=true`, then a `media_type=CAROUSEL`
+container with `children=<ID1>,<ID2>,...` + `caption`, then publish the carousel id.
+
+## Gotchas
+
+- **No text-only posts** — Instagram requires an image or video. Use a public
+  **JPEG** for images (PNG/other formats are rejected; extended JPEG like MPO/JPS too).
+- **Professional account required** — a Business/Creator IG account linked to a
+  Facebook Page. If `instagram_business_account` is null, the account isn't a
+  professional account or isn't linked; the user must fix that in IG / Page settings.
+- **Media must be a public URL** on a server Instagram can reach; local files
+  won't work. Host on cdn.acedata.cloud first.
+- **Rate limit:** 100 API-published posts per 24h (a carousel counts as 1). Check
+  via `GET /$IGID/content_publishing_limit`.
+- **Page Publishing Authorization (PPA):** some Pages must complete PPA before API
+  publishing works — surface the API error verbatim if it mentions PPA.
+- API version: keep the `vXX.0` path current if you hit a version/deprecation error.
+
+## Record the output
+
+After you successfully publish and obtain the live permalink, call the built-in
+`publish_artifact` tool ONCE so the user can track it in **My Outputs**:
+
+```
+publish_artifact(kind="image", channel="instagram", title="<title>", url="<the REAL permalink>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/juejin/SKILL.md

@@ -73,3 +73,17 @@ python3 $JJ publish --title "标题" --content-file a.md \
 - Publishing without a category + tag is rejected in 审核; prefer `--draft-only`.
 - **Never print `JUEJIN_COOKIES`** — it is full account access.
 - **ToS**: acts only on the user's own account with their own captured cookie.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="juejin", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/linkedin/SKILL.md

@@ -71,3 +71,17 @@ If the versioned endpoint is unavailable for the app, the older
   Page posts need `w_organization_social` + an admin role (not in this connector).
 - The `LinkedIn-Version` header is mandatory for `/rest/*`; a stale value
   returns a version error — bump to the current `YYYYMM`.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="linkedin", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/mastodon/SKILL.md

@@ -101,3 +101,17 @@ https://docs.joinmastodon.org/methods/media/
   get `429`.
 - `verify_credentials` returns HTML in fields like `note`; the plaintext source
   lives under the `source` object.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="message", channel="mastodon", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/medium/SKILL.md

@@ -93,3 +93,17 @@ to a link paragraph (never blocks the post).
   genuinely expired (reconnect).
 - **Never print `MEDIUM_COOKIES`** — it is full account access.
 - **ToS**: acts only on the user's own account with their own captured cookie.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="medium", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/notion/SKILL.md

@@ -120,3 +120,17 @@ curl -sS -X POST "https://api.notion.com/v1/pages" \
 - Most write failures (400/404) come from a property type mismatch —
   e.g. sending `{"select": "Open"}` instead of `{"select": {"name": "Open"}}`.
   Read the database schema once via `GET /v1/databases/<id>` if unsure.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="document", channel="notion", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/reddit/SKILL.md

@@ -77,3 +77,17 @@ curl -sS -H "Authorization: Bearer $REDDIT_TOKEN" -H "User-Agent: $UA" \
 - Respect rate limits: read the `X-Ratelimit-Remaining` response header; space
   out bulk submits.
 - Use `r/test` as a safe target when validating that the connection works.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="message", channel="reddit", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/substack/SKILL.md

@@ -93,3 +93,17 @@ python3 $SUB publish --title "Title" --content-file post.md --send-email --confi
   genuinely expired (reconnect); the CLI never retries a write.
 - **Never print `SUBSTACK_COOKIES`** — it is full account access.
 - **ToS**: acts only on the user's own account with their own captured cookie.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="substack", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/telegram/SKILL.md

@@ -122,3 +122,17 @@ user verbatim as the confirmation prompt.
   return an error (no shareable link exists).
 - **`edit`/`delete`** generally only apply to the user's own messages (admins can delete others
   in groups they manage).
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="message", channel="telegram", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/threads/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: threads
+description: Publish text, image, video or carousel posts to your Threads (@threads) account via the official Threads API, and read your own recent posts. Use when the user wants to post to Threads, cross-post a short update / thread, attach an image or link, or review their own Threads posts. Auth uses a Threads access token (BYOC). 支持 Threads 文本 / 图片 / 视频 / 轮播发布与自有贴文读取。
+when_to_use: |
+  Trigger when the user wants to publish a post to their Threads account or
+  review their own recent Threads posts. Threads is Meta's text-first social
+  app; the connector stores a Threads access token with threads_content_publish.
+  Posting publishes as their real account — confirm the text with the user first.
+connections: [threads]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+Call the **Threads API** (`graph.threads.net`) with `curl + jq`. The connector
+injects one credential: `$THREADS_ACCESS_TOKEN` (a long-lived Threads access
+token with the `threads_basic` + `threads_content_publish` scopes). Never echo it.
+
+Resolve the caller's Threads user id once (every publish needs it):
+
+```bash
+ME=$(curl -sS "https://graph.threads.net/v1.0/me?fields=id,username&access_token=$THREADS_ACCESS_TOKEN")
+TID=$(echo "$ME" | jq -r .id)
+echo "$ME"     # {"id":"<THREADS_USER_ID>","username":"..."}
+```
+
+Errors are JSON with `error.message` / `error.code` — show them verbatim.
+`401` / `OAuthException` → the token expired or lacks scope; reconnect the
+Threads connector.
+
+## Publish a post (two-step: create container → publish)
+
+**Confirm the text with the user first** (it publishes as their real account).
+Text ≤ **500 characters** (emoji counted as UTF-8 bytes).
+
+Step 1 — create a media container. Text-only (guard the 500-byte limit first):
+
+```bash
+TEXT="Shipping one API for AI images → posters, cards, mockups. https://platform.acedata.cloud #AI #API"
+[ "$(printf %s "$TEXT" | wc -c)" -le 500 ] || { echo "text exceeds Threads 500-byte limit — shorten it"; }
+CID=$(curl -sS -X POST "https://graph.threads.net/v1.0/$TID/threads" \
+  --data-urlencode "media_type=TEXT" \
+  --data-urlencode "text=$TEXT" \
+  -d "access_token=$THREADS_ACCESS_TOKEN" | jq -r .id)
+echo "container=$CID"
+```
+
+Image post — add `media_type=IMAGE` + a **public** `image_url` (Threads cURLs it
+server-side, so it must be on a public server); video uses `media_type=VIDEO` + `video_url`:
+
+```bash
+CID=$(curl -sS -X POST "https://graph.threads.net/v1.0/$TID/threads" \
+  --data-urlencode "media_type=IMAGE" \
+  -d "image_url=https://cdn.acedata.cloud/xxxx.jpg" \
+  --data-urlencode "text=caption here" \
+  -d "access_token=$THREADS_ACCESS_TOKEN" | jq -r .id)
+```
+
+Step 2 — publish the container. **Text posts publish immediately; for IMAGE /
+VIDEO / carousel containers you MUST wait ≥30s first** so Threads can
+fetch/process the upload — publishing too early fails or returns no id:
+
+```bash
+sleep 30   # REQUIRED for IMAGE / VIDEO / carousel; skip for TEXT-only posts
+curl -sS -X POST "https://graph.threads.net/v1.0/$TID/threads_publish" \
+  -d "creation_id=$CID" -d "access_token=$THREADS_ACCESS_TOKEN" | jq .
+# → {"id":"<THREADS_MEDIA_ID>"}
+```
+
+If `threads_publish` returns no id, the container isn't ready yet — poll
+`GET /v1.0/<CID>?fields=status&access_token=$THREADS_ACCESS_TOKEN` until
+`status=FINISHED`, then retry publish.
+
+Get the public URL of the published post and hand it to the user:
+
+```bash
+curl -sS "https://graph.threads.net/v1.0/<THREADS_MEDIA_ID>?fields=id,permalink&access_token=$THREADS_ACCESS_TOKEN" | jq -r .permalink
+```
+
+## Carousel (2–20 items)
+
+Create each child with `is_carousel_item=true`, then a `media_type=CAROUSEL`
+container with `children=<ID1>,<ID2>,...`, then publish the carousel id. Links:
+add `link_attachment=<URL>` (text-only posts, ≤5 links). Topic tag: `topic_tag=<TAG>`.
+
+## List my recent posts
+
+```bash
+curl -sS "https://graph.threads.net/v1.0/$TID/threads?fields=id,text,permalink,timestamp&limit=20&access_token=$THREADS_ACCESS_TOKEN" | jq '.data'
+```
+
+## Gotchas
+
+- **500-char limit**; emoji count as their UTF-8 byte length.
+- **Media must be a public URL** — Threads server-side cURLs `image_url`/`video_url`;
+  local files won't work. Upload to a public host / cdn.acedata.cloud first.
+- **Wait ~30s before publishing media** containers (text publishes instantly); if
+  `threads_publish` doesn't return an id, poll `GET /<container-id>?fields=status`.
+- **Rate limit:** 250 published posts per 24h per profile (a carousel counts as 1).
+- Threads tokens differ from Facebook/Instagram tokens — they come from the
+  Threads OAuth flow on `graph.threads.net`, not `graph.facebook.com`.
+
+## Record the output
+
+After you successfully publish and obtain the live permalink, call the built-in
+`publish_artifact` tool ONCE so the user can track it in **My Outputs**:
+
+```
+publish_artifact(kind="message", channel="threads", title="<title>", url="<the REAL permalink>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/wordpress/SKILL.md

@@ -141,3 +141,17 @@ echo "media id=$MEDIA_ID"
 - **Never publish silently.** Even if the user says "post it", prefer creating a
   draft and returning the `wp-admin` edit link unless they explicitly asked to
   go live.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="wordpress", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/x/SKILL.md

@@ -107,3 +107,17 @@ python3 $X delete --id 123456 --confirm                        # delete one of M
   suspended. Keep volume human-like.
 - **Never print `X_COOKIES`** — it is full account access.
 - **DMs are intentionally not exposed** by this skill.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="message", channel="x", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.

package/skills/zhihu/SKILL.md

@@ -218,3 +218,17 @@ python3 $BLOG edit-answer --id <answer-id> --content-file ans.html --confirm   #
 - **Scope**: Zhihu only. Other Chinese platforms (掘金 / CSDN / …) ship as their
   own per-platform skills (e.g. `csdn`, `juejin`), each with its own connector —
   not a `--platform` switch here.
+
+
+## Record the output
+
+After you successfully publish and obtain the live result URL, call the built-in
+`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:
+
+```
+publish_artifact(kind="article", channel="zhihu", title="<title>", url="<the REAL returned URL>", status="delivered")
+```
+
+Use the real returned URL — never fabricate one. Call it once per published item,
+only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
+See `_shared/artifacts.md`.