@cyning/harness 2.5.0 → 2.7.0

package/CHANGELOG.md

@@ -4,6 +4,39 @@
 
 ## [Unreleased]
 
+## [2.7.0] - 2026-07-24
+
+### Added
+
+- **`harness/lifecycle.yaml`（方向二 · 文档先行）**：登记 task 状态 / 转移 / 守卫（`to_30` · `close`）；`task_lint` severity=`warn`。Schema：`schema/lifecycle.v1.schema.json`。
+- **`harness lifecycle show [--json]`**：只读渲染包内 yaml（**不做**转移引擎、不写盘）。
+- **`verify --task` ↔ task lint（N2）**：E 级仅 `WARN: task lint FAIL`（不改 exit / 不改 `may_start_30`）；`--allow-lint-fail` 抑制 WARN；handoff JSON 增加 `lint: { ok, errors, warnings, suppressed? }`；无 `--task` 全量模式不跑 lint。
+
+### Notes
+
+- 背景：Post-G4 方案 N1+N2 · rethink 方向二骨架；dogfood active lint FAIL 率高故本波不做 block。
+- SPEC：`docs/spec/SPEC-lifecycle-and-verify-lint_v1.md`
+- minor · `npm test` 含 lifecycle + verify-lint-warn
+
+## [2.6.0] - 2026-07-24
+
+### Added
+
+- **task lint · 思考轮结构规则组（G4）**：条件触发（行首 `### R0` 或 `##/###` 标题含「思考轮」）后检查：
+  - **E8** R0–R5 槽位标题齐全（`^### R\d` 前缀宽容）
+  - **E9** 控制表字段 `actual_last_round` / `early_stop` / `residual_risks`
+  - **E10** `early_stop=yes` 时 `early_stop_reason` 非空
+  - **W4** 无思考轮节（SPEC 承载 / bugfix 合法豁免提示）
+  - **W5** 存在 `### R6+` 但缺 `round_extension_note`
+- 槽内容 `（待填）` / `（跳过 · 见思考轮控制）` 合法；**不**查思考内容质量（20 帽职责）。
+- SPEC：`docs/spec/SPEC-task-lint-thinking-rounds_v1.md`
+
+### Notes
+
+- 背景：机械化率审计 G4（rethink 矩阵 P1 · 第三波）；与 G1 同命令、分开交付。
+- minor · 无 verify 行为变更 · `npm test` 含既有回归全绿
+- **已发布**：`@cyning/harness@2.6.0`（npm `latest` · 2026-07-24）· tag `v2.6.0` 已推送
+
 ## [2.5.0] - 2026-07-24
 
 ### Changed
@@ -18,6 +51,7 @@
 - 背景：机械化率审计 G2（rethink 矩阵 P0 最后一块）；22/20 帽自此脱离「全帽零机械」。
 - dogfood：工作区 approved 任务全过（含版本后缀变体 ops_clarify · 恰好是 R1 审查抓出的案例）。
 - minor · verify 行为变更（本版核心 · 见上）· `npm test` 118 全绿 · SPEC `docs/spec/SPEC-reviews-retention-gate_v1.md`
+- **已发布**：`@cyning/harness@2.5.0`（npm `latest` · 2026-07-24）· tag `v2.5.0` 已推送
 
 ## [2.4.0] - 2026-07-24
 

package/docs/ONBOARDING.md

@@ -45,10 +45,16 @@ cd your-project
 `npx @cyning/harness verify` 在 30 执行前聚合扫描人工闸与测试声明，确保 ICVO 公理可机械检查：
 
 ```bash
-# 30 前聚合验证（gate-check + audit D5 + S5 warn + 可选 --graph）
+# 30 前聚合验证（gate-check + audit D5 + reviews + S5 warn + 可选 --graph）
 npx @cyning/harness verify --target /path/to/your-repo
 npx @cyning/harness verify --target /path/to/your-repo \
   --task docs/tasks/active/task_xxx.md
+# --task 另跑 task lint（v2.7+ · E 级仅 WARN，不挡 may_start_30）
+# 抑制 lint WARN：加 --allow-lint-fail
+
+# 只读生命周期登记（方向二 · 非引擎）
+npx @cyning/harness lifecycle show
+npx @cyning/harness lifecycle show --json
 
 # 仅人工闸
 npx @cyning/harness gate-check --target /path/to/your-repo
@@ -67,6 +73,9 @@ npx @cyning/harness sync index --target /path/to/your-repo
 | **D3** | 30 前置人闸 | 复用 `gate-check.sh`，HG-AUDIT-R1 非 approved 时 verify 非 0 |
 | **D5** | 改码任务测试声明 | `test_strategy=required` 但无测试/CI 引用时 verify 非 0 |
 | **S5** | Git 工作区干净 | dirty 时 warn（不直接 fail verify，但 apply 须 `--force`） |
+| **lint** | task 结构（仅 `--task`） | v2.7+ E 级 → `WARN: task lint`（不改 exit / `may_start_30`） |
+
+生命周期真值：[`harness/lifecycle.yaml`](../harness/lifecycle.yaml)（`lifecycle show` 只读）。
 
 Audit **不替代** 维护者最终判断；Agent 首输出仍须人工复核。
 

package/docs/USER_GUIDE_v1.0_zh.md

@@ -111,8 +111,9 @@ npx @cyning/harness@1.0.1 init --preset harness-only --ide cursor,agents --yes
 **原则**：Agent 可以写 task 和 review，**人工闸只有维护者能签**。
 
 ```bash
-# 30 前聚合验证（gate-check + audit D5 + S5 warn + 可选 --graph）
+# 30 前聚合验证（gate-check + audit D5 + reviews + task lint WARN + S5 · 可选 --graph）
 npx @cyning/harness verify --target . --task docs/tasks/active/task_xxx.md
+# lint FAIL 仅 WARN（v2.7+ · 不挡 30）；抑制：--allow-lint-fail
 
 # Agent handoff（v2.0.2+）：JSON 路由 + 下一帽提示
 npx @cyning/harness verify --target . \
@@ -120,6 +121,9 @@ npx @cyning/harness verify --target . \
   [--json] [--agent-hint] \
   [--workspace-root /path/to/Projects]
 
+# 只读生命周期登记（方向二 · harness/lifecycle.yaml · 非引擎）
+npx @cyning/harness lifecycle show [--json]
+
 # 仅人工闸
 npx @cyning/harness gate-check --target . --task docs/tasks/active/task_xxx.md
 npx @cyning/harness gate-check --graph --target .    # Inform 图谱闸
@@ -136,6 +140,7 @@ npx @cyning/harness gate-check --graph --target .    # Inform 图谱闸
 | `HG-TASK-DRAFT` | task 初稿维护者签 | pending 且 blocks 含 30 → 拒 30 |
 | `HG-GRAPH-MODULES` | 架构模块表人签 | pending → 拒改码 30 |
 | `HG-RELEASE` | 发版闸（产品仓） | 一般业务仓不涉及 |
+| `task_lint`（v2.7+） | `verify --task` 结构检查 | **仅 WARN** · 不改 `may_start_30` |
 
 ### 5.1 Agent handoff（v2.0.2+）
 
@@ -150,6 +155,7 @@ npx @cyning/harness gate-check --graph --target .    # Inform 图谱闸
 | `entry_invoke_30_resolved` | 绝对路径（`Projects/` 前缀须 `--workspace-root`） |
 | `next_hat` | `"30"` 或 `null` |
 | `agent_preamble` | 短句提醒首输出 GATE_VERIFY |
+| `lint`（v2.7+ · 仅 `--task`） | `{ ok, errors, warnings, suppressed? }` · 不参与 `may_start_30` |
 
 Schema：[`schema/verify_result.v1.schema.json`](../schema/verify_result.v1.schema.json)
 
@@ -166,7 +172,8 @@ Schema：[`schema/verify_result.v1.schema.json`](../schema/verify_result.v1.sche
 | `npx @cyning/harness init` | 首次安装模板与 manifest（可选 `--with-scripts`） |
 | `npx @cyning/harness upgrade` | 同步产品包更新（可加 `--gate-check` 先 audit） |
 | `npx @cyning/harness check` | 检查是否有新版本 |
-| `npx @cyning/harness verify` | 30 前聚合：gate-check + audit D5 + S5 warn + 可选 `--graph` · v2.0.2+ `--json` / `--agent-hint` / `--workspace-root` |
+| `npx @cyning/harness verify` | 30 前聚合：gate-check + audit D5 + reviews +（`--task`）lint WARN + S5 · 可选 `--graph` / `--json` / `--allow-lint-fail` |
+| `npx @cyning/harness lifecycle show` | 只读展示 `harness/lifecycle.yaml`（状态/转移/守卫 · v2.7+ · 非引擎） |
 | `npx @cyning/harness gate-check` | 仅人工闸（`--graph` / `--json`） |
 | `npx @cyning/harness audit` | ICVO 机械审计（D3/D5/S5） |
 | `npx @cyning/harness sync index` | 生成 `.cyning-harness/invoke_index.json` |

package/docs/rethink/2026-07-mechanization-rate/01_big_directions.md

@@ -28,6 +28,7 @@ v2.2 的故事（invoke 留档连续 4 任务失守 → `task close` 补闸）
 
 CLI 今天是一袋动词，背后实际是**一个** task 生命周期：`draft → R1 → approved → 30 → 40 → done → archived`。`verify` 是 30 转移的前置检查，`close` 是 done→archived 转移——状态机是隐式的。
 显式化后（如 `lifecycle.yaml`：状态/转移/前置条件），方向一产出的每个新闸都有**天然挂点**；「这个 task 现在能做什么」一条命令可答（`verify --json` 的 handoff 是胚胎）。
+**落地（v2.7.0 · 文档先行）**：产品包真值 [`harness/lifecycle.yaml`](../../../harness/lifecycle.yaml) + `npx @cyning/harness lifecycle show [--json]`（只读 · **不做**转移引擎）；`verify --task` 已挂 `task_lint`（severity=warn）。
 **原则**：闸只挡实质、宽容形式（slug 事件教训：现实有两种命名惯例，闸太死就误伤）。
 
 ### 方向三 · Agent 一等公民接口（分发放大器）

package/docs/rethink/2026-07-mechanization-rate/03_coverage_matrix.md

@@ -37,7 +37,7 @@ description: 机械化率统计矩阵 + 缺口聚类 + 候选闸优先级排序
 | ~~P0~~ ✅ | **G1 · task md 结构 lint** | 高（下游全部闸的输入假设） | 低（解析与 M5 共享） | **已落地 v2.3.0**：`harness task lint`（E1–E7/W1–W3）· 不接入 verify（dogfood 后另议） | 10 产出时 |
 | ~~P0~~ ✅ | **G2 · reviews 留档闸** | 高（与 invoke 失守同构，且是 HG-AUDIT-R1 的签署依据） | 低（glob 命名模式） | **已落地 v2.5.0**：verify blocking（`missing R<n> review`）+ close 检查 6 · 豁免 `--allow-no-review` · 匹配两侧剥离版本后缀 | verify（30 前）· close（归档前） |
 | ~~P1~~ ✅（task 部分） | **G3 · 文本纪律 grep 闸** | 中 | 极低（正则） | **已落地 v2.3.0**（E6 绝对路径）；invoke 预写 approved grep 缓做（SPEC R2：误报不可控） | 同 G1 |
-| **P1** | **G4 · 思考轮结构检查** | 中（阶段 C 纪律，漏槽=思考轮形同虚设） | 中（格式变体多，须宽容：只查槽位存在与控制表字段，不查内容质量） | 并入 `task lint`：R0–R5 槽 + `actual_last_round`/`early_stop`/`residual_risks` 字段存在性 | 10 产出时 |
+| ~~P1~~ ✅ | **G4 · 思考轮结构检查** | 中（阶段 C 纪律，漏槽=思考轮形同虚设） | 中（格式变体多，须宽容：只查槽位存在与控制表字段，不查内容质量） | **已落地 v2.6.0**：`task lint` 条件触发 E8–E10 / W4–W5（有节才查 · 形态 B/C 仅 W4） | 10 产出时 |
 | **P2** | **G7 · 执行证据** | 高但难（「真跑过」本质要 runner 见证） | 高 | `harness run -- <验证命令>`：包装执行、留 exit code + 输出摘要到 `.cyning-harness/runs/`，40 回填引用 run id | 方向二状态机内再做 |
 | **P3** | **G6 · git 行为层** | 中 | 高（需 hook/平台集成） | 暂留 prompt 层；远期 Agent 契约（方向三）的行为审计范畴 | 方向三 |
 

package/docs/rethink/2026-07-mechanization-rate/04_next_steps.md

@@ -27,7 +27,7 @@ description: 结论与立项建议 · 缺口到 SPEC/task 的转化路径 + 与
 - `close` 可选增第 6 项检查（归档时 R1 审查文应仍在）
 - 注意与现有流程的兼容：`findReviewPath` 已被 `verify --json` 消费（handoff.review_path），本次是把它从「信息」升级为「闸」
 
-### 第三波 · 思考轮结构检查（G4）· 建议 v2.4.0
+### 第三波 · 思考轮结构检查（G4）· ✅ v2.6.0
 
 - 并入 `task lint` 但作为独立规则组；宽容度设计需 dogfood 一轮（工作区 task 的槽位写法变体多）
 - 只查结构（槽位存在、控制表字段），**不查**内容质量——质量判定永远留在 22 帽

package/docs/spec/SPEC-lifecycle-and-verify-lint_v1.md

@@ -0,0 +1,174 @@
+# SPEC：lifecycle.yaml 最小版 + verify↔lint 挂点（N1+N2）（v1）
+
+> **状态**：`signed`（维护者签收 2026-07-24 · 对话「签收」）  
+> **track**：`epic`  
+> **关联图谱**：无（纯 Harness 工具链 / 过程轨）  
+> **上游**：工作区 [`PLAN_post_g4_next_mechanization_v1_zh.md`](../../../docs/harness/guides/PLAN_post_g4_next_mechanization_v1_zh.md) · rethink [`01_big_directions`](../rethink/2026-07-mechanization-rate/01_big_directions.md) 方向二  
+> **前置**：G1–G4 文档闸 ✅ · `@cyning/harness@2.6.0`  
+> **下游**：00 已起草 task → 20-task-audit → HG-AUDIT-R1 → 30
+
+---
+
+## Harness 元信息
+
+| 字段 | 值 |
+|------|-----|
+| **spec_slug** | `lifecycle-and-verify-lint` |
+| **test_strategy** | `required` |
+| **test_strategy_note** | N1：schema 校验夹具 + fixture yaml；N2：verify 三态（无 lint 错 / warn / 豁免）+ 既有 verify 回归 |
+| **entry_invoke_10_spec** | `Projects/docs/harness/invokes/by-task/cyning-harness-lifecycle-and-verify-lint/invoke_20260724_10_spec_lifecycle_and_verify_lint.md` |
+| **entry_invoke_00_draft** | 工作区 `docs/harness/prompts/PROMPT_00_draft_spec_or_task_v1_zh.md` |
+
+---
+
+## 1. 背景与目标
+
+G1–G4 把「文档存在性/结构」闸补齐后，CLI 仍是一袋动词：新闸的挂点靠临场设计（verify？close？独立命令？）。rethink 方向二主张用 **`lifecycle.yaml`** 显式登记状态/转移/守卫，让补闸变便宜。
+
+同时 G1 遗留决策未闭合：`task lint` 是否接入 `verify`。2026-07-24 dogfood：**active 16 · PASS 1 · FAIL 15**——全量 block 会立即误伤工作区。
+
+**本 Epic 双目标**：
+
+1. **N1**：产品仓落地 `lifecycle.yaml` 最小真值（文档 + schema；可选只读 CLI），**不**实现状态机引擎。  
+2. **N2**：在 lifecycle 上裁定并实现 **verify↔lint** 挂点语义——本波 **warn-only**（见 R2），为将来升 block 留泄压阀与登记位。
+
+---
+
+## 2. 范围
+
+### N1 · lifecycle.yaml 最小版
+
+- **D1 · 真值文件**：`harness/lifecycle.yaml`（随包分发）描述：
+  - `states[]`：至少覆盖 `draft` · `in_progress` · `done` · `archived`（与 task 状态词表 / close 对齐；允许注释映射 `pending` 等别名）
+  - `transitions[]`：至少 `→30`（开工）与 `done→archived`（close）；每条含 `id` · `from` · `to` · `guards[]`
+  - `guards[]` 元素：`{ id, command_or_check, severity: block|warn, allow_flag? }`
+  - 本波须把 **既有** 守卫登记进去：`HG-AUDIT-R1` / reviews 留档 / audit D5 / `task close` 五～六检（描述级 · 不要求引擎执行）
+- **D2 · Schema**：`schema/lifecycle.v1.schema.json`（或等价 YAML schema）+ 非法 fixture 校验测试
+- **D3 · 只读 CLI（最小）**：`harness lifecycle show [--json]` —— 读包内 yaml · 打印状态/转移/守卫表；**不做**转移执行、不做持久化状态
+- **D4 · 文档**：USER_GUIDE 或 ONBOARDING 一小节 + CHANGELOG；rethink 01 方向二链到本文件
+
+### N2 · verify 接入 task lint（本波语义）
+
+- **D5 · 裁定落地（R2）**：**severity = warn**（非 block）
+  - `verify --task`：在 gate-check + audit + reviews 之后调用 `lintTaskFile`；有 E 级 → `WARN: task lint FAIL · …` 拼入 stdout，**不**改 exit / **不**改 `may_start_30`
+  - `--json` handoff 增字段：`lint_ok` · `lint_errors[]`（或 `lint: { ok, errors, warnings }`）
+  - 豁免：`--allow-lint-fail`（即使未来升 block 也复用此旗；本波 warn 模式下作用为「抑制 WARN 行」或留痕 `lint_suppressed`）
+- **D6 · lifecycle 登记**：`to_30` 守卫含 `task_lint` · `severity: warn` · `allow_flag: --allow-lint-fail`；注释写明升 `block` 的前置条件（见 §非范围 / residual）
+- **D7 · 测试**：verify fixture 三态（lint pass 无 warn / lint fail 有 warn 且 exit 0 / `--allow-lint-fail`）；既有 verify 用例不回归
+- **D8 · 版本**：**v2.7.0**（N1 文档+只读 CLI + N2 warn 行为；无硬 block）
+
+---
+
+## 3. 非范围
+
+- **状态机引擎**（按转移执行、写回 status、事件溯源）—— 方向二下一波  
+- **N2 选项 C（verify block lint）**—— 本波不做；待 active lint FAIL 率下降或另立「仅新流转」策略后再开  
+- `harness run` / G7 执行证据  
+- G6 git 行为层 · HGM G2 查询  
+- SPEC 审查文闸（N3）· verify 无 `--task` 全量模式纳入 reviews  
+- 强制修复工作区存量 15 个 FAIL task（可另开 hygiene task）  
+- 改变既有 E1–E10 规则集语义
+
+---
+
+## 4. 验收标准
+
+### N1
+
+- [ ] `harness/lifecycle.yaml` 可被 schema 校验通过；含 `to_30` 与 `close` 两条主转移及既有守卫登记
+- [ ] 非法 yaml（缺 states / 非法 severity）→ schema 或 `lifecycle show` 可失败可定位
+- [ ] `harness lifecycle show` 退出 0 · 人读表含状态与守卫；`--json` 输出稳定字段
+- [ ] 文档章节可从 README/ONBOARDING/USER_GUIDE 链到
+
+### N2
+
+- [ ] `verify --task` 对 lint FAIL 的 task：exit **0**（在其余闸通过时）且 stdout 含 `WARN: task lint`
+- [ ] lint PASS：无该 WARN
+- [ ] `--json` 含 lint 结果字段；`may_start_30` **不**因 lint FAIL 变 false（本波）
+- [ ] `--allow-lint-fail` 可抑制 WARN（或显式 `lint_suppressed: true`）
+- [ ] `npm test` 全绿（含既有 verify 回归）
+
+### 发布
+
+- [ ] CHANGELOG v2.7.0；PLAN / rethink 回链本 SPEC
+
+---
+
+## 5. failure_paths
+
+| 触发条件 | 系统行为 | 可重试 |
+|----------|----------|--------|
+| lifecycle.yaml 损坏 / 不符 schema | `lifecycle show` exit ≠0 · 信息可定位 | 修 yaml |
+| verify 时 task 文件不可读 | 既有 verify 行为不变 | 修正路径 |
+| lint FAIL（本波） | WARN · exit 仍由其余闸决定 | 修 task 或 `--allow-lint-fail` |
+| 业务仓未升级 2.7.0 | 无 lifecycle 子命令 · verify 无 lint WARN | upgrade |
+| 误以为 lint FAIL 会挡 30 | 文档 + lifecycle 表 severity=warn 明示 | — |
+
+---
+
+## 6. 依赖与引用
+
+- rethink 01 方向二；PLAN_post_g4 N1/N2  
+- `lib/task-lint.js` · `lib/verify.js` · `lib/task-meta.js`（handoff）  
+- G1 SPEC：刻意不接入 verify 的历史裁定 → 本 SPEC **修订**为 warn 挂点（非沉默独立）  
+- dogfood 证据：2026-07-24 active `PASS=1 FAIL=15`
+
+---
+
+## 7. 思考轮（10-spec 回填 · R0–R5）
+
+### R0 · 读入与约束
+
+读入：PLAN_post_g4（点菜 N1+N2）· rethink 01 方向二原文 · G1/G4 SPEC 非范围（verify 不接入）· verify.js 当前插点顺序（gate → audit D5 → reviews → S5 warn）· dogfood active 15/16 lint FAIL。约束：本波 **不**做引擎；闸三问（挂点/误报/泄压）必须过；不误伤存量。
+
+### R1 · 范围 / 非范围 / 场景
+
+**场景**：① 维护者/Agent 查「to_30 有哪些守卫」→ lifecycle show；② 30 前 verify 看到结构问题但不被存量堵死 → lint WARN；③ 未来升 block 时有登记位与 `--allow-lint-fail`。  
+**同 Epic 理由**：N2 的挂点必须写进 N1 的转移表，拆开会再临场一次。  
+**非范围**：引擎、C 硬挡、N3/N4/G6/G7——避免 Epic 膨胀。
+
+### R2 · 方案对比
+
+| 决策点 | 选项 | 裁定 | 理由 |
+|---|---|---|---|
+| N1 形态 | 仅 md 文档 / yaml+schema / yaml+引擎 | **yaml+schema+只读 show** | 真值可校验；引擎无消费者则违反「消费者先行」 |
+| N1 CLI | 无 / show / doctor+建议 | **show** | doctor 暗示修复策略，本波无库存治理承诺 |
+| N2 A 维持独立 | 永不进 verify | **否** | 丢掉机械化挂点；与方向二冲突 |
+| N2 B warn-only | verify 提示不挡 | **是 · 本波** | FAIL 率 15/16，block=治理负担 |
+| N2 C block+allow | 硬挡 + 豁免 | **推迟** | 须 hygiene 或「仅新流转」另 SPEC；本波在 yaml 预留 severity 升级路径 |
+| 版本 | 拆 2.7 docs + 2.8 lint | **同发 2.7.0** | 同 Epic 同挂点叙事；warn 非 breaking |
+
+### R3 · 边界 / 失败语义 / 安全
+
+- **挂点**：lint 检查时刻 = verify `--task`（产物 task md 已存在）✓；全量无 `--task` 模式本波 **不**跑 lint（与 G2 全量策略一致，避免扫库爆炸）。  
+- **误报**：沿用 lint 形式宽容；WARN 须带 rule 列表便于修。  
+- **泄压**：`--allow-lint-fail`；升 block 后同旗变豁免。  
+- **安全**：只读 lint；不改 task 文件；lifecycle show 不写盘。  
+- **兼容**：未升级仓行为不变。
+
+### R4 · 验收 / 可测性 / test_strategy
+
+`test_strategy: required`。N1：schema 正反例 + show JSON 快照字段。N2：verify 夹具三态 + 全量模式「不出现 lint WARN」断言。回归：既有 verify/close/lint 套件。
+
+### R5 · SPEC 签收就绪 · 是否可交 00 出 task
+
+SPEC 自足：双 D 包边界清晰，N2 裁定写死为 warn，C 升级条件在 residual。**可交 00**：建议单 task `cyning-harness-lifecycle-and-verify-lint`（D1–D8 同 PR），或拆 `…-lifecycle` + `…-verify-lint` 两 task 串行（lifecycle 先 merge）。图谱无需 bootstrap。版本 **v2.7.0**。
+
+### 思考轮控制
+
+| 字段 | 值 |
+|------|-----|
+| `actual_last_round` | `R5` |
+| `early_stop` | `no` |
+| `early_stop_reason` | — |
+| `residual_risks` | ① 升 C（block）时机依赖存量 FAIL 率或「新流转」定义未在本 SPEC 冻结；② lifecycle 描述级守卫与代码路径可能漂移——须 30 实现时对照 verify/close 源码回填 yaml；③ `lifecycle show` 若被误解为引擎，需文档醒目标「只读」 |
+| `round_extension_note` | — |
+
+---
+
+## 修订记录
+
+| 日期 | 摘要 |
+|------|------|
+| 2026-07-24 | 10-spec R0–R5（维护者点菜「开 N1+N2」）· 分支清理后同会话落盘 |
+| 2026-07-24 | 维护者签收（对话「签收」）· 下游 00 起草 task |

package/docs/spec/SPEC-task-lint-thinking-rounds_v1.md

@@ -0,0 +1,144 @@
+# SPEC：task lint 思考轮结构规则组（G4）（v1）
+
+> **状态**：`signed`（维护者签收 2026-07-24 · 对话「签收，继续」）  
+> **track**：`feature`  
+> **关联图谱**：无（纯 Harness 工具链）  
+> **上游思考**：[`docs/rethink/2026-07-mechanization-rate/`](../rethink/2026-07-mechanization-rate/)（缺口 G4 · P1）  
+> **前置**：v2.3.0 `task lint`（G1+G3）· 本 SPEC 为其规则组扩展  
+> **下游**：00 已起草 task → 20-task-audit → HG-AUDIT-R1 → 30
+
+---
+
+## Harness 元信息
+
+| 字段 | 值 |
+|------|-----|
+| **spec_slug** | `task-lint-thinking-rounds` |
+| **test_strategy** | `required` |
+| **test_strategy_note** | 条件触发三形态 + 每条 E/W 规则的 fail/pass fixture；`npm test` 全绿含回归 |
+| **entry_invoke_10_spec** | `Projects/docs/harness/invokes/by-task/cyning-harness-task-lint-thinking-rounds/invoke_20260724_10_spec_task_lint_thinking_rounds.md` |
+| **entry_invoke_00_draft** | 工作区 `docs/harness/prompts/PROMPT_00_draft_spec_or_task_v1_zh.md` |
+
+---
+
+## 1. 背景与目标
+
+rethink 02 D3：10 帽「预置 R0–R5 思考轮槽 + 思考轮控制表」是纯 Prompt 纪律（零机械）。v2.3.0 `task lint` 落地时本项被显式推迟（SPEC R1：写法变体多 · 宽容度需独立 dogfood）——本 SPEC 即第三波。
+
+**变体实测（2026-07-24 · SPEC 设计依据）**：
+
+| 形态 | 实例 | 占比（active 16） |
+|---|---|---|
+| **A · task 内嵌**（### R0–R5 + 控制表） | hat_chain_assessment · v0_2_d3_ide · ops_desk_kimi_code_spec_10_refine | ~2-3/16 |
+| **B · SPEC 承载**（task 无槽位 · 链 SPEC） | 近三波 task（lint/reviews-gate 等）· 3 份 SPEC 均有完整结构 | ~2/16 |
+| **C · 无思考轮**（bugfix 轨 / Issue≈SPEC） | hat_v2_split 等 | ~12/16 |
+
+**目标**：`task lint` 新增思考轮规则组——**条件触发**（有思考轮节才查结构完整性），只查结构不查内容质量；形态 B/C 不挡（W 级提示）。
+
+## 2. 范围
+
+- **D1 · `lib/task-lint.js` 规则组扩展**：
+  - 触发条件：文件含思考轮节（标题含「思考轮」或存在 `### R0` 槽标题）
+  - **E 级**（触发后）：E8 R0–R5 槽位标题齐全 · E9 控制表必填字段齐全（`actual_last_round` / `early_stop` / `residual_risks`）· E10 `early_stop=yes` 时 `early_stop_reason` 非空
+  - **W 级**：W4 无思考轮节（提示 · 注明 SPEC 承载/bugfix 轨合法豁免）· W5 存在 `### R6`+ 但 `round_extension_note` 缺失或为空
+  - 槽位内容为 `（待填）`/`（跳过 · 见思考轮控制）` **合法**（draft 期语义 · 同自检结论占位原则）
+- **D2 · 测试**：三形态（A 完整 pass / A 缺槽或缺字段 fail / B·C 仅 W4）+ E10 逻辑用例 + W5 用例；`npm test` 全绿含 118 例回归
+- **D3 · dogfood**：工作区 active + done tasks 全量 lint，三形态分布与规则命中落自检结论（只报告）
+- **D4 · 文档**：`harness/prompts/10-task-requirements.md` 思考轮摘要节补「v2.6+ task lint 机械检查结构」；CHANGELOG + 版本 **v2.6.0**；rethink 03 G4 行 ❌→✅
+
+## 3. 非范围
+
+- 思考轮**内容质量**判定（是否「真思考」）—— 20 帽职责，永不在 lint
+- SPEC 文件的 lint（E1 元信息字段不同 · 规则组设计为可复用，SPEC lint 下一轮）
+- `verify` 接入 lint（维持 v2.3 裁定 · 独立命令）
+- 强制所有 task 必须有思考轮（形态 B/C 合法 · 本闸不消灭变体）
+
+---
+
+## 4. 验收标准
+
+- [ ] 形态 A 完整（R0–R5 + 三字段 + early_stop 逻辑一致）→ 无 E · exit 0
+- [ ] 形态 A 缺槽（如缺 `### R3`）→ E8 exit 2；缺控制表字段 → E9；`early_stop=yes` 无 reason → E10
+- [ ] 形态 B/C（无思考轮节）→ 仅 W4 · exit 0
+- [ ] `### R6` 存在且 `round_extension_note` 空 → W5 · exit 0
+- [ ] 槽位 `（待填）`/`（跳过 · 见思考轮控制）` 不触发任何 E
+- [ ] `npm test` 全绿（新增用例 + 118 例回归）
+- [ ] dogfood 三形态分布落自检结论
+- [ ] 10-task Prompt + CHANGELOG（v2.6.0）；rethink G4 行 ❌→✅
+
+---
+
+## 5. failure_paths
+
+| 触发条件 | 系统行为 | 可重试 |
+|----------|----------|--------|
+| 有思考轮节但结构不全 | exit 2 · 逐条列出（E8/E9/E10）· 不改文件 | 补齐后重跑 |
+| 形态 B/C | W4 提示 · exit 0 | — |
+| 槽标题变体（如 `### R3 · 边界`） | 槽匹配按 `^### R\d` 前缀（形式宽容）| 误报则 dogfood 期调整 |
+| 既有 task 大量 W4 | 不影响 exit · dogfood 记录分布 | — |
+| 业务仓未升级 2.6.0 | 旧 lint 无本规则组 · 行为不变 | upgrade |
+
+---
+
+## 6. 依赖与引用
+
+- 复用：`lib/task-lint.js`（规则组框架 · E/W 分级）· `lib/task-meta.js`（`extractSection` 行首锚定）
+- 纪律原文：`harness/prompts/10-task-requirements.md`「OSS 阶段 C · 思考轮」节；工作区 `FRAGMENT_rethink_backfill_spec_v1_zh.md`（控制表字段定义）
+- 变体实测：2026-07-24 扫描（§1 表）
+- 缺口出处：rethink 02（D3）· 03（G4 行）· SPEC-task-lint-structure-gate R1（推迟裁定）
+
+---
+
+## 7. 思考轮（10-spec 回填 · R0–R5）
+
+### R0 · 读入与约束
+
+读入：rethink 02 D3 / 03 G4 / 04 第三波定义；v2.3 SPEC 的推迟裁定；变体实测数据（§1）；10-task 新帽思考轮摘要节（v2.4.0）。约束：只查结构不查内容是 04 定下的硬边界；不消灭形态 B/C（它们是 R1 审查已接受的合法轨）。
+
+### R1 · 范围 / 非范围 / 场景
+
+变体实测驱动设计：active 16 个中仅 ~3 个形态 A——**无条件强制槽位 = 误伤 80% 存量**，故核心设计是**条件触发**（有节才查）。场景：① 形态 A task 的 10 产出自查（主）；② 22/20 审查时辅助核对控制表；③ 维护者批量体检。SPEC 文件的结构与本规则组同构，但 E1 元信息字段不同（spec_slug ≠ task_slug），SPEC lint 不在本波（非范围已列）。
+
+### R2 · 方案对比
+
+| 决策点 | 选项 | 裁定 | 理由 |
+|---|---|---|---|
+| 触发方式 | 全员强制 / 条件触发 / 只对阶段 C 标记 task | **条件触发（有节才查）** | 变体实测：强制 = 80% 误伤；「阶段 C 标记」本身无机械标记可锚 |
+| 无思考轮节 | 沉默 / W4 提示 / E 级 | **W4** | 形态 B/C 合法但值得可见（提示里也写明豁免路径，教育新用户） |
+| 槽内容 | 查非占位 / 不查 | **不查**（`（待填）`/`（跳过）` 合法） | draft 期语义与自检结论占位原则一致；填没填的思考质量是 20 帽职责 |
+| early_stop 逻辑 | 查 / 不查 | **查（E10）** | `yes` 必须配 reason 是控制表自身的逻辑完整性，属结构非内容 |
+| R6+ | 不查 / W5 / E | **W5** | 扩展理由缺失值得提示，但 R6 使用率低，E 级过重 |
+| 槽标题匹配 | 精确 `### R0` | **`^### R\d` 前缀宽容**（允许 `### R3 · 边界` 后缀） | 实测槽标题带主题后缀是惯例 |
+
+### R3 · 边界 / 失败语义 / 安全
+
+- **E/W 分界原则**：触发后结构残缺 = E（有节就等于承诺了结构）；未触发 = 最多 W（不承诺不查）。
+- **触发条件假阳性**：文件正文提到「思考轮」三字但无槽位 → 触发条件要求「标题含思考轮 **或** 存在 `### R0` 槽标题」——纯文本提及（如本段）不触发，因为 `### R0` 必须行首锚定（extractSection 同款锚定）。「标题含思考轮」单独触发会不会误伤？一个写着「## 思考轮说明」但无槽的文件 → E8 fail。裁定：触发 = 存在 `^### R0` 槽标题 **或** `^#{2,3}.*思考轮` 标题；两者任一即按形态 A 要求。dogfood 验证误伤面（D3）。
+- **安全**：纯只读；无 git 动作；不影响既有 E1–E7 行为（118 例回归兜底）。
+
+### R4 · 验收 / 可测性 / test_strategy
+
+`test_strategy: required`。fixture：形态 A 完整 / 缺槽 / 缺字段 / early_stop 无 reason / R6 无扩展理由 / 形态 B / 形态 C / 槽标题带后缀宽容 / 正文提及「思考轮」不触发。dogfood 落三形态分布与 W4 计数。
+
+### R5 · SPEC 签收就绪 · 是否可交 00 出 task
+
+SPEC 自足：条件触发模型有三形态实测支撑，E/W 边界清晰，宽容条款逐条在案。**可交 00 起草 task**。图谱：纯工具链。版本 v2.6.0（lint 规则组扩展 · 无 verify 行为变更）。落地后 rethink 矩阵 ❌ 8 → 7；P1 队列余 SPEC 审查闸与 verify 全量模式决策。
+
+### 思考轮控制
+
+| 字段 | 值 |
+|------|-----|
+| `actual_last_round` | `R5` |
+| `early_stop` | `no` |
+| `early_stop_reason` | — |
+| `residual_risks` | ① 触发条件的假阳性（文件有「思考轮」标题但槽在别处）——dogfood D3 实测，必要时触发条件收紧为仅 `### R0`；② 历史形态 A 文件可能结构不全被 E 挡（存量仅 ~3 个 · 影响面小且可豁免豁免阀之外直接修复）；③ SPEC lint 复用需求可能提前到来（规则组已按可复用设计） |
+| `round_extension_note` | — |
+
+---
+
+## 修订记录
+
+| 日期 | 摘要 |
+|------|------|
+| 2026-07-24 | 10-spec R0–R5 同会话回填（维护者点菜「1」）· 基于 rethink G4 + 变体实测（形态 A/B/C 分布） |
+| 2026-07-24 | 维护者签收（对话「签收，继续」）· 下游 00 起草 task |

package/harness/lifecycle.yaml

@@ -0,0 +1,69 @@
+# Task lifecycle · 最小真值（方向二文档先行 · v1）
+#
+# 只读登记：状态 / 转移 / 守卫。不由引擎执行。
+# CLI：npx @cyning/harness lifecycle show [--json]
+# Schema：schema/lifecycle.v1.schema.json
+
+version: "1"
+
+states:
+  - id: draft
+    note: "含 pending / active 等词表别名 · 见 KNOWN_STATUS_TOKENS"
+  - id: in_progress
+  - id: done
+    note: "close 可接受 completed 别名"
+  - id: archived
+    note: "task close 归档后 · 物理上在 done/ 目录"
+
+transitions:
+  - id: to_30
+    from: ["draft", "in_progress"]
+    to: in_progress
+    hat: "30"
+    description: "执行帽开工（verify --task 聚合）"
+    guards:
+      - id: HG-AUDIT-R1
+        command_or_check: "gate-check · human_gate HG-AUDIT-R1=approved"
+        severity: block
+      - id: HG-TASK-DRAFT
+        command_or_check: "gate-check · HG-TASK-DRAFT=approved（blocks 22,30）"
+        severity: block
+      - id: audit_D5
+        command_or_check: "verify/audit · test_strategy vs 测试文件存在"
+        severity: block
+      - id: reviews_retention
+        command_or_check: "verify · findReview R<n> 存在性（v2.5+）"
+        severity: block
+        allow_flag: "--allow-no-review"
+      - id: task_lint
+        command_or_check: "verify --task · lintTaskFile（v2.7+）"
+        severity: warn
+        allow_flag: "--allow-lint-fail"
+        note: "升 block 前置：active lint FAIL 率下降或另立「仅新流转」SPEC（N2-C）"
+
+  - id: close
+    from: ["done"]
+    to: archived
+    hat: "close"
+    description: "task close · active→done 归档"
+    guards:
+      - id: close_invoke
+        command_or_check: "task close 检查1 · invoke 快照存在"
+        severity: block
+      - id: close_self_check
+        command_or_check: "task close 检查2 · 自检结论已回填"
+        severity: block
+      - id: close_acceptance
+        command_or_check: "task close 检查3 · 验收勾选"
+        severity: block
+        allow_flag: "--allow-unchecked"
+      - id: close_slug
+        command_or_check: "task close 检查4 · slug 一致"
+        severity: block
+      - id: close_status
+        command_or_check: "task close 检查5 · 状态 done/completed"
+        severity: block
+      - id: close_review
+        command_or_check: "task close 检查6 · R<n> 审查文（v2.5+）"
+        severity: block
+        allow_flag: "--allow-no-review"

package/harness/prompts/10-task-requirements.md

@@ -40,12 +40,14 @@
 - 10-task 草稿 **须预置 R0 + R1–R5** 五槽 + **思考轮控制** 表（见 `wizard/templates/TASK_TEMPLATE_upstream_pr_v1.md`）。
 - **可提前停 / 可增 R6+**；须填 reason · residual_risks（无则 `none`）。
 - **20-task-audit 审思考是否充分**；不通过 → **退回 10-task** 补轮后再审 R+1。
+- **v2.6+ 机械检查结构**（条件触发）：`task lint` 在存在 `### R0` 或思考轮标题时查 E8–E10（槽位/控制表/`early_stop` 逻辑）；无节仅 W4（SPEC 承载 / bugfix 合法）；不查内容质量。
 
 ## 修订记录
 
 | 日期 | 摘要 |
 |------|------|
 | 2026-07-24 | V2 拆分收编：自 `10-requirements.md` 改名为 `10-task-requirements.md`（来源：工作区 `10-task-requirements.md` · 2026-06-12 v2） |
+| 2026-07-24 | G4：思考轮摘要节补 v2.6+ `task lint` 条件触发结构检查 |
 
 ## 给 Cursor
 

package/lib/cli.js

@@ -42,6 +42,7 @@ function usage(version = 'unknown') {
   npx @cyning/harness audit [--target PATH] [--task FILE]
   npx @cyning/harness gate-check [--target PATH] [--task FILE] [--graph] [--json]
   npx @cyning/harness verify [--target PATH] [--task FILE] [--graph] [--json] [--agent-hint] [--workspace-root PATH]
+  npx @cyning/harness lifecycle show [--json]
   npx @cyning/harness sync index [--target PATH]
   npx @cyning/harness task check --file PATH [--no-circular] [--registry DIR]...
   npx @cyning/harness task close --file PATH [--target PATH] [--yes] [--allow-unchecked]
@@ -61,7 +62,8 @@ function usage(version = 'unknown') {
   check       读 manifest.json · 对比当前包版本是否有可升级版本
   audit       ICVO 机械审计：复用 gate-check · D5 测试声明检查 · S5 git-clean 提醒
   gate-check  调用 wizard/gate-check.sh（业务仓无需 clone 即可用）
-  verify      30 前聚合：gate-check + audit D5 + S5 warn + 可选 --graph
+  verify      30 前聚合：gate-check + audit D5 + reviews + task lint WARN（v2.7+）+ S5 warn + 可选 --graph
+  lifecycle   只读展示 harness/lifecycle.yaml（状态/转移/守卫 · v2.7+）
   sync index  生成 .cyning-harness/invoke_index.json
   task check  校验 task.harness.v1.json sidecar · --no-circular 检测 depends_on 环
   task close  受闸归档：5 项机械校验（invoke/自检结论/勾选/slug/状态）后 mv active→done（v2.2+）
@@ -128,6 +130,10 @@ export async function runCli(argv) {
     await cmdVerify(rest);
     return;
   }
+  if (cmd === 'lifecycle') {
+    await cmdLifecycle(rest);
+    return;
+  }
   if (cmd === 'sync') {
     await cmdSync(rest);
     return;
@@ -386,11 +392,12 @@ async function cmdVerify(args) {
   // D3 · implemented in lib/verify.js
   const { verifyTarget, buildVerifyHandoff, formatAgentHint } = await import('./verify.js');
   if (args.includes('--help') || args.includes('-h')) {
-    console.log(`用法: npx @cyning/harness verify [--target PATH] [--task FILE] [--graph] [--json] [--agent-hint] [--workspace-root PATH]
+    console.log(`用法: npx @cyning/harness verify [--target PATH] [--task FILE] [--graph] [--json] [--agent-hint] [--workspace-root PATH] [--allow-no-review] [--allow-lint-fail]
 
-无 --task 时：扫描 docs/tasks/active/task_*.md 并逐项列出闸表（同 gate-check）。
+无 --task 时：扫描 docs/tasks/active/task_*.md 并逐项列出闸表（同 gate-check）；本波不跑 task lint。
 任一 task 阻塞则 VERIFY: BLOCKED · exit 2；全部可 30 则 VERIFY: PASS。
---json：输出 Agent handoff JSON（may_start_30 · entry_invoke_30 · review_path 等）。
+--task：另跑 task lint；E 级仅 WARN（v2.7+ · 不改 may_start_30）；--allow-lint-fail 抑制 WARN。
+--json：输出 Agent handoff JSON（may_start_30 · entry_invoke_30 · review_path · lint 等）。
 --agent-hint：人类可读 handoff 摘要（可与 --json 同用）。
 --workspace-root：解析 task 中 Projects/ 前缀的 entry_invoke 路径。
 `);
@@ -408,7 +415,15 @@ async function cmdVerify(args) {
   const json = rest.includes('--json');
   const agentHint = rest.includes('--agent-hint');
   const allowNoReview = rest.includes('--allow-no-review');
-  rest = rest.filter((a) => a !== '--graph' && a !== '--json' && a !== '--agent-hint' && a !== '--allow-no-review');
+  const allowLintFail = rest.includes('--allow-lint-fail');
+  rest = rest.filter(
+    (a) =>
+      a !== '--graph' &&
+      a !== '--json' &&
+      a !== '--agent-hint' &&
+      a !== '--allow-no-review' &&
+      a !== '--allow-lint-fail',
+  );
 
   if (rest.length > 0) {
     const err = new Error(`verify 未知参数: ${rest.join(' ')}`);
@@ -417,7 +432,7 @@ async function cmdVerify(args) {
   }
 
   const target = resolveTarget(process.cwd(), targetArg);
-  const result = verifyTarget(target, { taskFile, graph, allowNoReview });
+  const result = verifyTarget(target, { taskFile, graph, allowNoReview, allowLintFail });
 
   // forward gate-check/audit/graph stdout if any（--json 时仍透传机械闸表）
   if (result.stdout && !json) {
@@ -431,6 +446,7 @@ async function cmdVerify(args) {
     taskFile,
     workspaceRoot: workspaceRoot ? path.resolve(workspaceRoot) : undefined,
     allowNoReview,
+    allowLintFail,
   });
 
   if (json) {
@@ -458,6 +474,37 @@ async function cmdVerify(args) {
   }
 }
 
+async function cmdLifecycle(args) {
+  const { loadLifecycle, formatLifecycleShow } = await import('./lifecycle.js');
+  const [sub, ...rest] = args;
+  if (!sub || sub === '--help' || sub === '-h' || args.includes('--help') || args.includes('-h')) {
+    console.log(`用法: npx @cyning/harness lifecycle show [--json]
+
+只读展示产品包 harness/lifecycle.yaml（状态 / 转移 / 守卫登记）。
+不做转移执行、不写盘（方向二文档先行 · v2.7+）。
+`);
+    return;
+  }
+  if (sub !== 'show') {
+    const err = new Error(`lifecycle 子命令未知: ${sub}\n用法: lifecycle show [--json]`);
+    err.exitCode = 1;
+    throw err;
+  }
+  const json = rest.includes('--json');
+  const unknown = rest.filter((a) => a !== '--json');
+  if (unknown.length > 0) {
+    const err = new Error(`lifecycle show 未知参数: ${unknown.join(' ')}`);
+    err.exitCode = 1;
+    throw err;
+  }
+  const { data } = loadLifecycle();
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(formatLifecycleShow(data));
+  }
+}
+
 async function cmdSync(args) {
   if (args.includes('--help') || args.includes('-h')) {
     console.log(`用法: npx @cyning/harness sync index [--target PATH]`);
@@ -630,10 +677,12 @@ async function cmdTaskLint(args) {
   if (args.includes('--help') || args.includes('-h')) {
     console.log(`用法: npx @cyning/harness task lint --file PATH [--json]
 
-task md 结构闸（G1）+ 文本规则包（G3）· 纯只读：
+task md 结构闸（G1）+ 文本规则包（G3）+ 思考轮结构（G4）· 纯只读：
   E 级（exit 2）：E1 元信息/task_slug · E2 状态行 · E3 验收标准含勾选项
     E4 失败路径节 · E5 自检结论节 · E6 绝对本机路径 · E7 slug 一致
+    E8–E10（条件触发：有 ### R0 或思考轮标题）：槽位齐全 · 控制表字段 · early_stop 逻辑
   W 级（仅 warn）：W1 状态 token 词表外 · W2 缺人工闸节 · W3 自检结论占位
+    W4 无思考轮节（形态 B/C 豁免提示）· W5 R6+ 缺 round_extension_note
   末行协议：LINT: PASS · <file> / LINT: FAIL · <file>
   --json：{ok, errors[], warnings[], file, slug}（errors 元素 {rule, message, line?}）
 `);

package/lib/lifecycle.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'js-yaml';
+import { resolveHarnessRoot } from './paths.js';
+
+const SEVERITIES = new Set(['block', 'warn']);
+
+/**
+ * 轻量结构校验（不引入 Ajv）：对齐 schema/lifecycle.v1.schema.json 必填约束。
+ * @returns {{ ok: boolean, errors: string[] }}
+ */
+export function validateLifecycle(data) {
+  const errors = [];
+  if (!data || typeof data !== 'object') {
+    return { ok: false, errors: ['lifecycle 根须为 object'] };
+  }
+  if (typeof data.version !== 'string' || !data.version.trim()) {
+    errors.push('缺 version（string）');
+  }
+  if (!Array.isArray(data.states) || data.states.length === 0) {
+    errors.push('缺 states[] 或为空');
+  } else {
+    data.states.forEach((s, i) => {
+      if (!s || typeof s.id !== 'string' || !s.id.trim()) {
+        errors.push(`states[${i}] 缺 id`);
+      }
+    });
+  }
+  if (!Array.isArray(data.transitions) || data.transitions.length === 0) {
+    errors.push('缺 transitions[] 或为空');
+  } else {
+    data.transitions.forEach((t, i) => {
+      if (!t || typeof t.id !== 'string' || !t.id.trim()) {
+        errors.push(`transitions[${i}] 缺 id`);
+      }
+      if (!Array.isArray(t?.from) || t.from.length === 0) {
+        errors.push(`transitions[${i}] 缺 from[]`);
+      }
+      if (typeof t?.to !== 'string' || !t.to.trim()) {
+        errors.push(`transitions[${i}] 缺 to`);
+      }
+      if (!Array.isArray(t?.guards)) {
+        errors.push(`transitions[${i}] 缺 guards[]`);
+      } else {
+        t.guards.forEach((g, j) => {
+          if (!g || typeof g.id !== 'string') {
+            errors.push(`transitions[${i}].guards[${j}] 缺 id`);
+          }
+          if (!g || typeof g.command_or_check !== 'string') {
+            errors.push(`transitions[${i}].guards[${j}] 缺 command_or_check`);
+          }
+          if (!g || !SEVERITIES.has(g.severity)) {
+            errors.push(
+              `transitions[${i}].guards[${j}] severity 须为 block|warn（当前: ${g?.severity}）`,
+            );
+          }
+        });
+      }
+    });
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+/**
+ * 加载并校验 lifecycle.yaml。
+ * @param {{ harnessRoot?: string, filePath?: string }} [options]
+ */
+export function loadLifecycle(options = {}) {
+  const harnessRoot = options.harnessRoot ?? resolveHarnessRoot();
+  const filePath =
+    options.filePath ?? path.join(harnessRoot, 'harness', 'lifecycle.yaml');
+
+  if (!fs.existsSync(filePath)) {
+    const e = new Error(`lifecycle.yaml 不存在: ${filePath}`);
+    e.exitCode = 1;
+    throw e;
+  }
+
+  let data;
+  try {
+    data = yaml.load(fs.readFileSync(filePath, 'utf8'));
+  } catch (err) {
+    const e = new Error(`lifecycle.yaml 解析失败: ${err.message}`);
+    e.exitCode = 1;
+    throw e;
+  }
+
+  const v = validateLifecycle(data);
+  if (!v.ok) {
+    const e = new Error(`lifecycle.yaml 校验失败:\n  - ${v.errors.join('\n  - ')}`);
+    e.exitCode = 1;
+    e.validationErrors = v.errors;
+    throw e;
+  }
+
+  return { data, filePath, harnessRoot };
+}
+
+/**
+ * 人读表。
+ */
+export function formatLifecycleShow(data) {
+  const lines = [
+    `lifecycle v${data.version}`,
+    '',
+    '## states',
+    ...data.states.map((s) => `- ${s.id}${s.note ? ` · ${s.note}` : ''}`),
+    '',
+    '## transitions',
+  ];
+  for (const t of data.transitions) {
+    lines.push(`### ${t.id} · ${t.from.join('|')} → ${t.to}${t.hat ? ` · hat=${t.hat}` : ''}`);
+    if (t.description) lines.push(`  ${t.description}`);
+    for (const g of t.guards) {
+      const allow = g.allow_flag ? ` · allow=${g.allow_flag}` : '';
+      lines.push(`  - [${g.severity}] ${g.id}: ${g.command_or_check}${allow}`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n').trimEnd();
+}

package/lib/task-lint.js

@@ -17,6 +17,14 @@ import {
  */
 const ABS_PATH_RE = /(\/(?:Users|home|root)\/[^\s/`\\]|[A-Za-z]:\\Users\\[^\s`\\])/;
 const FAILURE_HEADING_RE = /^#{2,4}\s.*(失败路径|failure_paths)/i;
+/** G4 触发：行首 ### R0（可带后缀） */
+const R0_HEADING_RE = /^###\s+R0(\b|[^\d]|$)/m;
+/** G4 触发（叠加）：行首 ##/### 标题含「思考轮」 */
+const THINK_HEADING_RE = /^#{2,3}\s+.*思考轮/m;
+/** 槽位标题：### Rn（前缀宽容） */
+const RN_HEADING_RE = /^###\s+R(\d+)\b/gm;
+/** 控制表字段行：| `field` | / | **field** | / | field | */
+const CTRL_FIELD_RE = /^\|\s*`?\*{0,2}([a-z_]+)\*{0,2}`?\s*\|\s*(.*?)\s*\|/i;
 
 function err(rule, message, line) {
   return line ? { rule, message, line } : { rule, message };
@@ -25,8 +33,79 @@ function warn(rule, message, line) {
   return line ? { rule, message, line } : { rule, message };
 }
 
+function parseControlFields(lines) {
+  const fields = {};
+  for (const l of lines) {
+    const m = l.match(CTRL_FIELD_RE);
+    if (!m) continue;
+    const key = m[1].toLowerCase();
+    let val = m[2].trim();
+    if (val.startsWith('`') && val.endsWith('`')) val = val.slice(1, -1).trim();
+    fields[key] = val;
+  }
+  return fields;
+}
+
+function isEmptyCtrlValue(val) {
+  if (val == null) return true;
+  const v = String(val).trim();
+  return v === '' || v === '—' || v === '-' || v === '–';
+}
+
+/**
+ * G4 · 思考轮结构规则组（条件触发）。
+ * 触发优先：存在 ### R0；叠加：行首 ##/### 含「思考轮」。
+ * 正文提及「思考轮」不触发。
+ */
+function lintThinkingRounds(content, lines, errors, warnings) {
+  const hasR0 = R0_HEADING_RE.test(content);
+  const hasThinkHeading = THINK_HEADING_RE.test(content);
+  const triggered = hasR0 || hasThinkHeading;
+
+  if (!triggered) {
+    warnings.push(
+      warn('W4', '无思考轮节（SPEC 承载 / bugfix 轨合法豁免 · 有节则查 R0–R5 与控制表）'),
+    );
+    return;
+  }
+
+  // E8 · R0–R5 槽位齐全
+  const found = new Set();
+  const rnRe = new RegExp(RN_HEADING_RE.source, 'gm');
+  let m;
+  while ((m = rnRe.exec(content)) !== null) {
+    found.add(Number(m[1]));
+  }
+  const missing = [];
+  for (let i = 0; i <= 5; i += 1) {
+    if (!found.has(i)) missing.push(`R${i}`);
+  }
+  if (missing.length) {
+    errors.push(err('E8', `思考轮槽位不全，缺：${missing.join(', ')}`));
+  }
+
+  // E9 / E10 · 控制表字段
+  const fields = parseControlFields(lines);
+  const required = ['actual_last_round', 'early_stop', 'residual_risks'];
+  const missFields = required.filter((k) => !(k in fields));
+  if (missFields.length) {
+    errors.push(err('E9', `思考轮控制表缺字段：${missFields.join(', ')}`));
+  }
+
+  const early = (fields.early_stop || '').toLowerCase();
+  if (early === 'yes' && isEmptyCtrlValue(fields.early_stop_reason)) {
+    errors.push(err('E10', 'early_stop=yes 时 early_stop_reason 须非空'));
+  }
+
+  // W5 · R6+ 须有 round_extension_note
+  const hasR6Plus = [...found].some((n) => n >= 6);
+  if (hasR6Plus && isEmptyCtrlValue(fields.round_extension_note)) {
+    warnings.push(warn('W5', '存在 ### R6+ 但 round_extension_note 缺失或为空'));
+  }
+}
+
 /**
- * task lint · task md 结构闸（G1）+ 文本规则包（G3）。
+ * task lint · task md 结构闸（G1）+ 文本规则包（G3）+ 思考轮结构（G4）。
  * 纯只读；E 级 → ok:false（CLI exit 2），W 级仅提醒。
  */
 export function lintTaskFile(filePath, options = {}) {
@@ -114,6 +193,9 @@ export function lintTaskFile(filePath, options = {}) {
     warnings.push(warn('W2', '缺 ### 人工闸 节（轻量 task 可忽略本提醒）'));
   }
 
+  // G4 · 思考轮结构（条件触发）
+  lintThinkingRounds(content, lines, errors, warnings);
+
   return {
     ok: errors.length === 0,
     errors,

package/lib/verify.js

@@ -1,15 +1,16 @@
 import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
 import path from 'node:path';
 import { resolveHarnessRootForTarget, wizardScript } from './paths.js';
 import { auditTarget } from './audit.js';
 import { buildTaskHandoff, findReview, listActiveTasks } from './task-meta.js';
+import { lintTaskFile } from './task-lint.js';
 
 /**
- * 30 前聚合验证：gate-check + audit D5（仅 --task）+ reviews 留档闸（仅 --task）+ S5 git-clean warn + 可选 --graph
+ * 30 前聚合验证：gate-check + audit D5（仅 --task）+ reviews 留档闸（仅 --task）
+ * + task lint WARN（仅 --task · v2.7+）+ S5 git-clean warn + 可选 --graph
  */
 export function verifyTarget(target, options = {}) {
-  const { taskFile, graph, allowNoReview = false } = options;
+  const { taskFile, graph, allowNoReview = false, allowLintFail = false } = options;
   const harnessRoot = resolveHarnessRootForTarget(target);
 
   // 1. gate-check（含 --graph）
@@ -49,12 +50,22 @@ export function verifyTarget(target, options = {}) {
         };
       }
     }
+
+    // 3b. task lint（N2 · v2.7+）：severity=warn · 不改 exit / may_start_30
+    const lint = runTaskLintForVerify(target, taskFile);
+    if (!lint.ok) {
+      if (allowLintFail) {
+        gateResult.stdout += `WARN: task lint FAIL suppressed（--allow-lint-fail · 留痕）\n`;
+      } else {
+        const rules = lint.errors.map((e) => e.rule).join(',');
+        gateResult.stdout += `WARN: task lint FAIL · ${rules || 'errors'}（不挡 may_start_30 · 修结构或 --allow-lint-fail）\n`;
+      }
+    }
   }
 
   // 4. S5 git-clean：warn 不挡
   const gitResult = runGitCleanCheck(target);
   if (gitResult.dirty) {
-    // 把 warn 拼到 stdout 里让 CLI 透传
     const warn = `WARN: 工作区未 clean（S5）：建议 commit 后再执行 apply\n`;
     gateResult.stdout += warn;
   }
@@ -66,6 +77,39 @@ export function verifyTarget(target, options = {}) {
   };
 }
 
+function runTaskLintForVerify(target, taskFile) {
+  try {
+    return lintTaskFile(taskFile, { cwd: target });
+  } catch (err) {
+    return {
+      ok: false,
+      errors: [{ rule: 'E_IO', message: err.message }],
+      warnings: [],
+    };
+  }
+}
+
+/** 规范化 lint 结果供 handoff */
+export function lintSnapshotForHandoff(target, taskFile, { allowLintFail = false } = {}) {
+  if (!taskFile) return null;
+  let result;
+  try {
+    result = lintTaskFile(taskFile, { cwd: target });
+  } catch (err) {
+    result = {
+      ok: false,
+      errors: [{ rule: 'E_IO', message: err.message }],
+      warnings: [],
+    };
+  }
+  return {
+    ok: result.ok,
+    errors: result.errors ?? [],
+    warnings: result.warnings ?? [],
+    suppressed: Boolean(allowLintFail && !result.ok),
+  };
+}
+
 function runGateCheck(target, taskFile, graph, harnessRoot) {
   const script = wizardScript(harnessRoot, 'gate-check.sh');
   const args = [script, '--target', target];
@@ -171,13 +215,14 @@ function runGitCleanCheck(target) {
  * 构建 verify --json / --agent-hint 的 Agent handoff 载荷。
  */
 export function buildVerifyHandoff(target, options = {}) {
-  const { taskFile, workspaceRoot, allowNoReview = false } = options;
+  const { taskFile, workspaceRoot, allowNoReview = false, allowLintFail = false } = options;
   const handoffOpts = { workspaceRoot };
 
   if (taskFile) {
     const handoff = buildTaskHandoff(target, taskFile, handoffOpts);
     const reviewOk = handoff.review_found || allowNoReview;
     const verifyOk = handoff.may_start_30 && reviewOk;
+    const lint = lintSnapshotForHandoff(target, taskFile, { allowLintFail });
     return {
       schema_version: '1',
       verify_ok: verifyOk,
@@ -185,6 +230,7 @@ export function buildVerifyHandoff(target, options = {}) {
       may_start_30: verifyOk,
       blocked_reason: handoff.blocked_reason ?? (reviewOk ? null : 'missing R<n> review'),
       next_hat: verifyOk ? '30' : null,
+      lint,
     };
   }
 
@@ -231,6 +277,11 @@ export function formatAgentHint(payload) {
     if (item.next_hat) {
       lines.push(`  next_hat: ${item.next_hat}`);
     }
+    if (item.lint) {
+      const n = item.lint.errors?.length ?? 0;
+      const tag = item.lint.suppressed ? 'suppressed' : item.lint.ok ? 'ok' : `FAIL(${n})`;
+      lines.push(`  lint: ${tag}`);
+    }
     for (const w of item.warnings ?? []) {
       lines.push(`  warn: ${w}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyning/harness",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "cyning-harness discipline package · init / upgrade / check CLI",
   "license": "MIT",
   "type": "module",

package/schema/lifecycle.v1.schema.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://cyning.dev/schemas/cyning-harness/lifecycle.v1.json",
+  "title": "cyning-harness Task Lifecycle (minimal)",
+  "description": "状态/转移/守卫登记 · 只读真值 · 非引擎（v2.7+）",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["version", "states", "transitions"],
+  "properties": {
+    "version": {
+      "type": "string",
+      "description": "lifecycle 文档 schema 版本"
+    },
+    "states": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "note": { "type": "string" }
+        }
+      }
+    },
+    "transitions": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "from", "to", "guards"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "from": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "type": "string", "minLength": 1 }
+          },
+          "to": { "type": "string", "minLength": 1 },
+          "hat": { "type": "string" },
+          "description": { "type": "string" },
+          "guards": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["id", "command_or_check", "severity"],
+              "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "command_or_check": { "type": "string", "minLength": 1 },
+                "severity": { "type": "string", "enum": ["block", "warn"] },
+                "allow_flag": { "type": "string" },
+                "note": { "type": "string" }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/schema/verify_result.v1.schema.json

@@ -35,6 +35,16 @@
           "type": "array",
           "items": { "type": "string" }
         },
+        "lint": {
+          "description": "v2.7+ · 仅 --task；不参与 may_start_30",
+          "type": ["object", "null"],
+          "properties": {
+            "ok": { "type": "boolean" },
+            "errors": { "type": "array" },
+            "warnings": { "type": "array" },
+            "suppressed": { "type": "boolean" }
+          }
+        },
         "gates": {
           "type": "array",
           "items": {