Skill: freshmand/loongflow (version 1.0.1)

--- name: loongflow description: "LoongFlow brings evolutionary multi-agent optimization to your coding agent harness. Drop it into Codex, Claude Code, Cursor or any OpenClaw agent — then watch PEES (Plan-Execute-Evaluate-Summary) iterate your code, algorithms, or prompts toward a target score, just like a harness-native eval loop but without writing a single test fixture. Two modes: Native PEES (async subagent, zero config, fires-and-forgets into the background) and LoongFlow Engine (full evolutionary search with islands, Boltzmann selection, MAP-Elites diversity, 50+ iterations, checkpoint/resume). Pairs perfectly with any task where 'run it once' isn't good enough. Use when tasks need structured iteration, optimization, evolution, or when user mentions loongflow/PEES." --- # LoongFlow — PEES 迭代问题求解 当用户希望通过多轮迭代来优化方案时使用此 Skill——代码优化、算法进化、结构化重试与学习，或任何"一次生成质量不够、需要反复打磨"的任务。 ## 第一步：分析任务，推荐模式 收到任务后，先分析复杂度，向用户介绍两种模式并给出推荐： **Native PEES（推荐中小型任务）：** - 适合：单文件修复、小功能、bug fix、聚焦的质量提升 - 工作方式：**异步 subagent**——任务丢给独立 subagent 跑 PEES 迭代，主 session 立刻释放，不阻塞对话 - 优点：无需额外配置，透明工作区，完成时直接通知用户 - 限制：最多 5 轮迭代，单线程，无种群进化 - 进度：每轮迭代完成后写入 `.loongflow/tasks.json`，统一监控 **LoongFlow Engine（推荐复杂优化任务）：** - 适合：优化问题、多文件项目、需要 50+ 轮迭代、种群进化 - 工作方式：下载 LoongFlow 框架，后台运行进化引擎，cron 定时汇报进度 - 优点：多岛模型、Boltzmann 选择、MAP-Elites 多样性、断点续跑、成本追踪 - 限制：需要 `ANTHROPIC_API_KEY` + `ANTHROPIC_BASE_URL`，有安装步骤 - 源码：https://github.com/baidu-baige/LoongFlow **先询问用户选择哪种模式，再执行。** ## 第二步：按模式执行 用户确认模式后，读取对应的参考文件并严格按其指令操作： - **Native PEES** → 读取并遵循 `references/native-pees.md` - **LoongFlow Engine** → 读取并遵循 `references/engine-mode.md` ## 任务监控（两种模式通用） 所有 LoongFlow 任务（无论 native 还是 engine）都通过统一的任务注册表管理： - **注册表**：`<agentWorkspace>/.loongflow/tasks.json` - **监控 cron**：所有任务共用一个 `openclaw cron`，每 10 分钟触发一次。每次向用户推送**有实质内容的进度摘要**：分数趋势（0.XX → 0.XX → 0.XX）、本轮策略（从 plan.md/log 提取）、关键发现（从 summary.md/log 提取）。 - **任务完成**：subagent / engine 直接 `infoflow_send` 最终结果，并将任务标记为 `done` cron 创建命令详见 `references/monitoring.md`（两种模式共用，不要在各模式文件里单独维护，也不要内联 cron 命令）。 ## 架构参考：任务复杂度分级 LoongFlow 将 Agent 任务分为三个层级： | 层级 | 说明 | 适合场景 | |------|------|---------| | **Simple（简单）** | ReAct 循环 + 持久化记忆 | 聊天机器人、工具调用、格式转换 | | **Standard（标准）** | ReAct + 自我评估 + 迭代改进 | 代码审查、文档生成、数据分析 | | **Advanced（高级）** | PEES 进化循环 + loongflow-memory | 数学优化、算法设计、NP-hard 问题 | ### 复杂度判断流程 ``` 任务分析 ├── 只需对话 + 简单工具？→ SIMPLE ├── 需要文件操作或代码生成？ │ ├── 有数值评估指标？→ ADVANCED │ └── 无数值指标？→ STANDARD └── 需要迭代优化？ ├── 有明确打分函数？→ ADVANCED └── 定性改进？→ STANDARD ```

path: references/engine-mode.md
content: # LoongFlow Engine Mode

Follow these instructions to set up and run the LoongFlow evolutionary optimization engine.

**Model format:** Model names must use the `anthropic/` prefix (e.g., [REDACTED_SECRET], `anthropic/deepseek-v3.2`). The actual model can be any model accessible via the configured endpoint. Requires `ANTHROPIC_API_KEY` and `ANTHROPIC_BASE_URL`.

## Step 1: Check Prerequisites and Install

### 确定当前 Workspace 路径

**关键**：skill 可能安装在任意 workspace，必须动态确定当前 workspace，而不是总用 main。

> ⚠️ 注意：以下 bash 代码块是**示意伪代码**，`$0` 在 agent 执行时无效（agent 不是 shell 脚本）。
> **实际执行时，agent 应直接用 Python 查询 openclaw.json 确定 workspace**，不要照搬 `$0` 那行。

```bash
# 示意：SKILL.md 在 <workspace>/skills/loongflow/SKILL.md，向上两级即 workspace
# 实际执行时请改用下方 Python fallback，不要使用 $0

# fallback（推荐）：从 openclaw.json 查当前 agent 的 workspace
CURRENT_WORKSPACE=$(python3 -c "
import json, os
d = json.load(open('/root/.openclaw/openclaw.json'))
agents = d.get('agents', {}).get('list', [])
agent_id = os.environ.get('OPENCLAW_AGENT_ID', '')
hit = next((a for a in agents if a.get('id') == agent_id), None)
defaults = d.get('agents', {}).get('defaults', {})
print((hit or {}).get('workspace') or defaults.get('workspace', '/root/.openclaw/workspace'))
" 2>/dev/null || echo "/root/.openclaw/workspace")

LOONGFLOW_DIR="$CURRENT_WORKSPACE/.loongflow/engine"
echo "CURRENT_WORKSPACE: $CURRENT_WORKSPACE"
echo "LOONGFLOW_DIR: $LOONGFLOW_DIR"
```

### Quick check: already installed?

If `.loongflow/engine/.venv` exists and loongflow is importable, skip to Step 2:

```bash
if [ -d "$LOONGFLOW_DIR/.venv" ]; then
    "$LOONGFLOW_DIR/.venv/bin/python" -c "import loongflow; print('loongflow ok')" 2>/dev/null && echo "READY"
fi
```

If output is `loongflow ok` / `READY`, **skip directly to Step 2 (Configure the Task)**.

### Fresh install

Only run this if `.loongflow/engine/.venv` does NOT exist or loongflow is not importable:

1. **ANTHROPIC_API_KEY** is set:
   ```bash
   echo $ANTHROPIC_API_KEY | head -c 10
   ```
   If empty, tell the user:
   > LoongFlow requires an API key. Please set it:
   > `export ANTHROPIC_API_KEY="your-key-here"`

2. **ANTHROPIC_BASE_URL** is set:
   ```bash
   echo $ANTHROPIC_BASE_URL
   ```
   If empty, tell the user:
   > LoongFlow requires a base URL for the API endpoint. Please set it:
   > `export ANTHROPIC_BASE_URL="https://api.anthropic.com"` (or your custom endpoint)

3. **网络可达性检查**（百度内网环境）：
   ```bash
   curl -s --connect-timeout 5 https://github.com -o /dev/null -w "%{http_code}" || echo "UNREACHABLE"
   ```
   If unreachable, tell the user:
   > 当前环境无法访问 GitHub，请确认是否有内网镜像地址，或手动下载 LoongFlow 到 `$LOONGFLOW_DIR`。

4. **Download and install:**

```bash
# Clone if not already present
if [ ! -d "$LOONGFLOW_DIR" ]; then
    git clone https://github.com/baidu-baige/LoongFlow "$LOONGFLOW_DIR"
fi

cd "$LOONGFLOW_DIR"
git pull origin main

# Prefer uv (handles Python version automatically), fall back to pip
# NOTE: Do NOT use `source .venv/bin/activate` — use full paths to avoid shell compatibility issues
if command -v uv &> /dev/null; then
    uv venv .venv --python 3.12
    uv pip install -e . --python .venv/bin/python
else
    python3.12 -m venv .venv || python3 -m venv .venv
    .venv/bin/pip install -e .
fi

# Verify
.venv/bin/python -c "import loongflow; print('loongflow ok')"
```

**Note:** `uv venv --python 3.12` will automatically download Python 3.12 if not available on the system. This is the preferred approach.

## Step 2: Configure the Task

Create a task directory under `agents/general_agent/examples/` inside the engine dir:

```bash
TASK_SLUG="<task-slug>"  # kebab-case name from user's task
TASK_DIR="$LOONGFLOW_DIR/agents/general_agent/examples/$TASK_SLUG"
mkdir -p "$TASK_DIR"
```

### Generate task_config.yaml

Adapt the following template based on the user's task. Key fields to customize:
- `evolve.task`: The user's detailed task description
- `evolve.max_iterations`: Higher for harder problems (default: 50)
- `evolve.target_score`: The target quality threshold (default: 0.9)
- `evolve.evaluator.timeout`: Longer for complex evaluations (default: 600s)

```yaml
# workspace_path is relative to the engine dir (.loongflow/engine/)
workspace_path: "agents/general_agent/examples/<task-slug>/output"

llm_config:
  model: "anthropic/deepseek-v3.2"    # Must use anthropic/ prefix. Any model name after the slash.
  # url and api_key can also be set via ANTHROPIC_BASE_URL and ANTHROPIC_API_KEY env vars
  # url: "https://api.anthropic.com"
  # [REDACTED_SECRET]"

planners:
  general_planner:
    permission_mode: "acceptEdits"
    max_turns: 100

executors:
  general_executor:
    permission_mode: "acceptEdits"
    max_turns: 100

summarizers:
  general_summarizer:
    permission_mode: "acceptEdits"
    max_turns: 100

evolve:
  task: |
    <INSERT USER'S TASK DESCRIPTION HERE>
  planner_name: "general_planner"
  executor_name: "general_executor"
  summary_name: "general_summarizer"
  max_iterations: 100
  target_score: 1.0
  concurrency: 1
  evaluator:
    timeout: 1800
    agent:
      permission_mode: "acceptEdits"
      max_turns: 100
  database:
    storage_type: "in_memory"
    num_islands: 1
    population_size: 50
    checkpoint_interval: 5
    sampling_weight_power: 2
```

### Copy User Files

If the user has source code, data files, or evaluation scripts relevant to the task, copy them into the task directory:

```bash
# Copy user's files if provided
cp -r <user-files> "$TASK_DIR/"
```

If the user provides a custom evaluation script, save it as `eval_program.py` in the task directory. It must implement:

```python
def evaluate(solution_path: str) -> dict:
    return {
        "status": "success",
        "score": 0.0,  # 0.0 to 1.0
        "summary": "Description of evaluation result",
        "metrics": {},
        "artifacts": {}
    }
```

## Step 3: Launch Evolution

```bash
cd "$LOONGFLOW_DIR"
# Use full python path — do NOT use `source .venv/bin/activate`
PYTHONPATH=$PYTHONPATH:./src .venv/bin/python agents/general_agent/general_evolve_agent.py \
  --config "agents/general_agent/examples/$TASK_SLUG/task_config.yaml" \
  > "agents/general_agent/examples/$TASK_SLUG/run.log" 2>&1 &
echo $! > "agents/general_agent/examples/$TASK_SLUG/.run.pid"
echo "Started PID: $(cat agents/general_agent/examples/$TASK_SLUG/.run.pid)"
sleep 3
tail -20 "agents/general_agent/examples/$TASK_SLUG/run.log"
```

Tell the user:
> LoongFlow evolution started in background for task `<task-slug>`.
> PID: `<pid>`, Log: `<log-path>`

## Step 4: 注册任务 + 设置监控

### 注册到 tasks.json

**注意**：路径解析和注册合并在一个 Python 脚本中执行，避免 bash→Python 环境变量跨代码块传递失效的问题。

将以下脚本保存后执行，替换 `<task-slug>` 为实际值：

```python
import json, time, os
from pathlib import Path

# === 路径解析（内联，不依赖外部环境变量）===
try:
    d = json.load(open('/root/.openclaw/openclaw.json'))
    agents = d.get('agents', {}).get('list', [])
    agent_id = os.environ.get('OPENCLAW_AGENT_ID', '')
    hit = next((a for a in agents if a.get('id') == agent_id), None)
    defaults = d.get('agents', {}).get('defaults', {})
    agent_workspace = (hit or {}).get('workspace') or defaults.get('workspace', '/root/.openclaw/workspace')
except Exception:
    agent_workspace = '/root/.openclaw/workspace'

task_slug = "<task-slug>"   # 替换为实际值
loongflow_dir = str(Path(agent_workspace) / '.loongflow' / 'engine')
tasks_json_path = Path(agent_workspace) / '.loongflow' / 'tasks.json'
notify_user = os.environ.get('BAIDU_CC_USERNAME', '') or os.popen('whoami').read().strip()
now_epoch = int(time.time())  # UTC epoch，无时区问题

print(f"agent_workspace: {agent_workspace}")
print(f"loongflow_dir: {loongflow_dir}")
print(f"tasks.json: {tasks_json_path}")
print(f"notify_user: {notify_user}")

# === 注册任务 ===
tasks_json_path.parent.mkdir(parents=True, exist_ok=True)
data = json.loads(tasks_json_path.read_text()) if tasks_json_path.exists() else {"tasks": []}

data["tasks"].append({
    "id": task_slug,
    "name": task_slug,
    "mode": "engine",
    "status": "running",
    "agentWorkspace": agent_workspace,
    "notifyUser": notify_user,
    "pidFile": f"{loongflow_dir}/agents/general_agent/examples/{task_slug}/.run.pid",
    "logFile": f"{loongflow_dir}/agents/general_agent/examples/{task_slug}/run.log",
    "startedAtEpoch": now_epoch,        # UTC epoch，不依赖时区
    "maxIterations": 50,
    "updatedAtEpoch": now_epoch
})
tasks_json_path.write_text(json.dumps(data, indent=2, ensure_ascii=False))
print(f"Task registered: {task_slug}")
print(f"tasks.json written to: {tasks_json_path}")
```

### 确保监控 Cron 存在

**必须读取 `references/monitoring.md` 并按其指令操作**——cron 命令统一维护在那里，不要在此处内联。

执行步骤：
1. 先检查是否已有 loongflow 监控 cron（命令见 monitoring.md "检查是否已存在" 一节）
2. 若 **FOUND**：跳过，不重复创建
3. 若 **MISSING**：执行 monitoring.md "创建监控 Cron" 一节中的 `openclaw cron add` 命令

> 所有任务共用同一个监控 cron，cron message 包含完整的摘要生成逻辑，每 10 分钟向用户推送有实质内容的进度摘要（分数趋势、本轮策略、关键发现）。

### On Completion

When evolution finishes, report to the user:
- **Best score** achieved
- **Iteration count**: total iterations completed
- **Final solution content** (the regex, code, etc.)

### Stopping a Task

```bash
PID=$(cat "$LOONGFLOW_DIR/agents/general_agent/examples/<task-slug>/.run.pid")
kill $PID
```


path: references/monitoring.md
content: # LoongFlow 监控 Cron 配置

所有 LoongFlow 任务（native 和 engine 模式）共用**同一个**监控 cron，在首次启动任务时创建，后续任务直接复用。

## 检查是否已存在

```bash
openclaw cron list --json | python3 -c "
import json, sys
jobs = json.load(sys.stdin).get('jobs', [])
found = [j for j in jobs if 'loongflow' in j.get('name','').lower()]
print('FOUND' if found else 'MISSING')
"
```

- **FOUND**：不重复创建，直接跳过。
- **MISSING**：执行下方命令创建。

## 创建监控 Cron

```bash
openclaw cron add \
  --name "loongflow任务监控" \
  --every "10m" \
  --session isolated \
  --announce \
  --channel infoflow \
  --timeout-seconds 120 \
  --message '你是 LoongFlow 任务监控 agent。每次触发时，扫描所有活跃任务并向用户发送有价值的进度摘要。

## 数据收集

1. 读取 /root/.openclaw/openclaw.json，遍历 agents.list[].workspace（fallback: agents.defaults.workspace），收集所有 workspace 路径
2. 对每个 workspace，读取 <workspace>/.loongflow/tasks.json（不存在则跳过）
3. 合并所有 status=running 的任务

## 每个 running 任务的数据提取

**native 模式：**
- 读取 taskDir/index.md，提取：
  - 所有已完成迭代的分数列表（从 "Score: 0.XX" 行提取）
  - 最新迭代的 Insight 内容（关键发现）
  - 最新迭代的 Plan 摘要（本轮策略）
  - 当前 bestScore 和 currentIteration（从 tasks.json）
- 分析趋势：计算最近 2 轮分数差，判断是否在改进

**engine 模式：**
- 读取 logFile 最后 100 行，提取：
  - 最新 best_score 和当前 iteration 数
  - 最近一轮的 plan/execute 摘要（如有）
  - 是否有 ERROR 或异常
- 用 kill -0 检查进程是否还活着（pidFile 中的 PID）

**时间计算：**
- `import time; now = int(time.time())`，与 updatedAtEpoch 相减得秒数，除以 3600 得小时数
- 严禁用本地时间字符串比较

## 生成摘要消息

对每个 running 任务，发送一条有实质内容的摘要，格式如下：

```
📊 **<task-name>** [native/engine] · 第 X/N 轮 · 最佳分 0.XX

**进度趋势：** 分数 0.XX → 0.XX → 0.XX（↑上升 / →持平 / ↓下降）
**本轮策略：** <从 plan.md 或 log 提取的一句话，说明这轮在做什么>
**关键发现：** <从 summary.md 的 Insight 或 log 提取，说明学到了什么>
**预计剩余：** 还有 N 轮 / 已达上限 / 距上次更新 Xh
```

**规则：**
- "本轮策略" 和 "关键发现" 必须来自实际内容，不能是占位符
- 如果没有足够信息（第一轮刚开始），只发前两行，注明 "首轮运行中"
- 如果 engine 进程已退出（kill -0 失败）：标记 status=done，发最终结果摘要（best_score、总迭代数、solution 路径）
- 如果任务连续 3 轮分数无提升（delta < 0.05），在摘要中加 ⚠️ 提示用户考虑切换 Engine 模式

## 通知分发

- 从每个任务的 notifyUser 字段读取收件人（fallback: os.environ.get("BAIDU_CC_USERNAME") or whoami）
- 用 infoflow_send 分别发给对应的 notifyUser
- 每个任务发一条消息（不要把多个任务拼在一条里）

## Cron 生命周期管理

- 本轮结束后若仍有 running 任务：保留 cron
- 若无 running 任务：等下一轮再确认，连续两轮无 running 任务才执行 `openclaw cron rm <cron-id>` 删除本 cron
- 用 tasks.json 中的一个字段记录"上轮无任务"状态，避免依赖外部状态'
```

> **注意**：`--message` 使用单引号包裹，内部无需对 `$` 转义，避免 shell 提前展开变量。

## 重要约束

- ⚠️ **不要用 `infoflow_cron`**（systemEvent 模式）——它只触发 heartbeat，不执行实际逻辑。
- ⚠️ **不要依赖 HEARTBEAT.md**——cron 触发的 isolated session 不读 HEARTBEAT.md。
- 必须用 `--session isolated --announce` 才能真正执行检查并推送结果。
- 所有任务共用同一个监控 cron，不要为每个任务单独创建。
- `--timeout-seconds 120`：摘要生成需要读取文件和分析内容，给足时间。


path: references/native-pees.md
content: # Native PEES Mode（异步 Subagent）

Native PEES 以异步方式运行——将任务交给独立 subagent 执行，主 session 立刻释放，不阻塞对话。

## Step 1: 准备工作区

在主 session 中创建工作区目录和初始文件：

```
.loongflow/<task-slug>-<YYYYMMDD-HHMMSS>/
├── index.md       # 迭代索引，subagent 读写
├── task.md        # 任务描述和成功标准
├── iteration_1/   # 每轮迭代目录（由 subagent 创建）
│   ├── plan.md
│   ├── execute.md
│   ├── evaluate.md
│   └── summary.md
└── result.md      # 最终结果（subagent 写入）
```

- `<task-slug>`：从任务描述派生的 kebab-case 短名
- `<YYYYMMDD-HHMMSS>`：创建时间戳

## Step 2: 写入 task.md 和 index.md

**task.md** 写入任务描述和成功标准。如果用户提供了明确标准则直接使用，否则从任务描述推导并确认。

**index.md** 初始内容：

```markdown
# PEES Evolution Index

## Task
<task description>

## Success Criteria
<criteria>

## Target Score
<0.0–1.0>

## Iterations
(none yet)
```

## Step 3: 注册任务到 tasks.json

**注意**：路径解析和注册合并在一个 Python 脚本中执行，避免 bash→Python 环境变量跨代码块传递失效的问题。

将以下内容保存为临时脚本并执行，替换 `<task-slug>` 和 `<YYYYMMDD-HHMMSS>` 为实际值：

```python
import json, time, os
from pathlib import Path

# === 路径解析（内联，不依赖外部环境变量）===
# 从 openclaw.json 查当前 agent 的 workspace
try:
    d = json.load(open('/root/.openclaw/openclaw.json'))
    agents = d.get('agents', {}).get('list', [])
    agent_id = os.environ.get('OPENCLAW_AGENT_ID', '')
    hit = next((a for a in agents if a.get('id') == agent_id), None)
    defaults = d.get('agents', {}).get('defaults', {})
    agent_workspace = (hit or {}).get('workspace') or defaults.get('workspace', '/root/.openclaw/workspace')
except Exception:
    agent_workspace = '/root/.openclaw/workspace'

tasks_json_path = Path(agent_workspace) / '.loongflow' / 'tasks.json'
notify_user = os.environ.get('BAIDU_CC_USERNAME', '') or os.popen('whoami').read().strip()
now_epoch = int(time.time())  # UTC epoch，无时区问题

print(f"agent_workspace: {agent_workspace}")
print(f"tasks.json: {tasks_json_path}")
print(f"notify_user: {notify_user}")

# === 注册任务 ===
task_id = "<task-slug>-<YYYYMMDD-HHMMSS>"   # 替换为实际值
task_dir = Path(agent_workspace) / '.loongflow' / task_id

tasks_json_path.parent.mkdir(parents=True, exist_ok=True)
data = json.loads(tasks_json_path.read_text()) if tasks_json_path.exists() else {"tasks": []}

data["tasks"].append({
    "id": task_id,
    "name": "<task-slug>",              # 替换为实际值
    "mode": "native",
    "status": "running",
    "taskDir": str(task_dir),           # 任务迭代目录（.loongflow/<task-id>/）
    "agentWorkspace": agent_workspace,  # agent workspace 根目录（用于定位 tasks.json）
    "notifyUser": notify_user,
    "startedAtEpoch": now_epoch,        # UTC epoch，不依赖时区
    "currentIteration": 0,
    "maxIterations": 5,
    "bestScore": 0,
    "updatedAtEpoch": now_epoch
})
tasks_json_path.write_text(json.dumps(data, indent=2, ensure_ascii=False))
print(f"Task registered: {task_id}")
print(f"tasks.json written to: {tasks_json_path}")
```

> **说明**：`taskDir`（任务迭代目录，存放 iteration_N/ 等文件）和 `agentWorkspace`（workspace 根目录，用于定位 tasks.json）是两个不同概念，不要混淆。无论 skill 安装在哪个 workspace，tasks.json 始终写在对应 workspace 下，不跨 workspace 混用。

## Step 4: 启动 Subagent

用 `sessions_spawn` 启动一个 subagent，传入完整的 PEES 执行指令：

```
sessions_spawn:
  runtime: "subagent"
  mode: "run"
  label: "pees-<task-slug>"
  task: |
    你是一个 PEES 迭代优化 agent。执行以下任务，完成后通过 infoflow_send 通知用户。

    任务目录（迭代文件存放处）：<task-dir>（即 <agent-workspace>/.loongflow/<task-id>/，绝对路径）
    Agent Workspace 根目录：<agent-workspace>（用于定位 tasks.json）
    tasks.json 路径：<agent-workspace>/.loongflow/tasks.json
    任务 ID：<task-id>
    通知用户：<notify-user>（从 tasks.json 该任务的 notifyUser 字段读取，fallback: $BAIDU_CC_USERNAME）

    ## 你的任务
    <完整任务描述，从 task.md 内容复制>

    ## 成功标准
    <成功标准>

    ## 目标分数
    <target-score>

    ## PEES 执行规则

    最多执行 5 轮迭代。每轮：

    ### Plan
    1. 读 <task-dir>/index.md，回顾已有迭代和分数
    2. 写 <task-dir>/iteration_N/plan.md：本轮策略、与上轮的区别、具体行动计划

    ### Execute
    1. 用工具实现计划（读写文件、运行命令）
    2. 写 <task-dir>/iteration_N/execute.md：记录所有操作和结果

    ### Evaluate
    1. 测试结果，打分 0.0–1.0
    2. 写 <task-dir>/iteration_N/evaluate.md：测试证据、分数、状态（pass/partial/fail）

    ### Summary
    1. 分析本轮得失，提取下轮关键 insight
    2. 写 <task-dir>/iteration_N/summary.md：结论、insight、决策（done/iterate/escalate）

    ### 更新 index.md
    每轮结束后追加：
    ```
    ## Iteration N
    - Plan: <一句话>
    - Score: 0.XX
    - Status: pass/partial/fail
    - Insight: <关键 insight>
    ```

    ### 更新 tasks.json
    每轮结束后用 UTC epoch 更新字段（`import time; int(time.time())`）：
    - `currentIteration`
    - `bestScore`
    - `updatedAtEpoch`（UTC epoch，不要用本地时间字符串）

    ## 终止条件
    - **成功**：分数 >= 目标分 → 写 result.md，标记任务 status=done
    - **达到上限**：5 轮后写 result.md，记录最佳结果，status=done
    - **连续 3 轮无提升**：记录每轮 bestScore，若最近 3 轮提升均 < 0.05，写 result.md（status=escalate），建议用户切换 Engine 模式，status=done

    ## result.md 格式
    ```markdown
    # Result
    - Final Score: 0.XX
    - Status: success / partial / escalate
    - Best Iteration: N
    - Total Iterations: N
    - Summary: <结果摘要>
    - Solution: <最终方案或文件路径>
    ```

    ## 完成后通知用户
    任务完成后：
    1. 更新 tasks.json 中 status=done，updatedAtEpoch=当前 UTC epoch
    2. 从 tasks.json 该任务的 notifyUser 字段读取收件人（fallback: $BAIDU_CC_USERNAME）
    3. 用 infoflow_send 发消息给该用户：
       ```
       ✅ PEES 任务完成｜<task-slug>｜最终分: 0.XX｜迭代: N/5
       <result.md 中的 Solution 内容>
       ```
```

启动后立刻告知用户：
> 任务 `<task-slug>` 已在后台启动，完成后会通知你。你可以继续聊其他的。

## Step 5: 确保监控 Cron 存在

**必须读取 `references/monitoring.md` 并按其指令操作**——cron 命令统一维护在那里，不要在此处内联。

执行步骤：
1. 先检查是否已有 loongflow 监控 cron（命令见 monitoring.md "检查是否已存在" 一节）
2. 若 **FOUND**：跳过，不重复创建
3. 若 **MISSING**：执行 monitoring.md "创建监控 Cron" 一节中的 `openclaw cron add` 命令

> 所有任务共用同一个监控 cron，cron message 包含完整的摘要生成逻辑，每 10 分钟向用户推送有实质内容的进度摘要（分数趋势、本轮策略、关键发现）。


Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (HIGH)