@clickzetta/cz-cli-darwin-x64 0.3.91 → 0.3.93

package/bin/skills/clickzetta-realtime-sync-pipeline/SKILL.md

@@ -1,323 +1,324 @@
 ---
 name: clickzetta-realtime-sync-pipeline
 description: |
-  创建和管理 ClickZetta Lakehouse 实时同步任务（单表），将外部数据源的数据实时同步到 Lakehouse。
-  支持 Kafka、MySQL、PostgreSQL 等数据源作为来源端，Lakehouse 作为目标端。
-  实时同步任务为持续运行的流式任务，无需配置调度策略，提交后即持续运行。
-  当用户说"Studio 实时同步"、"realtime sync"、"单表 CDC 同步"、"实时数据同步"、"Kafka 实时同步到 Lakehouse"、
-  "MySQL 单表实时同步"、"单表实时同步"、"实时数据迁移"时触发。
-  包含实时同步任务创建、数据源配置、字段映射（含 JSONPath 计算列）、部署运维等
-  ClickZetta Studio 特有逻辑。
-  Keywords: real-time sync, single table, Kafka source, MySQL source, streaming
+  Create and manage ClickZetta Lakehouse real-time sync tasks (single-table), syncing data from external sources
+  to Lakehouse in real time.
+  Supports Kafka, MySQL, PostgreSQL, and other data sources as the source, with Lakehouse as the target.
+  Real-time sync tasks are continuously running streaming tasks — no scheduling required; they start running upon submission.
+  Triggered when the user says "Studio real-time sync", "realtime sync", "single-table CDC sync",
+  "real-time data sync", "Kafka real-time sync to Lakehouse", "MySQL single-table real-time sync",
+  "single-table real-time sync", "real-time data migration".
+  Covers real-time sync task creation, data source configuration, column mapping (including JSONPath computed columns),
+  deployment, and operations — all ClickZetta Studio specific logic.
+  Keywords: real-time sync, single table, Kafka source, MySQL source, streaming, CDC
 ---
 
-# 实时同步（单表）Pipeline 工作流
+# Single-table Real-time Sync Pipeline Workflow
 
-## 向导：收集必要信息
+## Wizard: Collect Required Information
 
-开始创建实时同步任务前，优先使用交互式问答工具（如 `question`）收集以下信息并弹出选项菜单；若无此类工具，则用文字一次性列出所有问题：
+Before creating a real-time sync task, use an interactive question tool (e.g., `question`) to collect the following information via option menus. If no such tool is available, list all questions in text at once:
 
 ```
 question({
   questions: [
     {
-      question: "数据源类型？",
+      question: "Data source type?",
       options: [
-        { label: "Kafka", description: "Kafka Topic 实时接入，支持 JSON 消息解析" },
-        { label: "MySQL / Aurora MySQL", description: "单表 CDC 实时同步" },
-        { label: "PostgreSQL / Aurora PG", description: "单表 CDC 实时同步" },
-        { label: "SQL Server", description: "单表 CDC 实时同步" }
+        { label: "Kafka", description: "Kafka Topic real-time ingestion, supports JSON message parsing" },
+        { label: "MySQL / Aurora MySQL", description: "Single-table CDC real-time sync" },
+        { label: "PostgreSQL / Aurora PG", description: "Single-table CDC real-time sync" },
+        { label: "SQL Server", description: "Single-table CDC real-time sync" }
       ]
     },
     {
-      question: "同步粒度？",
+      question: "Sync granularity?",
       options: [
-        { label: "单表/单 Topic", description: "本 skill 支持，精细化配置" },
-        { label: "整库/多表", description: "建议改用 clickzetta-cdc-sync-pipeline" }
+        { label: "Single table/topic", description: "Supported by this skill, fine-grained configuration" },
+        { label: "Full database/multi-table", description: "Use clickzetta-cdc-sync-pipeline instead" }
       ]
     }
   ]
 })
 ```
 
-**如果用户已经提供了足够信息，直接进入工作流，不再弹出菜单。**
+**If the user has already provided sufficient information, proceed directly to the workflow without showing the menu.**
 
 ---
 
-## 适用场景
+## Applicable Scenarios
 
-- 将外部数据源的数据实时同步到 Lakehouse（低延迟、持续运行）
-- Kafka Topic → Lakehouse 表（支持 JSON 消息解析）
-- MySQL / PostgreSQL / SQL Server 等数据库 → Lakehouse 表（CDC 变更捕获）
-- 数据时效性要求高，需要秒级或分钟级延迟
-- 单张源表/Topic 到单张目标表的实时同步
-- 关键词：实时同步、CDC、流式同步、realtime sync、Kafka 实时同步
+- Sync data from external sources to Lakehouse in real time (low latency, continuously running)
+- Kafka Topic → Lakehouse table (supports JSON message parsing)
+- MySQL / PostgreSQL / SQL Server databases → Lakehouse table (CDC change capture)
+- High data freshness requirements — second-level or minute-level latency
+- Single source table/topic to single target table real-time sync
+- Keywords: real-time sync, CDC, streaming sync, Kafka real-time sync
 
-## 与其他同步方式的区别
+## Comparison with Other Sync Methods
 
-| 维度 | 实时同步（本 Skill） | 离线同步 | 多表实时同步 |
-|------|---------------------|---------|------------|
-| 任务类型 ID | `14`（REALTIME/CDC） | `10` / `291` | `281` |
-| 同步粒度 | 单表/单 Topic | 单表/多表 | 整库/多表 |
-| 运行模式 | 持续运行（流式） | 周期调度（批量） | 持续运行（流式） |
-| 调度策略 | 无需配置，提交即运行 | 需配置 Cron 表达式 | 无需配置，提交即运行 |
-| 延迟 | 秒级~分钟级 | 取决于调度周期 | 秒级~分钟级 |
-| 适用 Skill | `clickzetta-realtime-sync-pipeline` | `clickzetta-batch-sync-pipeline` | `clickzetta-cdc-sync-pipeline` |
+| Dimension | Real-time Sync (This Skill) | Batch Sync | Multi-table Real-time Sync |
+|-----------|---------------------------|------------|--------------------------|
+| Task Type ID | `14` (REALTIME/CDC) | `10` / `291` | `281` |
+| Sync Granularity | Single table/topic | Single/multi-table | Full database/multi-table |
+| Run Mode | Continuously running (streaming) | Scheduled (batch) | Continuously running (streaming) |
+| Scheduling | Not required, runs upon submission | Cron expression required | Not required, runs upon submission |
+| Latency | Seconds to minutes | Depends on schedule interval | Seconds to minutes |
+| Applicable Skill | `clickzetta-realtime-sync-pipeline` | `clickzetta-batch-sync-pipeline` | `clickzetta-cdc-sync-pipeline` |
 
-## 前置依赖
+## Prerequisites
 
-- ClickZetta Lakehouse Studio 账户，具备创建同步任务、目标表的权限
-- 源端数据源已在 Studio 中配置（Kafka / MySQL / PostgreSQL / SQL Server 等）
-- 目标端 Lakehouse 数据源可用
-- Sync VCluster 可用（实时同步任务 task_type=14 需要 Sync VCluster）
-- **执行环境（满足其一即可，优先使用 cz-cli）**：
-  - **cz-cli 路径**：已安装 cz-cli（`brew install cz-cli 或参考官方文档安装`），并完成 `cz-cli setup` 配置
-  - **MCP 路径**：clickzetta-studio-mcp 工具可用（`create_task`、`save_integration_task`、`publish_task`、`list_data_sources`、`LH_show_object_list` 等）
+- ClickZetta Lakehouse Studio account with permissions to create sync tasks and target tables
+- Source data source already configured in Studio (Kafka / MySQL / PostgreSQL / SQL Server, etc.)
+- Target Lakehouse data source available
+- Sync VCluster available (real-time sync task_type=14 requires a Sync VCluster)
+- **Execution environment (one of the following, cz-cli preferred)**:
+  - **cz-cli path**: cz-cli installed (`brew install cz-cli or refer to official docs`) and `cz-cli setup` completed
+  - **MCP path**: clickzetta-studio-mcp tools available (`create_task`, `save_integration_task`, `publish_task`, `list_data_sources`, `LH_show_object_list`, etc.)
 
-## 环境探测（执行前必读）
+## Environment Detection (Read Before Execution)
 
-在开始任何操作前，先判断当前执行环境：
+Before starting any operation, determine the current execution environment:
 
-**第一步：检测 cz-cli 是否可用**
+**Step 1: Check if cz-cli is available**
 ```bash
 cz-cli --version
 ```
-- 若命令存在 → **走 cz-cli 路径**（见本文档末尾"cz-cli 替代路径"章节）
-- 若命令不存在 → 继续检测 MCP
+- If command exists → **use cz-cli path** (see "cz-cli Alternative Path" section at the end of this document)
+- If command not found → continue to check MCP
 
-**第二步：检测 MCP 是否可用（仅在 cz-cli 不可用时）**
+**Step 2: Check if MCP is available (only when cz-cli is unavailable)**
 
-尝试调用 `list_data_sources` 工具查询数据源列表。
-- 若工具存在于 tool list → **走 MCP 路径**（本文档默认路径）
-- 若工具不存在 → 停止执行，提示用户：
-  > "当前环境既无 cz-cli 也无 MCP 工具，请安装其中之一后重试。
-  > cz-cli 安装：`brew install cz-cli 或参考官方文档安装`，然后运行 `cz-cli setup`
-  > MCP 安装：参考 clickzetta-studio-mcp 配置文档"
+Try calling the `list_data_sources` tool to query the data source list.
+- If tool exists in tool list → **use MCP path** (default path in this document)
+- If tool not found → stop execution and prompt the user:
+  > "Neither cz-cli nor MCP tools are available in the current environment. Please install one of them before retrying.
+  > cz-cli installation: `brew install cz-cli or refer to official docs`, then run `cz-cli setup`
+  > MCP installation: refer to clickzetta-studio-mcp configuration docs"
 
-## 工作流
+## Workflow
 
-### 步骤 1：确认 Sync VCluster 可用
+### Step 1: Confirm Sync VCluster Availability
 
 ```
-使用 LH_show_object_list（object_type='VCLUSTERS'）查看可用虚拟集群。
-筛选 vcluster_type 包含 SYNC 的集群。
-如无可用 Sync VCluster，需先创建后再继续。
+Use LH_show_object_list (object_type='VCLUSTERS') to view available virtual clusters.
+Filter for clusters where vcluster_type contains SYNC.
+If no Sync VCluster is available, create one before proceeding.
 ```
 
-### 步骤 2：查找可用数据源
+### Step 2: Find Available Data Sources
 
 ```
-使用 list_data_sources 查看已配置的数据源列表。
-按类型过滤：
+Use list_data_sources to view configured data source list.
+Filter by type:
 - Kafka: ds_type=2
 - MySQL: ds_type=5
 - PostgreSQL: ds_type=7
 - SQL Server: ds_type=8
-记录源端 datasource_name 和目标端 Lakehouse datasource_name。
+Record the source datasource_name and target Lakehouse datasource_name.
 ```
 
-### 步骤 3：探查源端数据结构（可选）
+### Step 3: Explore Source Data Structure (Optional)
 
 ```
-使用 list_namespaces 查看源端数据源的命名空间（数据库/Schema）。
-使用 list_metadata_objects 查看命名空间下的表/Topic 列表。
-使用 get_metadata_detail 查看具体表/Topic 的字段结构。
+Use list_namespaces to view the source data source's namespaces (databases/schemas).
+Use list_metadata_objects to view tables/topics under a namespace.
+Use get_metadata_detail to view the column structure of a specific table/topic.
 ```
 
-### 步骤 4：创建实时同步任务
+### Step 4: Create Real-time Sync Task
 
 ```
-使用 create_task 创建任务：
-- task_type: 14（实时同步）
-- task_name: 自定义任务名称（建议包含源和目标信息，如 "rt_sync_kafka_orders"）
-- data_folder_id: 目标文件夹 ID（可通过 list_folders 获取）
+Use create_task to create the task:
+- task_type: 14 (real-time sync)
+- task_name: custom task name (recommend including source and target info, e.g., "rt_sync_kafka_orders")
+- data_folder_id: target folder ID (obtainable via list_folders)
 
-记录返回的 task_id 和 studio_url。
+Record the returned task_id and studio_url.
 ```
 
-### 步骤 5：配置同步内容
+### Step 5: Configure Sync Content
 
 ```
-使用 save_integration_task 配置同步：
-- task_id: 步骤 4 返回的任务 ID
-- source_datasource_name: 源端数据源名称
-- source_schema: 源端数据库/Schema（Kafka 场景为 Topic 所在命名空间）
-- source_table: 源端表名或 Kafka Topic 名称
-- source_ds_type: 源端类型（2=Kafka, 5=MySQL, 7=PostgreSQL, 8=SQL Server）
-- sink_datasource_name: 目标 Lakehouse 数据源名称
-- sink_schema: 目标 Schema（默认 public）
-- sink_table: 目标表名（可选，默认与源表同名）
-- sink_ds_type: 1（Lakehouse）
+Use save_integration_task to configure sync:
+- task_id: task ID returned in Step 4
+- source_datasource_name: source data source name
+- source_schema: source database/schema (for Kafka, the namespace containing the topic)
+- source_table: source table name or Kafka topic name
+- source_ds_type: source type (2=Kafka, 5=MySQL, 7=PostgreSQL, 8=SQL Server)
+- sink_datasource_name: target Lakehouse data source name
+- sink_schema: target schema (default: public)
+- sink_table: target table name (optional, defaults to same as source table)
+- sink_ds_type: 1 (Lakehouse)
 ```
 
-> **说明**：系统会自动获取源端和目标端的元数据，生成字段映射。如目标表不存在，会自动创建。
+> **Note**: The system automatically retrieves source and target metadata to generate column mappings. If the target table does not exist, it will be auto-created.
 
-### 步骤 6：Kafka JSON 消息解析（Kafka 数据源专用）
+### Step 6: Kafka JSON Message Parsing (Kafka Source Only)
 
-如果 Kafka Topic 的消息格式为 JSON，可在 Studio UI 中通过新增计算列解析嵌套字段：
+If the Kafka topic message format is JSON, you can add computed columns in Studio UI to parse nested fields:
 
-- 使用 JSONPath 规则解析 value 字段中的内容
-- 示例：`$.id` 提取顶层 id 字段，`$.data.code` 提取嵌套字段
-- 默认使用 Kafka Topic 内置字段（key、value、timestamp、partition、offset）进行映射
-- 计算列配置需在 Studio UI 中完成（通过 studio_url 打开）
+- Use JSONPath rules to parse content from the value field
+- Examples: `$.id` extracts the top-level id field, `$.data.code` extracts a nested field
+- By default, Kafka topic built-in fields (key, value, timestamp, partition, offset) are used for mapping
+- Computed column configuration must be done in Studio UI (open via studio_url)
 
-### 步骤 7：提交部署
+### Step 7: Submit and Deploy
 
 ```
-实时同步任务不需要配置调度策略（无需调用 save_task_configuration）。
-直接使用 publish_task 提交任务：
-- task_id: 任务 ID
-- task_version: 当前版本号（通过 get_task_detail 获取）
+Real-time sync tasks do not require scheduling configuration (no need to call save_task_configuration).
+Use publish_task to submit the task directly:
+- task_id: task ID
+- task_version: current version number (obtainable via get_task_detail)
 
-提交后任务即开始持续运行。
+The task starts running continuously upon submission.
 ```
 
-> **重要**：实时同步任务不支持开发状态下的测试运行，提交即为正式部署。
+> **Important**: Real-time sync tasks do not support test runs in development state — submission is production deployment.
 
-### 步骤 8：运维监控
+### Step 8: Operations and Monitoring
 
 ```
-提交后在运维中心管理实时同步任务：
+After submission, manage real-time sync tasks in the Operations Center:
 
-查看任务状态：get_task_detail
-查看运行记录：list_task_run（注意实时任务为持续运行，不同于离线任务的周期实例）
+View task status: get_task_detail
+View run history: list_task_run (note: real-time tasks run continuously, unlike batch tasks with periodic instances)
 
-Studio UI 中可进行：
-- 启动/停止任务
-- 查看同步延迟和吞吐量
-- 查看错误日志
+In Studio UI you can:
+- Start/stop the task
+- View sync latency and throughput
+- View error logs
 ```
 
 ---
 
-## 支持的数据源
+## Supported Data Sources
 
-### 来源端
+### Source
 
-| 数据源 | ds_type | 说明 |
-|--------|---------|------|
-| Kafka | 2 | 支持 JSON 消息解析（JSONPath 计算列） |
-| MySQL | 5 | CDC 变更捕获 |
-| PostgreSQL | 7 | CDC 变更捕获 |
-| SQL Server | 8 | CDC 变更捕获 |
-| Aurora MySQL | 39 | CDC 变更捕获 |
-| Aurora PostgreSQL | 40 | CDC 变更捕获 |
-| PolarDB MySQL | 19 | CDC 变更捕获 |
-| PolarDB PostgreSQL | 48 | CDC 变更捕获 |
+| Data Source | ds_type | Description |
+|------------|---------|-------------|
+| Kafka | 2 | Supports JSON message parsing (JSONPath computed columns) |
+| MySQL | 5 | CDC change capture |
+| PostgreSQL | 7 | CDC change capture |
+| SQL Server | 8 | CDC change capture |
+| Aurora MySQL | 39 | CDC change capture |
+| Aurora PostgreSQL | 40 | CDC change capture |
+| PolarDB MySQL | 19 | CDC change capture |
+| PolarDB PostgreSQL | 48 | CDC change capture |
 
-### 目标端
+### Target
 
-| 数据源 | ds_type |
-|--------|---------|
+| Data Source | ds_type |
+|------------|---------|
 | Lakehouse | 1 |
 
-## 故障排除
+## Troubleshooting
 
-| 问题 | 排查方向 |
-|------|---------|
-| 任务创建失败 | 检查是否有可用的 Sync VCluster（`LH_show_object_list` 查看 VCLUSTERS，筛选 SYNC 类型） |
-| 源端连接失败 | 检查数据源配置中的连接信息、网络可达性、账号权限 |
-| Kafka 消费无数据 | 检查 Topic 名称是否正确、消费位点设置、Kafka 集群连通性 |
-| JSON 解析失败 | 检查 JSONPath 表达式是否正确、消息格式是否为合法 JSON |
-| 同步延迟增大 | 检查 Sync VCluster 资源是否充足、源端数据量是否突增 |
-| 目标表写入失败 | 检查目标表是否存在、字段类型是否兼容、权限是否充足 |
-| 任务异常停止 | 查看执行日志（`list_executions` + `get_execution_log`）排查具体错误 |
+| Issue | Investigation |
+|-------|--------------|
+| Task creation failed | Check if a Sync VCluster is available (`LH_show_object_list` to view VCLUSTERS, filter for SYNC type) |
+| Source connection failed | Check data source connection info, network reachability, account permissions |
+| No data consumed from Kafka | Check topic name, consumer offset settings, Kafka cluster connectivity |
+| JSON parsing failed | Check JSONPath expression correctness, verify message format is valid JSON |
+| Increasing sync latency | Check if Sync VCluster resources are sufficient, whether source data volume has spiked |
+| Target table write failed | Check if target table exists, column type compatibility, sufficient permissions |
+| Task stopped unexpectedly | Check execution logs (`list_executions` + `get_execution_log`) for specific errors |
 
-## 注意事项
+## Notes
 
-### 运行模式
+### Run Mode
 
-- 实时同步任务为持续运行的流式任务，提交后即开始运行，无需配置调度
-- 不支持开发状态下的测试运行
-- 停止后需手动重新启动
+- Real-time sync tasks are continuously running streaming tasks — they start running upon submission without scheduling
+- Test runs in development state are not supported
+- After stopping, manual restart is required
 
-### Sync VCluster 要求
+### Sync VCluster Requirements
 
-- 实时同步任务（task_type=14）必须使用 Sync VCluster
-- 创建任务前需确认有可用的 Sync VCluster
-- 可通过 `LH_show_object_list`（object_type='VCLUSTERS'）查看，筛选 vcluster_type 包含 SYNC 的集群
+- Real-time sync tasks (task_type=14) must use a Sync VCluster
+- Confirm a Sync VCluster is available before creating the task
+- Check via `LH_show_object_list` (object_type='VCLUSTERS'), filter for clusters where vcluster_type contains SYNC
 
-### Kafka 数据源特殊说明
+### Kafka Source Special Notes
 
-- 支持指定消费起始位点（earliest / latest / 指定 offset）
-- JSON 消息可通过 JSONPath 计算列解析嵌套字段
-- 默认字段包括：key、value、timestamp、partition、offset
+- Supports specifying consumer start offset (earliest / latest / specific offset)
+- JSON messages can be parsed via JSONPath computed columns for nested fields
+- Default fields include: key, value, timestamp, partition, offset
 
-### 与多表实时同步的选择
+### Choosing Between Single-table and Multi-table Real-time Sync
 
-- 单表实时同步（本 Skill）：适合单张表/Topic 的精细化同步
-- 多表实时同步（`clickzetta-cdc-sync-pipeline`）：适合整库 CDC、多表批量实时同步
-- 如需同步整个数据库的所有表，建议使用多表实时同步
+- Single-table real-time sync (this skill): suitable for fine-grained sync of a single table/topic
+- Multi-table real-time sync (`clickzetta-cdc-sync-pipeline`): suitable for full database CDC, multi-table batch real-time sync
+- If you need to sync all tables in a database, use multi-table real-time sync
 
 ---
 
-## cz-cli 替代路径
+## cz-cli Alternative Path
 
-> 仅在 cz-cli 可用且 MCP 不可用时使用本节。步骤编号与上方 MCP 路径对应。
-> 所有操作通过 `cz-cli agent run` 委托给内置 agent 完成，agent 内置完整的 Studio MCP 工具访问能力。
+> Use this section only when cz-cli is available and MCP is not. Step numbers correspond to the MCP path above.
+> All operations are delegated to the built-in agent via `cz-cli agent run`, which has full Studio MCP tool access.
 
-### 单表实时同步（cz-cli 版）
+### Single-table Real-time Sync (cz-cli Version)
 
-**快速路径**：直接创建任务，然后在 Studio UI 配置数据源
+**Quick path**: Create the task directly, then configure data source in Studio UI
 
 ```bash
-# 步骤 1：创建实时同步任务（task_type=14，即 REALTIME/CDC）
+# Step 1: Create real-time sync task (task_type=14, i.e., REALTIME/CDC)
 cz-cli task create "rt_sync_<table>" --type REALTIME --folder <folder_name>
-# 返回 task_id 和 studio_url，在 studio_url 中完成数据源配置和字段映射
+# Returns task_id and studio_url — complete data source configuration and column mapping at studio_url
 
-# 步骤 2：配置完成后，发布任务（实时同步无需配置调度，提交即持续运行）
+# Step 2: After configuration, deploy the task (real-time sync needs no scheduling, runs continuously upon submission)
 cz-cli task deploy "rt_sync_<table>" -y
 ```
 
-**完整 agent 路径**（需要 agent 完成数据源探查和配置）：
+**Full agent path** (when agent is needed for data source exploration and configuration):
 
 ```bash
-# 一键完成：让 agent 完成完整的实时同步任务创建
-cz-cli agent run "创建实时同步任务（task_type=14），将数据源 <source_ds_name> 中 <schema>.<table>（或 Kafka topic <topic>）实时同步到 Lakehouse public schema，使用 Sync VCluster，任务名 rt_sync_<table>，放在 <folder_name> 文件夹下" \
+# One-shot: let the agent complete the full real-time sync task creation
+cz-cli agent run "Create a real-time sync task (task_type=14), sync data source <source_ds_name> <schema>.<table> (or Kafka topic <topic>) to Lakehouse public schema in real time, use Sync VCluster, task name rt_sync_<table>, place in <folder_name> folder" \
   --format a2a --dangerously-skip-permissions
 ```
 
-对于需要精细控制的场景，可拆分步骤：
+For scenarios requiring fine-grained control, split into steps:
 
 ```bash
-# 步骤 1：确认 Sync VCluster 可用
-cz-cli agent run "列出所有可用的 VCluster，筛选 vcluster_type 包含 SYNC 的集群，确认有可用的 Sync VCluster" \
+# Step 1: Confirm Sync VCluster availability
+cz-cli agent run "List all available VClusters, filter for clusters where vcluster_type contains SYNC, confirm a Sync VCluster is available" \
   --format a2a --dangerously-skip-permissions
 
-# 步骤 2：查找数据源
-cz-cli agent run "列出所有已配置的数据源，按类型过滤（Kafka: ds_type=2, MySQL: ds_type=5, PostgreSQL: ds_type=7, SQL Server: ds_type=8），记录源端和目标端 Lakehouse 数据源名称" \
+# Step 2: Find data sources
+cz-cli agent run "List all configured data sources, filter by type (Kafka: ds_type=2, MySQL: ds_type=5, PostgreSQL: ds_type=7, SQL Server: ds_type=8), record source and target Lakehouse data source names" \
   --format a2a --dangerously-skip-permissions
 
-# 步骤 3（可选）：探查源端数据结构
-cz-cli agent run "查看数据源 <source_ds_name> 的命名空间列表，以及 <schema> 下的表/Topic 列表和字段结构" \
+# Step 3 (Optional): Explore source data structure
+cz-cli agent run "View namespace list for data source <source_ds_name>, and the table/topic list and column structure under <schema>" \
   --format a2a --dangerously-skip-permissions
 
-# 步骤 4-5：创建并配置实时同步任务
-cz-cli agent run "创建实时同步任务（task_type=14），源端 datasource=<source_ds_name>，schema=<schema>，table=<table>（source_ds_type=<type>），目标 Lakehouse public.<table>，任务名 rt_sync_<table>" \
+# Steps 4-5: Create and configure real-time sync task
+cz-cli agent run "Create a real-time sync task (task_type=14), source datasource=<source_ds_name>, schema=<schema>, table=<table> (source_ds_type=<type>), target Lakehouse public.<table>, task name rt_sync_<table>" \
   --format a2a --dangerously-skip-permissions
 
-# 步骤 7：提交部署
-cz-cli agent run "提交实时同步任务 rt_sync_<table>，使其开始持续运行" \
+# Step 7: Submit and deploy
+cz-cli agent run "Submit real-time sync task rt_sync_<table> to start continuous running" \
   --format a2a --dangerously-skip-permissions
 ```
 
-> **注意**：实时同步任务不需要配置调度策略，提交即开始持续运行。Kafka JSON 消息的计算列配置需在 Studio UI 中完成。
+> **Note**: Real-time sync tasks do not require scheduling configuration — they start running continuously upon submission. Kafka JSON message computed column configuration must be done in Studio UI.
 
 ---
 
-### 运维监控（cz-cli 版）
+### Operations and Monitoring (cz-cli Version)
 
 ```bash
-# 查看最近运行记录
+# View recent run history
 cz-cli runs list --task <task_name>
 
-# 查看运行详情
+# View run details
 cz-cli runs detail <run_id>
 
-# 查看执行日志
+# View execution logs
 cz-cli attempts log <run_id>
 
-# 下线任务（停止持续运行）
+# Undeploy task (stop continuous running)
 cz-cli task undeploy <task_name> -y
 ```
-

package/bin/skills/clickzetta-realtime-sync-pipeline/eval_cases.jsonl

@@ -1,5 +1,5 @@
-{"case_id":"001","type":"should_call","user_input":"怎么用 Studio 创建单表实时同步任务？","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["实时同步","task_type","28"]}
-{"case_id":"002","type":"should_call","user_input":"Kafka 单个 topic 实时同步到 Lakehouse 表怎么配置？","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["Kafka","实时同步"]}
-{"case_id":"003","type":"should_call","user_input":"单表实时同步和多表实时同步有什么区别？","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["单表","多表","28","281"]}
-{"case_id":"004","type":"should_call","user_input":"MySQL 单表 CDC 实时同步到 Lakehouse 怎么做？","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["MySQL","实时同步","CDC"]}
-{"case_id":"005","type":"should_call","user_input":"实时同步任务需要配置调度策略吗？","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["无需配置","持续运行"]}
+{"case_id":"001","type":"should_call","user_input":"How do I create a single-table real-time sync task in Studio?","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["real-time sync","task_type","14"]}
+{"case_id":"002","type":"should_call","user_input":"How do I configure a single Kafka topic to sync to a Lakehouse table in real time?","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["Kafka","real-time sync"]}
+{"case_id":"003","type":"should_call","user_input":"What is the difference between single-table real-time sync and multi-table real-time sync?","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["single","multi","14","281"]}
+{"case_id":"004","type":"should_call","user_input":"How do I do MySQL single-table CDC real-time sync to Lakehouse?","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["MySQL","real-time sync","CDC"]}
+{"case_id":"005","type":"should_call","user_input":"Does a real-time sync task need scheduling configuration?","expected_skill":"clickzetta-realtime-sync-pipeline","expected_output_contains":["no scheduling","continuously running"]}