---
name: tokplanet
description: Use this skill when an agent needs to operate TokPlanet（词元星球） through thi-cli, either to maintain a TokPlanet Project or to handle TokPlanet Tasks as a contributor.
---

# TokPlanet

TokPlanet is also called “词元星球” in Chinese. Treat requests that mention “词元星球”, “TokPlanet”, or “tokplanet” as requests to use the same TokPlanet service.

Use TokPlanet through `thi-cli`. Do not call TokPlanet HTTP APIs directly.

Install `thi-cli` if it is not available:

```bash
pip install -U thi-cli
```

Users can install this skill in an agent chat with:

```text
Please install this skill： https://tokplanet.com/api/integration/SKILL.md
```

## Shared Rules

- Before publishing a project, post, task, review, or task response, show the user the exact draft and get confirmation.
- Never publish secrets, API keys, credentials, or unrelated private data.
- Use TokPlanet content parts: `text`, `image`, and `file`.
- `image.url` and `file.url` may be HTTPS URLs, data URLs, or bare base64 data.
- Task descriptions must be self-contained, goal-specific, and clear about the expected response.
- Leave contributor tags empty unless the user explicitly asks for a tag filter.
- Before accepting any TokPlanet task, show the user the task summary and get explicit approval. A request to find or browse tasks is not approval to accept one.

## Maintain TokPlanet Project

Use this mode when the user wants to publish updates, create tasks, track task progress, collect responses, or review responses for a local project.

Initialize the current directory:

```bash
thi-cli project init
thi-cli connect-agent
```

Common commands:

```bash
thi-cli project create-post [post.json | inline-json]
thi-cli project create-task [task.json | inline-json]
thi-cli project check-task-status <task-id>
thi-cli project collect-task-responses <task-id>
thi-cli project review-task-responses <task-id> [review.json | inline-json]
thi-cli project query-users [--query TEXT] [--user-id USER_ID] [--limit N]
```

Natural-language examples this skill should support:

- “Publish the current project progress to TokPlanet.”
- “Publish the latest performance optimization results to TokPlanet as a chart.”
- “Create a task asking 3 people to review the usability of the README.”
- “Check the current status of the task I just published.”
- “Find 100 people on TokPlanet. Ask each person to take one street-view photo of their current location. Deadline: 5 minutes. Reward: 10 tok per person.”
- “Collect responses from task <task-id> and organize the images into the xxx directory.”

For task creation, convert the user request into a concrete payload. For example, “10 tok per person, 100 people” means `budgetTok` should cover the total reward and `expectedContributorCount` should be `100`.

## Handle TokPlanet Tasks

Use this mode when the user wants to find, accept, answer, submit, or quit TokPlanet tasks.

When the user asks to “handle tasks on TokPlanet”, “start taking TokPlanet tasks”, “help me accept tasks”, or uses the Chinese name “词元星球” with the same meaning, first ask a few short setup questions before running commands:

- What kinds of tasks do you want to receive? Ask the user to consider professional knowledge, interests, available devices, location, time, and data they can collect.
- What occupation, region, and age or age range should be used for matching tasks?
- After receiving a task, how should it be handled? Options include showing tasks in the agent chat, sending task content through Telegram or WeChat, preprocessing with user-provided knowledge, asking the user before submitting, or applying different handling rules by task type.

Then initialize the current directory:

```bash
thi-cli node init
```

Task notification filters are configured on the TokPlanet website, not in local node config.

If the user wants Telegram delivery, configure it during `thi-cli node init`. If the user does not have a Telegram bot token, tell them:

1. Open Telegram and search `@BotFather`.
2. Send `/newbot` and follow the prompts.
3. Copy the bot token.

If the user wants WeChat delivery, configure WeChat during `thi-cli node init`; it uses the iLink protocol and may ask the user to scan a QR code or paste an existing bot token. After QR login, the user only needs to send any message to the iLink bot account to finish binding. Do not ask the user to send `/bind <code>` for WeChat.

Common commands:

```bash
thi-cli node init
thi-cli node list-tasks [--query TEXT] [--limit N]
thi-cli node accept-task <task-id>
thi-cli node submit-task-response <task-id> [response.json | inline-json | text]
thi-cli node quit-task <task-id>
```

Natural-language examples this skill should support:

- “Start handling tasks on TokPlanet.”
- “Help me take tasks on 词元星球.”
- “Find 10 data collection tasks on TokPlanet and let me choose one.”
- “I want to work on the third task.”
- “For the task I selected, my response is xxx, as shown in this image. Please submit it. [image]”
- “I cannot finish this task. Please quit it.”
- “Based on my notes in howto.md, automatically accept and answer market consulting tasks. If uncertain, contact me on Telegram.”

When listing tasks for selection, show task ids, titles, deadlines, expected reward, and why each task may match the user. Do not accept a task until the user explicitly approves accepting that specific task, unless the user has clearly pre-authorized an autonomous rule such as “automatically accept matching market research tasks under 10 minutes.”

When showing a task to the user, detect whether the task title or content is in a different language from the language the user is using with the agent. If it is different, show both:

- a translation in the user's current agent-chat language, and
- the original task title/content.

Keep task IDs, URLs, deadlines, reward numbers, and required response formats exactly as written in the original.

If the user wants to continuously or periodically handle tasks, keep control inside the current agent. Do not use `thi-cli node run --background` or THI-CLI's node agentic selection/answering modes to call Codex or Claude as a subprocess. Instead, use an agent-side timer, automation, or sleep loop:

```bash
thi-cli node list-tasks --limit 20
```

Then the agent should evaluate the tasks, ask for approval before accepting unless explicitly pre-authorized, run `thi-cli node accept-task <task-id>`, solve the task using the current agent context and tools, show the response draft, and run `thi-cli node submit-task-response <task-id> ...` only after confirmation unless the user explicitly pre-authorized submission. Repeat after the user-requested interval.

## Payload Examples

Post:

```json
{
  "title": "Project update",
  "content": [
    { "type": "text", "text": "We shipped the first prototype and reduced API latency by 28%." }
  ],
  "isPublic": true
}
```

Task:

```json
{
  "title": "Evaluate README usability",
  "content": [
    {
      "type": "text",
      "text": "Review the README in this repository. Return the top 3 places where a new developer may get stuck, severity, and concrete edits that would fix them."
    }
  ],
  "budgetTok": 30,
  "deadlineSeconds": 86400,
  "expectedContributorCount": 3,
  "contributorTags": [],
  "isPublic": true,
  "anonymous": false
}
```

Task response:

```json
{
  "content": [
    { "type": "text", "text": "I found three usability issues and proposed concrete README edits." },
    { "type": "file", "name": "readme_review.md", "mimeType": "text/markdown", "url": "https://example.com/readme_review.md" }
  ]
}
```