From a4874dcce3c36d1c13c349b5db62acea3554ce5f Mon Sep 17 00:00:00 2001
From: qxbyte <xueqiang361@gmail.com>
Date: Sun, 5 Jul 2026 16:43:59 +0800
Subject: [PATCH 1/8] feat(specode): add intake skill (project analysis +
 clarify + write requirements)

New standalone skill (skills/intake/, peer to specode/ and distill/),
user-invocable:false, invoked by the orchestration SKILL via the Skill
tool during the requirements phase. Owns the four intake sub-steps
(project_root confirm / agent-docs scan / experience retrieval / draft),
preserves the requirements.md frontmatter contract (spec_id / created_at
/ project_root via write-project-root single writer), and is the primary
node for ragkit/experience retrieval. Quality lives in Step 2 (read real
code) + Step 3 (analysis-driven clarification), not a thin questionnaire.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Qiang Xue <qxbyte@users.noreply.github.com>
---
 plugins/specode/skills/intake/SKILL.md | 103 +++++++++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 plugins/specode/skills/intake/SKILL.md

diff --git a/plugins/specode/skills/intake/SKILL.md b/plugins/specode/skills/intake/SKILL.md
new file mode 100644
index 0000000..87a1bff
--- /dev/null
+++ b/plugins/specode/skills/intake/SKILL.md
@@ -0,0 +1,103 @@
+---
+name: intake
+user-invocable: false
+description: specode 的需求 intake 引擎——项目分析 + 定位 + 澄清 + 写 requirements.md。在 spec 起始阶段（requirements phase）由 specode 编排 SKILL 通过 Skill 工具按名调用（specode:intake），取代旧的「brainstorming 兼职写需求 / 或薄弱 native 问卷」。产出 <specsRoot>/<slug>/requirements.md（含 project_root frontmatter 契约）+ 交给 design 阶段的定位指针。不是用户直接触发的命令。
+---
+
+# intake — specode 需求 intake 引擎
+
+## §0 你是谁 / 何时被调用
+
+- specode 编排壳在 **requirements phase** 通过 `Skill` 工具按名调用你（`specode:intake`）；此时 `<specsRoot>` 已解析、`<specsRoot>/<slug>/` 目录已建、slug 已定。
+- 你是 requirements 的**唯一生产者**——specode 不再分「superpowers 在/不在」两条 requirements 路径。superpowers 的 `brainstorming` 从此**只做 design**（产 design.md），不再兼职写需求。
+- 你相对旧「native 2-4 问问卷」的价值全在 **§3 项目分析** + **§4 基于分析的澄清**：先读真实项目建立事实基线，再问有依据的问题——这才是 specode 版的"驱动生成能力"，不是空泛问卷。
+- 你的产物：
+  1. `<specsRoot>/<slug>/requirements.md`（散文需求 + 硬 frontmatter 契约，见 §1）；
+  2. 一段交给 design 阶段的「**参考定位（非事实来源）**」定位指针（§5，临时上下文，不持久化为事实）。
+
+## §1 硬约束 🔒（绝不可动）
+
+1. **frontmatter 契约（最高优先级，用户明确要求保留）**：`requirements.md` 顶部 YAML **必须**含三个字段——`spec_id` / `created_at` / `project_root`。其中 **`project_root` 是下游 distill / task-swarm / retrieval 的单一事实源**，**只能**经 `resolve_root.py write-project-root` 单一验证写入口落盘（它校验绝对路径 / 目录存在 / `/Volumes` 挂载），**绝不手写该字段**。你换的是"谁生成 requirements 的正文内容"，**绝不破坏这套契约元素**。
+2. **散文需求**：`requirements.md` 是自然语言 spec（背景 / 范围 in-out / `- [ ] AC-N` / 开放问题），**无形式化子句、无 checkbox**——计划在 tasks.md、设计在 design.md，别越界。Bug 修复用 Current / Expected 散文写在这里，不单独建 `bugfix.md`。
+3. **用户可见输出中文**；技术名 / 路径 / 代码标识符 / frontmatter 键名保持英文原样。
+4. **不回贴全文**（见 §6 报告纪律）。
+
+## §2 run.sh resolver 前缀（每次 CLI 调用）
+
+所有 `resolve_root.py` 调用**必须**走 `run.sh` 包装器 + 绝对 plugin-root。skill 驱动的 Bash 里 `$CLAUDE_PLUGIN_ROOT` 不一定有值，必须 `find` 兜底。shell 状态不跨 Bash 调用保留，所以**每次**都带这段自包含 resolver 前缀：
+
+```bash
+R="${CLAUDE_PLUGIN_ROOT:-$CODEBUDDY_PLUGIN_ROOT}"; [ -f "$R/scripts/run.sh" ] || R="$(find "$HOME/.claude/plugins/cache" "$HOME/.codebuddy/plugins/cache" -path '*/specode/*/scripts/run.sh' 2>/dev/null | sort -V | tail -1)"; R="${R%/scripts/run.sh}"
+sh "$R/scripts/run.sh" "$R/scripts/resolve_root.py" <verb> <args...>
+```
+
+## §3 autonomous-mode 感知（每个 AskUserQuestion 站点适用）
+
+本 skill 有两处会 `AskUserQuestion`（§Step1 project_root 确认、§Step3 澄清）。每处**先**按 specode 的 autonomous-mode 规则判定是否跳过：用 `resolve_root.py read-defaults --key interactive --json` 取 `interactive`，用 `read-defaults --key <relevant> --json` 取该 gate 的 effective value + source；当 `interactive == false` 且该 key `source ∈ {env, file}`（有效值非 schema default）时，**跳过提问直接用 default**（autonomous / CI 路径）；否则原样 `AskUserQuestion`。Mapping：project_root 确认 → `project_root_default`；澄清 → 无独立 key，仅受 `interactive` 主开关约束（非交互则基于已有信息尽力起草、把不确定项写进「开放问题」而非阻塞）。
+
+## §4 流程（5 步，质量在 Step 2–3）
+
+### Step 1 — project_root 确认（必做，autonomous-aware）
+
+1. 取默认：`resolve_root.py resolve-project-root`（返回 cwd 的 `git rev-parse --show-toplevel`，无 git 则 cwd）。
+2. 按 §3 决定：`AskUserQuestion` 一次（默认值预选，让用户确认或覆盖）/ 或 autonomous 直接用 default。
+3. **持有确认的绝对路径**——Step 2（约束扫描 + 检索）用它、Step 4 经 `write-project-root` 落盘。此刻 requirements.md frontmatter 尚未写，直接用持有的绝对路径，**不要** `read-project-root`。
+
+### Step 2 — 项目分析（intake 高于问卷的关键，先读真实项目再问）
+
+不是"问用户要什么"就完事——**先读真实项目建立事实基线**：
+
+- **a. 项目级约束扫描**（filesystem-only）：扫下列存在的文件并以 **path-only**（不拷内容）注入 requirements 草稿的 `## 项目级约束（CLAUDE.md / AGENT.md）` 段。扫描序（去重、仅存在的）：(1) `<project_root>/CLAUDE.md|AGENTS.md|AGENT.md|CODEBUDDY.md`；(2) `<project_root>` 直接父目录下同 4 文件（覆盖 monorepo workspace 根）；(3) 用户描述中点名的子目录。段模板：
+
+  ```markdown
+  ## 项目级约束（CLAUDE.md / AGENT.md）
+
+  > 主 agent 的 system prompt 已自动加载下列文件；这里列出来是为了 design / 执行阶段 / 下游 task-swarm subagent 都能看见这条约束链路。**优先级高于本 spec 的其他描述**：冲突时以下列文件为准。
+
+  - `<abs/path/to/CLAUDE.md>`
+  - `<abs/path/to/parent/AGENTS.md>`
+  ```
+
+  为何 path-only：主 agent 上下文已有完整内容，复制一遍只是冗余 + 陈旧风险；task-swarm 渲染 task.md 时按同样规则把路径塞进 subagent prompt。一个文件都没扫到（典型 fresh 项目）→ **整段省略**（不写「无」之类占位）。
+
+- **b. 经验检索定位**（`<project_root>/knowledge-base/MEMORY.md` 存在时）——**这是 ragkit / 经验检索的主节点**。按 `skills/specode/references/retrieval.md` 跑：先试 Tier-0 Gate（`ragkit:query` 可用且 `knowledge-base/.ragkit/chunks.json` 存在时多路召回），否则两级 gated（Tier-1 读 MEMORY 小索引比对当前需求页面/字段/域，命中才 Tier-2 读 ≤5 点全文）。产出「**参考定位（非事实来源）**」指针（文件路径 + 调用链）。`MEMORY.md` 不存在 → **静默跳过**（不报错、不写空段）。**顶层不变量**：指针只定位真实代码，**真实代码是唯一事实**；不把 KB 内容当当前代码的真相。
+
+- **c. 读真实代码**：对 b 定位到的关键文件**实际打开读**（不只拿路径）——理解现有结构 / 命名 / 模式，作为需求分析与范围界定的事实基线。
+
+- **d. fresh 项目**（无 knowledge-base、无 agent docs）→ b/c 静默跳过，靠 Step 3 澄清 + 用户描述建立理解。
+
+### Step 3 — 澄清（brainstorming 级，非固定问卷）
+
+在 Step 2 的项目分析之上做**逐条澄清**（一次一个问题、优先多选），围绕 **purpose / scope（in / out）/ constraints / success criteria**。关键：**由 Step 2 的分析驱动**——问的是「基于现有的 `X` 代码/模式，这个需求该怎样接入 / 边界在哪」这类**有依据的问题**，不是空泛问卷。
+
+- autonomous-aware（§3）：非交互则基于已有信息尽力起草，把不确定项写进「开放问题」，不阻塞。
+- **何时停**：intent / scope / AC 足够清晰、开放问题已列出即可——不要过度追问（YAGNI）。
+
+### Step 4 — 写 requirements.md
+
+按 `assets/templates/requirements.md` 结构写正文：`## 背景 / 为什么` · `## 范围`（包含 / 不包含）· `## 验收标准`（`- [ ] AC-N`，可观察可验证）· `## 开放问题`（+ Step 2a 的 `## 项目级约束` 段，若有）。落 `<specsRoot>/<slug>/requirements.md`。
+
+然后落 **frontmatter（§1 硬约束）**：
+
+1. 写 `spec_id: <slug>` / `created_at: YYYY-MM-DD`（可随正文一起写进顶部 YAML）。
+2. **`project_root` 只经单一写入口落盘**：
+   ```bash
+   sh "$R/scripts/run.sh" "$R/scripts/resolve_root.py" write-project-root --spec <specsRoot>/<slug> --root <Step1 确认的绝对路径>
+   ```
+   它校验并把 `project_root` 写进 requirements.md frontmatter。**绝不手写该字段。**
+
+### Step 5 — 交接给 design
+
+把 Step 2b 的「参考定位（非事实来源）」指针作为**临时上下文**交回 specode 编排（供 design 阶段用：specode 调 `brainstorming` 时把这段作为 context 传入，或 native design 直接沿用）。**不持久化为 requirements.md 的事实结论**（retrieval.md 顶层不变量）。design 默认继承这些指针、仅在开辟 intake 未覆盖的新领域时才补查（design 的检索是**条件性 top-up**，非强制）。
+
+交接后**结束本 skill**，把控制权还给 specode 编排（它接着进入 design phase）。
+
+## §5 报告纪律
+
+不回贴 requirements.md 全文。报告只含：文件路径（一行）+ 3-8 条要点/关键澄清 + 开放问题（若有）+ 下一步（进入 design）。唯一例外是用户明确要求看全文。
+
+## §6 References
+
+- `skills/specode/references/retrieval.md` — 经验检索规格（Step 2b 的引擎；intake 是其**主节点**）。
+- `assets/templates/requirements.md` — 需求模板（Step 4 结构 + frontmatter 契约）。
+- `skills/specode/SKILL.md` §Autonomous-mode defaults rule — §3 判定的完整规则来源。

From 7c42284e2f87e6931576985774bf88133d993a42 Mon Sep 17 00:00:00 2001
From: qxbyte <xueqiang361@gmail.com>
Date: Sun, 5 Jul 2026 16:46:52 +0800
Subject: [PATCH 2/8] feat(specode): SKILL delegates requirements to
 specode:intake; design single-artifact
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Flow step 2 (requirements) now invokes the specode:intake skill (always,
  no superpowers fork); the four intake sub-steps + frontmatter contract
  live in skills/intake/SKILL.md.
- Flow step 3 (design): brainstorming produces design.md only (single
  artifact), pre-instructed that requirements are already settled; note
  that brainstorming's auto-handoff to writing-plans now aligns with the
  design→tasks order. Relocation check = one file.
- Flow step 4 (tasks): writing-plans' execution-handoff question is
  ignored (not "suppressed") — specode's selector supersedes it.
- Fallback matrix, quick map, orchestration+relocation, iron rule 1, and
  continuation row all updated; requirements retrieval is the primary
  node, design is a conditional top-up.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Qiang Xue <qxbyte@users.noreply.github.com>
---
 plugins/specode/skills/specode/SKILL.md | 55 +++++++++----------------
 1 file changed, 20 insertions(+), 35 deletions(-)

diff --git a/plugins/specode/skills/specode/SKILL.md b/plugins/specode/skills/specode/SKILL.md
index 9b49f2f..199c89d 100644
--- a/plugins/specode/skills/specode/SKILL.md
+++ b/plugins/specode/skills/specode/SKILL.md
@@ -91,36 +91,19 @@ fi
 Each phase is annotated "if superpowers is installed, call it / otherwise go native". To decide "installed or not": **first try to call the matching superpowers skill via the `Skill` tool; if it is unavailable (skill missing / call fails), take the native branch.**
 
 1. **specsRoot**: `get-root` (first-time setup if missing) → obtain `<specsRoot>` → `mkdir -p <specsRoot>/<slug>/` (the host agent derives the kebab-case slug from the request).
-2. **requirements (clarify + requirements)** — four sub-steps, always in this order:
-   1. **`project_root` confirmation (required)**: get the default via `resolve_root.py resolve-project-root` (it returns `git rev-parse --show-toplevel` of cwd, falling back to cwd) and call `AskUserQuestion` **once** with that default pre-selected to let the user confirm or override. Hold the confirmed absolute path; it's needed by sub-steps 2–3 (docs scan + 经验检索) and gets persisted to frontmatter at sub-step 4 **via `resolve_root.py write-project-root`** (the single writer — do not hand-write the frontmatter field).
-   2. **Project-level agent docs scan (filesystem-only, no memory recall)**: scan the filesystem for project-level agent-instruction docs and inject them as a `## 项目级约束（CLAUDE.md / AGENT.md）` section into the requirements draft. Scan order (deduped, only existing files): (1) `<project_root>/CLAUDE.md|AGENTS.md|AGENT.md|CODEBUDDY.md`; (2) `<project_root>` 直接父目录下同 4 个文件（覆盖 monorepo workspace 根，如 `wework-ops-assistant/CLAUDE.md` 而下挂子 git repo 自身没有）;(3) 任何已经在用户描述中点名的子目录（如「ops-web 模块」）。Template — **paths only, do not copy content**:
+2. **requirements (clarify + requirements)** — **invoke the `specode:intake` skill via the `Skill` tool** and let it own this whole phase. intake is a **standalone specode skill** (`skills/intake/`, peer to `distill`, `user-invocable: false`) — it is the **sole producer of `requirements.md`**; there is **no** "superpowers vs native" fork here anymore (`brainstorming` is used only for design, see step 3). intake internally runs, in order: (1) `project_root` confirmation (`resolve-project-root` default → `AskUserQuestion` once, autonomous-aware) — it holds the confirmed absolute path; (2) **project analysis**: agent-docs scan (`## 项目级约束` path-only section) + **experience retrieval — this is the primary retrieval node** (per `references/retrieval.md`: Tier-0 RagKit / two-tier gated) + actually reading the located real code; (3) analysis-driven clarification (brainstorming-caliber, one question at a time, not a fixed wizard); (4) write `requirements.md` per the template **and persist the frontmatter contract** — `spec_id` / `created_at` + `project_root` **via `resolve_root.py write-project-root`** (single validated writer; never hand-write it); (5) hand the located 「参考定位（非事实来源）」 pointers back as ephemeral context for design. Full behavior lives in `skills/intake/SKILL.md` — do not re-derive it here.
 
-      ```markdown
-      ## 项目级约束（CLAUDE.md / AGENT.md）
-
-      > 主 agent 的 system prompt 已自动加载下列文件；这里列出来是为了 design / 执行阶段 / 下游 task-swarm subagent 都能看见这条约束链路。**优先级高于本 spec 的其他描述**：发生冲突时以下列文件为准。
-
-      - `<abs/path/to/CLAUDE.md>`
-      - `<abs/path/to/parent/AGENTS.md>`
-      ```
-
-      为何 path-only 而非内容拷贝：主 agent 的上下文里已经有完整内容，requirements.md 复制一遍只是冗余 + 内容陈旧风险。task-swarm 0.7.3+ 渲染 task.md 时会按同样的扫描规则把这些路径塞进 coder/reviewer/validator prompt（subagent 进程不自动加载这些文件，必须用路径告知），所以 specode + task-swarm 联合保证从 requirements → design → 执行 → subagent 整条链路都看得见项目级约束。若一个文件都没扫到（典型的 fresh 项目），**整段省略**（不要写「无」之类占位）。
-
-      > **v4.0.0 BREAKING + 新检索（philosophy 不同，勿混为一谈）**: 旧的 P3-1 codemap recall（确定性脚本把历史**内容**当事实自动注入、不省 token）已于 4.0.0 **完全移除**——不再自动从 `.ai-memory/knowledge/` 召回任何东西。**现引入一套全新的、定位优先的经验检索**（下面的 sub-step 3，规格见 `references/retrieval.md`）：注入的是**指针非事实**、由**模型判断**而非脚本召回、默认只读小索引、读 `<project_root>/knowledge-base/`（**非**旧 `.ai-memory/knowledge/`）。要手动把经验沉淀进 `knowledge-base/`，用 `/specode:distill <slug>`（见 §Acceptance 末尾的沉淀提示 + `skills/distill/SKILL.md`）。
-   3. **经验检索（若 `<project_root>/knowledge-base/MEMORY.md` 存在）**: 用 sub-step 1 已确认的 `project_root`（此时 requirements.md frontmatter 尚未写，直接用持有的绝对路径，不要 `read-project-root`），按 `references/retrieval.md` 跑**两级 gated** —— Tier-1 读 `knowledge-base/MEMORY.md` 小索引、比对当前需求的页面/字段/域；命中才 Tier-2 读 ≤5 个点全文、用其前后端文件 + 调用链**定位真实代码**。命中结果贴成「**参考定位（非事实来源）**」段，仅作需求分析 / 范围界定的输入：**定位用、非事实**——指针只指向真实代码，**真实代码才是唯一事实**；**不写进 `requirements.md` 的事实结论**。`knowledge-base/MEMORY.md` 不存在（fresh 项目 / 未 distill 过）→ **静默跳过**，不报错、不写空段。引擎细节（两级触发条件 / 注入格式 / schema 契约）见 `references/retrieval.md`，此处不重述。
-   4. **draft requirements (+ design, dual-artifact)**:
-      - superpowers installed → call `superpowers:brainstorming` **once, spanning the requirements AND design phases** (it internally does clarification + requirements exploration + design presentation + the user-approval gate). Pre-instruct it with **two** target paths: 澄清结论 → `<specsRoot>/<slug>/requirements.md`, 设计展示 → `<specsRoot>/<slug>/design.md` (per the `assets/templates/design.md` sections).
-      - not installed → **specode-native**: the host agent clarifies with an `AskUserQuestion` wizard (2-4 blocking sub-questions), then writes per the `assets/templates/requirements.md` template.
-      - Relocate the artifact(s) to `<specsRoot>/<slug>/requirements.md`（superpowers 路径还要检查 `design.md`，见 §superpowers orchestration + relocation）.
-      - Write the YAML frontmatter: set `spec_id: <slug>` / `created_at: YYYY-MM-DD`, then persist `project_root` **via `resolve_root.py write-project-root --spec <specsRoot>/<slug> --root <abs from sub-step 1>`** (single validated writer; never hand-write this field).
+   > **frontmatter 契约 🔒**: `requirements.md` 的 `spec_id` / `created_at` / `project_root` 是下游 distill / task-swarm / retrieval 的单一事实源；`project_root` 只经 `write-project-root` 单一写入口落盘。intake 负责保证这套契约，specode 编排不重复写、不手改。
 3. **design (传统设计文档)**:
-   - superpowers installed → `design.md` was already produced by the step-2 brainstorming call (dual-artifact); verify it landed at `<specsRoot>/<slug>/design.md` and covers the template sections, backfilling gaps if needed.
-   - not installed → **specode-native**: the host agent authors `design.md` per the `assets/templates/design.md` template（背景与目标 / 架构概览 / 模块划分与职责 / 接口设计 / 数据流 / 错误处理 / 测试策略——散文，无 checkbox）.
-   - **经验检索（同 requirements，定位用）**: design 同样按 `references/retrieval.md` 跑**两级 gated** —— 此 phase frontmatter 已写，用 §specsRoot resolver `resolve_root.py read-project-root --spec <specsRoot>/<slug>` 取 `project_root`；命中点的前后端文件 + 调用链用于把**模块边界 / 接口设计 ground 到真实代码**（design 的判断仍基于真实代码，检索只缩短定位延迟）。`<project_root>/knowledge-base/MEMORY.md` 不存在 → 静默跳过。
+   - superpowers installed → call `superpowers:brainstorming` for **design only** (single artifact → `design.md`). Pre-instruct it: **requirements are already settled in `requirements.md` (read it as input) — go straight to design presentation, produce only `design.md`** per the `assets/templates/design.md` sections (背景与目标 / 架构概览 / 模块划分与职责 / 接口设计 / 数据流 / 错误处理 / 测试策略——散文，无 checkbox); also pass intake's 「参考定位（非事实来源）」 pointers as ephemeral grounding context. Relocate the artifact to `<specsRoot>/<slug>/design.md` (post-relocation check = **one** file).
+
+     > brainstorming 的终态硬编码为「invoke writing-plans」——这正好对齐 specode 的 design → tasks 顺序，**顺其自然即可**：让它（或你）产完 design.md 后进入 tasks phase（step 4），不要在 design 里另起炉灶。
+   - not installed → **specode-native**: the host agent authors `design.md` per the `assets/templates/design.md` template（同上七节，散文无 checkbox）.
+   - **经验检索（条件性 top-up，非强制）**: design 默认**继承 intake（step 2）已定位的指针**，不重复全量检索。仅当 design 开辟了 intake 未覆盖的新领域时，才按 `references/retrieval.md` 补查一次（此 phase frontmatter 已写，用 `resolve_root.py read-project-root --spec <specsRoot>/<slug>` 取 `project_root`）；命中点的前后端文件 + 调用链用于把**模块边界 / 接口设计 ground 到真实代码**（design 的判断仍基于真实代码）。`<project_root>/knowledge-base/MEMORY.md` 不存在 → 静默跳过。
 
-   > **v4.0.0 BREAKING**: 旧的 P3-2 rule-acknowledgement post-check 段（grep `[[rule-*]]` 是否被 design.md 引用并 AskUser 处理偏离）**仍保持移除**——design 阶段不做任何与 `.ai-memory/knowledge/rules/` 关联的 rule 检查。上面的 design 检索是**定位用**（把设计 ground 到真实代码），**不引入任何「规则确认 / 偏离 gate」**——它只产出指针，不产出 must / 规则。
+   > **v4.0.0 BREAKING**: 旧的 P3-2 rule-acknowledgement post-check 段（grep `[[rule-*]]` 是否被 design.md 引用并 AskUser 处理偏离）**仍保持移除**——design 阶段不做任何与 `.ai-memory/knowledge/rules/` 关联的 rule 检查。design 检索是**定位用**（把设计 ground 到真实代码），**不引入任何「规则确认 / 偏离 gate」**——它只产出指针，不产出 must / 规则。
 4. **tasks (executable plan)**:
-   - superpowers installed → call `superpowers:writing-plans`. Pre-instruct the target path `<specsRoot>/<slug>/tasks.md` **and instruct it to skip its own execution-handoff question** (specode's 执行方式 selector supersedes it).
+   - superpowers installed → call `superpowers:writing-plans`. Pre-instruct the target path `<specsRoot>/<slug>/tasks.md`. **writing-plans 结尾会硬编码问一句「Subagent-Driven vs Inline Execution」——它无参数可关；忽略那个提问、不据此进入执行**，继续走 specode 自己的 §执行方式 selector（step 5）。specode 只能"消化"这个提问，不是真的能抑制它。
    - not installed → **specode-native**: break down into `## Task N` + `**Files:**` + `**Interfaces:**` + `验证: AC-N` + `- [ ]` TDD steps per the `assets/templates/tasks.md` template.
    - Relocate the artifact to `<specsRoot>/<slug>/tasks.md`.
    - tasks 阶段**不做单独检索**——直接继承 design.md 已定位好的文件路径（`**Files:**` 从 design 的模块/接口落点导出）。
@@ -139,14 +122,14 @@ Each phase is annotated "if superpowers is installed, call it / otherwise go nat
 
    > **v4.0.0 → 重新挂回**: 4.0.0 曾把 acceptance 后的自动 distill sub-step 整体移除；现按 `auto_distill` default **把入口提示重新挂回**（见上一条 bullet，遵循既有 autonomous-mode 规则——interactive 时询问、非 interactive 有 effective default 时静默，**非无条件自动执行**）。沉淀目标是项目 `knowledge-base/`（供下次 requirements/design 检索定位），md-only 行为见 `skills/distill/SKILL.md`。
 
-phase ↔ skill quick map: `requirements + design` → brainstorming (one call, dual artifacts); `tasks` → writing-plans; execution → subagent-driven-development / executing-plans (the task-swarm path does not use superpowers); acceptance → verification-before-completion / requesting-code-review.
+phase ↔ skill quick map: `requirements` → **`specode:intake`** (specode's own standalone skill, always — no superpowers fork); `design` → brainstorming (design only, single artifact) or native; `tasks` → writing-plans; execution → subagent-driven-development / executing-plans (the task-swarm path does not use superpowers); acceptance → verification-before-completion / requesting-code-review.
 
 ## superpowers orchestration + relocation (belt and suspenders)
 
-superpowers' brainstorming / writing-plans have their own default output paths + filenames (e.g. `docs/superpowers/specs/YYYY-MM-DD-*.md`), so when delegating, specode must actively relocate to guarantee the core invariant holds:
+superpowers' brainstorming / writing-plans have their own default output paths + filenames (e.g. `docs/superpowers/specs/YYYY-MM-DD-*.md`), so when delegating, specode must actively relocate to guarantee the core invariant holds. (Note: `requirements.md` is **not** produced by superpowers anymore — it is produced by the `specode:intake` skill, which writes directly to the fixed path, so no relocation is needed for it.)
 
-1. **Pre-instruction**: before calling the skill, explicitly tell it the target **absolute path(s) + fixed filename(s)** (superpowers' spec/plan locations support user-preference overrides) — brainstorming → **two** targets: 澄清结论 `<specsRoot>/<slug>/requirements.md` + 设计展示 `<specsRoot>/<slug>/design.md`; writing-plans' plan output → `<specsRoot>/<slug>/tasks.md` (the tasks format *is* the writing-plans format, so it slots in seamlessly; also instruct writing-plans to skip its own execution-handoff question — specode's selector supersedes it).
-2. **Post-relocation (backstop)**: after the skill returns, verify **every** expected `<specsRoot>/<slug>/<fixed-name>` is in place (brainstorming: check both files); if not, `mv` / rename the file(s) the skill actually produced to the fixed location. The invariant holds whether or not the skill honored the pre-instruction.
+1. **Pre-instruction**: before calling the skill, explicitly tell it the target **absolute path + fixed filename** (superpowers' spec/plan locations support user-preference overrides) — brainstorming → **one** target: `<specsRoot>/<slug>/design.md` (design only; requirements are already in `requirements.md`); writing-plans' plan output → `<specsRoot>/<slug>/tasks.md` (the tasks format *is* the writing-plans format, so it slots in seamlessly). writing-plans will still end by asking its own execution-handoff question — **ignore it, don't act on it**; specode's 执行方式 selector supersedes it.
+2. **Post-relocation (backstop)**: after the skill returns, verify the expected `<specsRoot>/<slug>/<fixed-name>` is in place (brainstorming: `design.md`; writing-plans: `tasks.md`); if not, `mv` / rename the file the skill actually produced to the fixed location. The invariant holds whether or not the skill honored the pre-instruction.
 
 Which superpowers skill to call when, and how to do pre/post, is detailed in `references/superpowers-wiring.md`.
 
@@ -156,12 +139,13 @@ specode treats both superpowers and task-swarm as **soft dependencies** (purely
 
 | phase | matching plugin | absent → specode-native fallback |
 |---|---|---|
-| clarify + requirements + design | `superpowers:brainstorming` (one call, dual artifacts) | host agent clarifies via `AskUserQuestion` wizard (2-4 questions) + writes per the `requirements.md` template + authors `design.md` per the design template (传统设计文档) |
+| clarify + requirements | **`specode:intake`** (specode's own skill — always used, no superpowers here) | intake itself degrades gracefully: if `brainstorming`-caliber clarification isn't needed it still runs project analysis + one-question-at-a-time clarification + writes `requirements.md` with the frontmatter contract. There is no separate superpowers path to fall back from. |
+| design (传统设计文档) | `superpowers:brainstorming` (design only, single artifact) | host agent authors `design.md` per the design template (背景与目标 / 架构概览 / 模块划分 / 接口设计 / 数据流 / 错误处理 / 测试策略, 散文无 checkbox) |
 | executable plan (tasks) | `superpowers:writing-plans` | host agent breaks down Tasks per the `tasks.md` template (Goal/Arch/Stack + `## Task N` + `**Interfaces:**` + `验证: AC-N` + `- [ ]` TDD steps) |
 | execution | task-swarm (concurrent) / `superpowers:executing-plans` | host agent runs TDD in `tasks.md` Task order (red → green), appending `implementation-log.md` |
 | acceptance | `superpowers:verification-before-completion` | host agent verifies item by item against `AC-N` / `design.md` 测试策略 / `tasks.md` checkboxes + writes acceptance summary |
 
-**How to decide**: the host agent first tries calling the matching superpowers skill via `Skill`; if unavailable, take the native branch. Do not stall or tell the user to install something just because superpowers is absent — pick up natively right away.
+**How to decide**: requirements always goes through `specode:intake` (no superpowers here). For design / tasks / execution / acceptance, the host agent first tries calling the matching superpowers skill via `Skill`; if unavailable, take the native branch. Do not stall or tell the user to install something just because superpowers is absent — pick up natively right away.
 
 ## 执行方式 selector (the single fixed per-spec selector, after tasks.md completes)
 
@@ -185,7 +169,7 @@ When presenting, pass question / header / options **verbatim** per the `referenc
 | Directory state | Inferred phase | Resume action (after user go-ahead) |
 |---|---|---|
 | no `requirements.md` | intake | rerun requirements (brainstorming / native clarification) |
-| has `requirements.md`, no `design.md` | design | run design (brainstorming dual-artifact / native authoring) |
+| has `requirements.md`, no `design.md` | design | run design (brainstorming design-only / native authoring) |
 | has `design.md`, no `tasks.md`, and `design.md` contains `## Task` + `- [ ]` | **legacy spec (5.x)** | treat `design.md` as the plan per pre-6.0.0 semantics — resume execution / acceptance directly |
 | has `design.md` (new-style, prose), no `tasks.md` | tasks | run tasks breakdown (writing-plans / native per tasks template) |
 | `tasks.md` with unchecked `- [ ]` | executing | resume execution (task-swarm checks run state / superpowers resumes executing-plans / native resumes sequentially) |
@@ -216,7 +200,7 @@ When writing / updating spec documents, **never** reprint the full text in chat.
 
 ## Iron rules
 
-1. **Fixed-artifact invariant**: always produce only the 4 documents `requirements.md` / `design.md` / `tasks.md` / `implementation-log.md`, with fixed filenames, filed in `<specsRoot>/<slug>/`, independent of the execution engine; after delegating to superpowers you must run the post-relocation check (brainstorming: both requirements.md and design.md).
+1. **Fixed-artifact invariant**: always produce only the 4 documents `requirements.md` / `design.md` / `tasks.md` / `implementation-log.md`, with fixed filenames, filed in `<specsRoot>/<slug>/`, independent of the execution engine. `requirements.md` is written directly by the `specode:intake` skill (no relocation); after delegating design/tasks to superpowers you must run the post-relocation check (brainstorming → `design.md`; writing-plans → `tasks.md`).
 2. **specsRoot: read config first, then ask**: call `get-root` on every start; only when missing, `AskUserQuestion` once and `set-root` to write it back, then use it silently thereafter; use the user's directory verbatim as the root, appending nothing.
 3. **CLIs must go through run.sh + absolute path**: all specode CLIs go through the `run.sh` wrapper + an absolute plugin-root path resolved by the §specsRoot resolver (env var `$CLAUDE_PLUGIN_ROOT` / `$CODEBUDDY_PLUGIN_ROOT`, falling back to a cache glob — the env var is **not** reliably set in skill-driven Bash calls); never a bare `python3 <script>`, never a hard-coded version path.
 4. **执行方式 selector verbatim per example**: the `AskUserQuestion` question / header / options are taken verbatim from `references/selectors.md`, adaptively showing only options for installed engines; never invent / collapse.
@@ -224,7 +208,8 @@ When writing / updating spec documents, **never** reprint the full text in chat.
 
 ## References
 
+- `../intake/SKILL.md` — the standalone `specode:intake` skill: full behavior of the requirements phase (project analysis + experience retrieval + clarification + writing `requirements.md` with the frontmatter contract). Invoked via the `Skill` tool at Flow step 2.
 - `references/selectors.md` — verbatim `AskUserQuestion` example for the 「执行方式」 selector (the first-time directory-setup question is here too).
 - `references/obsidian.md` — specsRoot path resolution and directory conventions.
 - `references/superpowers-wiring.md` — the per-phase ↔ superpowers skill mapping, pre-instructions, and post-relocation instructions.
-- `references/retrieval.md` — 两级 gated 经验检索注入规格（requirements/design phase 调用）。
+- `references/retrieval.md` — 经验检索注入规格（intake 项目分析为主节点 / design 条件性 top-up）。

From 7d447d1d53a53fee2a3802bc5e51ca34d465c285 Mon Sep 17 00:00:00 2001
From: qxbyte <xueqiang361@gmail.com>
Date: Sun, 5 Jul 2026 16:48:12 +0800
Subject: [PATCH 3/8] feat(specode): retrieval primary node = intake; design =
 conditional top-up
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- superpowers-wiring: requirements produced by specode:intake (native, no
  fallback); brainstorming = design-only single artifact; writing-plans'
  handoff is ignored not suppressed; relocation covers design/tasks only.
- retrieval: 触发面 becomes intake(项目分析, primary) + design(conditional
  top-up, inherits intake pointers) + tasks/execution zero; Tier-0 gate
  scope reworded accordingly.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Qiang Xue <qxbyte@users.noreply.github.com>
---
 .../skills/specode/references/retrieval.md        | 12 +++++++-----
 .../specode/references/superpowers-wiring.md      | 15 ++++++++++-----
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/plugins/specode/skills/specode/references/retrieval.md b/plugins/specode/skills/specode/references/retrieval.md
index 8bc678a..f1f6486 100644
--- a/plugins/specode/skills/specode/references/retrieval.md
+++ b/plugins/specode/skills/specode/references/retrieval.md
@@ -1,6 +1,6 @@
 # specode 经验检索注入（Tier-0 Gate + 两级 gated，模型驱动 prose）
 
-> 本文件是 requirements / design 两个 phase 的检索规格。检索智能全在这里的 prose，
+> 本文件是检索规格。**主调用方 = `specode:intake` skill 的项目分析步（§Step 2b）——检索的主节点**；design phase 只做**条件性 top-up**（默认继承 intake 已定位的指针，仅在开辟新领域时补查）。检索智能全在这里的 prose，
 > **运行时无新增脚本**：读 `MEMORY.md` 用 `Read` 工具即可（它是 `<project_root>/knowledge-base/` 下的本地文件）。
 
 ## 顶层不变量 🔒（与本能力存在的理由）
@@ -13,7 +13,9 @@ KB 是「**定位用，非事实用**」：
 
 ## 触发面
 
-- 只在 **requirements** 与 **design** 两个 phase 触发。
+- **主节点 = intake（requirements phase 的项目分析步）**：由 `specode:intake` skill §Step 2b 调用，产「参考定位（非事实来源）」指针。
+- **design phase = 条件性 top-up**：**默认继承 intake 的指针、不重复全量检索**；仅当 design 开辟了 intake 未覆盖的新领域时才按本规格补查一次。
+- **tasks 阶段不检索**：直接继承 design.md 已定位的文件路径。
 - **执行 / task-swarm 阶段零注入**：不向 task-swarm 传任何 KB / 检索产物，task-swarm 保持任意 spec 的纯执行器。
 
 ## 前置（决定要不要检索）
@@ -25,7 +27,7 @@ KB 是「**定位用，非事实用**」：
 
 ## Tier-0 Gate：RagKit（可选加速路，先于 Tier-1）
 
-本节仅在「前置」通过（MEMORY.md 存在）后才被求值，且与「触发面」约束相同：**仅 requirements / design 两 phase 生效，执行 / task-swarm 阶段不触发**。满足以下**全部**条件才走本节；任一不满足 → 跳过本节按下方两级 gated 流程执行，且**不要读取 RagKit 的任何文档/skill**（零额外 token）：
+本节仅在「前置」通过（MEMORY.md 存在）后才被求值，且与「触发面」约束相同：**仅 intake（requirements 项目分析，主节点）与 design（条件性 top-up）生效，执行 / task-swarm 阶段不触发**。满足以下**全部**条件才走本节；任一不满足 → 跳过本节按下方两级 gated 流程执行，且**不要读取 RagKit 的任何文档/skill**（零额外 token）：
 
 1. 会话可用 skills 列表中存在 `ragkit:query`；
 2. `test -f <project_root>/knowledge-base/.ragkit/chunks.json` 成立（索引已构建）。
@@ -63,8 +65,8 @@ KB 是「**定位用，非事实用**」：
 > 以上仅为定位指针，**可能指向计划中 / 已重构 / 已移动的代码**。实际改动以当前真实代码为准，需逐一打开核对。
 ```
 
-- 在 **requirements phase**：该段帮助分析「这个需求要动哪些真实代码」，可作为澄清 / 范围界定的输入；不写进 `requirements.md` 的事实结论。
-- 在 **design phase**：该段帮助把模块边界 / 接口设计 ground 到真实代码；design 的判断仍基于真实代码（tasks 阶段不再单独检索，直接继承 design.md 已定位的文件路径）。
+- 在 **intake（requirements phase 项目分析）**：该段帮助分析「这个需求要动哪些真实代码」，作为澄清 / 范围界定的输入；**不写进 `requirements.md` 的事实结论**（作临时上下文交给 design）。
+- 在 **design phase（条件性 top-up）**：默认直接用 intake 交来的指针把模块边界 / 接口设计 ground 到真实代码；只有开辟新领域才补查。design 的判断仍基于真实代码（tasks 阶段不再单独检索，直接继承 design.md 已定位的文件路径）。
 
 ## schema ↔ 推理 对照表（变更纪律 🔒）
 
diff --git a/plugins/specode/skills/specode/references/superpowers-wiring.md b/plugins/specode/skills/specode/references/superpowers-wiring.md
index 103146e..d497937 100644
--- a/plugins/specode/skills/specode/references/superpowers-wiring.md
+++ b/plugins/specode/skills/specode/references/superpowers-wiring.md
@@ -4,16 +4,21 @@ description: Use when specode needs to invoke a superpowers skill at a given pha
 
 # superpowers orchestration mapping
 
-| Phase | superpowers installed | Absent → specode-native |
+| Phase | producer | Absent → specode-native |
 |---|---|---|
-| Clarification + requirements + design | superpowers:brainstorming (one call spans both phases, dual artifacts) | AskUserQuestion clarification + write per requirements template; author design.md per the design template (传统设计文档) |
+| Clarification + requirements | **`specode:intake`** (specode's own standalone skill — always; **not** superpowers) | intake is native to specode; there is no superpowers path here to fall back from. It always runs project analysis + clarification + writes `requirements.md` with the frontmatter contract. |
+| Design (传统设计文档) | superpowers:brainstorming (**design only**, single artifact → design.md) | Author design.md per the design template |
 | Executable plan (tasks) | superpowers:writing-plans → tasks.md | Self-decompose Tasks + TDD steps per the tasks template |
 | Execution | task-swarm / superpowers:subagent-driven-development / superpowers:executing-plans | Sequential TDD following tasks.md Tasks |
 | Acceptance | superpowers:verification-before-completion (+ requesting-code-review) | Verify each AC-N / design.md 测试策略 / tasks.md checkbox in order |
 
 ## Artifact placement (double-check, invariant enforcement)
-1. Pre-call: when invoking a skill, explicitly pass the target absolute path(s) and fixed filename(s) — brainstorming → **both** `requirements.md` (澄清结论) and `design.md` (设计展示, per the design template sections); writing-plans → `tasks.md` (also instruct it to skip its own execution-handoff question — specode's 执行方式 selector supersedes it).
-2. Post-call: after the skill returns, verify that every expected `<specsRoot>/<slug>/<fixed-name>` is in place (brainstorming: check **two** files); if not, move/rename the skill's actual output to that path.
+`requirements.md` is written directly by `specode:intake` at the fixed path — **no relocation needed**. Only design/tasks are delegated to superpowers and need the belt-and-suspenders check:
+
+1. Pre-call: when invoking a skill, explicitly pass the target absolute path + fixed filename — brainstorming → `design.md` (design only; requirements are already settled in `requirements.md`, tell brainstorming to read it as input and go straight to design); writing-plans → `tasks.md`.
+2. **writing-plans' execution-handoff question**: writing-plans ends by asking "Subagent-Driven vs Inline Execution". It has no flag to disable this. **Ignore that question — do not act on it**; specode's 执行方式 selector supersedes it. (This is "digest", not "suppress" — you cannot actually stop it from asking.)
+3. **brainstorming's terminal handoff**: brainstorming is hardcoded to end by invoking writing-plans. That happens to match specode's design → tasks order, so let it flow naturally into the tasks phase — just make sure design.md landed first.
+4. Post-call: after the skill returns, verify the expected `<specsRoot>/<slug>/<fixed-name>` is in place (brainstorming → design.md; writing-plans → tasks.md); if not, move/rename the skill's actual output there.
 
 ## Availability check
-Attempt to invoke superpowers via the Skill tool first; if unavailable or not installed, take the native branch. Same logic applies to task-swarm (if `/task-swarm:swarm` invocation fails, fall back to native).
+Requirements always uses `specode:intake` (invoke it via the Skill tool). For design / tasks / execution / acceptance, attempt to invoke the superpowers skill via the Skill tool first; if unavailable or not installed, take the native branch. Same logic applies to task-swarm (if `/task-swarm:swarm` invocation fails, fall back to native).

From 8f4d9a675e02bb368e20af4a38a81455eca7f434 Mon Sep 17 00:00:00 2001
From: qxbyte <xueqiang361@gmail.com>
Date: Sun, 5 Jul 2026 16:48:36 +0800
Subject: [PATCH 4/8] feat(specode): spec command + SessionStart hint mention
 specode:intake for requirements

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Qiang Xue <qxbyte@users.noreply.github.com>
---
 plugins/specode/commands/spec.md      | 2 +-
 plugins/specode/scripts/spec_hooks.py | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/plugins/specode/commands/spec.md b/plugins/specode/commands/spec.md
index 90c4f67..940b092 100644
--- a/plugins/specode/commands/spec.md
+++ b/plugins/specode/commands/spec.md
@@ -20,4 +20,4 @@ After activation, follow the orchestration logic in specode SKILL.md (each phase
    - default: `resolve_root.py resolve-project-root` (returns `git rev-parse --show-toplevel` of cwd, falling back to cwd) → present it via `AskUserQuestion` **once** for the user to confirm/override.
    - persist: after requirements.md exists, `resolve_root.py write-project-root --spec <specsRoot>/<slug> --root <abs>` writes it into the requirements.md YAML frontmatter (validates absolute path / dir exists / `/Volumes` mounted). This frontmatter field is the **only** place project_root lives.
    - read (any later phase / skill): `resolve_root.py read-project-root --spec <specsRoot>/<slug>` — the single read entry. Never read cwd/workdir instead.
-4. Follow SKILL.md §pipeline: requirements (brainstorming/native) → design (brainstorming dual-artifact/native, 传统设计文档) → tasks (writing-plans/native) → "execution mode" selector → execution → acceptance. Four fixed artifacts land under `<specsRoot>/<slug>/`.
+4. Follow SKILL.md §pipeline: requirements (**`specode:intake` skill** — project analysis + clarification + writes requirements.md with the frontmatter contract) → design (brainstorming design-only/native, 传统设计文档) → tasks (writing-plans/native) → "execution mode" selector → execution → acceptance. Four fixed artifacts land under `<specsRoot>/<slug>/`.
diff --git a/plugins/specode/scripts/spec_hooks.py b/plugins/specode/scripts/spec_hooks.py
index bab36e4..04a515f 100644
--- a/plugins/specode/scripts/spec_hooks.py
+++ b/plugins/specode/scripts/spec_hooks.py
@@ -21,10 +21,11 @@
     "specode（spec-mode 轻量工作流）可用。仅在用户输入 `/specode:spec <需求>`、"
     "`/specode:continue <slug>`、`/specode:list` 或显式要求用 spec 模式时激活；"
     "否则按普通对话处理。激活后遵循 "
-    "specode SKILL.md：① 在 requirements/design/tasks/执行/验收各 phase 优先调对应 superpowers "
-    "skill（缺席则 specode-native 降级）；② 4 份固定产物 requirements.md / design.md / "
-    "tasks.md / implementation-log.md 永远以固定文件名落在 <specsRoot>/<slug>/；③ tasks 完成后用 "
-    "AskUserQuestion 呈现「执行方式」selector（task-swarm / superpowers / specode 自执行）。"
+    "specode SKILL.md：① requirements 由 specode:intake skill 产（项目分析+澄清+写需求）；"
+    "design/tasks/执行/验收各 phase 优先调对应 superpowers skill（缺席则 specode-native 降级）；"
+    "② 4 份固定产物 requirements.md / design.md / tasks.md / implementation-log.md 永远以固定文件名"
+    "落在 <specsRoot>/<slug>/；③ tasks 完成后用 AskUserQuestion 呈现「执行方式」selector"
+    "（task-swarm / superpowers / specode 自执行）。"
 )
 
 

From 57f3a71968e27d49e15aa097ccaefbfb8fd9570b Mon Sep 17 00:00:00 2001
From: qxbyte <xueqiang361@gmail.com>
Date: Sun, 5 Jul 2026 16:49:36 +0800
Subject: [PATCH 5/8] docs: READMEs describe specode:intake as the
 requirements-phase engine

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Qiang Xue <qxbyte@users.noreply.github.com>
---
 README.md       | 16 +++++++++++-----
 README.zh-CN.md |  8 +++++---
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 0bf38b4..0d69f49 100644
--- a/README.md
+++ b/README.md
@@ -192,12 +192,16 @@ back to cwd) and asks you to confirm it once per spec. On the **first
 ever** run it also asks once for your document management directory
 and remembers it. The agent then walks the pipeline:
 
-1. **requirements** — clarify + write `requirements.md` (via
-   `superpowers:brainstorming`, or a native `AskUserQuestion` wizard).
+1. **requirements** — the `specode:intake` skill (specode's own, always)
+   runs project analysis (agent-docs scan + experience retrieval +
+   reading the located real code) → analysis-driven clarification →
+   writes `requirements.md` with the frontmatter contract (`spec_id` /
+   `created_at` / `project_root`). This is also the **primary node for
+   ragkit/experience retrieval**.
 2. **design** — produce a traditional design doc `design.md`
    (architecture / modules / interfaces / data flow / error handling /
-   test strategy; brainstorming's design output lands here, or native
-   authoring).
+   test strategy) via `superpowers:brainstorming` (design only) or native
+   authoring.
 3. **tasks** — produce the executable plan `tasks.md` (via
    `superpowers:writing-plans`, or native Task breakdown). Engine-neutral:
    every execution path consumes this one file.
@@ -268,7 +272,9 @@ plugins/specode/
       selectors.md                执行方式 selector verbatim examples
       obsidian.md                 specsRoot path resolution + conventions
       superpowers-wiring.md       phase ↔ superpowers skill mapping
-      retrieval.md                two-tier gated experience retrieval spec
+      retrieval.md                experience retrieval spec (intake primary node)
+  skills/intake/
+    SKILL.md                      requirements phase engine (analysis + clarify + write)
   skills/distill/
     SKILL.md                      /specode:distill behavior (case/navigation points)
     references/                   breakdown heuristics + doc templates
diff --git a/README.zh-CN.md b/README.zh-CN.md
index c1a84ce..8107d93 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -120,8 +120,8 @@ specode 共有四条命令。
 
 先 `cd` 到你的项目目录——specode 以 cwd 推导项目根默认值（`git rev-parse --show-toplevel`，无 git 则 cwd），并在每条 spec 开始时让你确认一次。**首次运行**时还会询问一次文档管理目录并记住它。之后代理依次走完流水线：
 
-1. **需求阶段** — 澄清 + 写 `requirements.md`（通过 `superpowers:brainstorming`，或原生 `AskUserQuestion` 向导）。
-2. **设计阶段** — 生成传统设计文档 `design.md`（架构 / 模块划分 / 接口设计 / 数据流 / 错误处理 / 测试策略；brainstorming 的设计产出落在这里，或原生撰写）。
+1. **需求阶段** — 由 `specode:intake` skill（specode 自己的，永远走它）执行：项目分析（agent-docs 扫描 + 经验检索 + 读定位到的真实代码）→ 基于分析的澄清 → 写 `requirements.md`（含 `spec_id` / `created_at` / `project_root` frontmatter 契约）。这里也是 **ragkit / 经验检索的主节点**。
+2. **设计阶段** — 生成传统设计文档 `design.md`（架构 / 模块划分 / 接口设计 / 数据流 / 错误处理 / 测试策略），通过 `superpowers:brainstorming`（只产 design）或原生撰写。
 3. **计划阶段（tasks）** — 生成可执行计划 `tasks.md`（通过 `superpowers:writing-plans`，或原生任务分解）。引擎中立：所有执行路径消费同一份文件。
 4. **执行方式选择器** — 从自适应 4 个选项中选择执行路径（详见上方亮点）。
 5. **执行阶段** — 以 TDD 方式跑完计划，追加写入 `implementation-log.md`。
@@ -175,7 +175,9 @@ plugins/specode/
       selectors.md                执行方式选择器逐字示例
       obsidian.md                 specsRoot 路径解析 + 惯例
       superpowers-wiring.md       阶段 ↔ superpowers 技能映射
-      retrieval.md                两级 gated 经验检索规格
+      retrieval.md                经验检索规格（intake 为主节点）
+  skills/intake/
+    SKILL.md                      需求阶段引擎（项目分析 + 澄清 + 写需求）
   skills/distill/
     SKILL.md                      /specode:distill 行为（case/navigation 知识点）
     references/                   拆分启发式 + 文档模板

From 3a93dcd3b510529f609ef4416812d95abb5dcc2a Mon Sep 17 00:00:00 2001
From: qxbyte <xueqiang361@gmail.com>
Date: Sun, 5 Jul 2026 16:55:32 +0800
Subject: [PATCH 6/8] =?UTF-8?q?refactor(specode):=20lighten=20always-loade?=
 =?UTF-8?q?d=20SKILL=20=E2=80=94=20sink=20reference-grade=20detail=20to=20?=
 =?UTF-8?q?refs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Zero behavior change; SKILL.md 215 → 171 lines (~20% lighter). The shell
now carries rules + pointers, not reference manuals:
- full resolve_root.py verb table → references/obsidian.md
- autonomous-mode mapping + decision pseudo-code → new references/autonomous-mode.md
- resolver "why" prose trimmed to essentials (snippet kept)
- v4.0.0 removal-rationale blockquotes compressed to one-liners
- Absence-fallback matrix (triple-stated with Flow + superpowers-wiring)
  slimmed to prose + pointer

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Qiang Xue <qxbyte@users.noreply.github.com>
---
 plugins/specode/skills/intake/SKILL.md        |  4 +-
 plugins/specode/skills/specode/SKILL.md       | 60 +++----------------
 .../specode/references/autonomous-mode.md     | 38 ++++++++++++
 .../skills/specode/references/obsidian.md     | 17 ++++++
 4 files changed, 65 insertions(+), 54 deletions(-)
 create mode 100644 plugins/specode/skills/specode/references/autonomous-mode.md

diff --git a/plugins/specode/skills/intake/SKILL.md b/plugins/specode/skills/intake/SKILL.md
index 87a1bff..1a4cf72 100644
--- a/plugins/specode/skills/intake/SKILL.md
+++ b/plugins/specode/skills/intake/SKILL.md
@@ -33,7 +33,7 @@ sh "$R/scripts/run.sh" "$R/scripts/resolve_root.py" <verb> <args...>
 
 ## §3 autonomous-mode 感知（每个 AskUserQuestion 站点适用）
 
-本 skill 有两处会 `AskUserQuestion`（§Step1 project_root 确认、§Step3 澄清）。每处**先**按 specode 的 autonomous-mode 规则判定是否跳过：用 `resolve_root.py read-defaults --key interactive --json` 取 `interactive`，用 `read-defaults --key <relevant> --json` 取该 gate 的 effective value + source；当 `interactive == false` 且该 key `source ∈ {env, file}`（有效值非 schema default）时，**跳过提问直接用 default**（autonomous / CI 路径）；否则原样 `AskUserQuestion`。Mapping：project_root 确认 → `project_root_default`；澄清 → 无独立 key，仅受 `interactive` 主开关约束（非交互则基于已有信息尽力起草、把不确定项写进「开放问题」而非阻塞）。
+本 skill 有两处会 `AskUserQuestion`（§Step1 project_root 确认、§Step3 澄清）。每处**先**按 autonomous-mode 规则判定是否跳过——完整规则（gate→key→env mapping + 决策伪代码）见 `skills/specode/references/autonomous-mode.md`。要点：`interactive == false` 且该 gate 的 key `source ∈ {env, file}` 时跳过提问用 default，否则原样 `AskUserQuestion`。本 skill 的两处 gate：project_root 确认 → key `project_root_default`；澄清 → 无独立 key，仅受 `interactive` 主开关约束（非交互则基于已有信息尽力起草、把不确定项写进「开放问题」而非阻塞）。
 
 ## §4 流程（5 步，质量在 Step 2–3）
 
@@ -100,4 +100,4 @@ sh "$R/scripts/run.sh" "$R/scripts/resolve_root.py" <verb> <args...>
 
 - `skills/specode/references/retrieval.md` — 经验检索规格（Step 2b 的引擎；intake 是其**主节点**）。
 - `assets/templates/requirements.md` — 需求模板（Step 4 结构 + frontmatter 契约）。
-- `skills/specode/SKILL.md` §Autonomous-mode defaults rule — §3 判定的完整规则来源。
+- `skills/specode/references/autonomous-mode.md` — §3 判定的完整规则来源（gate→key→env + 伪代码）。
diff --git a/plugins/specode/skills/specode/SKILL.md b/plugins/specode/skills/specode/SKILL.md
index 199c89d..934037c 100644
--- a/plugins/specode/skills/specode/SKILL.md
+++ b/plugins/specode/skills/specode/SKILL.md
@@ -34,55 +34,18 @@ Bug fixes do not get a separate `bugfix.md` — write Current / Expected directl
 
 **Every time specode starts, first call `resolve_root.py get-root` via run.sh to read specsRoot.** Only when the config is missing (typically first use) ask the user via `AskUserQuestion`, then immediately `set-root` to write it back to config. Afterwards all sessions use it silently and automatically, never prompting again.
 
-All specode CLIs **must** be invoked through the `run.sh` wrapper with an **absolute** plugin-root path. Resolve that root robustly: prefer the host env var `$CLAUDE_PLUGIN_ROOT` (CodeBuddy: `$CODEBUDDY_PLUGIN_ROOT`), but **never assume it is set**. The host only inline-substitutes / exports `${CLAUDE_PLUGIN_ROOT}` for hooks and MCP/LSP subprocesses, and only the bare token — a CLI call emitted from *this skill body* with the `${VAR:-fallback}` form is neither substituted nor run in an env that carries the variable, so it expands **empty** and you get `sh: /scripts/run.sh: No such file or directory`. Always fall back to globbing the plugin cache, and never call a bare `python3 <script>`. Shell state does not persist between Bash calls, so prefix **every** CLI call with this self-contained resolver:
+All specode CLIs **must** be invoked through the `run.sh` wrapper with an **absolute** plugin-root path — the host env var `$CLAUDE_PLUGIN_ROOT` (CodeBuddy: `$CODEBUDDY_PLUGIN_ROOT`) is **not** reliably set in skill-driven Bash, so always fall back to a cache `find`, and never call a bare `python3 <script>`. Shell state does not persist between Bash calls, so prefix **every** CLI call with this self-contained resolver:
 
 ```bash
 R="${CLAUDE_PLUGIN_ROOT:-$CODEBUDDY_PLUGIN_ROOT}"; [ -f "$R/scripts/run.sh" ] || R="$(find "$HOME/.claude/plugins/cache" "$HOME/.codebuddy/plugins/cache" -path '*/specode/*/scripts/run.sh' 2>/dev/null | sort -V | tail -1)"; R="${R%/scripts/run.sh}"
 sh "$R/scripts/run.sh" "$R/scripts/resolve_root.py" <verb> <args...>
 ```
 
-The resolver tries the env var first (works wherever the host exports it), verifies `run.sh` actually exists there, and otherwise locates the cached install with `find` and picks the newest version (`sort -V | tail -1`) — never a hard-coded version. Use `find` (not a shell glob): under zsh an unmatched glob aborts with `no matches found`, which `2>/dev/null` does not suppress; `find` stays silent on missing dirs / no match. `run.sh` auto-probes the interpreter (`python3 → python → py`) and execs through the args. The verbs match the `commands/*.md` command files:
+(`find` not a shell glob — zsh aborts on an unmatched glob; `find` stays silent. `sort -V | tail -1` picks the newest cached version, never hard-coded. `run.sh` probes `python3 → python → py`.) The full **verb table** (`get-root` / `set-root` / `list-specs` / `resolve|write|read-project-root` / `plan-unchecked` / `read|write|reset-default`) lives in `references/obsidian.md`.
 
-| verb | Purpose | exit |
-|---|---|---|
-| `get-root [--root P]` | Resolve specsRoot (`--root` > env `SPECODE_ROOT` > config.specsRoot) | 0 ok / 3 unconfigured |
-| `set-root --root <abs>` | Absolute path, persisted to `~/.config/specode/config.json.specsRoot` | 0 / 1 path not absolute |
-| `list-specs [--root P]` | List spec slugs (one per line) under root: subdirs containing any fixed doc (`requirements.md` / `design.md` / `tasks.md` / `implementation-log.md`) **plus empty subdirs (intake — dir created, requirements not yet written)**; hidden dirs excluded | 0 / 3 unconfigured |
-| `resolve-project-root [--cwd P]` | Compute the project_root default (`git rev-parse --show-toplevel` of cwd, else cwd) for the user to confirm | 0 |
-| `write-project-root --spec <dir\|file> --root <abs>` | **Single writer** of project_root → spec's requirements.md frontmatter (validates absolute / dir exists / `/Volumes` mounted) | 0 / 1 invalid |
-| `read-project-root --spec <dir\|file>` | **Single reader** of project_root from requirements.md frontmatter — all downstream skills use this | 0 / 3 missing field / 4 invalid value |
-| `read-defaults [--key K] [--json]` | **v3.4.0 M1/M9**：读 autonomous-mode defaults（优先级 env > `~/.config/specode/defaults.json` > schema）。单 key 返回纯值；`--json` 或不传 `--key` 返 `{value, source}` JSON | 0 / 1 unknown key |
-| `write-default --key K --value V` | **v3.4.0 M1/M9**：持久化某个 defaults key。5 个合法 key：`interactive`/`project_root_default`/`execution_mode_default`/`auto_distill`/`specs_root_default`；type + execution_mode whitelist 校验 | 0 / 1 invalid |
-| `reset-default --key K \| --all` | **v3.4.0 M1/M9**：删除单 key 或 `--all` 整文件 wipe | 0 / 1 invalid |
-
-**Autonomous-mode defaults rule（v3.4.0 / v0.9 M1/M9）🔒**：每个下面调用 `AskUserQuestion` 的地方，**必须**先 `read-defaults --key <relevant> --json` 拿 effective value + source；当 `interactive == false` 且该 key 的 `source ∈ {env, file}`（即有效值非 schema default）时，**跳过 AskUserQuestion 直接用 default**——这是 autonomous mode / CI 路径。`interactive == true`（schema default）时所有 gate 原样保留 — 默认行为零变化。Mapping：
-
-| SKILL gate | defaults key | env var |
-|---|---|---|
-| 首次 specsRoot 设置 | `specs_root_default` | `SPECODE_SPECS_ROOT_DEFAULT` |
-| project_root 确认（sub-step 2.1） | `project_root_default` | `SPECODE_PROJECT_ROOT` |
-| 执行方式 selector（tasks 后） | `execution_mode_default` | `SPECODE_EXECUTION_MODE`（值：`ask` / `task-swarm` / `superpowers-subagent` / `superpowers-executing` / `specode-self`） |
-| distill 末尾 prompt | `auto_distill` | `SPECODE_AUTO_DISTILL` |
-| Master switch | `interactive` | `SPECODE_INTERACTIVE` |
-
-调用模式（每个 AskUserQuestion 调用站点适用，伪代码）：
-
-```bash
-# 1) Read both keys via resolve_root.py
-INTERACTIVE=$(... read-defaults --key interactive --json | jq -r '.value')
-DEFAULT_INFO=$(... read-defaults --key <relevant-key> --json)
-DEFAULT_VALUE=$(echo "$DEFAULT_INFO" | jq -r '.value')
-DEFAULT_SOURCE=$(echo "$DEFAULT_INFO" | jq -r '.source')
-
-# 2) Decide: skip AskUserQuestion if non-interactive + has effective default
-if [ "$INTERACTIVE" = "false" ] && [ "$DEFAULT_SOURCE" != "default" ] && [ -n "$DEFAULT_VALUE" ]; then
-  use "$DEFAULT_VALUE"  # silent path — autonomous / CI
-else
-  ask via AskUserQuestion  # original interactive path
-fi
-```
+**Autonomous-mode defaults rule 🔒**: at every `AskUserQuestion` gate below, first read the relevant default + source via `read-defaults --key <relevant> --json`; when `interactive == false` **and** `source ∈ {env, file}`, skip the prompt and use the default (autonomous / CI path); `interactive == true` → all gates behave as before (zero behavior change). The gate→key→env mapping and the decision pseudo-code live in `references/autonomous-mode.md`.
 
-**project_root single-source-of-truth rule 🔒**: project_root lives in exactly one place — the spec's `requirements.md` frontmatter. specode writes it once (via `write-project-root`); every later phase and downstream skill (distill, task-swarm) obtains it via `read-project-root`. No component re-derives it from cwd / workdir / guessing.
+**project_root single-source-of-truth rule 🔒**: project_root lives in exactly one place — the spec's `requirements.md` frontmatter. The `specode:intake` skill writes it once (via `write-project-root`); every later phase and downstream skill (distill, task-swarm) obtains it via `read-project-root`. No component re-derives it from cwd / workdir / guessing.
 
 **First-time setup flow**: `get-root` exits 3 → call `AskUserQuestion` to ask the user for the document directory (absolute path, used **verbatim** as the specs root; specode makes no assumptions about its structure and appends nothing) → after the user provides it, persist with `set-root --root <abs>` → never ask again. `project_root` is **inferred per-spec** (default: `git rev-parse --show-toplevel` of cwd, falling back to cwd itself) and **confirmed once via `AskUserQuestion`** before requirements is written — see §requirements phase. Path-resolution details are in `references/obsidian.md`.
 
@@ -101,7 +64,7 @@ Each phase is annotated "if superpowers is installed, call it / otherwise go nat
    - not installed → **specode-native**: the host agent authors `design.md` per the `assets/templates/design.md` template（同上七节，散文无 checkbox）.
    - **经验检索（条件性 top-up，非强制）**: design 默认**继承 intake（step 2）已定位的指针**，不重复全量检索。仅当 design 开辟了 intake 未覆盖的新领域时，才按 `references/retrieval.md` 补查一次（此 phase frontmatter 已写，用 `resolve_root.py read-project-root --spec <specsRoot>/<slug>` 取 `project_root`）；命中点的前后端文件 + 调用链用于把**模块边界 / 接口设计 ground 到真实代码**（design 的判断仍基于真实代码）。`<project_root>/knowledge-base/MEMORY.md` 不存在 → 静默跳过。
 
-   > **v4.0.0 BREAKING**: 旧的 P3-2 rule-acknowledgement post-check 段（grep `[[rule-*]]` 是否被 design.md 引用并 AskUser 处理偏离）**仍保持移除**——design 阶段不做任何与 `.ai-memory/knowledge/rules/` 关联的 rule 检查。design 检索是**定位用**（把设计 ground 到真实代码），**不引入任何「规则确认 / 偏离 gate」**——它只产出指针，不产出 must / 规则。
+   > design 检索是**定位用**（把设计 ground 到真实代码），只产出指针、**不引入任何「规则确认 / 偏离 gate」**（4.0.0 起不做任何 `.ai-memory/knowledge/rules/` 关联的 rule 检查；勿重新引入）。
 4. **tasks (executable plan)**:
    - superpowers installed → call `superpowers:writing-plans`. Pre-instruct the target path `<specsRoot>/<slug>/tasks.md`. **writing-plans 结尾会硬编码问一句「Subagent-Driven vs Inline Execution」——它无参数可关；忽略那个提问、不据此进入执行**，继续走 specode 自己的 §执行方式 selector（step 5）。specode 只能"消化"这个提问，不是真的能抑制它。
    - not installed → **specode-native**: break down into `## Task N` + `**Files:**` + `**Interfaces:**` + `验证: AC-N` + `- [ ]` TDD steps per the `assets/templates/tasks.md` template.
@@ -135,15 +98,7 @@ Which superpowers skill to call when, and how to do pre/post, is detailed in `re
 
 ## Absence fallback (first-class, not a footnote)
 
-specode treats both superpowers and task-swarm as **soft dependencies** (purely runtime, invoked via this SKILL's prose, zero imports). When absent, clarification / planning / execution / acceptance **all sink down to specode itself**, guaranteeing a full start → coding-complete run with only specode installed. The fallback matrix is a **first-class path on par with "call superpowers"**:
-
-| phase | matching plugin | absent → specode-native fallback |
-|---|---|---|
-| clarify + requirements | **`specode:intake`** (specode's own skill — always used, no superpowers here) | intake itself degrades gracefully: if `brainstorming`-caliber clarification isn't needed it still runs project analysis + one-question-at-a-time clarification + writes `requirements.md` with the frontmatter contract. There is no separate superpowers path to fall back from. |
-| design (传统设计文档) | `superpowers:brainstorming` (design only, single artifact) | host agent authors `design.md` per the design template (背景与目标 / 架构概览 / 模块划分 / 接口设计 / 数据流 / 错误处理 / 测试策略, 散文无 checkbox) |
-| executable plan (tasks) | `superpowers:writing-plans` | host agent breaks down Tasks per the `tasks.md` template (Goal/Arch/Stack + `## Task N` + `**Interfaces:**` + `验证: AC-N` + `- [ ]` TDD steps) |
-| execution | task-swarm (concurrent) / `superpowers:executing-plans` | host agent runs TDD in `tasks.md` Task order (red → green), appending `implementation-log.md` |
-| acceptance | `superpowers:verification-before-completion` | host agent verifies item by item against `AC-N` / `design.md` 测试策略 / `tasks.md` checkboxes + writes acceptance summary |
+specode treats both superpowers and task-swarm as **soft dependencies** (purely runtime, invoked via this SKILL's prose, zero imports). When absent, planning / execution / acceptance **all sink down to specode itself**, guaranteeing a full start → coding-complete run with only specode installed — the native path is **first-class**, not a footnote. (requirements is never a fallback case: it always runs through `specode:intake`, which is specode-native by design.) The per-phase producer ↔ superpowers-skill ↔ native-fallback table lives in `references/superpowers-wiring.md`; the native branches are also spelled out inline per phase in §Flow above.
 
 **How to decide**: requirements always goes through `specode:intake` (no superpowers here). For design / tasks / execution / acceptance, the host agent first tries calling the matching superpowers skill via `Skill`; if unavailable, take the native branch. Do not stall or tell the user to install something just because superpowers is absent — pick up natively right away.
 
@@ -210,6 +165,7 @@ When writing / updating spec documents, **never** reprint the full text in chat.
 
 - `../intake/SKILL.md` — the standalone `specode:intake` skill: full behavior of the requirements phase (project analysis + experience retrieval + clarification + writing `requirements.md` with the frontmatter contract). Invoked via the `Skill` tool at Flow step 2.
 - `references/selectors.md` — verbatim `AskUserQuestion` example for the 「执行方式」 selector (the first-time directory-setup question is here too).
-- `references/obsidian.md` — specsRoot path resolution and directory conventions.
+- `references/obsidian.md` — specsRoot path resolution, the full `resolve_root.py` verb table, and directory conventions.
+- `references/autonomous-mode.md` — the autonomous / CI defaults rule: gate→key→env mapping + the skip-the-prompt decision pseudo-code.
 - `references/superpowers-wiring.md` — the per-phase ↔ superpowers skill mapping, pre-instructions, and post-relocation instructions.
 - `references/retrieval.md` — 经验检索注入规格（intake 项目分析为主节点 / design 条件性 top-up）。
diff --git a/plugins/specode/skills/specode/references/autonomous-mode.md b/plugins/specode/skills/specode/references/autonomous-mode.md
new file mode 100644
index 0000000..3a29981
--- /dev/null
+++ b/plugins/specode/skills/specode/references/autonomous-mode.md
@@ -0,0 +1,38 @@
+---
+description: Use at every AskUserQuestion gate in the specode flow to decide whether to skip the prompt and use a persisted default (autonomous / CI mode) — the interactive master switch, the 5 defaults keys, and the skip decision.
+---
+
+# Autonomous-mode defaults (v3.4.0 / v0.9 M1/M9)
+
+specode's user gates (`AskUserQuestion`) block in autonomous / CI runs where no human is present. This reference specifies how each gate decides to **skip the prompt and use a persisted default** instead.
+
+## The rule 🔒
+
+At **every** `AskUserQuestion` call site, first read the relevant default + its source via `resolve_root.py read-defaults --key <relevant> --json`. When `interactive == false` **and** that key's `source ∈ {env, file}` (i.e. the effective value is not the schema default), **skip the prompt and use the default** — this is the autonomous / CI path. When `interactive == true` (schema default), all gates behave exactly as before — **default behavior is unchanged**.
+
+## Gate → key → env var mapping
+
+| SKILL gate | defaults key | env var |
+|---|---|---|
+| First-time specsRoot setup | `specs_root_default` | `SPECODE_SPECS_ROOT_DEFAULT` |
+| project_root confirmation (intake Step 1) | `project_root_default` | `SPECODE_PROJECT_ROOT` |
+| 执行方式 selector (after tasks) | `execution_mode_default` | `SPECODE_EXECUTION_MODE` (values: `ask` / `task-swarm` / `superpowers-subagent` / `superpowers-executing` / `specode-self`) |
+| distill prompt (acceptance end) | `auto_distill` | `SPECODE_AUTO_DISTILL` |
+| Master switch | `interactive` | `SPECODE_INTERACTIVE` |
+
+## Decision (pseudo-code, applies at each call site)
+
+```bash
+# 1) Read both keys via resolve_root.py (through run.sh + absolute root)
+INTERACTIVE=$(... read-defaults --key interactive --json | jq -r '.value')
+DEFAULT_INFO=$(... read-defaults --key <relevant-key> --json)
+DEFAULT_VALUE=$(echo "$DEFAULT_INFO" | jq -r '.value')
+DEFAULT_SOURCE=$(echo "$DEFAULT_INFO" | jq -r '.source')
+
+# 2) Skip AskUserQuestion if non-interactive + has an effective (non-schema) default
+if [ "$INTERACTIVE" = "false" ] && [ "$DEFAULT_SOURCE" != "default" ] && [ -n "$DEFAULT_VALUE" ]; then
+  use "$DEFAULT_VALUE"   # silent path — autonomous / CI
+else
+  ask via AskUserQuestion  # original interactive path
+fi
+```
diff --git a/plugins/specode/skills/specode/references/obsidian.md b/plugins/specode/skills/specode/references/obsidian.md
index f58a2dc..54785d0 100644
--- a/plugins/specode/skills/specode/references/obsidian.md
+++ b/plugins/specode/skills/specode/references/obsidian.md
@@ -15,6 +15,23 @@ specsRoot (the user's document management directory) is **stored in exactly one
 
 CLI via run.sh: `resolve_root.py get-root` / `set-root --root P` / `list-specs` (for the question example, see `selectors.md` §First-time directory setup).
 
+## verbs (`resolve_root.py`, all via run.sh + absolute plugin-root)
+
+| verb | Purpose | exit |
+|---|---|---|
+| `get-root [--root P]` | Resolve specsRoot (`--root` > env `SPECODE_ROOT` > config.specsRoot) | 0 ok / 3 unconfigured |
+| `set-root --root <abs>` | Absolute path, persisted to `~/.config/specode/config.json.specsRoot` | 0 / 1 path not absolute |
+| `list-specs [--root P]` | List spec slugs under root: subdirs with any fixed doc (`requirements.md` / `design.md` / `tasks.md` / `implementation-log.md`) **plus empty subdirs (intake)**; hidden dirs excluded | 0 / 3 unconfigured |
+| `resolve-project-root [--cwd P]` | Compute the project_root default (`git rev-parse --show-toplevel` of cwd, else cwd) for the user to confirm | 0 |
+| `write-project-root --spec <dir\|file> --root <abs>` | **Single writer** of project_root → spec's requirements.md frontmatter (validates absolute / dir exists / `/Volumes` mounted) | 0 / 1 invalid |
+| `read-project-root --spec <dir\|file>` | **Single reader** of project_root from requirements.md frontmatter — all downstream skills use this | 0 / 3 missing field / 4 invalid value |
+| `plan-unchecked --spec <dir\|file>` (alias `design-unchecked`) | Count unchecked `- [ ]` in the plan (tasks.md; 5.x legacy: design.md) | 0 all-checked / 2 has-unchecked (prints N) / 3 no-plan |
+| `read-defaults [--key K] [--json]` | Read autonomous-mode defaults (env > `~/.config/specode/defaults.json` > schema). Single key → plain value; `--json` / no `--key` → `{value, source}` JSON | 0 / 1 unknown key |
+| `write-default --key K --value V` | Persist a defaults key. 5 valid keys: `interactive` / `project_root_default` / `execution_mode_default` / `auto_distill` / `specs_root_default`; type + execution_mode whitelist validated | 0 / 1 invalid |
+| `reset-default --key K \| --all` | Remove one key or `--all` wipe | 0 / 1 invalid |
+
+Autonomous-mode behavior (when to skip each `AskUserQuestion`) is specified in `references/autonomous-mode.md`.
+
 ## Directory conventions
 - The directory the user provides is used **verbatim** as the specs root; specode appends no internal sub-structure (the user may supply a fully qualified path such as `.../spec-in/<os>-<user>/specs`).
 - Each spec = `<specsRoot>/<slug>/`, containing the fixed files `requirements.md` / `design.md` / `tasks.md` / `implementation-log.md`.

From af2ed9dd1a2f08ef41da89bbdb63380b6337f867 Mon Sep 17 00:00:00 2001
From: qxbyte <xueqiang361@gmail.com>
Date: Sun, 5 Jul 2026 16:59:46 +0800
Subject: [PATCH 7/8] refactor(specode): drop dead v3/codemap-term noise from
 distill (zero behavior)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

No functional codemap/.ai-memory remnants exist (removed cleanly in
4.0.0/5.0.1). But distill repeated "no codemap knowledge write / no
codemap recall / no .ai-memory" ~5x — declaring non-use of tools that no
longer exist. Collapsed to neutral live constraints (md-only / don't
consume old KB as fact / don't feed downstream); history detail lives in
CHANGELOG; kept one checkout-backup escape-hatch pointer and the one-line
"don't reintroduce rule-check" guard.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Qiang Xue <qxbyte@users.noreply.github.com>
---
 plugins/specode/CHANGELOG.md            |  9 ++++++-
 plugins/specode/commands/distill.md     |  2 +-
 plugins/specode/skills/distill/SKILL.md | 33 +++++++++----------------
 3 files changed, 21 insertions(+), 23 deletions(-)

diff --git a/plugins/specode/CHANGELOG.md b/plugins/specode/CHANGELOG.md
index 0cbadf4..c4e3b17 100644
--- a/plugins/specode/CHANGELOG.md
+++ b/plugins/specode/CHANGELOG.md
@@ -4,7 +4,14 @@ specode 是 spec-driven 轻量工作流插件：requirements → design → task
 
 ## Unreleased
 
-## 6.0.0 (2026-07-03)
+## 6.1.0 (2026-07-05)
+
+- **新增独立 intake skill**（`skills/intake/`，与 `distill` 平级，`user-invocable: false`，由编排 SKILL 经 Skill 工具按名 `specode:intake` 调用）接管 **requirements phase**：项目分析（agent-docs 扫描 + 经验检索 + 读定位到的真实代码）→ 基于分析的澄清（brainstorming 级，非固定问卷）→ 写 `requirements.md`。**保留 frontmatter 契约不动**：`spec_id` / `created_at` / `project_root`（后者仍经 `write-project-root` 单一写入口）。
+- **修正 6.0.0 的 brainstorming 双产物错位**：brainstorming 从此**只产 design.md（单产物）**，requirements 由 intake 产。requirements phase 不再分「superpowers 在/不在」——永远走 intake，消掉一个 fork。relocate 后置检查回到单文件。
+- **检索节点收敛**：主节点移到 intake 的项目分析步；**design 降为条件性 top-up**（默认继承 intake 指针，仅新领域才补查）；tasks / 执行零注入不变。
+- **弊端修复**：writing-plans 结尾硬编码的「Subagent vs Inline」执行方式提问无参数可关——SKILL 措辞从「抑制」改为**「忽略、不据此执行，继续走 specode selector」**（诚实：只能消化不能抑制）。
+- **SKILL 轻量化（零行为变化）**：`skills/specode/SKILL.md` 215 → 171 行——完整 `resolve_root.py` verb 表下沉到 `references/obsidian.md`；autonomous-mode mapping + 决策伪代码抽到新 `references/autonomous-mode.md`；resolver why-prose 精简；v4.0.0 移除说明压成一行；重复三处的 Absence-fallback 矩阵 slim 成指针。
+- **清理 v3/codemap 死术语噪声（零行为变化）**：功能层无残留（codemap / `.ai-memory` 活代码路径在 4.0.0/5.0.1 已干净移除）；但 `distill` skill 反复对着已不存在的工具声明「无 codemap knowledge write / 不调 codemap recall / 不读 .ai-memory」约 5 处——收敛为中性的活约束（md-only / 不消费旧 KB 当事实 / 不喂下游），历史细节留 CHANGELOG，仅保留一条 checkout-backup 逃生指针。
 
 - **BREAKING**: 固定产物 3 → 4 —— `design.md` 重定义为**传统设计文档**（背景与目标/架构概览/模块划分/接口设计/数据流/错误处理/测试策略，散文无 checkbox）；新增 `tasks.md` 承载可执行计划（writing-plans 格式 + `**Interfaces:**` 契约块，引擎中立，task-swarm / superpowers / 自执行统一消费）。流水线变为 requirements → design → tasks → 执行方式 selector → 执行 → 验收；brainstorming 一次跨 requirements+design 双产物落盘（后置 relocate 检查两份）。
 - **BREAKING**: continue 改「加载即停」——`/specode:continue <slug>` 只读文档 + 汇报进度简报（阶段/文档状态/checkbox x/N）后停下等用户指令，不再自动续跑；用户说「继续」才从推断阶段续跑，提出需求变更则先消化进文档再问。
diff --git a/plugins/specode/commands/distill.md b/plugins/specode/commands/distill.md
index 93bc8e1..1042a71 100644
--- a/plugins/specode/commands/distill.md
+++ b/plugins/specode/commands/distill.md
@@ -17,7 +17,7 @@ description: 手动把一个已完成（或进行中）的 spec 沉淀为项目
 
 - **主写域 = `<project_root>/knowledge-base/`**（`cases/` + `navigation/` + `MEMORY.md`）；Obsidian 是**可选副本**，不是默认主产物
 - spec 目录**只读**：绝不修改 `<specsRoot>/<slug>/` 下任何文件
-- **md-only**：无 yml、无 `codemap knowledge write`、无 `.ai-memory`、无任何静默注入
+- **md-only**：只产 markdown，无 yml、无任何静默注入
 - `--target-dir` / 用户输入路径**直写不拼接**；`/Volumes/` 下需先校验挂载
 - `knowledge-base/` 不提交项目仓库（落盘时 `ensure-gitignore` 保证）
 - `project_root` 经 `resolve_root.py read-project-root --spec ...` 读取，**不从 cwd 反推**
diff --git a/plugins/specode/skills/distill/SKILL.md b/plugins/specode/skills/distill/SKILL.md
index e544606..b47a116 100644
--- a/plugins/specode/skills/distill/SKILL.md
+++ b/plugins/specode/skills/distill/SKILL.md
@@ -6,9 +6,9 @@ description: >
   markdown knowledge points. Default output: md-only, written to the project's
   own `<project_root>/knowledge-base/` (cases/ + navigation/ + MEMORY.md);
   optionally copied to an Obsidian vault. Trigger ONLY via
-  `/specode:distill <slug>` — never auto-run by the main specode flow. No
-  codemap recall, no .ai-memory yml, no auto-injection. Pure "atomic
-  locate-pointer 沉淀器 for the current project".
+  `/specode:distill <slug>` — never auto-run by the main specode flow.
+  Md-only, no auto-injection. Pure "atomic locate-pointer 沉淀器 for the
+  current project".
 ---
 
 # distill — project knowledge-base 沉淀器（原子双轨）
@@ -32,18 +32,10 @@ distill 是一个**手动、按需**触发的沉淀器：把一个完成（或
 **当前 agent 上下文**，提炼成若干**原子知识点**（一需求扇出 N 份独立文档），
 落到该 spec 所属项目的 `knowledge-base/`，并维护一份轻量索引 `MEMORY.md`。
 
-**md-only** —— 无 yml、无 `codemap knowledge write`、无 `.ai-memory`、无任何
-静默注入。历史沿革（仍然成立的事实）：
-
-- v1-v3 的 distill 曾是「记忆 ingest 管线」，写 dual yml + md 到
-  `<project_root>/.ai-memory/knowledge/` 供 `codemap recall` 在后续 spec 自动
-  注入。Round 1/2 基线实验证明 recall 往返**并不净省 token**，4.0.0 整体拔除。
-- yml / `codemap knowledge write` 路径在 5.0.1 移除（其唯一消费者 `codemap
-  recall` 早在 4.0.0 已删，yml 无物可喂）。
-- 当前形态（本次重写）：从「Obsidian-primary 5 类组织器」改为「项目
-  `knowledge-base/` primary 的原子双轨（case + navigation）定位沉淀器 + 可选
-  Obsidian 副本」。要 v3 的自动注入行为，checkout
-  `backup/specode-v3.4.0-task-swarm-v0.9.2`。
+**md-only**（只产 markdown，无任何静默注入）。当前形态 = 项目
+`knowledge-base/` primary 的原子双轨（case + navigation）定位沉淀器 + 可选
+Obsidian 副本。（v1-v3 的自动注入 / yml 形态已在 4.0.0 / 5.0.1 完全移除；要旧
+行为 checkout `backup/specode-v3.4.0-task-swarm-v0.9.2`。历史细节见 CHANGELOG。）
 
 ---
 
@@ -140,15 +132,14 @@ spec `requirements.md` frontmatter 的 `project_root`），**不从 cwd 反推**
      「继续沉淀 / 中止」；用户选中止则结束，不写任何文档。
    （5.x legacy spec 的计划在 design.md 里，`plan-unchecked` 自动兜底识别，无需分支处理。）
 
-### Step 2 — 读全 spec + 回顾 agent 上下文（NO recall）
+### Step 2 — 读全 spec + 回顾 agent 上下文（不消费旧 KB）
 
 `Read` `<specsRoot>/<slug>/` 下每个 `.md`（requirements / design / tasks /
 implementation-log 等），并回顾本轮 agent 上下文里反复用到的「找文件 / 调用链 /
 配置映射」导航经验，留作 Step 3。
 
-> **NO recall**：**不**读任何旧 KB（`knowledge-base/` / `MEMORY.md`）当事实
-> 输入。distill 只**产出**指针，从不把历史 KB 当真相消费。不调用任何
-> `codemap recall`，不读 `.ai-memory/`。
+> **不消费旧 KB 当事实**：**不**读任何旧 KB（`knowledge-base/` / `MEMORY.md`）
+> 当事实输入。distill 只**产出**指针，从不把历史 KB 当真相消费。
 > （例外：Step 4 写 navigation 点前可 `Read` `MEMORY.md` **仅用于去重比对**——
 > 这是索引维护，不是把历史 KB 当事实喂给新内容，与本不变量不冲突。）
 
@@ -214,8 +205,8 @@ sh "$R/scripts/run.sh" "$R/scripts/knowledge.py" memory-rebuild --kb <project_ro
 | Obsidian 是可选副本，直写不拼接 | `--target-dir` / 用户输入的绝对路径直接作为写入目录，distill 不做任何路径拼接 |
 | `/Volumes/` 挂载校验 | 副本目录在 `/Volumes/` 下时先验挂载，未挂载则拒绝 |
 | `knowledge-base/` 不提交仓库 | 本地私有定位资产；落盘时 `ensure-gitignore` 保证 `.gitignore` 含 `knowledge-base/` |
-| Md-only | 只产 markdown —— 无 yml、无 `codemap knowledge write`、无 `.ai-memory` |
-| NO recall / 无注入 | distill 不读旧 KB 当事实、不调 `codemap recall`；产物不喂任何后续 spec 的 `requirements.md`、不喂 task-swarm |
+| Md-only | 只产 markdown（无 yml、无静默注入） |
+| 不消费旧 KB / 无注入 | distill 不读旧 KB 当事实；产物不喂任何后续 spec 的 `requirements.md`、不喂 task-swarm |
 | MEMORY 不手改 | 永远由 `knowledge.py memory-rebuild` 从各文档 frontmatter 全量重建 |
 | Read-before-overwrite | 目标 md 已存在 → `Read` 后问用户 overwrite / skip / merge |
 

From b70bfb50319e0c422af5f95bf054e53d8e283f2c Mon Sep 17 00:00:00 2001
From: qxbyte <xueqiang361@gmail.com>
Date: Sun, 5 Jul 2026 17:00:20 +0800
Subject: [PATCH 8/8] =?UTF-8?q?release(specode):=206.1.0=20=E2=80=94=20int?=
 =?UTF-8?q?ake=20skill,=20brainstorming=20design-only,=20SKILL=20lightenin?=
 =?UTF-8?q?g?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bump both manifests to 6.1.0, date the plugin CHANGELOG, add the root
CHANGELOG 6.1.0 section, refresh both README version rows.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Qiang Xue <qxbyte@users.noreply.github.com>
---
 .claude-plugin/marketplace.json            | 4 ++--
 CHANGELOG.md                               | 8 ++++++++
 README.md                                  | 2 +-
 README.zh-CN.md                            | 2 +-
 plugins/specode/.claude-plugin/plugin.json | 4 ++--
 5 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index 833b7fc..0f059bf 100644
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -9,8 +9,8 @@
     {
       "name": "specode",
       "source": "./plugins/specode",
-      "version": "6.0.0",
-      "description": "Lightweight spec-driven workflow: orchestrates superpowers skills per phase, lands 4 fixed docs (requirements/design/tasks/implementation-log). **v6.0.0 BREAKING**: 固定产物 3→4 — design.md 重定义为**传统设计文档**(背景与目标/架构概览/模块划分/接口设计/数据流/错误处理/测试策略,散文无 checkbox);新增 tasks.md 承载可执行计划(writing-plans 格式 + Interfaces 契约块,引擎中立,task-swarm/superpowers/自执行统一消费,pipeline.yml 改从 tasks.md 推导);流水线变为 requirements→design→tasks→执行方式 selector→执行→验收,brainstorming 一次跨 requirements+design 双产物落盘(后置 relocate 检查两份);continue 改「加载即停」— 只读文档+汇报进度简报后停下等指令,绝不自动续跑;design-unchecked 更名 plan-unchecked(tasks.md 优先,design.md 含 checkbox 按 5.x legacy 兜底,旧名保留 alias)。5.x 存量 spec 由 continue 推断表 legacy 行兜底识别,不中断。  **v5.2.0**: 新增 Tier-0 RagKit gate — 检测到 ragkit 插件 + 已建索引(chunks.json)时,requirements/design 的经验检索走 `ragkit:query` 多路召回(模型自主提炼检索词、可多轮多角度、≤5 点封顶),未安装零成本跳过,zero-import。 **v5.1.3**: `list-specs` 让 intake 阶段（目录已建、requirements 未写）的 spec 可见 — 列出含任一固定产物的子目录 + 空子目录(intake)，隐藏目录与无关内容目录仍排除；全库文档陈旧内容清理(README/CONTRIBUTING/SKILL 残留措辞)。 **v5.0.1**: distill skill 加 `user-invocable:false`(隐藏裸 `/distill` + 消除 `/specode:distill` 重复);distill 收敛为纯 md-only(移除 `--format yml|both` + codemap 死路径);清理全部 `.ai-memory`/codemap 文档残留 + requirements 模板删 recall 段。**v5.0.0 BREAKING**: 命令去 `specode-` 前缀 — `/specode:spec` / `/specode:continue` / `/specode:list` / `/specode:distill`(原 `/specode:specode-*`);内核 skill 加 `user-invocable:false` 隐藏裸 `/specode`。**v4.0.0 BREAKING**: 彻底拔出记忆注入工程 — 砍 P3-1 codemap recall / P3-2 rule-check / acceptance auto-distill prompt。保留 project-level CLAUDE.md scan。distill v4 完全重写为手动 md-only Obsidian wiki organizer, 默认写 `/Volumes/External HD/Obsidian/Notes/11-KnowledgeBase/<slug>/`。如需 v3 行为 checkout `backup/specode-v3.4.0-task-swarm-v0.9.2`。",
+      "version": "6.1.0",
+      "description": "Lightweight spec-driven workflow: orchestrates superpowers skills per phase, lands 4 fixed docs (requirements/design/tasks/implementation-log). **v6.1.0**: 新增独立 intake skill(skills/intake/,同 distill,user-invocable:false)接管 requirements phase — 项目分析(agent-docs 扫描+经验检索+读真实代码)+基于分析的澄清+写 requirements.md(保留 spec_id/created_at/project_root frontmatter 契约);修正 6.0.0 的brainstorming 双产物错位 — brainstorming 从此只产 design.md(单产物),requirements 由 intake 产;检索主节点移到 intake 项目分析步、design 降为条件性 top-up;弊端修复 — writing-plans 结尾的执行方式提问改为「忽略而非抑制」;SKILL 轻量化 215→171 行(verb 表/autonomous-mode 细节下沉到 refs,零行为变化)。 **v6.0.0 BREAKING**: 固定产物 3→4 — design.md 重定义为**传统设计文档**(背景与目标/架构概览/模块划分/接口设计/数据流/错误处理/测试策略,散文无 checkbox);新增 tasks.md 承载可执行计划(writing-plans 格式 + Interfaces 契约块,引擎中立,task-swarm/superpowers/自执行统一消费,pipeline.yml 改从 tasks.md 推导);流水线变为 requirements→design→tasks→执行方式 selector→执行→验收,brainstorming 一次跨 requirements+design 双产物落盘(后置 relocate 检查两份);continue 改「加载即停」— 只读文档+汇报进度简报后停下等指令,绝不自动续跑;design-unchecked 更名 plan-unchecked(tasks.md 优先,design.md 含 checkbox 按 5.x legacy 兜底,旧名保留 alias)。5.x 存量 spec 由 continue 推断表 legacy 行兜底识别,不中断。  **v5.2.0**: 新增 Tier-0 RagKit gate — 检测到 ragkit 插件 + 已建索引(chunks.json)时,requirements/design 的经验检索走 `ragkit:query` 多路召回(模型自主提炼检索词、可多轮多角度、≤5 点封顶),未安装零成本跳过,zero-import。 **v5.1.3**: `list-specs` 让 intake 阶段（目录已建、requirements 未写）的 spec 可见 — 列出含任一固定产物的子目录 + 空子目录(intake)，隐藏目录与无关内容目录仍排除；全库文档陈旧内容清理(README/CONTRIBUTING/SKILL 残留措辞)。 **v5.0.1**: distill skill 加 `user-invocable:false`(隐藏裸 `/distill` + 消除 `/specode:distill` 重复);distill 收敛为纯 md-only(移除 `--format yml|both` + codemap 死路径);清理全部 `.ai-memory`/codemap 文档残留 + requirements 模板删 recall 段。**v5.0.0 BREAKING**: 命令去 `specode-` 前缀 — `/specode:spec` / `/specode:continue` / `/specode:list` / `/specode:distill`(原 `/specode:specode-*`);内核 skill 加 `user-invocable:false` 隐藏裸 `/specode`。**v4.0.0 BREAKING**: 彻底拔出记忆注入工程 — 砍 P3-1 codemap recall / P3-2 rule-check / acceptance auto-distill prompt。保留 project-level CLAUDE.md scan。distill v4 完全重写为手动 md-only Obsidian wiki organizer, 默认写 `/Volumes/External HD/Obsidian/Notes/11-KnowledgeBase/<slug>/`。如需 v3 行为 checkout `backup/specode-v3.4.0-task-swarm-v0.9.2`。",
       "homepage": "https://github.com/qxbyte/pluginhub",
       "repository": "https://github.com/qxbyte/pluginhub",
       "license": "MIT",
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9c04f47..ed9bed1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 6.1.0 (2026-07-05) — specode
+
+- **新增独立 `intake` skill**（`skills/intake/`，同 `distill` 平级）接管 requirements phase：项目分析（agent-docs 扫描 + 经验检索 + 读真实代码）+ 基于分析的澄清 + 写 `requirements.md`（保留 `spec_id` / `created_at` / `project_root` frontmatter 契约，`project_root` 仍经 `write-project-root` 单写入口）。
+- **修正 6.0.0 brainstorming 双产物错位**：brainstorming 从此只产 `design.md`（单产物），requirements 由 intake 产；requirements phase 不再有 superpowers/native 分叉。
+- **检索节点收敛**：主节点 = intake 项目分析步；design = 条件性 top-up（继承 intake 指针）；tasks / 执行零注入不变。
+- **弊端修复**：writing-plans 结尾的执行方式提问改为「忽略而非抑制」（无参数可关，只能消化）。
+- **SKILL 轻量化**：`skills/specode/SKILL.md` 215 → 171 行，verb 表 / autonomous-mode 细节下沉到 references（零行为变化）。
+
 ## 6.0.0 (2026-07-03) — specode
 
 **BREAKING**：固定产物 3 → 4，修正 5.x 的两级错位（brainstorming 的设计产出被当成 requirements、writing-plans 的计划被当成 design）。
diff --git a/README.md b/README.md
index 0d69f49..e2845cf 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ any plugin it hosts. More plugins will land here over time.
 
 | Plugin | Version | What it does |
 | --- | --- | --- |
-| **specode** | 6.0.0 | A lightweight spec-driven **workflow** — orchestration shell that delegates each phase to [superpowers](https://github.com/obra/superpowers) skills (first-class native fallback) and lands 4 fixed docs per spec. **v6.0.0 BREAKING**: fixed docs 3 → 4 — `design.md` redefined as a **traditional design doc** (背景与目标/架构概览/模块划分/接口设计/数据流/错误处理/测试策略, prose only, no checkboxes); new `tasks.md` carries the executable plan (writing-plans format + `**Interfaces:**` contract blocks), engine-neutral — task-swarm (pipeline.yml now derived from it) / superpowers / specode self-execute all consume the same file; pipeline becomes requirements → design → tasks → 执行方式 selector → execute → acceptance, with brainstorming spanning requirements+design in one dual-artifact call; `/specode:continue` becomes **load-and-stop** — reads docs, reports a progress brief, then waits for the user's instruction (never auto-resumes); `design-unchecked` renamed `plan-unchecked` (tasks.md first, 5.x legacy design.md fallback, old name kept as alias); 5.x specs keep working via the legacy inference row. **v5.2.0**: Tier-0 RagKit gate tightened — probe changed from `test -d .ragkit` to `test -f .ragkit/chunks.json` (eliminates false-positive when only config.json exists after `backend set`); Tier-0 採纳条目 capped at Tier-2 discipline (≤5/phase, reasoned override allowed). **v5.1.3**: `list-specs` now surfaces intake-phase specs (dir created, requirements not yet written) — lists subdirs containing any fixed doc plus empty subdirs, hidden dirs still excluded; repo-wide stale-docs cleanup. **v5.1.2**: distill polish — `ensure-gitignore` skips in a non-git project with no existing `.gitignore` (no stray file); new `knowledge.py copy-to` verb (one-step dual-landing: copy cases/navigation + rebuild the dest's MEMORY) now used by distill Step 5; navigation `来源` keeps the origin slug (reusing specs listed in body). **v5.1.1**: validation-driven fixes — distill runs `design-unchecked` before sedimenting (warns if the spec isn't fully executed, so knowledge points don't reference unbuilt code); dedup navigation points against MEMORY before writing; retrieval emphasizes semantic relevance over tag-overlap. **v5.1.0**: reintroduces experience retrieval/injection on a new "pointers-not-facts" footing — new stdlib `knowledge.py` (ensure-gitignore/memory-rebuild/memory-validate); distill now emits **atomic case/navigation knowledge-points** to the project's `<project_root>/knowledge-base/` (cases/ + navigation/ + a MEMORY index, gitignored), optionally copied to Obsidian; new `references/retrieval.md` two-tier gated retrieval wired into the requirements/design phases (inject pointers not facts, default reads only the small index, ≤5 docs on hit); acceptance re-hooks the distill prompt via the existing `auto_distill` default. **v5.0.1**: the `distill` skill is now `user-invocable: false` (hides the bare `/distill` + the duplicate `/specode:distill`, leaving one clean command entry); distill is now **md-only** (dropped the dead `--format yml|both` + `codemap knowledge write` path); purged all remaining `.ai-memory`/codemap doc references and removed the obsolete recall section from the requirements template. **v5.0.0 BREAKING**: commands dropped the redundant `specode-` prefix — `/specode:spec` / `/specode:continue` / `/specode:list` / `/specode:distill` (were `/specode:specode-*`); the `distill` skill dir + name were renamed to `distill`; the `specode` orchestration skill is now `user-invocable: false` so the bare `/specode` no longer shows in the slash menu (still auto-activates via its commands). Preserved AI-EDS-era features: project-level `CLAUDE.md` / `AGENT.md` filesystem scan injected as `## 项目级约束` section (痛点 #14 方案 D), SessionStart cache-vs-marketplace drift hint (M8), autonomous-mode defaults — 5 schema keys + 5 `SPECODE_*` env vars + `read-defaults` / `write-default` / `reset-default` verbs (M1+M9). **v4.0.0 BREAKING**: removed memory-injection pipeline — P3-1 `codemap recall` injection / P3-2 rule-acknowledgement post-check / acceptance auto-distill prompt all dropped; round 1/2 baseline showed the recall round-trip did not net save token. `distill` skill v4 rewritten as a **manual-only Obsidian organizer** — `/specode:distill <slug>` writes md (default) to `/Volumes/External HD/Obsidian/Notes/11-KnowledgeBase/<slug>/`, no `.ai-memory/` writes. To restore v3 behaviour: `git checkout backup/specode-v3.4.0-task-swarm-v0.9.2`. |
+| **specode** | 6.1.0 | A lightweight spec-driven **workflow** — orchestration shell that delegates each phase to [superpowers](https://github.com/obra/superpowers) skills (first-class native fallback) and lands 4 fixed docs per spec. **v6.1.0**: new standalone `specode:intake` skill (peer to `distill`) owns the requirements phase — project analysis (agent-docs scan + experience retrieval + reading located real code) + analysis-driven clarification + writes `requirements.md` preserving the `spec_id`/`created_at`/`project_root` frontmatter contract; fixes the 6.0.0 brainstorming dual-artifact mismatch (brainstorming now produces `design.md` only); retrieval's primary node moves to intake with design as a conditional top-up; writing-plans' execution-mode question is now ignored (not "suppressed"); SKILL.md lightened 215→171 lines (verb table + autonomous-mode detail sunk to references) and dead v3/codemap-term noise dropped from distill. **v6.0.0 BREAKING**: fixed docs 3 → 4 — `design.md` redefined as a **traditional design doc** (背景与目标/架构概览/模块划分/接口设计/数据流/错误处理/测试策略, prose only, no checkboxes); new `tasks.md` carries the executable plan (writing-plans format + `**Interfaces:**` contract blocks), engine-neutral — task-swarm (pipeline.yml now derived from it) / superpowers / specode self-execute all consume the same file; pipeline becomes requirements → design → tasks → 执行方式 selector → execute → acceptance, with brainstorming spanning requirements+design in one dual-artifact call; `/specode:continue` becomes **load-and-stop** — reads docs, reports a progress brief, then waits for the user's instruction (never auto-resumes); `design-unchecked` renamed `plan-unchecked` (tasks.md first, 5.x legacy design.md fallback, old name kept as alias); 5.x specs keep working via the legacy inference row. **v5.2.0**: Tier-0 RagKit gate tightened — probe changed from `test -d .ragkit` to `test -f .ragkit/chunks.json` (eliminates false-positive when only config.json exists after `backend set`); Tier-0 採纳条目 capped at Tier-2 discipline (≤5/phase, reasoned override allowed). **v5.1.3**: `list-specs` now surfaces intake-phase specs (dir created, requirements not yet written) — lists subdirs containing any fixed doc plus empty subdirs, hidden dirs still excluded; repo-wide stale-docs cleanup. **v5.1.2**: distill polish — `ensure-gitignore` skips in a non-git project with no existing `.gitignore` (no stray file); new `knowledge.py copy-to` verb (one-step dual-landing: copy cases/navigation + rebuild the dest's MEMORY) now used by distill Step 5; navigation `来源` keeps the origin slug (reusing specs listed in body). **v5.1.1**: validation-driven fixes — distill runs `design-unchecked` before sedimenting (warns if the spec isn't fully executed, so knowledge points don't reference unbuilt code); dedup navigation points against MEMORY before writing; retrieval emphasizes semantic relevance over tag-overlap. **v5.1.0**: reintroduces experience retrieval/injection on a new "pointers-not-facts" footing — new stdlib `knowledge.py` (ensure-gitignore/memory-rebuild/memory-validate); distill now emits **atomic case/navigation knowledge-points** to the project's `<project_root>/knowledge-base/` (cases/ + navigation/ + a MEMORY index, gitignored), optionally copied to Obsidian; new `references/retrieval.md` two-tier gated retrieval wired into the requirements/design phases (inject pointers not facts, default reads only the small index, ≤5 docs on hit); acceptance re-hooks the distill prompt via the existing `auto_distill` default. **v5.0.1**: the `distill` skill is now `user-invocable: false` (hides the bare `/distill` + the duplicate `/specode:distill`, leaving one clean command entry); distill is now **md-only** (dropped the dead `--format yml|both` + `codemap knowledge write` path); purged all remaining `.ai-memory`/codemap doc references and removed the obsolete recall section from the requirements template. **v5.0.0 BREAKING**: commands dropped the redundant `specode-` prefix — `/specode:spec` / `/specode:continue` / `/specode:list` / `/specode:distill` (were `/specode:specode-*`); the `distill` skill dir + name were renamed to `distill`; the `specode` orchestration skill is now `user-invocable: false` so the bare `/specode` no longer shows in the slash menu (still auto-activates via its commands). Preserved AI-EDS-era features: project-level `CLAUDE.md` / `AGENT.md` filesystem scan injected as `## 项目级约束` section (痛点 #14 方案 D), SessionStart cache-vs-marketplace drift hint (M8), autonomous-mode defaults — 5 schema keys + 5 `SPECODE_*` env vars + `read-defaults` / `write-default` / `reset-default` verbs (M1+M9). **v4.0.0 BREAKING**: removed memory-injection pipeline — P3-1 `codemap recall` injection / P3-2 rule-acknowledgement post-check / acceptance auto-distill prompt all dropped; round 1/2 baseline showed the recall round-trip did not net save token. `distill` skill v4 rewritten as a **manual-only Obsidian organizer** — `/specode:distill <slug>` writes md (default) to `/Volumes/External HD/Obsidian/Notes/11-KnowledgeBase/<slug>/`, no `.ai-memory/` writes. To restore v3 behaviour: `git checkout backup/specode-v3.4.0-task-swarm-v0.9.2`. |
 | **task-swarm** | 0.10.1 | Multi-agent **orchestration** driven by a `pipeline.yml`: semantic task groups with cross-group concurrency, fork coders, per-group reviewer + validator loops. **v0.10.1**: the `task-swarm` orchestration skill is now `user-invocable: false` so the bare `/task-swarm` no longer shows in the slash menu (the `/task-swarm:swarm` command is unchanged). Preserved AI-EDS-era features: frontmatter-first `project_root` + registry-based run lookup (0.7.x), `## 项目级约束（必读）` section + `_PROJECT_AGENT_DOCS.md` inbox sentinel (0.7.3 + 0.7.4), lifecycle group with `init` dedupe (`--on-existing {error/resume/abort-old/force-new}` flag) + `run.pipeline_end_validator` (0.8.0 + 0.8.1), M2 `run-loop` auto-driver (0.8.1), task.md `## 开发纪律 (范式参考)` section listing superpowers skill names as paradigm identifiers (0.9.0–0.9.2). **v0.10.0 BREAKING**: removed `_ingest_lessons.py` + `cmd_resolve` auto-ingest + `--no-ingest` flag — `cmd_resolve` no longer writes `<project_root>/.ai-memory/knowledge/cases\|pitfalls/*.yml`. To restore v0.9.x behaviour: `git checkout backup/specode-v3.4.0-task-swarm-v0.9.2`. See [`plugins/task-swarm/`](./plugins/task-swarm). |
 | **obsidian-wiki** | 2.0.1 | Maintain an Obsidian LLM-Wiki with three skills: deterministic structure layer (`wiki-struct`: Home tree / READMEs / partition pages), content curation (`wiki-curate`: ingest / curate / lint), unified orchestrator (`wiki-orchestrate`). Generic code + per-vault config in the home-dir registry `~/.config/obsidian-wiki/` (falls back to `<vault>/.wiki/config.json`). **v2.0.0 BREAKING**: the spec-distill skill was extracted into specode's `/specode:distill`. See [`plugins/obsidian-wiki/`](./plugins/obsidian-wiki). |
 | **ragkit** | 0.1.0 | Standalone knowledge-base **RAG** — vector + lexical + metadata three-channel recall, RRF-fused, returns pointer cards. Optional downstream consumer of specode `distill` output; zero heavy deps (stdlib + numpy for lexical mode). See [`plugins/ragkit/`](./plugins/ragkit). |
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 8107d93..3ca8cc8 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -18,7 +18,7 @@
 
 | 插件 | 版本 | 做什么 |
 | --- | --- | --- |
-| **specode** | 6.0.0 | 轻量**规格驱动工作流**——编排外壳，每个阶段委托给 [superpowers](https://github.com/obra/superpowers) 技能（一等公民原生降级），每条规格固定产出 4 份文档。**v6.0.0 BREAKING**：固定产物 3→4——`design.md` 重定义为**传统设计文档**（背景与目标/架构概览/模块划分/接口设计/数据流/错误处理/测试策略，散文无 checkbox）；新增 `tasks.md` 承载可执行计划（writing-plans 格式 + `**Interfaces:**` 契约块），引擎中立——task-swarm（pipeline.yml 改从它推导）/ superpowers / specode 自执行统一消费同一份文件；流水线变为 requirements → design → tasks → 执行方式 selector → 执行 → 验收，brainstorming 一次跨 requirements+design 双产物落盘；`/specode:continue` 改**加载即停**——只读文档 + 汇报进度简报后停下等指令，绝不自动续跑；`design-unchecked` 更名 `plan-unchecked`（tasks.md 优先，5.x legacy design.md 兜底，旧名保留 alias）；5.x 存量 spec 经 legacy 推断行兜底不中断。**v5.2.0**：Tier-0 RagKit gate 收紧——探针从 `test -d .ragkit` 改为 `test -f .ragkit/chunks.json`（消除 `backend set` 只写 config.json 时的假阳性）；Tier-0 采纳条目封顶 Tier-2 同等纪律（≤5 点/phase，复杂需求可标注理由突破）。 **v5.1.3**：`list-specs` 让 intake 阶段（目录已建、requirements 未写）的 spec 可见——列出含任一固定产物的子目录 + 空子目录，隐藏目录仍排除；全库文档陈旧内容清理。 **v5.1.2**：distill 打磨——非 git 且无 .gitignore 时 `ensure-gitignore` 跳过(不建 stray);新增 `copy-to` 一步 dual-landing(复制 + 重建 dest MEMORY),distill Step5 改用;navigation `来源` 单值保留 origin。 **v5.1.1**：试跑验证修复——distill 沉淀前 `design-unchecked` 检查是否执行完(未完告警,防指向未落地代码);写 navigation 前比对 MEMORY 去重;retrieval 强调语义相关而非 tag 命中。 **v5.1.0**：以全新「定位用·非事实用」路线重新引入经验检索注入——新增 stdlib `knowledge.py`(ensure-gitignore/memory-rebuild/memory-validate);distill 改产**原子 case/navigation 知识点**到项目 `<project_root>/knowledge-base/`(cases/+navigation/+MEMORY 索引,不入仓),可选复制到 Obsidian;新增 `references/retrieval.md` 两级 gated 检索接入 requirements/design 阶段(注入指针非事实、默认只读小索引、命中才读≤5点);acceptance 末尾按 `auto_distill` 重新挂回 distill 提示。 **v5.0.1**：`distill` skill 改为 `user-invocable: false`（隐藏裸 `/distill` 与重复的 `/specode:distill`，只留命令一条）；distill 收敛为纯 **md-only**（移除已死的 `--format yml|both` 与 `codemap knowledge write` 路径）；清理全部 `.ai-memory`/codemap 文档残留，并从 requirements 模板删除已废弃的 recall 段。**v5.0.0 BREAKING**：命令去掉冗余 `specode-` 前缀——`/specode:spec` / `/specode:continue` / `/specode:list` / `/specode:distill`（原 `/specode:specode-*`）；`distill` skill 目录与 `name` 同改为 `distill`；编排内核 skill `specode` 改为 `user-invocable: false`，斜杠菜单不再显示裸 `/specode`（仍经命令自动激活）。AI-EDS 时代保留至 v4.0.0 的能力：项目级 `CLAUDE.md` / `AGENT.md` filesystem 扫描注入「## 项目级约束」段（痛点 #14 方案 D）、SessionStart cache 与 marketplace drift 提示（M8）、autonomous-mode defaults（5 schema key + 5 个 `SPECODE_*` env var + `read-defaults` / `write-default` / `reset-default` verb，M1+M9）。**v4.0.0 BREAKING**：拔除记忆注入工程——P3-1 `codemap recall` 注入 / P3-2 rule-acknowledgement post-check / acceptance 后自动 distill 全部砍掉；round 1/2 baseline 实验证明 recall 注入未 net 节省 token。`distill` skill v4 完全重写为**仅手动**Obsidian 整理器——`/specode:distill <slug>` 默认 md-only 写到 `/Volumes/External HD/Obsidian/Notes/11-KnowledgeBase/<slug>/`，不再写 `.ai-memory/`。如需 v3 行为：`git checkout backup/specode-v3.4.0-task-swarm-v0.9.2`。 |
+| **specode** | 6.1.0 | 轻量**规格驱动工作流**——编排外壳，每个阶段委托给 [superpowers](https://github.com/obra/superpowers) 技能（一等公民原生降级），每条规格固定产出 4 份文档。**v6.1.0**：新增独立 `specode:intake` skill（与 `distill` 平级）接管 requirements phase——项目分析（agent-docs 扫描 + 经验检索 + 读定位到的真实代码）+ 基于分析的澄清 + 写 `requirements.md`（保留 `spec_id`/`created_at`/`project_root` frontmatter 契约）；修正 6.0.0 brainstorming 双产物错位（brainstorming 从此只产 `design.md`）；检索主节点移到 intake、design 降为条件性 top-up；writing-plans 执行方式提问改为「忽略而非抑制」；SKILL.md 轻量化 215→171 行（verb 表 + autonomous-mode 细节下沉到 references），并清理 distill 里的 v3/codemap 死术语噪声。**v6.0.0 BREAKING**：固定产物 3→4——`design.md` 重定义为**传统设计文档**（背景与目标/架构概览/模块划分/接口设计/数据流/错误处理/测试策略，散文无 checkbox）；新增 `tasks.md` 承载可执行计划（writing-plans 格式 + `**Interfaces:**` 契约块），引擎中立——task-swarm（pipeline.yml 改从它推导）/ superpowers / specode 自执行统一消费同一份文件；流水线变为 requirements → design → tasks → 执行方式 selector → 执行 → 验收，brainstorming 一次跨 requirements+design 双产物落盘；`/specode:continue` 改**加载即停**——只读文档 + 汇报进度简报后停下等指令，绝不自动续跑；`design-unchecked` 更名 `plan-unchecked`（tasks.md 优先，5.x legacy design.md 兜底，旧名保留 alias）；5.x 存量 spec 经 legacy 推断行兜底不中断。**v5.2.0**：Tier-0 RagKit gate 收紧——探针从 `test -d .ragkit` 改为 `test -f .ragkit/chunks.json`（消除 `backend set` 只写 config.json 时的假阳性）；Tier-0 采纳条目封顶 Tier-2 同等纪律（≤5 点/phase，复杂需求可标注理由突破）。 **v5.1.3**：`list-specs` 让 intake 阶段（目录已建、requirements 未写）的 spec 可见——列出含任一固定产物的子目录 + 空子目录，隐藏目录仍排除；全库文档陈旧内容清理。 **v5.1.2**：distill 打磨——非 git 且无 .gitignore 时 `ensure-gitignore` 跳过(不建 stray);新增 `copy-to` 一步 dual-landing(复制 + 重建 dest MEMORY),distill Step5 改用;navigation `来源` 单值保留 origin。 **v5.1.1**：试跑验证修复——distill 沉淀前 `design-unchecked` 检查是否执行完(未完告警,防指向未落地代码);写 navigation 前比对 MEMORY 去重;retrieval 强调语义相关而非 tag 命中。 **v5.1.0**：以全新「定位用·非事实用」路线重新引入经验检索注入——新增 stdlib `knowledge.py`(ensure-gitignore/memory-rebuild/memory-validate);distill 改产**原子 case/navigation 知识点**到项目 `<project_root>/knowledge-base/`(cases/+navigation/+MEMORY 索引,不入仓),可选复制到 Obsidian;新增 `references/retrieval.md` 两级 gated 检索接入 requirements/design 阶段(注入指针非事实、默认只读小索引、命中才读≤5点);acceptance 末尾按 `auto_distill` 重新挂回 distill 提示。 **v5.0.1**：`distill` skill 改为 `user-invocable: false`（隐藏裸 `/distill` 与重复的 `/specode:distill`，只留命令一条）；distill 收敛为纯 **md-only**（移除已死的 `--format yml|both` 与 `codemap knowledge write` 路径）；清理全部 `.ai-memory`/codemap 文档残留，并从 requirements 模板删除已废弃的 recall 段。**v5.0.0 BREAKING**：命令去掉冗余 `specode-` 前缀——`/specode:spec` / `/specode:continue` / `/specode:list` / `/specode:distill`（原 `/specode:specode-*`）；`distill` skill 目录与 `name` 同改为 `distill`；编排内核 skill `specode` 改为 `user-invocable: false`，斜杠菜单不再显示裸 `/specode`（仍经命令自动激活）。AI-EDS 时代保留至 v4.0.0 的能力：项目级 `CLAUDE.md` / `AGENT.md` filesystem 扫描注入「## 项目级约束」段（痛点 #14 方案 D）、SessionStart cache 与 marketplace drift 提示（M8）、autonomous-mode defaults（5 schema key + 5 个 `SPECODE_*` env var + `read-defaults` / `write-default` / `reset-default` verb，M1+M9）。**v4.0.0 BREAKING**：拔除记忆注入工程——P3-1 `codemap recall` 注入 / P3-2 rule-acknowledgement post-check / acceptance 后自动 distill 全部砍掉；round 1/2 baseline 实验证明 recall 注入未 net 节省 token。`distill` skill v4 完全重写为**仅手动**Obsidian 整理器——`/specode:distill <slug>` 默认 md-only 写到 `/Volumes/External HD/Obsidian/Notes/11-KnowledgeBase/<slug>/`，不再写 `.ai-memory/`。如需 v3 行为：`git checkout backup/specode-v3.4.0-task-swarm-v0.9.2`。 |
 | **task-swarm** | 0.10.1 | 由 `pipeline.yml` 驱动的**多 agent 编排**：语义任务组 + 跨组并发、fork coder、按组 reviewer + validator 循环。**v0.10.1**：编排内核 skill `task-swarm` 改为 `user-invocable: false`，斜杠菜单不再显示裸 `/task-swarm`（命令 `/task-swarm:swarm` 不变）。AI-EDS 时代保留至 v0.10.0 的能力：frontmatter-first `project_root` + registry-based run 查找（0.7.x）、coder/reviewer/validator `task.md` 中「## 项目级约束（必读）」段 + `_PROJECT_AGENT_DOCS.md` inbox sentinel（0.7.3+0.7.4）、lifecycle group + `init` dedupe（`--on-existing` flag）+ `run.pipeline_end_validator`（0.8.0+0.8.1）、M2 `run-loop` 自动驱动器（0.8.1）、task.md 「## 开发纪律 (范式参考)」段列出 superpowers skill 名作为范式标识（0.9.0–0.9.2）。**v0.10.0 BREAKING**：拔除记忆注入工程——删 `_ingest_lessons.py` + `cmd_resolve` 自动 ingest + `--no-ingest` flag，`cmd_resolve` 不再写 `<project_root>/.ai-memory/knowledge/cases\|pitfalls/*.yml`。如需 v0.9.x 行为：`git checkout backup/specode-v3.4.0-task-swarm-v0.9.2`。详见 [`plugins/task-swarm/`](./plugins/task-swarm)。 |
 | **obsidian-wiki** | 2.0.1 | 维护 Obsidian LLM-Wiki 的三个 skill：确定性结构层（`wiki-struct`：Home 树 / README / 分区页）、内容策展（`wiki-curate`：ingest / curate / lint）、统一编排器（`wiki-orchestrate`）。通用代码 + 家目录注册表 `~/.config/obsidian-wiki/` 按库配置（回退库内 `.wiki/config.json`）。**v2.0.0 BREAKING**：spec-distill 已剥离并迁入 specode 的 `/specode:distill`。详见 [`plugins/obsidian-wiki/`](./plugins/obsidian-wiki)。 |
 | **ragkit** | 0.1.0 | 独立知识库 **RAG**——向量 + 词汇 + 元数据三路召回，RRF 融合，返回定位卡片。specode `distill` 产出的 `knowledge-base/` 可直接消费；零重型依赖（词汇路仅需 stdlib + numpy）。详见 [`plugins/ragkit/`](./plugins/ragkit)。 |
diff --git a/plugins/specode/.claude-plugin/plugin.json b/plugins/specode/.claude-plugin/plugin.json
index 8571ea3..ea2a56d 100644
--- a/plugins/specode/.claude-plugin/plugin.json
+++ b/plugins/specode/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "name": "specode",
-  "version": "6.0.0",
-  "description": "Lightweight spec-driven workflow: orchestrates superpowers skills per phase, lands 4 fixed docs (requirements/design/tasks/implementation-log). **v6.0.0 BREAKING**: 固定产物 3→4 — design.md 重定义为**传统设计文档**(背景与目标/架构概览/模块划分/接口设计/数据流/错误处理/测试策略,散文无 checkbox);新增 tasks.md 承载可执行计划(writing-plans 格式 + Interfaces 契约块,引擎中立,task-swarm/superpowers/自执行统一消费,pipeline.yml 改从 tasks.md 推导);流水线变为 requirements→design→tasks→执行方式 selector→执行→验收,brainstorming 一次跨 requirements+design 双产物落盘(后置 relocate 检查两份);continue 改「加载即停」— 只读文档+汇报进度简报后停下等指令,绝不自动续跑;design-unchecked 更名 plan-unchecked(tasks.md 优先,design.md 含 checkbox 按 5.x legacy 兜底,旧名保留 alias)。5.x 存量 spec 由 continue 推断表 legacy 行兜底识别,不中断。  **v5.2.0**: Tier-0 RagKit gate tightened — probe changed from `test -d .ragkit` to `test -f .ragkit/chunks.json` (eliminates false-positive when only config.json exists after `backend set`); Tier-0 采纳条目 capped at Tier-2 discipline (≤5/phase, reasoned override allowed). **v5.1.3**: `list-specs` 让 intake 阶段（目录已建、requirements 未写）的 spec 可见 — 列出含任一固定产物的子目录 + 空子目录(intake)，隐藏目录与无关内容目录仍排除；全库文档陈旧内容清理(README/CONTRIBUTING/SKILL 残留措辞)。 **v5.1.2**: distill 打磨 — ensure-gitignore 在非 git 且无既有 .gitignore 时跳过(不建 stray);新增 knowledge.py copy-to(一步 dual-landing:复制 cases/navigation + 重建 dest MEMORY),distill Step5 改用它;navigation 来源 单值保留 origin、复用 spec 写正文。 **v5.1.1**: 试跑验证修复 — distill 沉淀前用 design-unchecked 检查 spec 是否执行完(未完则告警,防知识点指向未落地代码);写 navigation 点前先比对 MEMORY 去重;retrieval 强调语义相关而非 tag 命中;F2(非 git project_root)评估为 by design 不修。 **v5.1.0**: 重新引入「经验检索注入」走全新「定位用·非事实用」路线 — 新增 stdlib knowledge.py(ensure-gitignore/memory-rebuild/memory-validate);distill 改产**原子 case/navigation 知识点**到项目 <project_root>/knowledge-base/(cases/+navigation/+MEMORY 索引,不入仓),可选复制到 Obsidian;新增 references/retrieval.md 两级 gated 检索接入 requirements/design phase(注入指针非事实、默认只读小索引、命中才读≤5点);acceptance 末尾按 auto_distill 重挂 distill 提示。 **v5.0.1**: distill skill 加 `user-invocable:false`(隐藏裸 `/distill` + 消除 `/specode:distill` 重复项,只留命令一条);distill 收敛为纯 **md-only**(移除 `--format yml|both` + `codemap knowledge write` 死路径);清理全部 `.ai-memory`/codemap 文档残留,并从 requirements 模板删除已废弃的「已知约束/历史坑」recall 段。**v5.0.0 BREAKING**: 命令去 `specode-` 前缀 — `/specode:spec` / `/specode:continue` / `/specode:list` / `/specode:distill`(原 `/specode:specode-*`);distill skill 目录与名同改为 `distill`;编排内核 skill `specode` 加 `user-invocable:false`,斜杠菜单不再显示裸 `/specode`(仍经命令/自然语言自动激活)。**v4.0.0 BREAKING**: 彻底拔出记忆注入工程 — 砍掉 specode 主流程的 (1) P3-1 codemap recall 注入 `## 已知约束 / 历史坑` 段, (2) P3-2 rule-acknowledgement post-check, (3) acceptance 后自动 AskUser 触发 distill。round 1/2 baseline 实验证明 recall 注入未 net 节省 token。保留 project-level CLAUDE.md / AGENT.md filesystem scan (不涉及 .ai-memory)。distill skill v4 完全重写: 仅手动触发 `/specode:distill <slug>`, 默认 md-only, 默认写 `/Volumes/External HD/Obsidian/Notes/11-KnowledgeBase/<slug>/` (--target-dir 可覆盖), 不再调 codemap recall, 不再默认写 .ai-memory yml。如需 v3 记忆注入行为, checkout `backup/specode-v3.4.0-task-swarm-v0.9.2`。",
+  "version": "6.1.0",
+  "description": "Lightweight spec-driven workflow: orchestrates superpowers skills per phase, lands 4 fixed docs (requirements/design/tasks/implementation-log). **v6.1.0**: 新增独立 intake skill(skills/intake/,同 distill,user-invocable:false)接管 requirements phase — 项目分析(agent-docs 扫描+经验检索+读真实代码)+基于分析的澄清+写 requirements.md(保留 spec_id/created_at/project_root frontmatter 契约);修正 6.0.0 的brainstorming 双产物错位 — brainstorming 从此只产 design.md(单产物),requirements 由 intake 产;检索主节点移到 intake 项目分析步、design 降为条件性 top-up;弊端修复 — writing-plans 结尾的执行方式提问改为「忽略而非抑制」;SKILL 轻量化 215→171 行(verb 表/autonomous-mode 细节下沉到 refs,零行为变化)。 **v6.0.0 BREAKING**: 固定产物 3→4 — design.md 重定义为**传统设计文档**(背景与目标/架构概览/模块划分/接口设计/数据流/错误处理/测试策略,散文无 checkbox);新增 tasks.md 承载可执行计划(writing-plans 格式 + Interfaces 契约块,引擎中立,task-swarm/superpowers/自执行统一消费,pipeline.yml 改从 tasks.md 推导);流水线变为 requirements→design→tasks→执行方式 selector→执行→验收,brainstorming 一次跨 requirements+design 双产物落盘(后置 relocate 检查两份);continue 改「加载即停」— 只读文档+汇报进度简报后停下等指令,绝不自动续跑;design-unchecked 更名 plan-unchecked(tasks.md 优先,design.md 含 checkbox 按 5.x legacy 兜底,旧名保留 alias)。5.x 存量 spec 由 continue 推断表 legacy 行兜底识别,不中断。  **v5.2.0**: Tier-0 RagKit gate tightened — probe changed from `test -d .ragkit` to `test -f .ragkit/chunks.json` (eliminates false-positive when only config.json exists after `backend set`); Tier-0 采纳条目 capped at Tier-2 discipline (≤5/phase, reasoned override allowed). **v5.1.3**: `list-specs` 让 intake 阶段（目录已建、requirements 未写）的 spec 可见 — 列出含任一固定产物的子目录 + 空子目录(intake)，隐藏目录与无关内容目录仍排除；全库文档陈旧内容清理(README/CONTRIBUTING/SKILL 残留措辞)。 **v5.1.2**: distill 打磨 — ensure-gitignore 在非 git 且无既有 .gitignore 时跳过(不建 stray);新增 knowledge.py copy-to(一步 dual-landing:复制 cases/navigation + 重建 dest MEMORY),distill Step5 改用它;navigation 来源 单值保留 origin、复用 spec 写正文。 **v5.1.1**: 试跑验证修复 — distill 沉淀前用 design-unchecked 检查 spec 是否执行完(未完则告警,防知识点指向未落地代码);写 navigation 点前先比对 MEMORY 去重;retrieval 强调语义相关而非 tag 命中;F2(非 git project_root)评估为 by design 不修。 **v5.1.0**: 重新引入「经验检索注入」走全新「定位用·非事实用」路线 — 新增 stdlib knowledge.py(ensure-gitignore/memory-rebuild/memory-validate);distill 改产**原子 case/navigation 知识点**到项目 <project_root>/knowledge-base/(cases/+navigation/+MEMORY 索引,不入仓),可选复制到 Obsidian;新增 references/retrieval.md 两级 gated 检索接入 requirements/design phase(注入指针非事实、默认只读小索引、命中才读≤5点);acceptance 末尾按 auto_distill 重挂 distill 提示。 **v5.0.1**: distill skill 加 `user-invocable:false`(隐藏裸 `/distill` + 消除 `/specode:distill` 重复项,只留命令一条);distill 收敛为纯 **md-only**(移除 `--format yml|both` + `codemap knowledge write` 死路径);清理全部 `.ai-memory`/codemap 文档残留,并从 requirements 模板删除已废弃的「已知约束/历史坑」recall 段。**v5.0.0 BREAKING**: 命令去 `specode-` 前缀 — `/specode:spec` / `/specode:continue` / `/specode:list` / `/specode:distill`(原 `/specode:specode-*`);distill skill 目录与名同改为 `distill`;编排内核 skill `specode` 加 `user-invocable:false`,斜杠菜单不再显示裸 `/specode`(仍经命令/自然语言自动激活)。**v4.0.0 BREAKING**: 彻底拔出记忆注入工程 — 砍掉 specode 主流程的 (1) P3-1 codemap recall 注入 `## 已知约束 / 历史坑` 段, (2) P3-2 rule-acknowledgement post-check, (3) acceptance 后自动 AskUser 触发 distill。round 1/2 baseline 实验证明 recall 注入未 net 节省 token。保留 project-level CLAUDE.md / AGENT.md filesystem scan (不涉及 .ai-memory)。distill skill v4 完全重写: 仅手动触发 `/specode:distill <slug>`, 默认 md-only, 默认写 `/Volumes/External HD/Obsidian/Notes/11-KnowledgeBase/<slug>/` (--target-dir 可覆盖), 不再调 codemap recall, 不再默认写 .ai-memory yml。如需 v3 记忆注入行为, checkout `backup/specode-v3.4.0-task-swarm-v0.9.2`。",
   "author": {
     "name": "xueqiang",
     "email": "xueqiang361@gmail.com"