摘要：本文通过 OpenClaw 官方文档（/usr/local/lib/node_modules/openclaw/docs/）与本地实测，拆解 6 个让 AI 从被动聊天机器人升级为主动数字员工的进阶技巧：Standing Orders 写工作合同、Hooks 植入自定义大脑、Dreaming 模拟睡眠整理记忆、Specialist Lanes 多智能体分工、Queue Steering 边干边接指令、Compaction 长会话生存术。每一节都包含原理、完整配置、实战代码与踩坑复盘。

前置阅读：本篇所有技巧默认你已完成 OpenClaw 在 PVE 环境下的私有化部署 与 初始化配置与 Skills/Gateway 设置，建议先把基础环境跑通再来啃这篇。

一、AI 没在偷懒，是你没给它"工作合同"

2026 年我自己用 OpenClaw 这半年，踩过最深的一个坑不是装不上、不是连不通，而是装好了之后不知道怎么"用"它。

用户：“你能不能每天早上 8 点帮我看一下邮件，把重要的挑出来？”

AI：（沉默 60 秒后）“好的，请告诉我邮件账号是哪一个，需要看哪些标签，重要的标准是什么，要不要回复，回复了要不要发出去……”

每问一次，重新交代一次。AI 像个永远在试用期的实习生，离开屏幕就忘了自己是谁。

后来翻 OpenClaw 文档才发现：这套系统从设计之初就预备了让 AI 真正"上班" 的完整机制，只是大多数人压根没翻到那几页。本文要讲的 6 个技巧，每一个都对应一个把 AI 从"聊天机器人"升级为"数字员工"的能力维度：

提示：文档藏在你本机 npm 全局模块里，路径 /usr/local/lib/node_modules/openclaw/docs/。cat 一下比百度搜一下管用一万倍。

下面分章节深扒。每一节都遵循 痛点 → 原理 → 配置 → 实战 → 踩坑 五段式。能用代码块说清楚的绝不废话。

二、Standing Orders + Cron：给 AI 一份永久授权书

2.1 痛点：每次都要"现场布置"，AI 永远在等指令

不开 Standing Orders 之前，OpenClaw 的工作模式是这样：

你：早上把邮件整理一下
AI：好的，你想怎么整理？
你：分类、挑重点、起草回复但别发
AI：好的，邮件账号是？
你：…………

每天重新交代一次，AI 永远在等你"按按钮"。这是临时工模式：你才是那个 24×7 在岗的人，AI 只是个昂贵的查字典工具。

2.2 原理：Standing Orders 是 AI 的"工作合同"

OpenClaw 给出的解法叫 Standing Orders（常驻指令）——直译过来就是"长期生效的命令"。本质是把"工作合同"写在 AGENTS.md 里，每次会话启动时自动注入到上下文，让 AI 永远记得自己有哪些 永久授权。

合同必须包含 4 个要素，缺一不可：

2.3 配置：完整的 Program 模板

直接抄官方文档里"周报"那个例子，然后改造成你的：

## Program: Weekly Status Report

**Authority:** Compile data, generate report, deliver to stakeholders
**Trigger:** Every Friday at 4 PM (enforced via cron job)
**Approval gate:** None for standard reports. Flag anomalies for human review.
**Escalation:** If data source is unavailable or metrics look unusual (>2σ from norm)

### Execution steps

1. Pull metrics from configured sources
2. Compare to prior week and targets
3. Generate report in Reports/weekly/YYYY-MM-DD.md
4. Deliver summary via configured channel
5. Log completion to Agent/Logs/

### What NOT to do

- Do not send reports to external parties
- Do not modify source data
- Do not skip delivery if metrics look bad - report accurately

注意最后那个 What NOT to do 块。这是新手最容易跳过、但工程上最重要的一段。AI 的能力边界往往不是"它能做什么"决定的，而是"它绝对不会做什么"决定的。

2.4 黄金搭档：Standing Orders 定义 What，Cron 定义 When

Standing Orders 单独存在是没用的——AI 不会"自己想起来"该干活。必须配合 Cron 才能真正自治：

Standing Order: "你负责每日邮件整理"
        ↓
Cron Job (8 AM daily): "执行邮件整理 per standing orders"
        ↓
Agent: 读取 standing orders → 执行步骤 → 报告结果

注意 cron 命令里不要重复写 Standing Order 的内容，应该只是触发词：

openclaw cron add \
  --name daily-inbox-triage \
  --cron "0 8 * * 1-5" \
  --tz Asia/Shanghai \
  --timeout-seconds 300 \
  --announce \
  --channel feishu \
  --to "user:ou_xxx" \
  --message "Execute daily inbox triage per standing orders. Check mail for new alerts. Parse, categorize, and persist each item. Report summary to owner. Escalate unknowns."

这种写法的好处是：改 Standing Order 不需要改 cron。需求变了改一处即可，不用满世界 grep cron 命令。

2.5 铁律：Execute-Verify-Report 三步走

光有 Standing Orders 还不够，必须配合 OpenClaw 推荐的 执行纪律：

### Execution rules

- Every task follows Execute-Verify-Report. No exceptions.
- "I'll do that" is not execution. Do it, then report.
- "Done" without verification is not acceptable. Prove it.
- If execution fails: retry once with adjusted approach.
- If still fails: report failure with diagnosis. Never silently fail.
- Never retry indefinitely - 3 attempts max, then escalate.

这 6 行字翻译成人话：

1. Execute：真去干，不是嘴上说"好的"
2. Verify：干完要验证（文件存在？消息送达？数据解析？）
3. Report：把"干了什么、验证了什么"汇报给我

加上这 6 行，AI 的"假装干完"故障率（这是 LLM Agent 最常见的失败模式）下降一个数量级。

2.6 多 Program 架构：一个 Agent 管多块业务

如果你的 AI 同时负责好几摊事，一个 Program 一摊，互相不打架：

## Program 1: Content & Social Media (Weekly)
...
## Program 2: Financial Processing (Event-driven)
...
## Program 3: System Monitoring (Continuous)
...

## Escalation Rules (All Programs)

- 任何 production 写操作都必须我审批
- 连续 3 次失败立即停止 + 飞书通知
- 检测到 secret/token 泄露立即 abort

每个 Program 有自己的 trigger 节奏（weekly / event / continuous）、自己的审批门、自己的边界。共用的只有最底层的 escalation rules。

2.7 踩坑：我犯过的两个错

踩坑 1：忘记写 What NOT to do

第一次配 Standing Order 时我只写了 Authority 和 Trigger，结果 AI 把"周报"发到了客户邮箱（因为 client 的邮箱地址也在通讯录里）。

✅ 修复：永远把"禁止事项"写在最显眼的位置，越具体越好（“不要发到 @example-client.com"比"不要发给外部"管用十倍）。

踩坑 2：Standing Order 漂亮但没配 Cron

写了一份漂亮的 daily inbox triage 文档，AI 看了一遍说"明白”。然后第二天我等到下午 5 点，邮件没整理。

Standing Orders without triggers become suggestions.

没有 cron 触发的 Standing Order，就是建议而已，AI 不会主动执行。

三、Hooks：在 Gateway 心跳里植入自定义大脑

3.1 痛点：默认行为不够用，又不想 fork 源码

OpenClaw 默认行为很多，但总有不爽的时刻：

• 我希望 /new 之前自动备份当前会话最关键的 3 条决策到 MEMORY.md
• 我希望飞书消息进来时先做一道 PII 清洗
• 我希望会话压缩前把不能丢的信息 dump 出来
• 我希望 Gateway 重启完自动 ping 我一下"我又活了"

这些都是合理需求。如果每个都得 fork 源码改一遍，等下次 OpenClaw 升级直接哭。

Hooks 就是为这个场景设计的：让你在 Gateway 关键事件上挂自己的脚本，不动源码、不挂主流程。

3.2 原理：14 个生命周期事件 × 你的 handler.ts

OpenClaw 暴露了 14 种内部事件，每一种都可以挂多个 handler：

3.3 配置：Hook 长什么样

每个 Hook 就是一个目录，两个文件：

my-hook/
├── HOOK.md          # 元数据 + 文档
└── handler.ts       # 实现代码

HOOK.md 模板：

---
name: pre-compact-dump
description: "压缩前把关键决策 dump 到 MEMORY.md"
metadata:
  {
    "openclaw": {
      "emoji": "💾",
      "events": ["session:compact:before"],
      "requires": { "bins": ["node"] }
    }
  }
---

# Pre-Compact Dump

会话压缩前自动从最近 30 条消息里提取"决策类"语句，追加到 MEMORY.md。

handler.ts 模板：

const handler = async (event) => {
  if (event.type !== "session" || event.action !== "compact:before") {
    return;
  }

  const { messageCount, tokenCount } = event.context;
  console.log(`[pre-compact-dump] ${messageCount} messages, ${tokenCount} tokens`);

  // 你的逻辑：扫消息历史、提取决策、追加到 MEMORY.md
  // ...

  // 推消息回用户（可选）
  event.messages.push(`✅ 压缩前已备份 ${messageCount} 条消息的关键决策`);
};

export default handler;

每个 event 都带这些字段：type、action、sessionKey、timestamp、messages（可推送给用户）、context（事件特定数据）。

3.4 实战：5 个开箱即用的 bundled hooks

OpenClaw 自带 5 个 hook，启用即用：

启用任何一个：

openclaw hooks list             # 查看
openclaw hooks enable session-memory
openclaw hooks check            # 验证可用性
openclaw hooks info session-memory   # 看详情

3.5 配置文件：精细控制每个 hook

~/.openclaw/openclaw.json：

{
  "hooks": {
    "internal": {
      "enabled": true,
      "entries": {
        "session-memory": {
          "enabled": true,
          "llmSlug": true
        },
        "command-logger": {
          "enabled": false
        },
        "my-hook": {
          "enabled": true,
          "env": { "MY_CUSTOM_VAR": "value" }
        }
      },
      "load": {
        "extraDirs": ["/path/to/more/hooks"]
      }
    }
  }
}

session-memory 的 llmSlug: true 会调用模型生成"描述性文件名"，比纯时间戳好用得多。

3.6 Hook 的发现优先级（避免覆盖坑）

按优先级从低到高：

1. Bundled hooks：随 OpenClaw 一起发的
2. Plugin hooks：插件自带的
3. Managed hooks：~/.openclaw/hooks/（用户级，跨 workspace 共享）
4. Workspace hooks：<workspace>/hooks/（每个 agent 独立）

关键规则：Workspace hooks 可以新增同名 hook，但不能覆盖前 3 类同名 hook。如果你想覆写 bundled 的 session-memory，方法是先 disable session-memory，再写自己的（用不同名字）。

3.7 踩坑：handler 里别干重活

Best practice：Keep handlers fast. Hooks run during command processing. Fire-and-forget heavy work with void processInBackground(event).

我第一次写 hook 时把"扫描会话历史 + 调 LLM 生成 slug"全塞 handler 里，结果每次 /new 都卡 3 秒。修复办法：

const handler = async (event) => {
  // 立即返回，重活丢后台
  void (async () => {
    try {
      await heavyWork(event);
    } catch (e) {
      console.error("[my-hook] background work failed", e);
    }
  })();
};

记住：handler 里 try/catch 永远要有，否则一个 hook 抛异常会影响后续 hook 执行。

3.8 排查：Hook 没生效怎么办

# 1. 确认目录结构对
ls -la ~/.openclaw/hooks/my-hook/
# 应看到 HOOK.md, handler.ts

# 2. 确认被发现
openclaw hooks list

# 3. 确认 eligible（依赖、平台、env 都满足）
openclaw hooks info my-hook

# 4. 确认启用
openclaw hooks check

# 5. 重启 gateway 让 hook 重载
openclaw gateway restart

# 6. 看日志
tail -f ~/.openclaw/logs/commands.log
./scripts/clawlog.sh | grep hook

四、Dreaming：让 AI 像人一样睡觉做梦整理记忆

4.1 痛点：AI 的记忆系统是个永远在升迁不公平的小公司

OpenClaw 默认的记忆策略很简单粗暴：

• 短期：当前会话上下文
• 长期：你手动写到 MEMORY.md 的内容

这意味着两件事：

1. AI 自己不会主动把"今天学到的重要东西"晋升到长期记忆
2. 你写了一堆无关琐事到 MEMORY.md 之后，AI 找东西就跟翻杂物间一样

关于本地记忆引擎 QMD 如何让搜索质量飞跃，请看前作 OpenClaw 本地记忆神器：QMD 实现零 Token、毫秒级响应。本节讨论的 Dreaming 是 QMD 之上的"记忆晋升机制"。

4.2 原理：模拟人脑三阶段睡眠

OpenClaw 的 Dreaming 系统直接抄了人脑的睡眠周期，分 3 个阶段：

每次 sweep 按 Light → REM → Deep 顺序跑一遍。只有 Deep 阶段会真的写 MEMORY.md，Light 和 REM 只产出 ## Light Sleep / ## REM Sleep 块到 DREAMS.md 里供你审阅。

4.3 Deep 阶段的评分公式

这是整个系统最值得拿出来讲的硬核部分。Deep 阶段决定一条短期记忆能不能晋升，靠的是 6 个加权信号：

权重最重的是 Relevance（0.30），意思是"被精准召回过"比"被重复提及"更重要。这反 LLM 圈普遍迷信"重复=重要"的直觉，但跟人脑认知科学完全一致。

晋升还要过三道阈值门：minScore、minRecallCount、minUniqueQueries。任何一个没过，就算评分高也不晋升。

4.4 启用：一行配置打开

~/.openclaw/openclaw.json：

{
  "plugins": {
    "entries": {
      "memory-core": {
        "config": {
          "dreaming": {
            "enabled": true,
            "timezone": "Asia/Shanghai",
            "frequency": "0 3 * * *"
          }
        }
      }
    }
  }
}

默认凌晨 3 点跑一次 sweep（人类睡觉 AI 干活，浪漫得很）。如果你想更密集：

"frequency": "0 */6 * * *"   // 每 6 小时一次

4.5 文件分工：DREAMS.md vs MEMORY.md

启用后 workspace 里会出现一组新文件：

memory/
├── .dreams/
│   ├── recall-store.json     # 短期召回库
│   ├── phase-signals.json    # 阶段强化信号
│   └── ingestion-checkpoint  # 摄入进度
├── dreaming/
│   ├── light/2026-05-19.md   # Light 阶段日报
│   ├── deep/2026-05-19.md    # Deep 阶段日报（含晋升详情）
│   └── rem/2026-05-19.md     # REM 阶段反思
DREAMS.md                       # 人类阅读用的"梦境日记"
MEMORY.md                       # 真正的长期记忆（只 Deep 阶段写）

4.6 Dream Diary：AI 自己写"日记"

最骚的功能。Dreaming 完成后会调一次 background subagent，让模型用自然语言写一段"梦境日记"追加到 DREAMS.md：

## Deep Sleep · 2026-05-19 03:00

今晚回顾了过去一周的对话。最反复出现的主题是用户在配置 Cloudflare R2 时遇到的
"endpoint URL invalid" 错误——这条信息在 5 天里被召回 8 次，跨了 3 个不同的
session，符合 Frequency × Recall × Diversity 的晋升标准，已写入 MEMORY.md。

另外有一条"用户偏好用 ini 而非 bash 标识 shell 代码块"的偏好被强化 4 次，
但跨 session 数不够（只有 1 个 session），暂列 candidate 池继续观察。

第一次读自己 AI 的"梦"是种很奇妙的体验——它真的有种"在反思"的感觉。

注意：Dream Diary 是给人看的，不是晋升源。只有"grounded memory snippets"才能进 MEMORY.md，AI 自己幻觉出的内容不会污染长期记忆。

4.7 CLI 工作流：手动 promote / 解释 / 预览

# 预览有哪些 candidate（不写）
openclaw memory promote
openclaw memory promote --limit 5

# 真写
openclaw memory promote --apply

# 看 Deep 阶段状态
openclaw memory status --deep

# 解释为什么某条没晋升
openclaw memory promote-explain "router vlan"
openclaw memory promote-explain "router vlan" --json

# 预览 REM 阶段产出（reflections + truths）
openclaw memory rem-harness
openclaw memory rem-harness --json

# 历史回填（grounded backfill，从老 YYYY-MM-DD.md 反向重建）
openclaw memory rem-backfill --path ./memory
openclaw memory rem-backfill --rollback   # 不喜欢就回滚

promote-explain 这个命令是真神器。每次你觉得"这条明明很重要为啥没晋升"，跑一下就告诉你具体卡在哪个分数 / 哪个阈值。

4.8 Slash 命令：聊天里直接控制

/dreaming status
/dreaming on
/dreaming off
/dreaming help

4.9 踩坑：blocked 状态怎么排查

跑一下：

openclaw memory status

如果输出 Dreaming status: blocked，意思是 managed cron 已建好但默认 agent 的 heartbeat 没在转。

修法：

1. 确认 default agent 启用了 heartbeat
2. 确认 heartbeat 的 target 不是 none
3. 等下一个 heartbeat 周期之后再跑 openclaw memory status --deep

我自己第一次启用就栽这坑里——以为 cron 自动跑就行，没意识到 cron 只是触发器，真正的 sweep 必须搭在 heartbeat 上才能跑完。

五、Specialist Lanes：多 Agent 不是"多开几个"，是"分摊瓶颈"

5.1 痛点：一个 Agent 啥都管 = 啥都管不好

我自己工作流目前有 4 个 Agent：

• 墨守 001：大总管，安全兜底、原始素材投递
• 墨客 002：写作（你正在读的这篇就是它写的）
• 墨盒 003：文件搬运、NAS 同步
• 墨攻 004：GitHub Pages 部署（规划中）

第一次配多 Agent 时我以为"多开几个不就完事"。结果连续翻车：

• 墨客在写长文，墨守想响应飞书新消息——卡住，因为模型 API 全局限流被吃满
• 墨盒在 scp 大文件，墨攻想跑 hugo build——卡住，因为 shell 容量被吃满
• 两个 Agent 都觉得"我应该处理这条消息"——双倍浪费 + 输出冲突

这才发现 OpenClaw 文档把这事讲得清清楚楚：多 Agent 的真正瓶颈不是"开了几个 Agent"，而是它们在抢什么资源。

5.2 First Principles：5 个真实瓶颈

OpenClaw 文档原话：

A specialist lane only improves throughput when it reduces contention for the real bottlenecks.

5 个真实瓶颈：

OpenClaw 默认已经做了两件事：

• session 级串行：一个 session 同时只允许一个 run mutate
• 全局并发上限：通过 command queue 限流

Specialist Lanes 的本质是在这两条之上叠加 policy：哪个 Agent 拥有哪类工作？哪些活留在聊天里？哪些活必须丢后台？

5.3 推荐 3 阶段渐进 rollout

Phase 1：Lane Contracts + Background Heavy Work（最便宜，最有效）

每个 Agent 在自己的 AGENTS.md 里写一份契约，包含 5 个要素：

# Lane Contract

## Owns（我负责什么）

- 写作（草稿、长文、社交平台改写）
- 选题筛选

## Does Not Own（我不碰的事）

- 文件同步 → 转交墨盒 003
- 网站部署 → 转交墨攻 004
- 飞书消息路由 → 转交墨守 001

## Chat Budget（聊天里的应答策略）

- 简单问题直接答
- 多步、慢、重 tool 的活：先简短 ack，然后丢后台 sub-agent
- 用户问"进度"时立即报告状态，不留白

## Handoff（转交时的格式）

转交时必须包含：
- 目标 lane（墨盒 003 / 墨攻 004 / ...）
- 任务目标
- 已完成的上下文摘要
- 下一步精确动作

## Tool Posture（工具姿态）

- 写作 lane 只用最小工具集（read / write / web_fetch）
- 严禁广撒网式 shell 操作
- 任何写盘动作前先 path validate

关键点：契约里 Does Not Own 比 Owns 重要。明确"不接哪些活"，比明确"接哪些活"更能避免 ownership ambiguity。

Phase 2：Priority + Concurrency 控制

调 queue 和模型容量，给重要 lane 留资源：

{
  agents: {
    defaults: {
      maxConcurrent: 4,
      subagents: {
        maxConcurrent: 8,
        delegationMode: "prefer"
      }
    }
  },
  messages: {
    queue: {
      mode: "collect",
      debounceMs: 1000,
      cap: 20,
      drop: "summarize"
    }
  }
}

• 直接对话 / 生产监控用高优先级 lane（low maxConcurrent，独占资源）
• 研究 / 草稿 / 批量 coding 用 lower 优先级，跑后台
• messages.queue.mode: "collect" 让 burst 消息合并成一个 followup turn（详见第六节）

Phase 3：Coordinator / Traffic Controller

只有当多个 lane 都活跃了再上：

• 跟踪每个 lane 当前的活
• 检测跨群重复请求（同一句话被两个 group 转发到同一个 lane）
• lane 之间路由 handoff summary
• 给 owner 只看 blockers / 完成结果 / 必须人审的决策

不要从 Phase 3 开始。“A coordinator without lane contracts just coordinates chaos.” 没有契约的 coordinator 协调的只是混乱。

5.4 实战：我的 4-Agent 配置

~/.openclaw/openclaw.json：

{
  agents: {
    defaults: {
      maxConcurrent: 4,
      subagents: { maxConcurrent: 8, delegationMode: "prefer" }
    },
    list: [
      {
        agentId: "001-moshou",
        agentDir: "~/.openclaw/agents/001-moshou/agent",
        // 大总管：所有飞书消息先到这里
      },
      {
        agentId: "002-moke",
        agentDir: "~/.openclaw/agents/002-moke/agent",
        // 写作 lane
      },
      {
        agentId: "003-inkbox",
        agentDir: "~/.openclaw/agents/003-inkbox/agent",
        // 同步 lane
      },
      {
        agentId: "004-mogong",
        agentDir: "~/.openclaw/agents/004-mogong/agent",
        // 部署 lane（规划中）
      }
    ]
  }
}

每个 Agent 有自己的 workspace、自己的 AGENTS.md/SOUL.md/MEMORY.md、自己的 auth profiles、自己的 session 历史。完全隔离。

5.5 踩坑：auth profile 不会跨 Agent 自动同步

这是文档里写得很明确但容易忽略的红线：

Never reuse agentDir across agents (it causes auth/session collisions).

Agents can read through to the default/main agent’s auth profiles when they do not have a local profile, but OpenClaw does not clone OAuth refresh tokens into the secondary agent store.

意思是：

• ❌ 多个 Agent 共用一个 agentDir → auth/session 冲突，惨案现场
• ✅ secondary agent 没有自己的 auth profile 时，只能读 main agent 的 static api_key/token，不能用 OAuth refresh token

如果要让多个 Agent 用同一个 OAuth 账号，每个 Agent 都得自己登录一次。手动复制 OAuth credential 几乎必败。

六、Queue Steering：让 AI 边干活边听你"叨叨"

6.1 痛点：AI 跑长工具链时无法纠偏

Agent 时代最反人类的体验之一：

你：帮我把这 50 篇文章批量改一下标题

AI：好，开始跑了…

（5 秒后）

你：等一下，标题里"2025"要改成"2026"

AI：（无视，继续跑原计划）……

等 AI 跑完 5 分钟才理你的修正。这个体验让人抓狂。

OpenClaw 默认开启的 Steering Queue 把这事彻底解决了。

6.2 原理：Runtime Boundary 注入

Steering 的设计哲学是：绝不打断正在跑的 tool call，但在模型边界上插入用户最新消息。

具体顺序（Pi 运行时）：

1. assistant 发起 tool calls
2. Pi 执行当前 assistant message 的 tool-call batch
3. Pi 触发 turn end 事件
4. Pi drains queued steering messages（关键步骤）
5. Pi 把这些消息当 user messages 拼到下一次 LLM 调用之前

这样既不破坏 tool result 与 assistant message 的配对（避免幻觉错乱），又能让下一次模型推理看到用户最新意图。

6.3 6 种模式对比

OpenClaw 给了 6 种 steering 模式，应付不同场景：

6.4 实战场景：什么时候用哪个？

6.5 配置：debounce 怎么调

{
  messages: {
    queue: {
      mode: "collect",
      debounceMs: 1000,
      cap: 20,
      drop: "summarize"
    }
  }
}

参数解释：

• mode: 上面 6 种之一
• debounceMs: 静默窗口。collect / followup / steer-backlog / steer fallback 用得到
• cap: 最多排队多少条消息
• drop: 超过 cap 怎么办（summarize 把多条合并、oldest 丢老的、newest 丢新的）

6.6 burst 例子：4 条消息同时进来

T0: AI 开始执行 tool call A
T1: 用户 1 发来 "等等，把日期改成 2026"
T2: 用户 2 发来 "顺便把 author 也改了"
T3: 用户 3 发来 "对了，标题去掉感叹号"
T4: 用户 4 发来 "如果耗时超过 5 分钟就停"
T5: AI tool call A 完成

不同模式的行为：

• steer：T5 时刻，AI 在下一次模型调用前看到 T1-T4 全部 4 条按到达顺序拼成的 user messages，一次性消化
• queue：T5 看到 T1，处理；T6 看到 T2，处理；T7 看到 T3……串行 4 轮
• collect：T5 等 debounce 1 秒，把 T1-T4 合并成一个新 followup turn 跑

steer 显然最像人类对话——你在地铁上跟同事讨论方案，对方边回边补充几条，你最终一起回应。queue 像古早 IRC，串行处理。

6.7 限制与边界

文档里几个关键限制：

Codex review and manual compaction turns reject same-turn steering.

• Codex 的 review turn 和手动 compaction turn 拒绝 same-turn steering。这两种 turn 不能被打断/插队，所以会回退到 followup 队列。
• Steering 总是针对当前活跃 session，不会创建新 session、不会改 tool policy、不会按 sender 拆分消息。

在多用户群聊里，inbound prompts 已经包含 sender 和路由上下文，所以下一次模型调用能看到"谁说了哪条"。

6.8 /steer 命令：显式插话

除了被动的 queue steering，还有主动的 /steer <message> 命令，立即插一条进队列：

/steer 注意只改 markdown 文件，不要碰 yaml

用于"我不想等 AI 走到下一个 boundary，但我也不想 abort 当前 run"的中间地带。

七、Compaction：长会话的"换气"机制

7.1 痛点：会话越跑越蠢

LLM 最反直觉的特性之一：上下文越长，模型越蠢。

• Token 越多，注意力越分散
• 每次 turn 都要重新读全部历史
• 重要决策淹没在闲聊里

跑了一周的 session，AI 有一半时间在"努力回忆我们 3 天前讨论了什么"，剩下一半时间在重复犯同一个错误。

OpenClaw 的解法叫 Compaction（会话压缩）：当 session 接近模型上下文上限时，自动把老对话浓缩成摘要，腾出空间给新对话。

7.2 触发时机

Compaction 不是定时跑的，是按需触发。触发条件包括：

• token 预算逼近上限（一般是 70-80%）
• 用户显式触发 /compact
• 某些 hook 主动调用

触发后会经过 session:compact:before → 实际压缩 → session:compact:after 三个生命周期事件，每个都可以挂 hook（见第三节）。

7.3 救命 Hook：在压缩前 dump 关键决策

这是 Compaction 最值得抢救的一刻。如果不主动备份，那些"已经沉到下方但未来可能很重要"的对话就被压成几句话的摘要了，细节永远丢失。

写一个 pre-compact-dump hook：

const handler = async (event) => {
  if (event.type !== "session" || event.action !== "compact:before") return;

  const { messageCount, tokenCount, sessionKey } = event.context;

  // 1. 抓最近 N 条消息
  const recent = await fetchRecentMessages(sessionKey, 50);

  // 2. 用规则筛"决策类"语句
  const decisions = recent.filter(m =>
    /决定|采用|放弃|改用|约定|不要再/.test(m.content)
  );

  // 3. 追加到 MEMORY.md
  const stamp = new Date().toISOString();
  await appendToMemory(`\n## Pre-compact dump @ ${stamp}\n` +
    decisions.map(d => `- ${d.content}`).join("\n")
  );

  event.messages.push(`💾 已备份 ${decisions.length} 条决策到 MEMORY.md`);
};

export default handler;

启用：

mkdir -p ~/.openclaw/hooks/pre-compact-dump
# 写 HOOK.md + handler.ts
openclaw hooks enable pre-compact-dump
openclaw gateway restart

7.4 compaction-notifier：让用户知道 AI 在"换气"

OpenClaw 自带 hook：

openclaw hooks enable compaction-notifier

启用后，会话压缩开始/结束时聊天里会出现明显提示：

🤖 OpenClaw is compacting the session transcript...
   (this might take a few seconds)
🤖 Compaction complete: 142 messages → 8.5k summary

体验上巨大改进——之前 AI 在那卡 10 秒不响应你不知道在干啥，现在你知道"它在换气"。

7.5 关于 command:stop 与 before_agent_finalize 的差异

文档里有一段容易踩坑的话：

command:stop observes the user issuing /stop; it is cancellation/command lifecycle, not an agent-finalization gate.

Plugins that need to inspect a natural final answer and ask the agent for one more pass should use the typed plugin hook before_agent_finalize instead.

翻译：

• command:stop 是用户主动按下停止键，跟"AI 自然完成"不是一回事
• 想在 AI 自然结束前介入（比如最后再 review 一遍），必须用 plugin hook before_agent_finalize

我第一次写"提交前 review"插件时把它挂在 command:stop 上，结果只有用户按 stop 才触发，AI 正常完成的情况下根本不跑。换 before_agent_finalize 立马解决。

7.6 Gateway 重启与 session_end

文档另一段重要约定：

Between the gateway:shutdown (or gateway:pre-restart) event and the rest of the shutdown sequence, the gateway also fires a typed session_end plugin hook for every session that was still active when the process stopped.

这意味着：

• Gateway 重启前，每个还活着的 session 都会收到 session_end 事件
• 你可以在这里做最后的清理（持久化、归档、通知）
• 但这个 drain 是有时限的，handler 卡住不会阻塞进程退出
• 已经被 replace/reset/delete/compaction 终结的 session 不会重复触发

如果你的工作流依赖"session 一定要优雅结束"，必须自己实现 idempotent 处理。指望 hook 兜底是不够的。

八、Putting It All Together：完整工作流示例

把这 6 个技巧拼成一个真实工作流，看怎么互相加成：

                  ┌────────────────┐
                  │  飞书消息进入   │
                  └───────┬────────┘
                          │
                ┌─────────▼──────────┐
        ◀───────│  message:received   │  ← Hook (PII 清洗)
                └─────────┬──────────┘
                          │
                ┌─────────▼──────────────┐
                │ 路由到对应 Agent (Lane)  │  ← Specialist Lanes
                │ (墨守 / 墨客 / 墨盒...)  │
                └─────────┬──────────────┘
                          │
                ┌─────────▼──────────────┐
                │ Agent 读取 AGENTS.md    │  ← Standing Orders
                │ (Authority/Trigger/...) │
                └─────────┬──────────────┘
                          │
              ┌───────────▼───────────┐
              │ AI 跑 tool chain       │
              └───────────┬───────────┘
                          │
              用户中途插话?│
                          ├─Yes─→ Steering Queue 排队等 boundary
                          ├─No──→ 继续
                          │
              ┌───────────▼───────────┐
              │ 接近 token 上限?        │
              └───────────┬───────────┘
                          │
                       Yes│
              ┌───────────▼───────────┐
              │ session:compact:before │  ← Hook (dump 决策)
              │ → 压缩                  │
              │ session:compact:after  │  ← Hook (notify)
              └───────────┬───────────┘
                          │
                          ▼
              ┌─────────────────────────┐
              │ 凌晨 3 点 cron 触发      │
              │ Dreaming sweep:         │
              │   Light → REM → Deep    │
              │ 关键内容写入 MEMORY.md   │
              └─────────────────────────┘

每一层都互相加成：

• Specialist Lanes 让消息路由到对的 Agent
• Standing Orders 让 Agent 知道自己负责什么
• Hooks 在关键节点插入定制逻辑
• Steering Queue 让用户实时纠偏
• Compaction 防止长会话拖垮系统
• Dreaming 把今天的有效信息晋升到长期记忆

这才是 OpenClaw 真正的设计目标——不是一个聊天网关，而是一套让 AI 能像人一样"上班"的运维操作系统。

九、写在最后：你的 AI 是临时工还是数字员工？

回头看本文 6 个技巧，每一个都对应一个真实问题：

如果你只是把 OpenClaw 当成"另一个 Claude Code 接到飞书"，那真的太亏了。

文档地址直接在你机器上：

ls /usr/local/lib/node_modules/openclaw/docs/
# automation/  cli/  concepts/  gateway/  plugins/  reference/  tools/ ...

每一个技巧本文都标了对应的文件路径。今晚翻一翻，明天开始让你的 AI 真正"上班"。

延伸阅读：

• OpenClaw 本地记忆神器：QMD 实现零 Token、毫秒级响应 - 配合 Dreaming 用，效果翻倍
• OpenClaw 进阶：Skills 配置 + Gateway 设置 + 对接飞书全攻略 - 基础环境
• OpenClaw 飞书插件踩坑：消息重复 + API 耗尽 - 多 Agent 配合飞书时必读

下篇预告：OpenClaw 多 Agent 协作实战——墨守、墨客、墨盒、墨攻是怎么联动的。把本篇 Specialist Lanes 那一节用真实代码完整演示。