@thinkingai/ae-cli 1.0.22 → 1.0.27

package/skills/ae-team/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: ae-team
+version: 1.0.0
+description: "AE/TE/ThinkingEngine/ThinkingAI ae-cli manual for AI Agent Team tasks: managing teams (list, create, update, delete, AI-generate, templates) and executing TeamRuns (start, chat, cancel, reply, result, artifacts). Use when the user asks to find a team, run a team task, check run status, retrieve results or artifacts, or set up multi-agent workflows. Must use ae-cli, read the matching references/<command>.md before composing commands, and never guess team IDs, run IDs, config structures, or parameter formats."
+---
+
+# ae-team
+
+> **CRITICAL — Before running any `+<command>` command, you MUST first read the corresponding `references/<command>.md`.** The reference filename equals the command name without the leading `+`, for example `+run-start` → `references/run-start.md`.
+> **CRITICAL — Never guess team IDs, run IDs, or config JSON structures.** Always use `+list` or `+list-templates` to discover real resources first.
+> **CRITICAL — For the core Agent workflow (find → start → poll → artifacts), follow Workflow A in the Typical Workflows section below.**
+
+## Global AE CLI Rules
+
+AE CLI (`ae-cli`) is the command-line tool for the AE / TE / ThinkingEngine analysis platform.
+
+Global parameters:
+
+| Parameter | Description |
+|---|---|
+| `--format <json\|table>` | Output format. Default is JSON. |
+| `--jq <expr>` | jq filter expression for JSON output. |
+| `--host <url>` | Override active AE host URL. |
+| `--yes` | Skip confirmation for write operations. |
+| `--dry-run` | Show request details without executing. |
+
+Output and errors:
+- Successful commands return machine-readable JSON by default.
+- Failed commands return `{ "ok": false, "error": { "type": "...", "message": "...", "hint": "..." } }` and exit non-zero.
+
+Safety constraints:
+- Read commands (`+list`, `+list-templates`, `+list-projects`, `+run-result`, `+run-artifacts`, `+ai-generate`) can execute directly once required IDs are known.
+- Write commands require explicit user intent and keep the confirmation prompt by default. Pass `--yes` only in fully automated pipelines.
+- Never invent team IDs, run IDs, `agentId` values, `mcpServerIds`, `skillIds`, `knowledgeBaseIds`, project IDs, or any resource identifiers. Discover them with list commands or accept them from the user.
+
+## When to Use
+
+Use `ae-team` for all AI Agent Team work:
+
+- **Team management**: list available teams, create/update/delete a team, generate a team config draft with AI, browse templates.
+- **TeamRun execution**: start a run, interact in chat mode, cancel a run, reply to a waiting run, poll result until completion, retrieve artifacts.
+
+If the user's intent is data analysis, audience management, metadata governance, or DataOps, switch to `ae-analysis` / `ae-dataops` / `ae-engage`.
+
+## Command Format
+
+```bash
+ae-cli team +<command> [options]
+```
+
+All commands live under the `team` service. Quick help:
+
+```bash
+ae-cli team --help
+ae-cli team +list --help
+ae-cli team +run-start --help
+```
+
+## Tool Groups (13)
+
+### Team Management (7)
+
+- `+list` ([doc](references/list.md)) — list all visible teams
+- `+create` ([doc](references/create.md)) — create a new team with a TeamConfig
+- `+update` ([doc](references/update.md)) — patch one or more fields of an existing team
+- `+delete` ([doc](references/delete.md)) — delete a team (409 if runs are active)
+- `+ai-generate` ([doc](references/ai-generate.md)) — AI-generate a team config draft from a goal description
+- `+list-templates` ([doc](references/list-templates.md)) — browse built-in team templates
+- `+list-projects` ([doc](references/list-projects.md)) — list projects available to the current user
+
+### TeamRun Execution (7)
+
+- `+run-start` ([doc](references/run-start.md)) — start a new TeamRun
+- `+run-watch` ([doc](references/run-watch.md)) — stream a TeamRun via SSE (preferred over polling)
+- `+run-chat` ([doc](references/run-chat.md)) — chat with a team (multi-turn, auto-resume)
+- `+run-cancel` ([doc](references/run-cancel.md)) — cancel a running TeamRun
+- `+run-reply` ([doc](references/run-reply.md)) — reply to a run in `waiting_user` state
+- `+run-result` ([doc](references/run-result.md)) — get the full result of a TeamRun (fallback polling)
+- `+run-artifacts` ([doc](references/run-artifacts.md)) — list artifacts produced by a TeamRun
+
+## TeamRun Status Reference
+
+| Status | Description |
+|---|---|
+| `pending` | Queued, waiting to start |
+| `running` | Actively executing |
+| `waiting_user` | Paused — `+run-watch` exits with code 2; read `pendingQuestion` from stdout, present to user, then call `+run-reply` |
+| `waiting_approval` | Paused — waiting for approval |
+| `paused` | Manually paused |
+| `completed` | Finished successfully |
+| `failed` | Execution failed |
+| `cancelled` | Cancelled by user |
+
+Terminal statuses: `completed`, `failed`, `cancelled`. Poll `+run-result` until one of these is reached.
+
+## Typical Workflows
+
+### Workflow A — Start an existing team and wait for results
+
+```bash
+# 1. Discover available teams
+ae-cli team +list
+
+# 2. (Optional) Discover project IDs if needed
+ae-cli team +list-projects
+
+# 3. Start a run
+ae-cli team +run-start --team-id <team_id> --input "分析上周用户留存数据" --yes
+
+# 4. Stream until done (blocks; no polling needed)
+ae-cli team +run-watch --id <run_id>
+# exit 0 → completed/partial_success → go to step 5
+# exit 1 → failed/cancelled → inspect errorMessage in output, report to user
+# exit 2 → waiting_user → go to step 4a
+
+# 4a. Handle waiting_user: read pendingQuestion from stdout, get user's answer, reply, re-watch
+ae-cli team +run-reply --id <run_id> --input "<user_answer>" --yes
+ae-cli team +run-watch --id <run_id>   # repeat until exit 0 or 1
+
+# 5. Retrieve artifacts
+ae-cli team +run-artifacts --id <run_id> --include-content true
+```
+
+### Workflow B — AI-generate a config, then create and run
+
+```bash
+# 1. Generate a draft config
+ae-cli team +ai-generate --prompt "需要一个分析用户行为并自动生成留存报告的团队"
+
+# 2. Create the team (paste / adjust the returned config)
+ae-cli team +create --name "留存分析团队" --config '<config_json>' --yes
+
+# 3. Start a run
+ae-cli team +run-start --team-id <new_team_id> --input "分析本月留存" --yes
+```
+
+### Workflow C — Multi-turn chat
+
+```bash
+# First turn
+ae-cli team +run-chat --team-id <team_id> --input "帮我分析DAU趋势" --yes
+
+# If run status is waiting_user, reply:
+ae-cli team +run-reply --id <run_id> --input "请重点分析周末下降原因" --yes
+
+# Continue same session
+ae-cli team +run-chat --team-id <team_id> --session-id <session_id> --input "给出优化建议" --yes
+```
+
+### Workflow D — Use a template to create a team
+
+```bash
+# 1. Browse templates
+ae-cli team +list-templates --locale zh
+
+# 2. Create from a template's config
+ae-cli team +create --name "我的分析团队" --config '<template_config>' --yes
+```
+
+## Quick Verification
+
+```bash
+ae-cli team --help
+```

package/skills/ae-team/references/ai-generate.md

@@ -0,0 +1,39 @@
+# team +ai-generate (AI-Generate Team Config Draft)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **Team management / config generation**
+
+## Use Cases
+- Given a plain-language description of a team's goal, generate a draft `{ name, description, members[] }` that can be reviewed and passed to `+create --config`.
+- Useful when the user has a goal but does not know how to write a TeamConfig manually.
+
+## Mandatory Rules (MUST)
+- `--prompt` is required (1–2000 chars). Pass the user's goal description as-is; do not pad it with generic boilerplate.
+- The returned draft is a **suggestion only** — always show it to the user for review before calling `+create`. Do not auto-create without user confirmation.
+- Do not fabricate `agentId` values; if the draft contains placeholder IDs, the user must replace them with real agent IDs before creating the team.
+
+## Command
+```bash
+ae-cli team +ai-generate --prompt "需要一个能分析用户留存并生成周报的团队"
+ae-cli team +ai-generate --prompt "A team that monitors DAU trends and sends alerts" --model <model_id>
+ae-cli team +ai-generate --dry-run --prompt "test"
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| `--prompt` | Yes | Team goal description (1–2000 chars) |
+| `--model` | No | Model ID to use for generation |
+
+## Decision Rules
+- If the user says "help me create a team" or "generate a team for [goal]", call this command first rather than jumping to `+create`.
+- Present the returned `name`, `description`, and `members` to the user. Ask them to confirm or adjust before proceeding.
+- If the user already has a config in mind, skip this command and go directly to `+create`.
+
+## Next Steps on Failure
+- Empty or low-quality result: ask the user to refine the prompt with more specific goals, roles, or steps.
+- Model error: try omitting `--model` to use the default.
+
+## Recommended Chaining
+- `+ai-generate` → user reviews and adjusts draft → `+create`

package/skills/ae-team/references/create.md

@@ -0,0 +1,94 @@
+# team +create (Create Team)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **Team management / write**
+
+## Use Cases
+- Create a new AI Agent team with a given name and TeamConfig.
+- Returns the newly created team object including its `id`.
+
+## Mandatory Rules (MUST)
+- `--config` must be a valid TeamConfig JSON (see structure below). Do not invent `agentId`, `mcpServerIds`, `skillIds`, or `knowledgeBaseIds` — obtain real IDs from the user or the appropriate resource discovery commands.
+- `--name` must be 1–100 characters.
+- `--description` must be ≤2000 characters if provided.
+- `--scope` must be `personal` or `company` if provided; defaults to `personal` on the server.
+- Write operation: keep the confirmation prompt unless `--yes` is explicitly requested.
+
+## TeamConfig Structure
+
+```json
+{
+  "version": 1,
+  "mode": "serial | parallel | leader",
+  "steps": [
+    {
+      "id": "s1",
+      "name": "Step name",
+      "agentId": "<real agent ID>",
+      "prompt": "Step instructions (≤50000 chars)",
+      "role": "agent | leader | reviewer",
+      "retryLimit": 2,
+      "dependencies": [],
+      "resourceOverride": {
+        "mcpServerIds": [],
+        "skillIds": [],
+        "knowledgeBaseIds": [],
+        "model": null
+      }
+    }
+  ],
+  "maxConcurrency": 5,
+  "output": {
+    "format": "markdown | json | xlsx | pptx | pdf | docx"
+  }
+}
+```
+
+**Mode constraints:**
+- `serial` / `parallel`: `steps` ≥ 1
+- `leader`: `steps` ≥ 2 (all `role: "agent"`), requires `leaderConfig`
+
+**leaderConfig** (required when `mode: "leader"`):
+```json
+"leaderConfig": {
+  "agentId": "<leader agent ID>",
+  "maxIterations": 10,
+  "availableAgents": [
+    { "id": "a1", "agentId": "...", "name": "...", "description": "...", "capabilities": "..." }
+  ]
+}
+```
+
+## Command
+```bash
+ae-cli team +create \
+  --name "日报分析团队" \
+  --config '{"version":1,"mode":"serial","steps":[{"id":"s1","name":"分析师","agentId":"xxx","prompt":"分析数据","role":"agent"}]}'
+
+ae-cli team +create --name "My Team" --config '...' --scope company --yes
+ae-cli team +create --dry-run --name "Test" --config '{}'
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| `--name` | Yes | Team name (1–100 chars) |
+| `--config` | Yes | TeamConfig JSON object |
+| `--description` | No | Description (≤2000 chars) |
+| `--scope` | No | `personal` (default) \| `company` |
+| `--enabled` | No | `true` (default) \| `false` |
+
+## Decision Rules
+- If the user provides a goal description instead of a config, call `+ai-generate` first to get a draft, then ask the user to review before calling `+create`.
+- If the user wants to base a team on a template, call `+list-templates` first to get the template config.
+- Always use `--dry-run` first when building a complex config to verify the request shape before executing.
+
+## Next Steps on Failure
+- `Invalid JSON`: check TeamConfig structure, especially `version`, `mode`, `steps[].id`, `steps[].agentId`.
+- `400 / validation error`: verify that `mode` constraints are satisfied (e.g. `leader` requires `leaderConfig`).
+- After success, capture the returned `id` for subsequent `+run-start` calls.
+
+## Recommended Chaining
+- `+ai-generate` → review draft → `+create` → `+run-start`
+- `+list-templates` → pick template config → `+create` → `+run-start`

package/skills/ae-team/references/delete.md

@@ -0,0 +1,39 @@
+# team +delete (Delete Team)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **Team management / write**
+
+## Use Cases
+- Permanently delete a team by ID.
+- Returns `{ "ok": true }` on success.
+
+## Mandatory Rules (MUST)
+- `--id` is required. Obtain the real team ID via `+list` — do not guess.
+- If the team has running tasks, the server returns **409**. Cancel or wait for active runs before retrying.
+- This is an irreversible operation — confirm with the user before executing.
+
+## Command
+```bash
+ae-cli team +delete --id <team_id>
+ae-cli team +delete --id <team_id> --yes
+ae-cli team +delete --dry-run --id <team_id>
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| `--id` | Yes | Team ID |
+
+## Decision Rules
+- Always call `+list` first to confirm the `id` and that the user is targeting the correct team.
+- If the server returns 409, call `+run-result` on active runs to check their status, then use `+run-cancel` to cancel any `running` or `waiting_user` runs.
+- Do not retry delete until all active runs have reached a terminal status.
+
+## Next Steps on Failure
+- `409 Conflict`: cancel active runs first (`+run-cancel --id <run_id> --yes`), then retry.
+- `404`: team already deleted or wrong ID — re-run `+list` to verify.
+
+## Recommended Chaining
+- `+list` → confirm target → `+delete`
+- `+run-cancel` (clear active runs) → `+delete`

package/skills/ae-team/references/list-projects.md

@@ -0,0 +1,45 @@
+# team +list-projects (List Available Projects)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **Project discovery**
+
+## Use Cases
+- List all projects the current user has access to, sourced from the authentication endpoint.
+- Returns an array of `{ projectId, projectName }` objects.
+- Use this before `+run-start` when you need to populate `--project-ids` or `--project-names` but don't know the available project IDs.
+
+## Mandatory Rules (MUST)
+- Do not guess project IDs or project names. Call `+list-projects` first to discover real values.
+- If the user references a project by name, match it against the returned list before passing it to `+run-start`.
+
+## Command
+```bash
+ae-cli team +list-projects
+ae-cli team +list-projects --format table
+ae-cli team +list-projects --dry-run
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| None | — | No parameters required |
+
+## Response Shape
+```json
+[
+  { "projectId": 1, "projectName": "项目A" },
+  { "projectId": 2, "projectName": "项目B" }
+]
+```
+
+## Decision Rules
+- When the user wants to start a run and mentions a project by name or says "关联项目", call `+list-projects` first to resolve the correct `projectId`.
+- Once project IDs are confirmed in the current conversation, reuse them without calling `+list-projects` again unless the user switches projects.
+
+## Next Steps on Failure
+- Empty result: the current account may have no associated projects; confirm account permissions with the administrator.
+- Auth error: run `ae-cli auth login`.
+
+## Recommended Chaining
+- `+list-projects` → user confirms `projectId` → `+run-start --project-ids '[<id>]'`

package/skills/ae-team/references/list-templates.md

@@ -0,0 +1,38 @@
+# team +list-templates (List Team Templates)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **Team management / discovery**
+
+## Use Cases
+- Browse built-in team templates provided by the platform.
+- Each template includes a ready-to-use `config` that can be passed directly to `+create --config`.
+- Supports locale-specific template names and descriptions.
+
+## Mandatory Rules (MUST)
+- Do not fabricate template names or configs. Always call this command first and present the real list to the user.
+- `--locale` must be one of `zh`, `en`, `ja`, `ko` if provided.
+
+## Command
+```bash
+ae-cli team +list-templates
+ae-cli team +list-templates --locale en
+ae-cli team +list-templates --locale zh --format table
+ae-cli team +list-templates --dry-run
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| `--locale` | No | `zh` (default) \| `en` \| `ja` \| `ko` |
+
+## Decision Rules
+- When the user says "show me team templates" or "I want to create a team from a template", call this command first.
+- Extract the `config` field from the chosen template and pass it to `+create --config`.
+- If the user asks for templates in a specific language, pass the corresponding `--locale`.
+
+## Next Steps on Failure
+- Empty list: the platform may not have templates configured for the current environment.
+
+## Recommended Chaining
+- `+list-templates` → user picks template → `+create --name "..." --config '<template.config>'`

package/skills/ae-team/references/list.md

@@ -0,0 +1,39 @@
+# team +list (List Teams)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **Team discovery**
+
+## Use Cases
+- List all AI Agent teams visible to the current user.
+- Returns an array of team summaries; key fields include `id`, `name`, `description`, `scope`, `enabled`, `config`.
+- Use this as the first step before any run or update operation to confirm the target `team_id`.
+
+## Mandatory Rules (MUST)
+- Do not guess team IDs. Always call `+list` first to discover real team IDs.
+- If the user references a team by name, match the name against the returned list before proceeding.
+
+## Command
+```bash
+ae-cli team +list
+ae-cli team +list --format table
+ae-cli team +list --dry-run
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| None | — | No parameters required |
+
+## Decision Rules
+- When the user says "show me the teams", "what teams do I have", or needs a `team_id` for a subsequent command and none is in context, call this first.
+- If many teams are returned, summarize by `id`, `name`, `scope`, and `enabled` to help the user pick the right one.
+- Once a team is confirmed in the current conversation, reuse its ID without calling `+list` again unless the user switches teams.
+
+## Next Steps on Failure
+- Empty result: confirm account permissions and host environment.
+- Auth error: run `ae-cli auth login`.
+
+## Recommended Chaining
+- `+list` → user confirms `team_id` → `+run-start` or `+run-chat`
+- `+list` → `+update` or `+delete`

package/skills/ae-team/references/run-artifacts.md

@@ -0,0 +1,51 @@
+# team +run-artifacts (List TeamRun Artifacts)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **TeamRun execution / read**
+
+## Use Cases
+- List all artifacts (output files, reports, documents) produced by a completed TeamRun.
+- By default, returns metadata only (no content). Use `--include-content true` to fetch full artifact content.
+- Supports filtering by artifact type.
+
+## Mandatory Rules (MUST)
+- `--id` is required. Obtain the real run ID from a previous `+run-start` or `+run-chat` response — do not guess.
+- Only call this command after `+run-result` confirms `status = completed`. Artifacts may be incomplete for non-terminal runs.
+
+## Command
+```bash
+# List artifact metadata (no content)
+ae-cli team +run-artifacts --id <run_id>
+
+# Include full content
+ae-cli team +run-artifacts --id <run_id> --include-content true
+
+# Filter by type
+ae-cli team +run-artifacts --id <run_id> --artifact-type report
+
+# Combine
+ae-cli team +run-artifacts --id <run_id> --artifact-type markdown --include-content true
+
+ae-cli team +run-artifacts --dry-run --id <run_id>
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| `--id` | Yes | TeamRun ID |
+| `--artifact-type` | No | Filter by artifact type (e.g. `report`, `markdown`, `xlsx`) |
+| `--include-content` | No | `true` to include full artifact content (default: `false`) |
+
+## Decision Rules
+- First call without `--include-content` to get the list and sizes. Then decide whether to fetch content.
+- Use `--include-content true` only when the user explicitly wants the artifact body (e.g. to display a report, extract data, or forward the content).
+- If the run has not yet completed, call `+run-result` first and wait for terminal status.
+
+## Next Steps on Failure
+- `404`: run ID not found — verify from the original start response.
+- Empty list: the run completed but produced no artifacts; inspect `+run-result` output for any inline results.
+
+## Recommended Chaining
+- `+run-result` (confirm `completed`) → `+run-artifacts`
+- `+run-artifacts` → user reviews metadata → `+run-artifacts --include-content true` (fetch content for specific artifact)

package/skills/ae-team/references/run-cancel.md

@@ -0,0 +1,38 @@
+# team +run-cancel (Cancel TeamRun)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **TeamRun execution / write**
+
+## Use Cases
+- Cancel a TeamRun that is in `pending`, `running`, or `waiting_user` state.
+- After cancellation, the run transitions to `cancelled` (a terminal status).
+
+## Mandatory Rules (MUST)
+- `--id` is required. Obtain the real run ID from a previous `+run-start` or `+run-chat` response — do not guess.
+- Write operation: keep the confirmation prompt unless `--yes` is explicitly requested.
+- Cancellation is irreversible. To re-run the same task, call `+run-start` again.
+
+## Command
+```bash
+ae-cli team +run-cancel --id <run_id>
+ae-cli team +run-cancel --id <run_id> --yes
+ae-cli team +run-cancel --dry-run --id <run_id>
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| `--id` | Yes | TeamRun ID |
+
+## Decision Rules
+- Before cancelling, verify the run status with `+run-result` to confirm it is not already in a terminal state (`completed`, `failed`, `cancelled`).
+- If the user wants to delete a team that has active runs, cancel all active runs first, then call `+delete`.
+
+## Next Steps on Failure
+- `404`: run ID not found — verify the run ID from the original start response.
+- Already terminal: the run has already completed, failed, or been cancelled — no action needed.
+
+## Recommended Chaining
+- `+run-result` (verify status) → `+run-cancel --yes`
+- `+run-cancel` (clear active runs) → `+delete` (team)

package/skills/ae-team/references/run-chat.md

@@ -0,0 +1,57 @@
+# team +run-chat (Chat with Team)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **TeamRun execution / write**
+
+## Use Cases
+- Send a message to a team in a multi-turn conversational session.
+- If the current session has a run in `waiting_user` state, the platform automatically resumes it.
+- Returns the session object (including `session.id`) and the new run object (including `run.id` and `status`).
+
+## Mandatory Rules (MUST)
+- `--team-id` is required. Obtain the real team ID via `+list` — do not guess.
+- `--input` is required. Pass the user's message verbatim.
+- To continue an existing session, pass `--session-id` with the `session.id` from the previous turn.
+- Write operation: keep the confirmation prompt unless `--yes` is explicitly requested.
+- After each turn, capture `session.id` and `run.id` for subsequent turns or replies.
+
+## Command
+```bash
+# First turn (starts a new session)
+ae-cli team +run-chat --team-id <team_id> --input "帮我分析最近的DAU趋势" --yes
+
+# Continue the same session
+ae-cli team +run-chat --team-id <team_id> --session-id <session_id> --input "继续上次的分析" --yes
+
+ae-cli team +run-chat --dry-run --team-id <team_id> --input "test"
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| `--team-id` | Yes | Team ID |
+| `--input` | Yes | User message |
+| `--session-id` | No | Existing session ID for multi-turn continuation |
+
+## Decision Rules
+- Use `+run-chat` when the task requires interactive back-and-forth (e.g. the team may ask clarifying questions).
+- Use `+run-start` instead for fully automated, single-shot tasks.
+- Always persist `session.id` from the response and pass it on subsequent turns with `--session-id`.
+- If a run enters `waiting_user` state, use `+run-reply` (not another `+run-chat`) to respond.
+
+## Waiting User Flow
+```
++run-chat → run.status = waiting_user
+→ +run-reply --id <run_id> --input "..." --yes
+→ poll +run-result until terminal
+→ optionally continue with +run-chat --session-id <session_id>
+```
+
+## Next Steps on Failure
+- `404` team not found: re-run `+list` to verify the team ID.
+- Session state confusion: if unsure of current session state, call `+run-result --id <run_id>` to check status.
+
+## Recommended Chaining
+- `+list` → `+run-chat` → `+run-reply` (if waiting_user) → `+run-result` → `+run-artifacts`
+- `+run-chat` (turn 1) → capture `session.id` → `+run-chat --session-id ...` (turn 2+)

package/skills/ae-team/references/run-reply.md

@@ -0,0 +1,41 @@
+# team +run-reply (Reply to Waiting TeamRun)
+
+> **Prerequisite:** Follow the Global AE CLI Rules in [`../SKILL.md`](../SKILL.md).
+
+Domain: **TeamRun execution / write**
+
+## Use Cases
+- Provide a user reply to a TeamRun that is paused in `waiting_user` state.
+- After reply, the run resumes execution automatically.
+
+## Mandatory Rules (MUST)
+- `--id` is required. The run **must be in `waiting_user` state** — sending a reply to a run in any other state will fail.
+- `--input` is required (1–50000 chars). Pass the user's reply verbatim.
+- Write operation: keep the confirmation prompt unless `--yes` is explicitly requested.
+- After replying, poll `+run-result` until the run reaches a terminal status.
+
+## Command
+```bash
+ae-cli team +run-reply --id <run_id> --input "请继续，使用方案A" --yes
+ae-cli team +run-reply --id <run_id> --input "好的，请重点分析周末下降原因" --yes
+ae-cli team +run-reply --dry-run --id <run_id> --input "test"
+```
+
+## Parameters
+| Parameter | Required | Description |
+|---|---|---|
+| `--id` | Yes | TeamRun ID (must be in `waiting_user` state) |
+| `--input` | Yes | User reply content (1–50000 chars) |
+
+## Decision Rules
+- Before calling `+run-reply`, always verify the run is in `waiting_user` state via `+run-result`.
+- If the run is in `running` state (not yet paused), wait and poll again — do not send a reply prematurely.
+- If the run is in a terminal state, it cannot be replied to — start a new run if needed.
+
+## Next Steps on Failure
+- `400` / wrong state: check the run status with `+run-result` first.
+- `404`: run ID not found — verify from the original start response.
+
+## Recommended Chaining
+- `+run-result` (confirm `waiting_user`) → `+run-reply` → poll `+run-result` → `+run-artifacts`
+- In chat mode: `+run-chat` → status `waiting_user` → `+run-reply` → `+run-chat` (next turn)