@comate/zulu 1.4.0-beta.2 → 1.4.0-beta.3

package/comate-engine/assets/skills/create-automation-tasks-comate/references/git_operations.md

@@ -0,0 +1,88 @@
+# Git 操作策略模板
+
+当 Automation 任务涉及 Git 操作（拉代码、改代码后提交/push）时，将以下策略融入 query 设计。
+
+## 适用场景
+
+- 任务需要在执行前拉取最新代码
+- 任务会修改代码并需要提交
+- 任务需要在独立分支上操作以隔离风险
+
+## 策略要点
+
+### 拉取代码
+
+```
+执行前先拉取最新代码：
+git fetch origin {branch}
+git checkout {branch}
+git pull origin {branch}
+```
+
+- 如果 pull 因网络错误失败，最多重试 3 次，间隔指数退避（4s, 8s, 16s）
+- 明确指定分支名，不要用模糊的 `git pull`
+
+### 分支管理
+
+```
+创建独立工作分支：
+git checkout -b automation/{task-name}-{date} {base-branch}
+```
+
+- 自动化任务建议在独立分支上操作，不直接修改 main/master
+- 分支命名建议：`automation/{task-name}-{YYYYMMDD}`
+- 除非用户明确要求，不要切换到其他已有分支
+
+### 提交规范
+
+自动化任务默认使用 `git add -A` + 单次 commit：
+
+```
+git add -A
+git commit -m "{描述性提交信息}"
+```
+
+- 提交信息要描述做了什么，不要写 "automation update" 这种无信息量的消息
+- 不要 force push 或 amend commit
+- 如果用户在 query 中明确要求按逻辑拆分 commit，则使用 `git add {具体文件}` 分次提交
+
+### 提交前清理
+
+提交前必须移除所有临时调试代码（extra logs、hard-coded config modifications、临时 feature flag overrides 等）。只有自动化测试代码和测试基础设施可以保留。
+
+### Push 策略
+
+```
+推送到远程：
+git push origin {branch-name}
+```
+
+- 如果 push 因网络错误失败，最多重试 4 次，指数退避（4s, 8s, 16s, 32s）
+- 明确指定目标分支，不要 `git push` 裸推
+- 不要 force push，除非用户在 query 中明确要求
+
+## query 片段示例
+
+**场景：自动修复后推到独立分支**
+```
+执行前拉取最新代码：
+git fetch origin main && git checkout main && git pull origin main
+
+创建工作分支：
+git checkout -b automation/dep-fix-$(date +%Y%m%d) main
+
+... (执行修复操作) ...
+
+提交并推送：
+git add -A
+git commit -m "fix: 自动修复依赖安全漏洞"
+git push origin automation/dep-fix-$(date +%Y%m%d)
+```
+
+**场景：只拉代码生成报告，不修改代码**
+```
+确保代码是最新的：
+git fetch origin main && git checkout main && git pull origin main
+
+注意：本次任务只读不写，不需要创建分支、commit 或 push。
+```

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

@@ -0,0 +1,96 @@
+# 长时间/复杂任务策略模板
+
+当 Automation 任务预期执行时间较长或步骤较多时，将以下策略融入 query 设计。
+
+## 适用场景
+
+- 全量代码扫描、安全审计
+- 大型项目的完整测试套件
+- 数据迁移、批量处理
+- 多步骤的端到端流程（拉代码 → 修改 → 测试 → 提交）
+
+## 策略要点
+
+### 超时管理
+
+- 在 frontmatter 中设置充足的 `timeoutSeconds`
+- 简单任务：1800（30分钟）
+- 中等任务：3600（1小时，默认）
+- 复杂任务：7200（2小时，上限）
+
+### 分步执行与中间检查点
+
+对于多步骤任务，在 query 中明确分步，让 Agent 逐步推进：
+
+```
+按以下步骤执行，每步完成后记录结果：
+
+步骤 1：...
+步骤 2：...
+步骤 3：...
+
+如果任一步骤失败，记录失败原因后继续执行后续步骤（除非后续步骤依赖前序结果）。
+```
+
+### 幂等性
+
+Automation 任务可能被重复执行（定时触发、补跑等），query 设计应考虑幂等：
+
+```
+注意幂等性：
+- 创建分支前先检查是否已存在同名分支：
+  git branch -D automation/dep-fix-20260420 2>/dev/null || true
+  git checkout -b automation/dep-fix-20260420 main
+- 生成报告时覆盖旧报告，不要追加产生重复内容
+- 修改代码前先检查是否已经做过相同修改
+```
+
+### 错误处理与自主排障
+
+```
+遇到错误时的处理策略：
+- 命令失败：分析错误输出，尝试修复后重试，最多重试 3 次
+- 网络错误：等待后重试，指数退避
+- 权限错误：记录问题，不要尝试 sudo 或修改系统权限
+- 环境问题（非本次修改导致的）：至少尝试 3 种不同的修复方案再放弃
+- 不可恢复的错误：记录详细错误信息，跳过该步骤继续执行
+```
+
+关键原则：**区分"代码问题"和"环境问题"**。如果测试失败是因为环境配置（缺少依赖、端口占用、服务未启动），应尝试修复环境而非修改代码。至少尝试 3 种不同的修复方案后再判定为阻塞。
+
+### 执行摘要规范
+
+Automation Agent 的唯一交付物是 `promise_done_summary.md`。对于复杂任务，建议在 query 中明确摘要格式：
+
+```
+完成后将执行摘要写入 promise_done_summary.md，包含：
+- 执行了哪些步骤，每步的结果（成功/失败/跳过）
+- 如果有代码修改，列出修改的文件和改动性质
+- 关键的终端输出、测试结果数据（作为验证证据）
+- 遇到的问题和处理方式
+- 需要人工关注的事项（如：测试覆盖不足、某个修复需要人工确认等）
+```
+
+这份摘要是用户判断任务执行质量的唯一依据，应当清晰、诚实、包含充分证据。如果任务未完全成功，不要写这个文件——让 Session 以 stopped 状态结束，摘要中记录原因即可。
+
+## query 片段示例
+
+**场景：全量安全扫描 + 自动修复**
+```
+执行全量安全扫描和自动修复（预计耗时较长）：
+
+步骤 1 - 依赖扫描：
+运行 npm audit，记录发现的漏洞列表
+
+步骤 2 - 自动修复：
+对可自动修复的漏洞执行 npm audit fix
+对不能自动修复的，记录在摘要中
+
+步骤 3 - 验证：
+运行 npm test 确保修复未引入回归
+
+步骤 4 - 提交（仅当步骤 3 通过时）：
+git add -A && git commit -m "fix: 自动修复安全漏洞" && git push origin {branch}
+
+注意：如果步骤 2 或 3 失败，仍然完成摘要，记录哪些修复了、哪些没修复。
+```

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

@@ -0,0 +1,94 @@
+# 测试与验证策略模板
+
+当 Automation 任务涉及代码修改、功能验证、质量检查时，将以下策略融入 query 设计。
+
+## 适用场景
+
+- 修改代码后需要验证正确性
+- 定期运行测试套件并报告结果
+- Bug 修复需要验证修复有效
+- 功能变更需要端到端验证
+
+## 核心原则
+
+**不能只靠代码静态推断来判断结果，必须依赖真实运行信息。** 日志、终端输出、测试结果都是重要证据。验证证据应写入 `promise_done_summary.md`。
+
+## 策略要点
+
+### 定义成功标准（写入 query）
+
+根据任务类型，在 query 中明确告诉 Agent 什么算"完成"：
+
+- **Bug 修复**：先复现 bug（运行触发 bug 的命令/测试），再验证修复后同样步骤不再出现 bug
+- **依赖更新**：更新后所有现有测试仍然通过
+- **新功能**：自动化测试通过 + 关键 API/命令的终端输出证明功能正常工作
+- **性能优化**：修改前后的性能数据对比（通过日志或 benchmark 命令输出）
+
+### 识别低信号测试结果
+
+以下结果**不足以**证明改动是正确的，不应视为验证通过：
+
+- "代码能编译"（除非改动只影响编译系统）
+- "应用能启动"（除非改动只影响启动流程）
+- "相关功能正常，但新代码实际上没有被执行到"
+
+在 query 中指导 Agent：如果只能拿到低信号结果，不要声称验证通过，应如实记录在摘要中。
+
+### 测试类型选择
+
+| 任务类型 | 建议测试方式 |
+|---------|------------|
+| 后端逻辑修改 | 自动化测试（unit/integration） |
+| API 变更 | curl/httpie 验证 + 自动化测试 |
+| 前端代码修改 | 构建验证 + lint + 自动化测试 |
+| 依赖/配置变更 | 全量测试套件 |
+| 纯报告生成 | 无需测试 |
+
+### 测试失败处理
+
+在 query 中指导 Agent 如何处理测试失败：
+
+```
+如果测试失败：
+1. 分析失败原因，区分是本次修改导致的还是已有问题
+2. 如果是本次修改导致的，尝试修复并重新测试
+3. 如果是已有问题，记录在摘要中但不阻塞任务完成
+4. 不要把失败的测试标记为通过
+```
+
+### 项目无测试套件
+
+如果项目没有自动化测试：
+- 使用构建成功（`npm run build`、`go build`、`cargo build`）作为基本验证
+- 使用 lint 通过（`npm run lint`、`flake8`）作为代码质量验证
+- 在摘要中标注"项目缺乏自动化测试覆盖，仅通过构建/lint 验证"
+
+## query 片段示例
+
+**场景：修改代码后验证**
+```
+修改完成后，执行以下验证：
+1. 运行 lint 检查：npm run lint
+2. 运行单元测试：npm test
+3. 如果测试失败，分析原因并尝试修复
+4. 在摘要中列出所有测试结果
+```
+
+**场景：定期测试报告**
+```
+运行完整测试套件：pytest --tb=short -q
+
+无论测试是否全部通过，都要生成报告，包含：
+- 通过/失败/跳过的测试数量
+- 失败测试的具体错误信息
+- 与上次运行的对比（如果可获取）
+```
+
+**场景：端到端验证**
+```
+验证策略：
+1. 运行 npm run build 确保构建成功
+2. 运行 npm test 确保自动化测试通过
+3. 如果涉及 API 变更，用 curl 验证关键端点响应正确
+4. 如果构建或测试失败，调查根因并尝试修复，最多重试 3 次
+```

package/comate-engine/assets/skills/create-automation-tasks-comate/scripts/check_config.py

@@ -0,0 +1,397 @@
+#!/usr/bin/env python3
+"""
+Comate Automation AUTOMATION.md validator.
+Parses YAML frontmatter from AUTOMATION.md, validates all fields (camelCase).
+Usage: python3 check_config.py <path/to/AUTOMATION.md>
+Exit 0 = valid, Exit 1 = invalid.
+"""
+
+import sys
+import re
+from pathlib import Path
+from typing import Optional
+
+try:
+    import yaml
+except ImportError:
+    print("ERROR: pyyaml not installed. Run: pip install pyyaml")
+    sys.exit(1)
+
+# ── IANA timezone set ─────────────────────────────────────────────────────────
+try:
+    from zoneinfo import available_timezones
+    VALID_TIMEZONES = available_timezones()
+except ImportError:
+    VALID_TIMEZONES = {
+        "UTC", "Asia/Shanghai", "Asia/Tokyo", "Asia/Seoul", "Asia/Singapore",
+        "Asia/Hong_Kong", "Asia/Kolkata", "Asia/Dubai", "Europe/London",
+        "Europe/Paris", "Europe/Berlin", "Europe/Moscow", "America/New_York",
+        "America/Chicago", "America/Denver", "America/Los_Angeles",
+        "America/Sao_Paulo", "Africa/Cairo", "Pacific/Auckland",
+    }
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+_errors = []
+_warnings = []
+
+def err(msg: str) -> None:
+    """Append an error message to the global error list."""
+    _errors.append(f"  [ERROR] {msg}")
+
+def warn(msg: str) -> None:
+    """Append a warning message to the global warning list."""
+    _warnings.append(f"  [WARN]  {msg}")
+
+def is_valid_cron(expr: str) -> bool:
+    """Return True if expr is a valid 5-field cron expression."""
+    fields = expr.strip().split()
+    if len(fields) != 5:
+        return False
+    field_pat = r"^(\*|(\*/\d+)|(\d+(-\d+)?(,\d+(-\d+)?)*))$"
+    return all(re.match(field_pat, f) for f in fields)
+
+def is_valid_iso8601(s: str) -> bool:
+    """Return True if s matches ISO 8601 datetime with timezone offset."""
+    return bool(re.match(
+        r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|[+-]\d{2}:\d{2})$", str(s)
+    ))
+
+def is_valid_hex8(s: str) -> bool:
+    """Return True if s is an 8-character lowercase hexadecimal string."""
+    return bool(re.match(r"^[0-9a-f]{8}$", str(s)))
+
+def is_string(v) -> bool:
+    """Return True if v is a non-empty string after stripping whitespace."""
+    return isinstance(v, str) and len(v.strip()) > 0
+
+# ── snake_case detection ──────────────────────────────────────────────────────
+
+KNOWN_SNAKE_TO_CAMEL = {
+    "trigger_at": "triggerAt",
+    "missed_policy": "missedPolicy",
+    "timeout_seconds": "timeoutSeconds",
+    "endpoint_id": "endpointId",
+    "body_contains": "bodyContains",
+    "required_headers": "requiredHeaders",
+    "channel_id": "channelId",
+}
+
+def check_snake_case_keys(d, path=""):
+    """Recursively warn about snake_case keys that should be camelCase."""
+    if not isinstance(d, dict):
+        return
+    for k, v in d.items():
+        full = f"{path}.{k}" if path else k
+        if k in KNOWN_SNAKE_TO_CAMEL:
+            warn(f"'{full}' uses snake_case. Use camelCase: '{KNOWN_SNAKE_TO_CAMEL[k]}'")
+        check_snake_case_keys(v, full)
+        if isinstance(v, list):
+            for i, item in enumerate(v):
+                check_snake_case_keys(item, f"{full}[{i}]")
+
+# ── frontmatter parser ────────────────────────────────────────────────────────
+
+def parse_frontmatter(text: str):
+    """Parse YAML frontmatter from AUTOMATION.md. Returns (cfg_dict, body_str) or (None, error)."""
+    text = text.lstrip("\ufeff")  # strip BOM
+    if not text.startswith("---"):
+        return None, "File must start with '---' (YAML frontmatter)"
+    rest = text[3:]
+    end = rest.find("\n---")
+    if end == -1:
+        return None, "No closing '---' found for YAML frontmatter"
+    yaml_str = rest[:end]
+    body = rest[end + 4:].strip()  # after closing ---
+    try:
+        cfg = yaml.safe_load(yaml_str)
+    except yaml.YAMLError as e:
+        return None, f"YAML parse error in frontmatter: {e}"
+    if not isinstance(cfg, dict):
+        return None, "Frontmatter must be a YAML mapping (dict)"
+    return (cfg, body), None
+
+# ── section validators (camelCase) ────────────────────────────────────────────
+
+def validate_top_level(cfg: dict) -> None:
+    """Validate top-level required fields: name, enabled, description, execution."""
+    for field in ("name", "enabled"):
+        if field not in cfg:
+            err(f"Missing required field: '{field}'")
+
+    if "name" in cfg:
+        if not re.match(r"^[a-z0-9]+(-[a-z0-9]+)*$", str(cfg["name"])):
+            err(f"'name' must be kebab-case (e.g. 'daily-dep-check'), got: '{cfg['name']}'")
+
+    if "enabled" in cfg and not isinstance(cfg["enabled"], bool):
+        err(f"'enabled' must be boolean (true/false), got: {cfg['enabled']!r}")
+
+    if "description" in cfg and not is_string(cfg["description"]):
+        err(f"'description' must be a non-empty string, got: {cfg['description']!r}")
+
+    if "execution" not in cfg:
+        err("Missing required block: 'execution'")
+
+
+def validate_execution(execution: dict) -> None:
+    """Validate the 'execution' block: workspace, model, timeoutSeconds."""
+    if not isinstance(execution, dict):
+        err("'execution' must be a mapping")
+        return
+
+    if "workspace" not in execution:
+        err("Missing required field: 'execution.workspace'")
+    else:
+        ws = str(execution["workspace"])
+        if not ws.startswith("/") and not ws.startswith("~"):
+            err(f"'execution.workspace' must be an absolute path, got: '{ws}'")
+
+    if "model" in execution:
+        if not is_string(execution["model"]):
+            err(f"'execution.model' must be a non-empty string, got: {execution['model']!r}")
+
+    if "timeoutSeconds" in execution:
+        t = execution["timeoutSeconds"]
+        if not isinstance(t, int) or t <= 0:
+            err(f"'execution.timeoutSeconds' must be a positive integer, got: {t!r}")
+        elif t > 7200:
+            warn(f"'execution.timeoutSeconds' is {t}s, exceeds recommended max of 7200s")
+
+
+def validate_schedule_block(schedule: dict, prefix: str = "schedule") -> None:
+    """Validate a schedule trigger block: cron, triggerAt, timezone, missedPolicy."""
+    if not isinstance(schedule, dict):
+        err(f"'{prefix}' must be a mapping")
+        return
+
+    for field in ("cron",):
+        if field not in schedule:
+            err(f"Missing required field: '{prefix}.{field}'")
+
+    # triggerAt is optional (Phase 2), validate format if present
+    if "triggerAt" in schedule:
+        if not is_valid_iso8601(str(schedule["triggerAt"])):
+            err(
+                f"'{prefix}.triggerAt' is not valid ISO 8601"
+                f" (e.g. 2026-04-14T09:00:00+08:00), got: '{schedule['triggerAt']}'"
+            )
+
+    if "cron" in schedule:
+        cron = str(schedule["cron"])
+        if not is_valid_cron(cron):
+            err(f"'{prefix}.cron' is not a valid 5-field cron expression (min hour day month weekday), got: '{cron}'")
+
+    if "timezone" in schedule:
+        tz = str(schedule["timezone"])
+        if tz not in VALID_TIMEZONES:
+            err(f"'{prefix}.timezone' is not a recognized IANA timezone, got: '{tz}'")
+
+    if "missedPolicy" in schedule:
+        policy = schedule["missedPolicy"]
+        if policy not in ("catchup_once", "skip_missed"):
+            err(f"'{prefix}.missedPolicy' must be 'catchup_once' or 'skip_missed', got: '{policy}'")
+
+
+def validate_webhook_block(webhook: dict, prefix: str) -> None:
+    """Validate a webhook trigger block: endpointId, method, filter."""
+    if not isinstance(webhook, dict):
+        err(f"'{prefix}.webhook' must be a mapping")
+        return
+
+    if "endpointId" not in webhook:
+        err(f"Missing required field: '{prefix}.webhook.endpointId' "
+            "(generate: node -e \"console.log(require('crypto').randomBytes(4).toString('hex'))\")")
+    elif not is_valid_hex8(str(webhook["endpointId"])):
+        err(f"'{prefix}.webhook.endpointId' must be an 8-char lowercase hex string, got: '{webhook['endpointId']}'")
+
+    if "method" in webhook:
+        if webhook["method"] not in ("GET", "POST"):
+            err(f"'{prefix}.webhook.method' must be 'GET' or 'POST', got: '{webhook['method']}'")
+
+    if "filter" in webhook:
+        f = webhook["filter"]
+        if not isinstance(f, dict):
+            err(f"'{prefix}.webhook.filter' must be a mapping")
+        else:
+            if "bodyContains" in f and not is_string(f["bodyContains"]):
+                err(f"'{prefix}.webhook.filter.bodyContains' must be a non-empty string")
+            if "requiredHeaders" in f:
+                rh = f["requiredHeaders"]
+                if not isinstance(rh, list) or not all(isinstance(h, str) for h in rh):
+                    err(f"'{prefix}.webhook.filter.requiredHeaders' must be a list of strings")
+
+
+def validate_github_block(github: dict, prefix: str) -> None:
+    """Validate a github trigger block: event, repository, branch."""
+    if not isinstance(github, dict):
+        err(f"'{prefix}.github' must be a mapping")
+        return
+
+    valid_events = (
+        "push", "pull_request_opened", "pull_request_closed",
+        "pull_request_merged", "ci_completed", "issue_created", "issue_closed",
+    )
+    if "event" not in github:
+        err(f"Missing required field: '{prefix}.github.event'")
+    elif github["event"] not in valid_events:
+        warn(f"'{prefix}.github.event' value '{github['event']}' is unrecognized. Known: {valid_events}")
+
+    if "repository" in github and not is_string(github["repository"]):
+        err(f"'{prefix}.github.repository' must be a non-empty string (e.g. 'org/repo')")
+
+    if "branch" in github and not is_string(github["branch"]):
+        err(f"'{prefix}.github.branch' must be a non-empty string")
+
+
+def validate_slack_block(slack: dict, prefix: str) -> None:
+    """Validate a slack trigger block: event, channelId."""
+    if not isinstance(slack, dict):
+        err(f"'{prefix}.slack' must be a mapping")
+        return
+
+    valid_events = ("app_mention", "message", "reaction_added", "file_shared", "channel_created")
+    if "event" not in slack:
+        err(f"Missing required field: '{prefix}.slack.event'")
+    elif slack["event"] not in valid_events:
+        warn(f"'{prefix}.slack.event' value '{slack['event']}' is unrecognized. Known: {valid_events}")
+
+    if "channelId" in slack and not is_string(slack["channelId"]):
+        err(f"'{prefix}.slack.channelId' must be a non-empty string")
+
+
+def validate_single_trigger(trigger: dict, idx: int) -> Optional[str]:
+    """Validate a single trigger entry by type; return the trigger type string or None."""
+    prefix = f"triggers[{idx}]"
+    valid_types = ("schedule", "webhook", "github", "slack")
+
+    if not isinstance(trigger, dict):
+        err(f"'{prefix}' must be a mapping")
+        return None
+
+    trigger_type = trigger.get("type")
+    if not trigger_type:
+        err(f"Missing required field: '{prefix}.type'")
+        return None
+
+    if trigger_type not in valid_types:
+        err(f"'{prefix}.type' must be one of {valid_types}, got: '{trigger_type}'")
+        return trigger_type
+
+    if trigger_type == "schedule":
+        if "schedule" not in trigger:
+            err(f"Missing required block: '{prefix}.schedule' (required when type=schedule)")
+        else:
+            validate_schedule_block(trigger["schedule"], prefix=f"{prefix}.schedule")
+
+    elif trigger_type == "webhook":
+        if "webhook" not in trigger:
+            err(f"Missing required block: '{prefix}.webhook'")
+        else:
+            validate_webhook_block(trigger["webhook"], prefix=prefix)
+
+    elif trigger_type == "github":
+        if "github" not in trigger:
+            err(f"Missing required block: '{prefix}.github'")
+        else:
+            validate_github_block(trigger["github"], prefix=prefix)
+
+    elif trigger_type == "slack":
+        if "slack" not in trigger:
+            err(f"Missing required block: '{prefix}.slack'")
+        else:
+            validate_slack_block(trigger["slack"], prefix=prefix)
+
+    return trigger_type
+
+
+def validate_triggers(cfg: dict) -> None:
+    """Validate the 'triggers' list: non-empty, each entry valid, at most one schedule."""
+    if "triggers" not in cfg:
+        err("Missing required field: 'triggers' (list of trigger configurations)")
+        return
+
+    triggers = cfg["triggers"]
+    if not isinstance(triggers, list) or len(triggers) == 0:
+        err("'triggers' must be a non-empty list")
+        return
+
+    schedule_count = 0
+    for i, t in enumerate(triggers):
+        ttype = validate_single_trigger(t, i)
+        if ttype == "schedule":
+            schedule_count += 1
+
+    if schedule_count > 1:
+        err(f"At most one trigger of type 'schedule' is allowed, found {schedule_count}")
+
+
+def validate_body(body: str) -> None:
+    """Warn if the AUTOMATION.md body (agent task instructions) is empty."""
+    if not body or not body.strip():
+        warn("AUTOMATION.md body (query) is empty. The executing Agent will have no task instructions.")
+
+
+# ── main ──────────────────────────────────────────────────────────────────────
+
+def validate(path: str) -> bool:
+    """Validate an AUTOMATION.md (or .yaml) config file; return True if valid."""
+    global _errors, _warnings
+    _errors, _warnings = [], []
+
+    config_path = Path(path)
+    if not config_path.exists():
+        print(f"File not found: {path}")
+        return False
+
+    text = config_path.read_text(encoding="utf-8")
+
+    # Detect file type: .md → parse frontmatter, .yaml/.yml → parse as raw YAML
+    if config_path.suffix in (".md",):
+        result, error = parse_frontmatter(text)
+        if error:
+            print(f"  [ERROR] {error}")
+            print(f"\nValidating: {path}")
+            print(f"  ✗ Found 1 error(s). Fix the issues above and re-run.")
+            return False
+        cfg, body = result
+        validate_body(body)
+    else:
+        # Legacy .yaml support
+        try:
+            cfg = yaml.safe_load(text)
+        except yaml.YAMLError as e:
+            print(f"YAML parse error: {e}")
+            return False
+        if not isinstance(cfg, dict):
+            print("ERROR: file must contain a YAML mapping (dict)")
+            return False
+        body = None
+
+    # Warn about snake_case keys
+    check_snake_case_keys(cfg)
+
+    validate_top_level(cfg)
+    validate_triggers(cfg)
+    if "execution" in cfg:
+        validate_execution(cfg["execution"])
+
+    print(f"\nValidating: {path}")
+    for line in _warnings:
+        print(line)
+    for line in _errors:
+        print(line)
+
+    if not _errors:
+        print("  ✓ AUTOMATION.md is valid")
+        return True
+    else:
+        print(f"  ✗ Found {len(_errors)} error(s). Fix the issues above and re-run.")
+        return False
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python3 check_config.py <path/to/AUTOMATION.md>")
+        sys.exit(1)
+    ok = validate(sys.argv[1])
+    sys.exit(0 if ok else 1)

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

@@ -1,6 +1,7 @@
 ---
 name: create-rule
 description: Create rules for persistent AI guidance. Use when the user wants to create a rule, add coding standards, set up project conventions, configure file-specific patterns.
+disable-model-invocation: true
 metadata:
   disableWhen:
     - isVisualStudio