@comate/zulu 1.4.0-beta.4 → 1.4.0-beta.6

package/comate-engine/assets/skills/code-security/scripts/parse_scan_result.py

@@ -35,6 +35,7 @@ parsed_result.json 格式:
         "startLine": 12,
         "endLine": 12,
         "hash": "abc123...",
+        "importPath": "com.example:foo:1.2.3",
         "is_sensitive": false,
         "aiAnalysisStatus": 0,
         "aiAnalysisStatusText": "无需分析",
@@ -43,9 +44,10 @@ parsed_result.json 格式:
 
 aiAnalysisStatus 说明:
     0 - 无需分析
-    1 - 分析中
+    1 - 分析中（脚本会单独归类到 analyzing_vuls；后续工作流会通过本地兜底分析判定，
+        被判定为真实漏洞的会重新合入修复列表）
     2 - 真实漏洞
-    3 - 误报（不进入修复流程）
+    3 - 误报（始终不进入修复流程）
 """
 
 import argparse
@@ -83,10 +85,13 @@ def parse_scan_result(scan_result):
     # type: (dict) -> dict
     """解析扫描结果，返回结构化漏洞数据。
 
-    aiAnalysisStatus=3 (误报) 和 aiAnalysisStatus=1 (分析中) 的漏洞会被单独归类，不进入修复流程。
+    aiAnalysisStatus=3（误报）和 aiAnalysisStatus=1（分析中）的漏洞会被单独归类。
+    误报永远不进入修复流程；分析中漏洞需先经工作流的「本地兜底分析」复核，
+    被判定为真实漏洞的会被合并回修复列表。
     """
-    data = scan_result.get("data", {})
-    runs = data.get("sarif", {}).get("runs", []) or data.get("runs", [])
+    data = scan_result.get("data", {}) or {}
+    sarif = data.get("sarif") or {}
+    runs = sarif.get("runs") or data.get("runs") or []
 
     # 提取 bundleHash（由 scan_vulnerability.py 写入顶层）
     bundle_hash = scan_result.get("bundleHash", "")
@@ -122,6 +127,8 @@ def parse_scan_result(scan_result):
             level = level_config.get("level", "NONE") if level_config else "NONE"
             level_cn = LEVEL_MAP.get(level, "低危")
             vul_hash = result.get("properties", {}).get("hash", "")
+            # SCA 类漏洞会带有非空 importPath（依赖引入路径），用于后续判定是否走 SCA 本地修复
+            import_path = result.get("properties", {}).get("importPath", "") or ""
 
             # AI 分析状态
             ai_status = result.get("properties", {}).get("aiAnalysisStatus", 0)
@@ -172,6 +179,7 @@ def parse_scan_result(scan_result):
                 "startLine": start_line,
                 "endLine": end_line,
                 "hash": vul_hash,
+                "importPath": import_path,
                 "is_sensitive": is_sensitive,
                 "aiAnalysisStatus": ai_status,
                 "aiAnalysisStatusText": ai_status_text,
@@ -197,6 +205,23 @@ def parse_scan_result(scan_result):
     false_positive_vuls.sort(key=sort_key)
     analyzing_vuls.sort(key=sort_key)
 
+    # 去重：仅当 hash 相同（即扫描端认定为同一漏洞）时才合并；
+    # 不能仅按 (file, startLine, endLine, is_sensitive) 去重——多条来源不同的漏洞
+    # 可能共享同一个 sink 点（例如多个数据流汇入同一行），它们的 hash 各不相同，
+    # 必须各自保留以便后续修复完整覆盖。
+    def deduplicate(vuls):
+        seen = set()
+        result = []
+        for v in vuls:
+            key = v.get("hash") or (v["file"], v["startLine"], v["endLine"], v["is_sensitive"])
+            if key not in seen:
+                seen.add(key)
+                result.append(v)
+        return result
+
+    common_vuls = deduplicate(common_vuls)
+    sensitive_vuls = deduplicate(sensitive_vuls)
+
     return {
         "total": len(common_vuls) + len(sensitive_vuls) + len(false_positive_vuls) + len(analyzing_vuls),
         "common_count": len(common_vuls),
@@ -263,6 +288,11 @@ def format_vul_report(vuls, title="漏洞报告", project_dir=""):
             loc_link = _make_file_link(vul["file"], vul["startLine"], project_dir)
             lines.append("    - {}".format(loc_link))
 
+            # SCA 漏洞展示依赖引入路径（importPath），便于定位需要升级的依赖链
+            import_path = vul.get("importPath", "")
+            if import_path:
+                lines.append("      - **依赖引入路径**：`{}`".format(import_path))
+
             # 数据流折叠展示
             if vul["codeFlows"]:
                 lines.append("      <details><summary>数据流</summary>\n")
@@ -303,30 +333,32 @@ def format_full_report(parsed, project_dir=""):
     if false_positive_count > 0:
         summary_parts.append("**{}** 个误报（已由 AI 分析确认，无需修复）".format(false_positive_count))
 
+    if analyzing_count > 0:
+        summary_parts.append("**{}** 个漏洞正在 AI 分析中（暂未判定）".format(analyzing_count))
+
     if summary_parts:
         parts.append("扫描发现 {}。\n".format("，".join(summary_parts)))
     else:
-        if analyzing_count > 0:
-            parts.append("扫描完成，**{}** 个漏洞正在 AI 分析中，暂未发现已确认的漏洞。\n".format(analyzing_count))
-        else:
-            parts.append("扫描完成，未发现漏洞。\n")
+        parts.append("扫描完成，未发现漏洞。\n")
         return "\n".join(parts)
 
-    if analyzing_count > 0:
-        parts.append("另有 **{}** 个漏洞正在 AI 分析中，分析完成后可能会被判定为误报而排除，分析期间暂不处理。\n".format(analyzing_count))
-
-    # 只有误报没有真实漏洞的情况
-    if real_vul_count == 0 and false_positive_count > 0:
+    # 只有误报没有真实漏洞、且没有分析中的情况（才能断言“全部为误报”）
+    if real_vul_count == 0 and false_positive_count > 0 and analyzing_count == 0:
         parts.append("所有检测到的漏洞均已被 AI 分析确认为误报，无需进行修复。\n")
         if parsed.get("false_positive_vuls"):
             parts.append(format_vul_report(parsed["false_positive_vuls"], "误报漏洞列表（仅供参考）", project_dir))
         return "\n".join(parts)
 
+    # 仅剩分析中的情况（无真实漏洞、无误报）
+    if real_vul_count == 0 and false_positive_count == 0 and analyzing_count > 0:
+        parts.append("当前暂无已确认的漏洞，需等待 AI 分析完成后再评估。\n")
+        return "\n".join(parts)
+
     if parsed["common_vuls"]:
         parts.append(format_vul_report(parsed["common_vuls"], "普通漏洞报告", project_dir))
 
     if parsed["sensitive_vuls"]:
-        parts.append(format_vul_report(parsed["sensitive_vuls"], "硬编码漏洞报告", project_dir))
+        parts.append(format_sensitive_table(parsed["sensitive_vuls"], 10, project_dir))
 
     # 误报漏洞折叠展示
     if false_positive_count > 0:
@@ -346,6 +378,42 @@ def format_full_report(parsed, project_dir=""):
 
     return "\n".join(parts)
 
+def format_sensitive_table(vuls, collapse_threshold=5, project_dir=""):
+    # type: (list, int, str) -> str
+    """将硬编码漏洞列表格式化为 Markdown 表格。
+
+    当漏洞数量超过 collapse_threshold 时，使用 <details> 标签折叠展示，
+    点击可展开或收起；否则直接展示完整表格。
+
+    Args:
+        vuls: 漏洞列表
+        collapse_threshold: 超过该行数时触发折叠（默认 5）
+        project_dir: 项目根目录，用于生成可点击的绝对路径链接。若为空，则相对路径链接。
+
+    Returns:
+        Markdown 
+    """
+    if not vuls:
+        return "未发现硬编码漏洞。\n"
+
+    total = len(vuls)
+    header = "| 序号 | 漏洞名称 | 漏洞位置 | 漏洞等级 |\n| --- | --- | --- | --- |"
+    rows = []
+    for idx, vul in enumerate(vuls, 1):
+        loc_link = _make_file_link(vul["file"], vul["startLine"], project_dir)
+        rows.append("| {} | {} | {} | {} |".format(idx, vul["name"], loc_link, vul["level_cn"]))
+
+    if total <= collapse_threshold:
+        return "{}\n{}\n".format(header, "\n".join(rows))
+
+    # 前 collapse_threshold 条直接展示，超出部分用 <details> 折叠
+    visible = "{}\n{}".format(header, "\n".join(rows[:collapse_threshold]))
+    hidden_rows = rows[collapse_threshold:]
+    hidden_table = "{}\n{}".format(header, "\n".join(hidden_rows))
+    collapsed = "<details>\n<summary>展开查看剩余 {} 条漏洞</summary>\n\n{}\n\n</details>".format(
+        len(hidden_rows), hidden_table
+    )
+    return "{}\n\n{}\n".format(visible, collapsed)
 
 def main():
     """
@@ -374,6 +442,21 @@ def main():
     # 解析
     parsed = parse_scan_result(scan_result)
 
+    # 紧凑统计行（必须优先打印，保证即使后续长报告被截断，计数仍可被模型读取）
+    stats_line = (
+        "STATS: total={total} common={common} sensitive={sensitive}"
+        " false_positive={fp} analyzing={analyzing}"
+    ).format(
+        total=parsed["total"],
+        common=parsed["common_count"],
+        sensitive=parsed["sensitive_count"],
+        fp=parsed["false_positive_count"],
+        analyzing=parsed["analyzing_count"],
+    )
+    print(stats_line)
+    print(stats_line, file=sys.stderr)
+    print("")
+
     # 输出 Markdown 报告到标准输出
     report = format_full_report(parsed, args.project_dir)
     print(report)
@@ -389,4 +472,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

package/comate-engine/assets/skills/code-security/scripts/repair_vulnerability.py

@@ -30,8 +30,8 @@ import utils
 
 logger = logging.getLogger("repair")
 
-# 修复轮询最大次数（每次间隔 3 秒，约 10 分钟）
-MAX_REPAIR_POLLS = 200
+# 修复轮询最大次数（每次间隔 3 秒，约 5 分钟）
+MAX_REPAIR_POLLS = 100
 REPAIR_POLL_INTERVAL = 3
 MAX_UPLOAD_RETRIES = 10
 
@@ -40,8 +40,10 @@ def diff_file_content(file_path, new_content):
     # type: (str, str) -> str
     """比较原文件与修复后内容，使用 difflib 生成精确 diff，返回 diff 列表 JSON。
 
-    每个不连续的变更区域（hunk）生成独立的 {from_content, to_content} 对，
-    确保每个 from_content 都是原文件中的连续子串，可以被 str.replace 精确匹配。
+    每个不连续的变更区域（hunk）生成独立的 {from_content, to_content} 对。
+    携带 n=3 上下文行，确保：
+    1. from_content 包含足够上下文在文件中唯一，str.replace 不会误匹配
+    2. 纯插入 hunk（只有 + 行）也有上下文锚点，from_content 不会为空字符串
     """
     with open(file_path, "r", encoding="utf-8") as f:
         old_content = f.read()
@@ -49,8 +51,8 @@ def diff_file_content(file_path, new_content):
     old_lines = old_content.splitlines(keepends=True)
     new_lines = new_content.splitlines(keepends=True)
 
-    # 使用 unified_diff 找出所有差异区域，n=0 不提供上下文行
-    diff = list(difflib.unified_diff(old_lines, new_lines, n=0))
+    # n=3 携带上下文行，避免 from_content 为空或匹配不唯一
+    diff = list(difflib.unified_diff(old_lines, new_lines, n=3))
 
     diffs = []  # type: list
     current_from = []  # type: list
@@ -68,6 +70,16 @@ def diff_file_content(file_path, new_content):
     for line in diff:
         if line.startswith("---") or line.startswith("+++"):
             continue
+        elif line.startswith("\\"):
+            # 防御性处理：兼容 git/POSIX 风格 diff 的 "" 标记。
+            # Python 标准库 difflib 当前版本不会输出该标记，但 splitlines(keepends=True)
+            # 已经天然保留了原文件是否以换行结尾的状态——若出现该标记，说明上一行实际无尾随换行，
+            # 此处主动剥掉可能被误加入的 "\n"，确保 from_content 能在原文件中精确匹配。
+            if current_from and current_from[-1].endswith("\n"):
+                current_from[-1] = current_from[-1][:-1]
+            if current_to and current_to[-1].endswith("\n"):
+                current_to[-1] = current_to[-1][:-1]
+            continue
         elif line.startswith("@@"):
             # 新 hunk 开始，先保存上一组
             _flush()
@@ -75,6 +87,11 @@ def diff_file_content(file_path, new_content):
             current_from.append(line[1:])
         elif line.startswith("+"):
             current_to.append(line[1:])
+        else:
+            # 上下文行（空格前缀），同时加入 from 和 to 作为锚点
+            context_line = line[1:]
+            current_from.append(context_line)
+            current_to.append(context_line)
 
     # 保存最后一组
     _flush()
@@ -133,7 +150,7 @@ def repair_vulnerability(root_path, vulnerability_info, username, user_id, chat_
             if upload_retry_count > MAX_UPLOAD_RETRIES:
                 print("错误: 修复上传重试 {} 次后仍有缺失文件".format(MAX_UPLOAD_RETRIES), file=sys.stderr)
                 return {"status": -1, "message": "修复上传重试次数超限"}
-            print("上传缺失文件: {} 个 (重试 {}/{})".format(len(missing),
+            print("上传缺失文件: {} 个 (重试 {}/{})".format(len(missing), 
                                                    upload_retry_count, MAX_UPLOAD_RETRIES), file=sys.stderr)
             upload_files_for_repair(root_path, missing, username, user_id, chat_id)
             time.sleep(REPAIR_POLL_INTERVAL)
@@ -155,21 +172,39 @@ def repair_vulnerability(root_path, vulnerability_info, username, user_id, chat_
             return result
 
         poll_count += 1
-        print("修复中，等待结果... ({}/{})".format(poll_count, MAX_REPAIR_POLLS), file=sys.stderr)
+        progress = min(99, int(poll_count * 100 / MAX_REPAIR_POLLS))
+        print("修复中... {}%".format(progress), file=sys.stderr)
         time.sleep(REPAIR_POLL_INTERVAL)
 
-    print("错误: 修复超时，已轮询 {} 次仍未完成".format(MAX_REPAIR_POLLS), file=sys.stderr)
+    print("错误: 修复超时，已等待超过预期时间", file=sys.stderr)
     return {"status": -1, "message": "修复超时"}
 
 
+def is_sca_vuln(vul):
+    # type: (dict) -> bool
+    """判定是否为 SCA 类漏洞。
+
+    SCA 漏洞的修复方式是升级依赖版本，与代码改写无关，后端修复接口对其无能为力，
+    因此直接在本地参考修复手册（references/vul_repair-sca.md）处理，不发起后端请求。
+
+    判定规则：漏洞条目带有非空 `importPath` 字段即为 SCA 漏洞。
+    """
+    return bool(vul.get("importPath"))
+
+
 def build_vulnerability_info(parsed):
     # type: (dict) -> dict
-    """从 parsed_result.json 构建修复接口所需的 vulnerability-info。"""
+    """从 parsed_result.json 构建修复接口所需的 vulnerability-info。
+
+    SCA 类漏洞会被过滤掉，不进入后端修复请求，由 agent 在本地参考手册自行修复。
+    """
     bundle_hash = parsed.get("bundle_hash", "")
     common_vuls = parsed.get("common_vuls", [])
 
     file_map = {}  # type: dict
     for vul in common_vuls:
+        if is_sca_vuln(vul):
+            continue
         fname = vul.get("file", "")
         if not fname:
             continue
@@ -207,7 +242,7 @@ def main():
 
     user_id = utils.make_user_id(args.username)
 
-    logger.info("repair_vulnerability start: username=%s, chat_id=%s, root_path=%s", args.username,
+    logger.info("repair_vulnerability start: username=%s, chat_id=%s, root_path=%s", args.username, 
                 args.chat_id, args.root_path)
 
     root_path = os.path.realpath(args.root_path)
@@ -228,6 +263,23 @@ def main():
             print("无普通漏洞需要修复", file=sys.stderr)
             sys.exit(0)
         vulnerability_info = build_vulnerability_info(parsed)
+        # 全部为 SCA 漏洞时，后端 files 为空，直接走本地兜底，由 agent 参考
+        # references/vul_repair-sca.md 修复
+        if not vulnerability_info.get("files"):
+            sca_count = sum(1 for v in parsed.get("common_vuls", []) if is_sca_vuln(v))
+            result = {
+                "status": -3,
+                "message": "all_vulns_are_sca_use_local_fallback",
+                "fallback": True,
+                "sca_only": True,
+                "sca_count": sca_count,
+                "data": {"files": []},
+            }
+            output_file = os.path.join(output_dir, "repair_result.json")
+            with open(output_file, "w", encoding="utf-8") as f:
+                json.dump(result, f, ensure_ascii=False, indent=2)
+            print(output_file)
+            return
     else:
         try:
             vulnerability_info = json.loads(args.vulnerability_info)
@@ -235,7 +287,8 @@ def main():
             print("错误: 漏洞信息 JSON 解析失败: {}".format(e), file=sys.stderr)
             sys.exit(1)
 
-    result = repair_vulnerability(root_path, vulnerability_info, args.username, user_id, args.chat_id)
+    result = repair_vulnerability(
+        root_path, vulnerability_info, args.username, user_id, args.chat_id)
 
     output_file = os.path.join(output_dir, "repair_result.json")
     with open(output_file, "w", encoding="utf-8") as f:
@@ -244,4 +297,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

package/comate-engine/assets/skills/code-security/scripts/scan_vulnerability.py

@@ -244,16 +244,31 @@ def get_analyzing_count(result):
     return count
 
 
+def _has_valid_runs(result):
+    # type: (dict) -> bool
+    """检查结果中是否包含有效的 runs 数据（非空列表）。"""
+    data = result.get("data") or {}
+    sarif = data.get("sarif") or {}
+    runs = sarif.get("runs") or data.get("runs")
+    return bool(runs)
+
+
 def _poll_ai_analysis(scan_info, chat_id, username, user_id, ai_analysis_timeout):
     # type: (dict, str, str, str, int) -> dict
-    """轮询等待 AI 分析完成，返回最新结果。"""
+    """轮询等待 AI 分析完成，返回最新结果。
+
+    维护 last_valid_result：仅当响应 status != 1 且 runs 非空时更新。
+    超时或循环结束时返回 last_valid_result（而非最后一次可能为空的响应），
+    避免服务端中间态导致漏洞数据丢失。
+    """
     start_time = time.time()
     poll_interval = 10
+    last_valid_result = None  # type: dict | None
 
     while True:
         elapsed = time.time() - start_time
         if elapsed >= ai_analysis_timeout:
-            print("\nAI 分析等待超时（已等待 {} 分钟），将使用当前结果继续".format(
+            print("\nAI 分析等待超时（已等待 {} 分钟），将使用最近有效结果继续".format(
                 int(elapsed // 60)), file=sys.stderr)
             logger.warning("AI analysis timeout after %d seconds", int(elapsed))
             break
@@ -266,17 +281,29 @@ def _poll_ai_analysis(scan_info, chat_id, username, user_id, ai_analysis_timeout
             json_body=scan_info,
         )
 
+        # 记录有效结果：status != 1 且 runs 非空
+        if result.get("status") != 1 and _has_valid_runs(result):
+            last_valid_result = result
+
         analyzing_count = get_analyzing_count(result)
-        if analyzing_count == 0:
+        # status=1 表示服务端扫描/分析仍在进行中，此时 runs 通常为 null，
+        # 不能仅凭 analyzing_count == 0 就判定分析完成，需要 status != 1 才算真正完成
+        if result.get("status") != 1 and analyzing_count == 0:
             print("\nAI 分析完成！", file=sys.stderr)
             logger.info("AI analysis completed after %d seconds", int(time.time() - start_time))
             return result
 
-        elapsed_min = int(elapsed // 60)
-        elapsed_sec = int(elapsed % 60)
-        print("AI 分析中... 剩余 {} 个漏洞待分析（已等待 {}分{}秒）".format(
-            analyzing_count, elapsed_min, elapsed_sec), file=sys.stderr)
+        elapsed_progress = min(99, int(elapsed * 100 / ai_analysis_timeout)) if ai_analysis_timeout > 0 else 0
+        if result.get("status") == 1:
+            print("AI 分析中... {}%（服务端仍在处理）".format(elapsed_progress), file=sys.stderr)
+        else:
+            print("AI 分析中... {}%（剩余 {} 个漏洞待分析）".format(
+                elapsed_progress, analyzing_count), file=sys.stderr)
 
+    # 超时：优先返回最近一次有效结果，避免返回 runs 为空的中间态
+    if last_valid_result is not None:
+        return last_valid_result
+    # 兜底：如果从未拿到过有效结果，返回最后一次响应（调用方会做写入前校验）
     return result
 
 
@@ -325,11 +352,12 @@ def scan_vulnerability(root_path, chat_id="", username="", user_id="", wait_ai=T
         if result.get("status") != 1:
             break
         poll_count += 1
-        print("扫描中，等待结果... ({}/{})".format(poll_count, MAX_SCAN_POLLS), file=sys.stderr)
+        progress = min(99, int(poll_count * 100 / MAX_SCAN_POLLS))
+        print("扫描中... {}%".format(progress), file=sys.stderr)
         time.sleep(SCAN_POLL_INTERVAL)
 
     if result.get("status") == 1:
-        print("错误: 扫描超时，已轮询 {} 次仍未完成".format(MAX_SCAN_POLLS), file=sys.stderr)
+        print("错误: 扫描超时，已等待超过预期时间", file=sys.stderr)
         return {"status": -1, "message": "扫描超时"}, bundle_hash
 
     # 第二阶段：等待 AI 分析完成（可选）
@@ -417,10 +445,14 @@ def main():
             root_path, args.scan_result, chat_id=args.chat_id,
             username=args.username, user_id=user_id,
         )
-        # 原地更新 scan_result.json
+        # 原地更新 scan_result.json（仅当结果包含有效 runs 时才覆盖，防止超时中间态清空漏洞）
         output_file = os.path.realpath(args.scan_result)
-        with open(output_file, "w", encoding="utf-8") as f:
-            json.dump(result, f, ensure_ascii=False, indent=2)
+        if _has_valid_runs(result):
+            with open(output_file, "w", encoding="utf-8") as f:
+                json.dump(result, f, ensure_ascii=False, indent=2)
+        else:
+            print("警告: AI 分析结果中 runs 为空，保留原 scan_result.json 不覆盖", file=sys.stderr)
+            logger.warning("AI analysis result has empty runs, skip overwriting %s", output_file)
         print(output_file)
     else:
         # 正常扫描模式

package/comate-engine/assets/skills/{create-automation-tasks-comate → create-automation}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: create-automation-tasks
+name: create-automation
 description: |
   帮助用户创建、配置和管理 Comate Automation 自动化任务。当用户表达以下意图时触发：
   - 创建/设置/新建自动化任务、定时任务、cron 任务
@@ -7,6 +7,10 @@ description: |
   - "每天/每周/每月自动帮我做..."
   - 配置 webhook 触发任务
   不适用于普通的一次性任务请求，仅适用于需要周期性或事件驱动执行的自动化配置。
+metadata:
+    enableWhen:
+        - isComateIDE
+disable-model-invocation: true
 ---
 
 # create_automation_tasks Skill
@@ -54,8 +58,6 @@ execution:
 ---
 
 这里写任务指令（query）。必须自包含，包含所有必要上下文。
-
-完成后请将执行摘要写入 promise_done_summary.md。
 ````
 
 同一任务可配置多个 trigger（schedule 至多一个）：
@@ -122,7 +124,6 @@ AUTOMATION.md 的 body（query）会被一个独立的 Comate Agent Session 执
 **Agent 已知的上下文**：
 - 通过 Unattended Prompt 注入，Agent 知道自己是**无人值守自动化 Session**，不会等待用户确认
 - Agent 知道触发类型、时间、workspace、Git 状态等元信息
-- Agent 知道完成任务后必须写入 `promise_done_summary.md` 文件作为成功信号
 
 **Agent 不具备的能力**：
 - 没有本次对话的历史上下文（每次 run 是全新 Session）
@@ -177,7 +178,7 @@ Agent 已自动加载 `.comate/rules/` 下的所有规则，大多数情况下
 2. **按需读取相关模板**：只读取与用户任务相关的模板
 3. **提取策略融入 query 或直接引用**：
    - 如果模板中的策略需要针对用户项目做具体适配（如替换具体命令、路径），则从模板中提取要点写进 query
-   - 如果模板整体适用且无需适配，可以在 query 中引用模板的**绝对路径**让执行 Agent 自行读取，例如：`关于 Git 操作细节，参考 /Users/xxx/.comate/skills/create-automation-tasks/references/git_operations.md`（注意：必须使用绝对路径，不能用 `{skill_dir}` 变量，因为执行 Agent 无法解析该变量）
+   - 如果模板整体适用且无需适配，可以在 query 中引用模板的**绝对路径**让执行 Agent 自行读取，例如：`关于 Git 操作细节，参考 ~/.comate/skills/.system/create-automation/references/git_operations.md`（注意：必须使用绝对路径，不能用 `{skill_dir}` 变量，因为执行 Agent 无法解析该变量）
 
 ---
 
@@ -211,7 +212,7 @@ Agent 已自动加载 `.comate/rules/` 下的所有规则，大多数情况下
 
 在设计 query 之前，先判断任务复杂度，选择对应策略：
 
-- **一条命令能完成**（跑测试、lint、生成报告）→ 直接写命令 + 摘要要求，**不读取任何模板，不添加任何额外策略**。示例 query：`运行 npm test，将结果摘要写入 promise_done_summary.md。`
+- **一条命令能完成**（跑测试、lint、生成报告）→ 直接写命令，**不读取任何模板，不添加任何额外策略**。示例 query：`运行 npm test。`
 - **2-3 个步骤，逻辑清晰**（依赖更新 + 测试验证）→ 按需读取 1-2 个模板，提取适用要点
 - **多步骤端到端流程**（拉代码 → 修改 → 测试 → push）→ 读取多个模板组合设计，参考 `long_running_task.md` 设计分步方案
 
@@ -219,7 +220,6 @@ Agent 已自动加载 `.comate/rules/` 下的所有规则，大多数情况下
 - **环境配置写在 query 最前面**（如果需要的话）：Agent 在全新 Session 中启动，不会继承用户终端的环境。参考 `references/env_setup.md` 中的策略
 - **利用 Skills/Rules 引用减少 query 冗余**：不需要在 query 中重复写 Rules 中已有的规范，Agent 会自动加载。但可以提示 Agent 注意某个 Rule 或使用某个 Skill（见上方"引用 Skills 和 Rules"语法）
 - 所有必要信息写进 query（不能依赖对话历史或隐含假设）
-- 结尾加上：`完成后请将执行摘要写入 promise_done_summary.md。`
 
 **3. 展示 AUTOMATION.md 并确认**
 
@@ -237,7 +237,7 @@ python3 {skill_dir}/scripts/check_config.py ~/.comate/automations/{taskName}/AUT
 
 **5. 引导试跑**
 
-> "配置已就绪。建议先去 Automations Dashboard 找到该任务，点击**立即运行（Run Now）**跑一次，在 Session History 中查看结果是否符合预期。"
+> "配置已就绪。建议先去 Automations Dashboard 找到该任务，点击**立即运行（Run Now）**跑一次，在 Session History 中查看结果是否符合预期"
 
 ### 管理已有任务
 

package/comate-engine/assets/skills/{create-automation-tasks-comate → create-automation}/references/long_running_task.md

@@ -58,21 +58,6 @@ Automation 任务可能被重复执行（定时触发、补跑等），query 设
 
 关键原则：**区分"代码问题"和"环境问题"**。如果测试失败是因为环境配置（缺少依赖、端口占用、服务未启动），应尝试修复环境而非修改代码。至少尝试 3 种不同的修复方案后再判定为阻塞。
 
-### 执行摘要规范
-
-Automation Agent 的唯一交付物是 `promise_done_summary.md`。对于复杂任务，建议在 query 中明确摘要格式：
-
-```
-完成后将执行摘要写入 promise_done_summary.md，包含：
-- 执行了哪些步骤，每步的结果（成功/失败/跳过）
-- 如果有代码修改，列出修改的文件和改动性质
-- 关键的终端输出、测试结果数据（作为验证证据）
-- 遇到的问题和处理方式
-- 需要人工关注的事项（如：测试覆盖不足、某个修复需要人工确认等）
-```
-
-这份摘要是用户判断任务执行质量的唯一依据，应当清晰、诚实、包含充分证据。如果任务未完全成功，不要写这个文件——让 Session 以 stopped 状态结束，摘要中记录原因即可。
-
 ## query 片段示例
 
 **场景：全量安全扫描 + 自动修复**

package/comate-engine/assets/skills/{create-automation-tasks-comate → create-automation}/references/testing_strategy.md

@@ -11,7 +11,7 @@
 
 ## 核心原则
 
-**不能只靠代码静态推断来判断结果，必须依赖真实运行信息。** 日志、终端输出、测试结果都是重要证据。验证证据应写入 `promise_done_summary.md`。
+**不能只靠代码静态推断来判断结果，必须依赖真实运行信息。** 日志、终端输出、测试结果都是重要证据。
 
 ## 策略要点