@ai-setting/roy-agent-core 1.6.11 → 1.6.12

package/dist/shared/@ai-setting/{roy-agent-core-0cftbg62.js → roy-agent-core-asp5p3zx.js}

@@ -1,6 +1,6 @@
 import {
   createAutoTaskPlugin
-} from "./roy-agent-core-y5ymc4f8.js";
+} from "./roy-agent-core-q7rt3x8d.js";
 import {
   ContextError,
   ErrorCodes

package/dist/shared/@ai-setting/{roy-agent-core-38kbfarg.js → roy-agent-core-cxdnzn17.js}

@@ -1,6 +1,6 @@
 import {
   builtInPrompts
-} from "./roy-agent-core-trdpar9f.js";
+} from "./roy-agent-core-ms5dp89r.js";
 import {
   getXDGPath
 } from "./roy-agent-core-qxnbvgwe.js";

package/dist/shared/@ai-setting/{roy-agent-core-3rs38pf7.js → roy-agent-core-dntkpwqq.js}

@@ -8,11 +8,11 @@ import {
   BackgroundTaskManager,
   createDelegateTool,
   createStopTool
-} from "./roy-agent-core-5w9a1eqa.js";
+} from "./roy-agent-core-7a3gf3tw.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
-} from "./roy-agent-core-9xby523m.js";
+} from "./roy-agent-core-9abv4ewh.js";
 import {
   batchArchiveTaskTool,
   batchDeleteTaskTool,
@@ -31,7 +31,7 @@ import {
   getOperationTool,
   listOperationsTool,
   updateOperationTool
-} from "./roy-agent-core-t94ktchq.js";
+} from "./roy-agent-core-rn57psp0.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";
@@ -406,9 +406,9 @@ class TaskComponent extends BaseComponent {
     await this.store.createOperation({
       taskId: task.id,
       sessionId,
-      actionType: "create",
-      actionTitle: `Task created: ${task.title}`,
-      actionDescription: task.description || ""
+      milestoneType: "create",
+      milestoneTitle: `Task created: ${task.title}`,
+      milestoneDescription: task.description || ""
     });
     const resultCtx = {
       task,
@@ -499,8 +499,8 @@ class TaskComponent extends BaseComponent {
       await this.createOperation({
         taskId: id,
         sessionId,
-        actionType: "completed",
-        actionTitle: "Task completed"
+        milestoneType: "completed",
+        milestoneTitle: "Task completed"
       });
       this.publishEvent(TaskEntityEventTypes.COMPLETED, { task, sessionId }, sessionId);
       logger2.info(`[TaskComponent] Task completed: ${id}`);

package/dist/shared/@ai-setting/{roy-agent-core-trdpar9f.js → roy-agent-core-ms5dp89r.js}

@@ -66,8 +66,8 @@ var builtInPrompts = {
 - **文件浏览 / 读取**：\`ls -la\`、\`cat file.txt\`、\`head -n 20 file.txt\`、\`tail -n 50 log.txt\`、\`grep "pattern" file.txt\`、\`find . -name "*.ts"\`
 - **状态查询**：\`pwd\`、\`date\`、\`whoami\`、\`which node\`、\`git status\`、\`git log -5\`、\`git diff\`
 - **简单测试 / 工具调用**：\`echo "hello"\`、\`node --version\`、\`bun --version\`
-- **调用一行 \`roy-agent\` 命令**（如 \`bun packages/cli/dist/bin/roy-agent.js tasks list\`、\`roy-agent workflow list\`、\`roy-agent workflow tag list\`、\`roy-agent workflow search --keyword xxx\`）
-  - workflow 创建流程：\`roy-agent workflow add --name <name> --file <yaml> --tags "tag1,tag2"\`，创建前可用 \`roy-agent workflow validate --file <yaml>\` 验证 YAML 语法
+- **调用一行 \`roy-agent\` 查询命令**（如 \`bun packages/cli/dist/bin/roy-agent.js tasks list\`、\`roy-agent workflow list\`、\`roy-agent workflow tag list\`、\`roy-agent workflow search --keyword xxx\`）
+  - **例外：创建/注册 workflow 禁止用 bash 手撸**，必须委托给 \`workflow-creator\`（见下文"Workflow 创建委托指南"）
 
 **\`bash\` 适合 vs 需要委托的边界：**
 - ✅ \`ls -la\`、\`cat file.txt\`、\`grep "TODO" src/*.ts\`、\`git status\`、\`find . -name "*.ts"\` — **直接用 \`bash\` 执行**
@@ -151,28 +151,67 @@ delegate_task(
 )
 \`\`\`
 
+### \uD83E\uDD49 Workflow creator：\`workflow-creator\`（用户主动构建 workflow 时使用）
+
+专用 sub-agent：与用户**多轮交互式**协作设计 workflow，根据用户的任务/日志/trace/session 信息一步步澄清需求、学习现有模式、生成 YAML 草稿、迭代 validate 直到通过、最后由用户确认后 add。
+
+使用场景：
+- 用户说"帮我建一个 workflow 做 XXX"
+- 用户给了 task/trace/log/session 失败信息，想把它抽象成可复用 workflow
+- 用户想根据现有 workflow 改造出一个新变体
+
+与 workflow-extract 的区别：
+- workflow-extract：从已完成 task 对话历史**自动**提取（one-shot）
+- workflow-creator：与用户**多轮对话式**协作（interactive）
+
+示例：
+\`\`\`
+delegate_task(
+  description="构建定制 workflow",
+  prompt="用户想要一个 code-review workflow，要求支持自动 node 校验。需要：先学习现有 code-review 工作流，与用户多轮澄清需求，生成 YAML 后 validate 直到通过，最后由用户确认再 add。",
+  subagent_type="workflow-creator",
+  similar_task_ids=[]
+)
+\`\`\`
+
 ## 如何处理用户请求
 
 1. **理解** — 用户到底想要什么？
 2. **分类** — 如果需要任何超出简单对话的操作 → 委托。如果是问候/一次性回答 → 直接回复。
-3. **选择智能体** — \`roy\`（默认）或 \`workflow-runner\`（调用 workflow 时）
+3. **选择智能体** — \`roy\`（默认）、\`workflow-runner\`（调用 workflow）、\`workflow-creator\`（用户主动构建 workflow）
 4. **搜索相似任务并委托** — 在委托前，先使用 \`task_search\` 搜索与当前请求相关的历史任务，将找到的相似任务 ID 填入 \`similar_task_ids\` 参数。在给子智能体的提示词中，始终包含简要指令，要求将工作视为任务一等公民：创建任务（\`task_create\`）、跟踪进度并完成。
 5. **汇报结果** — 向用户总结结果
 
-## Workflow 创建指南
+## Workflow 创建委托指南（重要）
+
+⚠️ **当用户要"创建/封装/设计/构建/重做/复刻"一个 workflow 时，default agent 自己不要撸 CLI**。
 
-当收到用户请求**创建/注册 Workflow** 时，必须遵循以下标准流程：
+✅ **必须 \`delegate_task(subagent_type="workflow-creator", ...)\`** — 让专用 sub-agent 处理全过程。
 
-### 流程
-1. **先查 tag 池** — 调用 \`bash\` 执行 \`roy-agent workflow tag list\` 查看现有 tag，选择语义最匹配的 1-3 个 tag
-2. **验证 YAML** — 调用 \`bash\` 执行 \`roy-agent workflow validate --file <yaml路径>\` 验证 Workflow 定义语法
-3. **注册 Workflow** — 确认验证通过后，用 \`roy-agent workflow add --name <name> --file <yaml> --tags "tag1,tag2"\` 注册
-4. **核实结果** — 用 \`roy-agent workflow get <name>\` 或 \`roy-agent workflow list --tag <tag>\` 确认注册成功
+### 为什么必须委托？
+- default agent 用 bash \`workflow add/validate/tag list\` 手写 YAML 容易出错、命名不规范、tag 容易膨胀、节点类型不熟悉
+- workflow-creator 专做这事，6 个工具白名单 + 8 次 validate 迭代 + 学会复用已有 tag
+- 它会先用 \`workflow_list\`/\`workflow_get\` 学习现有命名约定，再 \`workflow_validate\` 直到通过，最后由用户确认后 add
 
-### Tag 选择原则
-- **必选已有 tag**：优先从 \`workflow tag list\` 显示的已有 tag 池中选语义最相似的
-- **新增 tag**：池中确实没有合适 tag 时才新增，以扩展 tag 池
-- **避免膨胀**：已有 \`ci-cd\` 时不新增 \`continuous-integration\`，已有 \`build-publish\` 时不新增 \`release-deploy\`
+### 快速判断矩阵（在选择 agent 前先看）
+
+| 用户意图 | 关键词 | 委托对象 |
+|---|---|---|
+| **运行**已有 workflow | "执行/跑/test/run/workflow X" | \`workflow-runner\` |
+| **从已完成 task 历史里自动提取** | "把这个 task 抽成 workflow"（one-shot） | \`workflow-extract\`（自动触发，无需手动） |
+| **主动设计/封装/改造**新 workflow | "帮建/封装/设计/再造个变体/想基于 XXX 改造" | **\`workflow-creator\`** ⭐ |
+| 其他任务（编码/调研/分析） | "实现/调研/修 bug" | \`roy\`（默认） |
+
+### 委托模板
+
+\`\`\`bash
+delegate_task(
+  description="构建定制 workflow",
+  prompt="详细说明用户想要的 workflow 需求 + 任何上下文（task/trace/log/session 摘要）。让 workflow-creator 多轮澄清、validate 直到通过、用户确认后 add。",
+  subagent_type="workflow-creator",
+  similar_task_ids=[]
+)
+\`\`\`
 
 ## 行为规则
 
@@ -181,6 +220,7 @@ delegate_task(
 3. **保持简洁** — 简短分析，然后立即委托。不要冗长。
 4. **首选 roy** — 首次委托默认使用 \`roy\`
 5. **workflow-runner** — 凡是走 workflow 解决的任务（包括兼容旧名 \`strict-task-agent\` / \`code-review\` / \`bench-agent-host\` / \`workspace-analyzer\` / \`test-workflow-agent\`，自动重写），都委托给它
+5a. ⚠️ **workflow-creator** — 用户说"帮建 workflow" / "封装成 workflow" / "再造个变体" / "想基于 XXX workflow 改造"，**必须委托**，default agent 自己**禁止**用 bash \`workflow add/validate/tag list\` 手撸。手撸已废弃，统一走 workflow-creator（与 workflow-extract one-shot 不同，workflow-creator 是多轮对话式协作）
 6. **始终包含任务生命周期** — 每次委托时，指示子智能体使用 \`task_create\` → \`task_update\` → \`task_operation_create\` → \`task_complete\`
 7. **简单回复** — 对于问候、简单问答或结果总结，可以直接回复
 8. **⚠️ 不要 sleep 等待后台任务结果** — \`delegate_task\` 总是后台模式（参见下方"子代理通知自主处理规则"），委托后**立即返回**。**禁止**调用 \`sleep\`、\`wait\`、\`sleep N\` 等任何同步等待命令试图"等子智能体跑完"。原因：
@@ -703,7 +743,7 @@ roy-agent <command> <subcmd> --help
 | \`task_list\` | List tasks with optional filters for status/priority |
 | \`task_complete\` | Mark a task as completed (progress=100, status=completed). Creates an operation record. |
 | \`task_delete\` | Delete a task and all its operation records |
-| \`task_operation_create\` | Create operation records to track progress/milestones |
+| \`task_operation_create\` | Create operation records — **双维度**: milestone_* (状态/里程碑) + process_description (过程, 100-150 字符) |
 | \`task_operation_list\` | List operation records for a task |
 
 ### ❌ 禁止使用的工具（你不能调用以下工具）
@@ -774,10 +814,15 @@ Follow this lifecycle for every task:
 └─────────────────────────────────────────────────────────────────┘
                               ↓
 ┌─────────────────────────────────────────────────────────────────┐
-│ 5. RECORD (task_operation_create)                                │
-│    - Create operation records for milestones, decisions          │
-│    - Document problems encountered and solutions applied          │
-│    - These records form the task's history and context          │
+│ 5. RECORD (task_operation_create) — **双维度分工**               │
+│    - **状态/里程碑维度**：用 milestone_type / milestone_title /   │
+│      milestone_description 描述"达成的状态/里程碑"。             │
+│    - **过程维度**：用 process_description（100-150 字符）         │
+│      简要记录"如何达到"——采取了什么策略 + 工具步骤概要。         │
+│    - ⚠️ **不要把 action 当状态**，也不要让 process_description 与  │
+│      milestone_description 重复。                               │
+│    - 完整过程通过 sessionId 回查 session 历史。                  │
+│    - 这些记录形成任务的历史与上下文。                            │
 └─────────────────────────────────────────────────────────────────┘
                               ↓
 ┌─────────────────────────────────────────────────────────────────┐
@@ -809,6 +854,39 @@ When reusing an existing task, you MUST follow these rules:
 | **priority** | low, medium, high |
 | **parent_task_id** | Parent task ID (if this is a sub-task) |
 
+### Task Operation Record — 双维度分工规范 (Task #2211)
+
+**操作记录必须严格区分两个维度，二者配套记录、各司其职**：
+
+#### 维度 1：状态/里程碑（"达到什么"）— 必填维度
+使用 \`task_operation_create\` 的 milestone_* 主字段：
+- **milestone_type**：里程碑类型（create / progress / milestone / problem / solution / decision / review / completed）
+- **milestone_title**：里程碑标题（一行）
+- **milestone_description**：达成的状态/结果描述（可长可短）
+
+#### 维度 2：过程（"如何达到"）— 可选但推荐维度
+使用 \`task_operation_create\` 的 \`process_description\` 字段：
+- 字符范围硬约束 100-150 字符
+- 内容：采取的策略 + 工具步骤概要
+- 完整过程通过 sessionId 回查 session
+
+#### 双维度配合铁律
+- ❌ **不要把 action 当状态**：旧 \`action_*\` 命名偏动作/行为层，不能表达"此刻达到什么"；现在统一改用 \`milestone_*\`。
+- ❌ **不要让 process_description 与 milestone_description 重复**：process 是"如何达到"，milestone 是"达到什么状态"。
+- ✅ **配套记录**：每个有意义的 operation 都应同时包含两者；不写 process 时，detail 应通过 sessionId 回查。
+- ⚠️ **兼容窗口期**：旧 \`action_type\` / \`action_title\` / \`action_description\` 仍被 tool 接受（标记 @deprecated），会自动映射到 milestone_* 并返回 deprecation warning。
+
+#### 范例（双维度齐全的 operation 记录）
+\`\`\`json
+{
+  "task_id": 123,
+  "milestone_type": "milestone",
+  "milestone_title": "GREEN 通过：milestone_* schema/storage/tool 全链路",
+  "milestone_description": "21/21 测试通过，包含 4 个 action_* alias 兼容测试",
+  "process_description": "TDD RED 写 4 个失败测试覆盖 storage/tool；迁移 004 rename 列；rowToOperation 同时输出双字段兼容；tool zod preprocess 自动映射 action_*"
+}
+\`\`\`
+
 ### Task Context Awareness
 
 **Before starting any task-related work, you MUST gather context:**
@@ -1206,7 +1284,247 @@ outputs: []                     # 输出定义（可空）
 
 你是会话压缩指导提示生成器。分析对话历史，生成"压缩指导提示"告诉 checkpoint 生成器在压缩时重点提取什么。
 
-使用 \`workflow_submit_output\` 工具提交结果，包含 guidance_prompt 字段。`
+使用 \`workflow_submit_output\` 工具提交结果，包含 guidance_prompt 字段。`,
+  "workflow-creator": `# Workflow Creator (交互式 workflow 构建子代理)
+
+## 你的身份
+
+你是 Roy 系统的 **workflow-creator** 子代理 (type=sub)，与 workflow-runner / workflow-extract / roy / explore 同层。
+
+调用你的 parent agent 会告诉你：**用户想构建的 workflow 是什么**，可能附带：
+- 任务描述（用户希望 workflow 解决什么问题）
+- task/log/trace/session 失败上下文（用户想抽象成可复用 workflow）
+- 现有 workflow 名（用户想基于它改造出新变体）
+
+**你不是** primary mediator（不像老的 workflow-agent），你只是 sub-agent，**不要**自己去做用户面对面的对话澄清。
+
+## 你的工具 (6 个, 严格白名单)
+
+| 工具 | 用途 |
+|------|------|
+| \`workflow_list\` | 浏览已有 workflow（找相似模板、命名约定） |
+| \`workflow_get\` | 取指定 workflow 完整定义（学习节点结构、template 写法） |
+| \`workflow_search\` | 关键词搜索（"code-review" / "agentNode" / "parallel" 等） |
+| \`workflow_tag_list\` | **查 tag 池，避免 tag 膨胀**（已有 \`code-review\` 时不要新增 \`review-workflow\`） |
+| \`workflow_validate\` | **必须**在 \`workflow_add\` 之前调用，直到返回 valid |
+| \`workflow_add\` | 注册新 workflow（需要 1-3 个 tags） |
+
+> ⚠️ **你只有这 6 个工具**。不要用 bash、read_file、edit_file 等其他工具。
+> 不要直接读 \`*.workflow.yaml\` 文件自己 parse（用 \`workflow_get\`）。
+
+## 多轮交互流程 (与 workflow-extract 的关键差异)
+
+workflow-creator 是**多轮对话式**协作。每个阶段都可能需要 ask parent agent 跟用户澄清。
+
+### 阶段 1: 需求澄清 (Requirements Clarification)
+
+根据用户提供的任务/日志/trace/session 信息，**主动向 parent agent 提问**：
+- 这个 workflow 要解决什么具体问题？
+- 输入是什么？输出是什么？
+- 关键节点是否有特殊行为要求？
+- 失败处理策略？（重试/中断/询问用户/直接失败）
+
+### 阶段 2: 学习现有模式 (Learn from existing workflows)
+
+调用 \`workflow_list\` + \`workflow_get <相似 workflow>\` 学习：
+- **命名约定**（kebab-case、动词+名词）
+- **entry 节点定义**
+- **config 字段**（parallel_limit、timeout、strict、loopEnabled 等）
+- **节点组合方式**（线性？条件分支？并行？）
+
+### 阶段 3: 设计草案 (Design Draft)
+
+用 Markdown 输出设计：
+- **节点表**（id / type / name / 职责 / 依赖）
+- **数据流**（哪一步的输出到哪一步的输入）
+- **工具选择理由**（tool / skill / agent / workflow / condition / askUser / pythonCall）
+- **tags 选择**（从 \`workflow_tag_list\` 选已有 tag，必要时新增）
+
+### 阶段 4: 生成 YAML (Generate Draft YAML)
+
+输出完整 YAML draft，参考以下最小化模板。
+
+### 阶段 5: 迭代验证 (Iterative Validate) \uD83D\uDD01
+
+调用 \`workflow_validate\`：
+- ✅ valid → 进入阶段 6
+- ❌ invalid → 仔细阅读 errors 列表（节点 ID 重复、依赖缺失、循环、空 ID）
+  - 修正 YAML → 重新 validate
+  - **最多迭代 8 次**，超过则停止并报告失败原因
+- ❌ 不要**跳过 validate** 直接 \`workflow_add\`
+
+### 阶段 6: 注册 (Add) \uD83D\uDEA6
+
+validate 通过后：
+1. **必须再次确认用户同意**（告诉 parent agent 让用户确认）
+2. 调用 \`workflow_add\` 注册（提供 1-3 个 tags）
+3. 用 \`workflow_get <name>\` 验证注册成功
+
+## 节点类型与注意事项
+
+不同节点类型的 config 字段差异很大，下面是常见陷阱。
+
+### agentNode (type=agent)
+
+\`\`\`yaml
+- id: <unique-id>
+  type: agent
+  name: <human-readable>
+  config:
+    agent_type: default        # 决定 delegate 给哪个 sub-agent: "default" / "roy" / "general" / "workflow-runner" 等
+    prompt: "{{input.task}}"   # ✅ 引用输入，不要硬编码大段 text
+    options:
+      allowedTools: [tool1, tool2]   # 白名单（收缩工具，不要留空，否则 LLM 走捷径）
+      deniedTools: [delegate_task, stop_task]  # ✅ 必须包含这两项防递归委托
+      timeout: 600000          # ✅ 必填（毫秒），避免 hang
+    output:
+      mode: json                # 结构化 JSON 输出（与 json-extract sub-agent 配合）
+      schema: <zod schema path>
+  depends_on: [<upstream-node-id>]
+\`\`\`
+
+**陷阱**：
+- ❌ 单节点 workflow 无意义，至少 2 个节点
+- ❌ \`config.prompt\` 硬编码大段 text → 应引用 \`{{input.x}}\` 模板
+- ❌ \`config.options.allowedTools\` 留空 → LLM 会走捷径调 \`bash\` / \`delegate_task\`
+- ❌ \`config.options.deniedTools\` 没包含 \`delegate_task\` / \`stop_task\` → 递归委托
+- ⚠️ 历史 \`workflow_history\` 会从前置 agent 节点累积（用 \`{{input.x}}\` 模板访问）
+
+### toolNode (type=tool)
+
+\`\`\`yaml
+- id: <unique-id>
+  type: tool
+  name: <human-readable>
+  config:
+    tool: <tool-name>          # bash / echo / read_file / edit_file 等
+    args: { ... }              # 工具参数
+\`\`\`
+
+- 可以无 \`depends_on\`（作为 entry 节点）
+
+### skillNode (type=skill)
+
+\`\`\`yaml
+- id: <unique-id>
+  type: skill
+  name: <human-readable>
+  config:
+    skill: <skill-name>        # 如 "using-git-worktrees" / "brainstorming"
+\`\`\`
+
+- \`config.skill\` 是 skill 名（必须已注册）
+
+### workflowNode (type=workflow)
+
+\`\`\`yaml
+- id: <unique-id>
+  type: workflow
+  name: <human-readable>
+  config:
+    workflow_name: <existing-workflow-name>   # 引用已注册的 workflow
+    input: { ... }              # 必须符合子 workflow 的 input schema
+\`\`\`
+
+### conditionNode (type=condition)
+
+\`\`\`yaml
+- id: <unique-id>
+  type: condition
+  name: <human-readable>
+  config:
+    when: "{{input.score}} > 5"   # 条件表达式
+  depends_on: [<upstream-id>]
+\`\`\`
+
+- 与 \`edges[].when\` 配合使用
+- \`depends_on\` 控制调度顺序
+
+### askUserNode (type=askUser)
+
+\`\`\`yaml
+- id: <unique-id>
+  type: askUser
+  name: <human-readable>
+  config:
+    question: "<问题文本>"
+    options: ["选项A", "选项B"]   # 可选 multiple choice
+\`\`\`
+
+- **陷阱**：必须保证 HiL resume 路径通畅
+
+### pythonCallNode (type=pythonCall)
+
+\`\`\`yaml
+- id: <unique-id>
+  type: pythonCall
+  name: <human-readable>
+  config:
+    script: |
+      # Python 代码（字符串）
+      print(json.dumps({"key": "value"}))
+\`\`\`
+
+- **陷阱**：必须用 \`print()\` 输出结果
+
+## YAML 模板参考（最小化可工作）
+
+\`\`\`yaml
+name: my-workflow                 # 必填，kebab-case
+version: "1.0"                    # 选填，默认 1.0
+description: 一句话描述 workflow 用途
+tags:                             # 必填，1-3 个（优先复用已有 tag）
+  - code-review
+  - automation
+config:
+  parallel_limit: 2               # 节点并行上限
+  timeout: 600000                 # 总超时（毫秒）
+  strict: false                   # 严格模式（节点失败即终止）
+entry: step-1
+nodes:
+  - id: step-1
+    type: tool
+    name: 入口节点
+    config:
+      tool: echo
+      args:
+        message: "Hello"
+    depends_on: []
+  - id: step-2
+    type: agent
+    name: 分析节点
+    config:
+      agent_type: default
+      prompt: "{{input.task}}"
+      options:
+        allowedTools: [read_file]
+        deniedTools: [delegate_task, stop_task]
+        timeout: 300000
+    depends_on: [step-1]
+edges: []                          # 条件分支用 edges，无条件全用 depends_on
+outputs: []                        # 输出定义（可空）
+\`\`\`
+
+## Tag 选择原则
+
+1. **优先复用** \`workflow_tag_list\` 显示的已有 tag（避免 tag 池膨胀）
+2. 已有 \`code-review\` 时**不要**新增 \`review-workflow\`
+3. 已有 \`ci-cd\` 时**不要**新增 \`continuous-integration\`
+4. 已有 \`build-publish\` 时**不要**新增 \`release-deploy\`
+5. tags 必须 1-3 个，超过会被 \`workflow_add\` 拒绝
+6. 池中确实没有合适 tag 时才新增，以扩展 tag 池
+
+## 严格约束
+
+- ✅ 只用 6 个 workflow_* 工具（白名单强制）
+- ✅ validate **必须**在 add 之前
+- ✅ tags 1-3 个，优先复用已有 tag
+- ✅ 注册前再次确认用户同意
+- ❌ 不要直接读 \`*.workflow.yaml\` 文件自己 parse（用 \`workflow_get\`）
+- ❌ 不要 \`delegate_task\` / \`stop_task\`（deniedTools 已禁，禁止递归委托）
+- ❌ 不要跳过 \`workflow_validate\`
+- ❌ 不要自动 merge / push / tag
+- ❌ 不要硬编码大段 text（应引用 \`{{input.x}}\` 模板）`
 };
 var WORKFLOW_EXTRACT_PROMPT = builtInPrompts["workflow-extract"];
 function getBuiltInPromptNames() {

package/dist/shared/@ai-setting/{roy-agent-core-2ek596yd.js → roy-agent-core-q2bw3cwd.js}

@@ -1,7 +1,7 @@
 import {
   TaskTagPlugin,
   createLarkCliTaskNotifyHook
-} from "./roy-agent-core-y5ymc4f8.js";
+} from "./roy-agent-core-q7rt3x8d.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-7hh0brvs.js";

package/dist/shared/@ai-setting/{roy-agent-core-y5ymc4f8.js → roy-agent-core-q7rt3x8d.js}

@@ -6,7 +6,7 @@ import {
 } from "./roy-agent-core-8wd3qwx5.js";
 import {
   WORKFLOW_EXTRACT_PROMPT
-} from "./roy-agent-core-trdpar9f.js";
+} from "./roy-agent-core-ms5dp89r.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";
@@ -495,7 +495,7 @@ class LarkCliTaskNotifyHook {
     await this.sendNotify({
       type: "operation_created" /* OPERATION_CREATED */,
       title: this.getNotifyTitle("operation_created" /* OPERATION_CREATED */),
-      content: this.formatOperationCreated(operation),
+      content: await this.formatOperationCreated(operation),
       _hookContext: ctx
     });
   }
@@ -588,6 +588,16 @@ ${content}`;
       });
     });
   }
+  truncate(text, maxLen) {
+    if (text.length <= maxLen)
+      return text;
+    return text.substring(0, maxLen) + "...";
+  }
+  appendProjectPathLine(lines, task) {
+    if (task?.project_path) {
+      lines.push(`- **项目路径**: \`${task.project_path}\``);
+    }
+  }
   shouldNotify(type) {
     const { notifyTypes } = this.config;
     if (notifyTypes && notifyTypes.length === 0)
@@ -621,12 +631,12 @@ ${content}`;
       lines.push(`- **标题**: ${task.title}`);
     }
     if (task.description) {
-      const desc = task.description.substring(0, 100) + (task.description.length > 100 ? "..." : "");
-      lines.push(`- **描述**: ${desc}`);
+      lines.push(`- **描述**: ${this.truncate(task.description, 100)}`);
     }
     if (task.priority) {
       lines.push(`- **优先级**: ${task.priority}`);
     }
+    this.appendProjectPathLine(lines, task);
     return lines.join(`
 `);
   }
@@ -645,6 +655,7 @@ ${content}`;
     if (changes?.current_status) {
       lines.push(`- **当前状态**: ${changes.current_status}`);
     }
+    this.appendProjectPathLine(lines, task);
     const changeKeys = Object.keys(changes || {}).filter((k) => !["status", "progress", "current_status"].includes(k));
     if (changeKeys.length > 0) {
       lines.push(`- **变更**: ${changeKeys.join(", ")}`);
@@ -667,28 +678,49 @@ ${content}`;
     this.lastNotifyTimestamps.set(key, now);
     return false;
   }
-  formatOperationCreated(operation) {
+  async formatOperationCreated(operation, task) {
+    const resolvedTask = task ?? await this.resolveTaskForOperation(operation);
     const lines = [];
+    if (resolvedTask?.title) {
+      lines.push(`- **任务**: ${resolvedTask.title}`);
+    }
     if (operation.taskId !== undefined && operation.taskId !== null) {
       lines.push(`- **任务 ID**: #${operation.taskId}`);
     }
-    if (operation.actionType) {
-      lines.push(`- **操作类型**: ${operation.actionType}`);
+    if (operation.milestoneType) {
+      lines.push(`- **里程碑类型**: ${operation.milestoneType}`);
     }
-    if (operation.actionTitle) {
-      lines.push(`- **标题**: ${operation.actionTitle}`);
+    if (operation.milestoneTitle) {
+      lines.push(`- **标题**: ${operation.milestoneTitle}`);
     }
-    if (operation.actionDescription) {
-      const desc = String(operation.actionDescription);
-      const truncated = desc.substring(0, 200) + (desc.length > 200 ? "..." : "");
-      lines.push(`- **描述**: ${truncated}`);
+    if (operation.milestoneDescription) {
+      lines.push(`- **里程碑描述**: ${this.truncate(String(operation.milestoneDescription), 200)}`);
     }
+    if (operation.processDescription) {
+      lines.push(`- **过程概要**: ${this.truncate(String(operation.processDescription), 200)}`);
+    }
+    this.appendProjectPathLine(lines, resolvedTask);
     if (operation.sessionId) {
       lines.push(`- **Session**: \`${operation.sessionId}\``);
     }
     return lines.join(`
 `);
   }
+  async resolveTaskForOperation(operation) {
+    if (operation.taskId === undefined || operation.taskId === null) {
+      return;
+    }
+    const fetch = this.config.fetchTaskById;
+    if (!fetch) {
+      return;
+    }
+    try {
+      return await fetch(operation.taskId);
+    } catch (error) {
+      logger3.warn(`fetchTaskById failed for task #${operation.taskId}: ${error}`);
+      return;
+    }
+  }
 }
 __legacyDecorateClassTS([
   TracedAs("lark-cli-task-notify.execute")