feat: rename skills/skiff to pouch and move ACK state under .pouch

Use ~/.pouch, the pouch CLI, and .pouch.yaml as the SSOT container. Keep the inner skills/ packages, and store ACK project state in .pouch/ack instead of docs/ack.
2026-08-25 15:20:02 +08:00
parent ee31278947
commit f3cd56b78e
83 changed files with 1265 additions and 1192 deletions
@@ -1,4 +1,4 @@
-# Python（skiff CLI 运行时产物）
+# Python（pouch CLI 运行时产物）
 __pycache__/
 *.py[cod]
 *$py.class
@@ -1,4 +1,4 @@
-# 复制为 docs/ack/knowledge.yaml，替换占位符。结构见 templates/knowledge.schema.json。
+# 复制为 .pouch/ack/knowledge.yaml，替换占位符。结构见 templates/knowledge.schema.json。
 # Developer/Test 只能在任务证据中提出 candidate；只有 Coordinator 写入这里。
 version: 1
 updatedAt: "2026-08-01T12:43:06+08:00"
@@ -1,6 +1,6 @@
 # Agent Skills 仓库 ACK 协作协议（项目覆盖层）

-> 本项目基于 ACK Skill v0.18.0。通用规范由 `/ack` 从 Skill 自身的
+> 本项目基于 ACK Skill v0.19.0。通用规范由 `/ack` 从 Skill 自身的
 > `references/` 读取；本文件只保存当前仓库差异。

 ## 项目概览
@@ -9,9 +9,9 @@
 - 技术栈：Python 3、Markdown、JSON Schema
 - 运行命令：`python3 -m unittest discover -s tests -p 'test_*.py'`
 - Base URL：`n/a`
- 任务板：`docs/ack/tasks.yaml`
- 项目知识：`docs/ack/knowledge.yaml`
- 覆盖层文件：`docs/ack/project.md`
+- 任务板：`.pouch/ack/tasks.yaml`
+- 项目知识：`.pouch/ack/knowledge.yaml`
+- 覆盖层文件：`.pouch/ack/project.md`

 ## 通用规范（由 ACK Skill 按需读取）

@@ -26,7 +26,7 @@
 ## Worker 路由

 机器可校验的 worker profile、允许 worktree 和 receipt 只以
-`docs/ack/tasks.yaml` 为准。本次 Developer 使用当前项目根 `/home/ace/.skills`；Test
+`.pouch/ack/tasks.yaml` 为准。本次 Developer 使用当前项目根 `/home/ace/.skills`；Test
 必须使用 fresh worker，并在独立临时项目、独立假 CLI 配置目录中完成黑盒演练。

 ## 路径权限
@@ -34,7 +34,7 @@
 | 路径 | Coordinator | Test | Developer | 说明 |
 |------|:-----------:|:----:|:---------:|------|
 | `docs/ack-feishu-bug-intake.md` | R/W | Read-only | Read-only | 本需求规格与验收契约 |
-| `docs/ack/` | R/W | Read-only | Read-only | ACK 项目状态，只有 Coordinator 写 |
+| `.pouch/ack/` | R/W | Read-only | Read-only | ACK 项目状态，只有 Coordinator 写 |
 | `skills/ack/` | Read-only | Read-only | R/W | ACK Skill 实现、模板与通用规范 |
 | `tests/test_ack_feishu_intake_unit.py` | Read-only | Read-only | R/W | Developer 白盒测试 |
 | `tests/test_ack_feishu_intake_e2e.py` | Read-only | R/W | Read-only | Test 独立黑盒演练与回归测试 |
@@ -57,8 +57,8 @@ Test 黑盒复测：
 ```bash
 python3 -m unittest discover -s tests -p 'test_ack_feishu_intake_e2e.py'
 python3 -m unittest discover -s tests -p 'test_ack*.py'
-python3 skills/ack/scripts/validate_tasks.py docs/ack/tasks.yaml
-python3 skills/ack/scripts/validate_knowledge.py docs/ack/knowledge.yaml --tasks docs/ack/tasks.yaml
+python3 skills/ack/scripts/validate_tasks.py .pouch/ack/tasks.yaml
+python3 skills/ack/scripts/validate_knowledge.py .pouch/ack/knowledge.yaml --tasks .pouch/ack/tasks.yaml
 ```

 ## 本次任务硬规则
@@ -1,14 +1,14 @@
 version: 1
 updatedAt: "2026-08-23T20:30:26+08:00"
 source: "Coordinator (PM) Agent"
-ackVersion: "0.18.0"
+ackVersion: "0.19.0"
 project:
  name: "skills"
  repoPath: "/home/ace/orca/workspaces/.skills/record-bug"
  baseUrl: "n/a"
  devWorktree: "/home/ace/orca/workspaces/.skills/record-bug"
-  overlayFile: "docs/ack/project.md"
-  knowledgeFile: "docs/ack/knowledge.yaml"
+  overlayFile: ".pouch/ack/project.md"
+  knowledgeFile: ".pouch/ack/knowledge.yaml"
  orchestration:
    profileVersion: 1
    mode: "orca"
@@ -455,7 +455,7 @@ tasks:
        - "python3 -m unittest discover -s tests -p 'test_ack_feishu_intake_unit.py'"
        - "python3 -m unittest discover -s tests -p 'test_ack_feishu_intake_e2e.py'"
        - "python3 -m unittest discover -s tests -p 'test_ack*.py'"
-        - "python3 skills/ack/scripts/validate_tasks.py docs/ack/tasks.yaml"
+        - "python3 skills/ack/scripts/validate_tasks.py .pouch/ack/tasks.yaml"
      browser:
        page: "n/a"
        checks:
@@ -507,7 +507,7 @@ tasks:
            explicit tenant-b selection, trusted executable resolution,
            screenshot containment, stable opaque sourceRef deduplication and
            fail-closed handling for malformed, ambiguous, non-progressing and
-            over-limit responses. Validators, skiff check, compileall and diff
+            over-limit responses. Validators, pouch check, compileall and diff
            checks also passed.

    resolution:
@@ -617,7 +617,7 @@ tasks:
    verification:
      commands:
        - "python3 -m unittest tests.test_ack_omp_worker tests.test_ack_worker_profiles tests.test_ack_launch_worker"
-        - "python3 skills/ack/scripts/validate_tasks.py docs/ack/tasks.yaml"
+        - "python3 skills/ack/scripts/validate_tasks.py .pouch/ack/tasks.yaml"
      browser:
        page: "n/a"
        checks:
@@ -809,8 +809,8 @@ tasks:
    verification:
      commands:
        - "python3 -m unittest discover -s tests -p 'test_ack_omp_e2e.py'"
-        - "python3 skills/ack/scripts/validate_tasks.py docs/ack/tasks.yaml"
-        - "python3 skills/ack/scripts/validate_knowledge.py docs/ack/knowledge.yaml --tasks docs/ack/tasks.yaml"
+        - "python3 skills/ack/scripts/validate_tasks.py .pouch/ack/tasks.yaml"
+        - "python3 skills/ack/scripts/validate_knowledge.py .pouch/ack/knowledge.yaml --tasks .pouch/ack/tasks.yaml"
      browser:
        page: "n/a"
        checks:
@@ -1,12 +1,11 @@
-# Agent Skills 仓库
+# pouch

-自研 Agent Skills 与配套规范资料的单一事实来源（SSOT）。Skill 内容、规范包与可运行的 skiff CLI 在本仓库一并维护。
+自研 Agent Skills 与配套规范资料的单一事实来源（SSOT）。仓库名、家目录 `~/.pouch` 和 CLI 都叫 **pouch**。旧名是 `skills` / `skiff`。


 | 仓库              | 地址                                                                       | 职责                         |
 | --------------- | ------------------------------------------------------------------------ | -------------------------- |
-| **skills**（本仓库） | [https://git.yumee.top/laily/skills](https://git.yumee.top/laily/skills) | skill、规范包、skiff CLI 的当前 SSOT |
-| **skiff**       | [https://git.yumee.top/laily/skiff](https://git.yumee.top/laily/skiff)   | skiff CLI 的独立来源 / 上游同步参考    |
+| **pouch**（本仓库） | [https://git.yumee.top/laily/pouch](https://git.yumee.top/laily/pouch) | skill、规范包、pouch CLI 的当前 SSOT |


 ---
@@ -15,16 +14,16 @@

 ```bash
 # 1. 克隆并关联
-git clone https://git.yumee.top/laily/skills.git ~/.skills
-cd ~/.skills && ./install.sh
+git clone https://git.yumee.top/laily/pouch.git ~/.pouch
+cd ~/.pouch && ./install.sh

-# install.sh 会自动把 skiff 项目 skill 安装到所有 Agent
+# install.sh 会自动把 pouch 项目 skill 安装到所有 Agent
 # 2. 安装其他 skill
-skiff add declarative-openspec-loop -g
+pouch add declarative-openspec-loop -g

 # 3. 查看状态
-skiff list
-skiff status
+pouch list
+pouch status
 ```

 ---
@@ -41,13 +40,13 @@ skills/
 ├── discussion-notes/           # 讨论沉淀笔记
 │   ├── SKILL.md
 │   └── reference.md
-skiff/                          # CLI 源码（Python 3）
-bin/skiff                       # CLI 入口
-catalog.yaml                   # skiff 预置 Skill 来源目录
+pouch/                          # CLI 源码（Python 3）
+bin/pouch                       # CLI 入口
+catalog.yaml                   # pouch 预置 Skill 来源目录
 AGENTS.md                       # 本文档
 ```

-**本仓库包含**：`skills/`、`skiff/`、`bin/skiff`、`catalog.yaml`、`AGENTS.md`
+**本仓库包含**：`skills/`、`pouch/`、`bin/pouch`、`catalog.yaml`、`AGENTS.md`
 **本仓库不包含**：各项目的 skill 启用清单

 ---
@@ -61,7 +60,7 @@ AGENTS.md                       # 本文档
 | ---------------------------------------------------------------------- | ------------------------------------------------- |
 | [orc](skills/orc/SKILL.md)                                             | ORC 入口：显式编排开发、版本发布与产物任务，支持 Agent 分档         |
 | [ack](skills/ack/SKILL.md)                                             | ACK 入口：显式初始化、检查并运行项目三角色协作闭环                  |
-| [skiff](skills/skiff/SKILL.md)                                         | 本项目工作流：创建、使用、反馈与更新 builtin skill               |
+| [pouch](skills/pouch/SKILL.md)                                         | 本项目工作流：创建、使用、反馈与更新 builtin skill               |
 | [declarative-openspec-loop](skills/declarative-openspec-loop/SKILL.md) | 声明式编程循环：用户提供校验方式，Agent 自动 propose/apply/校验并迭代直到通过 |
 | [discussion-notes](skills/discussion-notes/SKILL.md)                   | 讨论沉淀：边讨论边维护 Markdown 笔记，无 .raw.md                 |

@@ -73,12 +72,12 @@ Skill 需要的稳定规范、模板、示例和脚本直接放在自己的目
 项目状态，不复制或链接 Skill 内容：

 ```bash
-skiff init ack
+pouch init ack
 ```

 ### 预置目录（Catalog）

-在 `catalog.yaml` 中预置，通过 skiff 拉取安装：
+在 `catalog.yaml` 中预置，通过 pouch 拉取安装：


 | Source | 来源 |
@@ -87,8 +86,8 @@ skiff init ack


 ```bash
-skiff fetch waza
-skiff add waza/think -g
+pouch fetch waza
+pouch add waza/think -g
 ```

 ### 自定义仓库（Custom Sources）
@@ -96,21 +95,21 @@ skiff add waza/think -g
 公司或团队维护、且一个仓库中包含多个 skill 时，使用命名 custom source：

 ```bash
-skiff source add company \
+pouch source add company \
  git@git.company.com:platform/agent-skills.git \
  --skills-path skills
-skiff list --source company
-skiff add company/internal-review -g
+pouch list --source company
+pouch add company/internal-review -g
 ```

 也可以接入已有本地 checkout：

 ```bash
-skiff source add company --local ~/code/company-skills --skills-path skills
+pouch source add company --local ~/code/company-skills --skills-path skills
 ```

-配置保存在 `~/.config/skiff/config.yaml`，Git source 默认 clone 到
-`~/.local/share/skiff/sources/<source>/`。项目 `.skills.yaml` 只记录逻辑
+配置保存在 `~/.config/pouch/config.yaml`，Git source 默认 clone 到
+`~/.local/share/pouch/sources/<source>/`。项目 `.pouch.yaml` 只记录逻辑
 source 名称，每台机器独立配置实际仓库地址。

 ### 社区（External NPM / GitHub）
@@ -127,28 +126,28 @@ npx skills find typescript
 ## 设计原则

 1. **SSOT** — 自研 skill 只存在于 `skills/<name>/`，不在 Agent 目录直接创建
-2. **项目自治** — 每个项目自己维护 `.skills.yaml`，本仓库不维护项目清单
+2. **项目自治** — 每个项目自己维护 `.pouch.yaml`，本仓库不维护项目清单
 3. **软链优先** — 通过 symlink 映射到 Agent 目录，改 skill 即改 SSOT
 4. **能力内聚** — Skill 使用的规范、模板和脚本与 `SKILL.md` 同目录维护
-5. **一体维护** — skill 与 CLI 同仓库维护；需要时再与独立 skiff 仓库同步
+5. **一体维护** — skill 与 CLI 同仓库维护

 ---

 ## 架构

 ```
-skills 仓库（本仓库）              skiff CLI
-skills/<name>/              ←──   skiff install / enable
-skiff/                      ←──   python3 -m skiff
-catalog.yaml               ←──   skiff add / fetch
+pouch 仓库（本仓库）              pouch CLI
+skills/<name>/              ←──   pouch install / enable
+pouch/                      ←──   python3 -m pouch
+catalog.yaml               ←──   pouch add / fetch
         ↑
-    ~/.skills（symlink）
+    ~/.pouch（symlink）
         │
    ┌────┴────┐
    ▼         ▼
 ~/.cursor/skills/     project/.agents/skills/
 ~/.claude/skills/     project/.claude/skills/
-~/.codex/skills/      project/.skills.yaml
+~/.codex/skills/      project/.pouch.yaml
 ~/.agents/skills/     （agents 标准目录，覆盖 OMP）
 ```

@@ -158,8 +157,8 @@ catalog.yaml               ←──   skiff add / fetch
 | 层级               | 位置                                 | 维护方式                            |
 | ---------------- | ---------------------------------- | ------------------------------- |
 | **Builtin**        | `skills/<name>/`                   | 本仓库 commit                      |
-| **Catalog** | `catalog.yaml` + checkout 缓存 | `skiff catalog add / fetch` |
-| **Custom Source** | `~/.local/share/skiff/sources/` 或本地路径 | `skiff source add/fetch` |
+| **Catalog** | `catalog.yaml` + checkout 缓存 | `pouch catalog add / fetch` |
+| **Custom Source** | `~/.local/share/pouch/sources/` 或本地路径 | `pouch source add/fetch` |
 | **External NPM** | `node_modules/`                    | `npx skills add` / `skills-npm` |

 ### 非 Skill 资料分类
@@ -184,10 +183,10 @@ catalog.yaml               ←──   skiff add / fetch

 ## 项目级启用

-每个项目**自己维护** `.skills.yaml`，不由本仓库管理：
+每个项目**自己维护** `.pouch.yaml`，不由本仓库管理：

 ```yaml
-# .skills.yaml（在项目根目录）
+# .pouch.yaml（在项目根目录）
 skills:
  - name: declarative-openspec-loop
    source: builtin
@@ -205,38 +204,38 @@ targets:          # 可选，默认 all

 | 概念             | 类比                          |
 | -------------- | --------------------------- |
-| skills 仓库      | npm registry                |
-| `.skills.yaml` | `package.json` dependencies |
-| `skiff enable` | `npm install`               |
-| `skiff sync`   | `npm ci`                    |
+| pouch 仓库      | npm registry                |
+| `.pouch.yaml` | `package.json` dependencies |
+| `pouch enable` | `npm install`               |
+| `pouch sync`   | `npm ci`                    |


 项目级命令：

 ```bash
 cd ~/code/my-app
-skiff enable declarative-openspec-loop
-skiff disable declarative-openspec-loop
-skiff sync
+pouch enable declarative-openspec-loop
+pouch disable declarative-openspec-loop
+pouch sync
 ```

 ---

-## skiff 命令
+## pouch 命令

-详见 [skiff README](https://git.yumee.top/laily/skiff)。
+详见 [pouch README](https://git.yumee.top/laily/pouch)。

 ### 已实现


 | 命令                                     | 说明                  |
 | -------------------------------------- | ------------------- |
-| `skiff bootstrap`                      | 将 skiff 项目 skill 全局安装到所有 Agent |
-| `skiff list`                           | 列出所有 skill          |
-| `skiff status`                         | 安装状态总览              |
-| `skiff add <name> [-g]`                | 项目或全局安装（symlink） |
-| `skiff remove <name> [-g]`             | 移除 symlink |
-| `skiff catalog add` / `skiff fetch`    | 管理和拉取 catalog source |
+| `pouch bootstrap`                      | 将 pouch 项目 skill 全局安装到所有 Agent |
+| `pouch list`                           | 列出所有 skill          |
+| `pouch status`                         | 安装状态总览              |
+| `pouch add <name> [-g]`                | 项目或全局安装（symlink） |
+| `pouch remove <name> [-g]`             | 移除 symlink |
+| `pouch catalog add` / `pouch fetch`    | 管理和拉取 catalog source |


 ### 草稿与健康检查
@@ -244,10 +243,10 @@ skiff sync

 | 命令 | 说明 |
 | --- | --- |
-| `skiff create <name> --idea TEXT [--from-project PATH]` | 从 `_template/` 创建草稿 |
-| `skiff check <name>` | 校验草稿或正式 skill |
-| `skiff finalize <name>` | 校验并将草稿转为正式 skill |
-| `skiff doctor [--fix]` | symlink 健康检查与修复 |
+| `pouch create <name> --idea TEXT [--from-project PATH]` | 从 `_template/` 创建草稿 |
+| `pouch check <name>` | 校验草稿或正式 skill |
+| `pouch finalize <name>` | 校验并将草稿转为正式 skill |
+| `pouch doctor [--fix]` | symlink 健康检查与修复 |


 ---
@@ -282,12 +281,12 @@ description: >-

 ### 新建流程

-1. `skiff create my-skill --idea "..." --from-project .`
-2. Agent 编辑 `~/.skills/.drafts/my-skill/SKILL.md`
-3. `skiff check my-skill`
-4. 用户确认后执行 `skiff finalize my-skill`
-5. `skiff add my-skill -a cursor -g -y` 验证
-6. 在本仓库 commit；需要的项目再用 `skiff add my-skill` 启用
+1. `pouch create my-skill --idea "..." --from-project .`
+2. Agent 编辑 `~/.pouch/.drafts/my-skill/SKILL.md`
+3. `pouch check my-skill`
+4. 用户确认后执行 `pouch finalize my-skill`
+5. `pouch add my-skill -a cursor -g -y` 验证
+6. 在本仓库 commit；需要的项目再用 `pouch add my-skill` 启用

 **禁止**在 `~/.cursor/skills/` 或项目 Agent 目录直接创建非 symlink 的 skill。

@@ -299,7 +298,7 @@ symlink 正确时，Agent 在项目里改 skill 文件 = 直接改 SSOT：

 ```
 project/.agents/skills/foo/SKILL.md
-  → ~/.skills/skills/foo/SKILL.md
+  → ~/.pouch/skills/foo/SKILL.md
  → 在本仓库 commit
 ```

@@ -314,7 +313,7 @@ Claude Code 对 symlink 支持不稳定：可能无法发现 skill，或写入
 | -------------- | ----------------------------------------------------- |
 | Cursor / Codex | symlink，正常                                            |
 | Claude Code    | symlink 单个 skill 目录，不要 symlink 整个 `~/.claude/skills/` |
-| symlink 被替换    | `skiff doctor --fix` → 重建 symlink                         |
+| symlink 被替换    | `pouch doctor --fix` → 重建 symlink                         |


 ---
@@ -324,7 +323,7 @@ Claude Code 对 symlink 支持不稳定：可能无法发现 skill，或写入

 | 场景             | 工具                                                   |
 | -------------- | ---------------------------------------------------- |
-| 自研 skill 安装/管理 | **skiff**                                            |
+| 自研 skill 安装/管理 | **pouch**                                            |
 | 社区 skill 安装    | **Vercel `npx skills add`**                          |
 | NPM 包内 skill   | **skills-npm** / **skill-indexer**                   |
 | 搜索发现           | **npx skills find** / [skills.sh](https://skills.sh) |
@@ -337,13 +336,13 @@ Claude Code 对 symlink 支持不稳定：可能无法发现 skill，或写入

 | 我要…        | 命令                                | 在哪   |
 | ---------- | --------------------------------- | ---- |
-| 首次安装       | `git clone <repo> ~/.skills && ~/.skills/install.sh` | 任意   |
-| 新建 skill   | `skiff create` → Agent 完善 → `check/finalize` | 任意项目 |
-| 全局启用       | `skiff install <name>`            | 任意   |
-| 项目启用       | `skiff enable <name>`             | 项目目录 |
-| 看状态        | `skiff status`                    | 任意   |
+| 首次安装       | `git clone <repo> ~/.pouch && ~/.pouch/install.sh` | 任意   |
+| 新建 skill   | `pouch create` → Agent 完善 → `check/finalize` | 任意项目 |
+| 全局启用       | `pouch install <name>`            | 任意   |
+| 项目启用       | `pouch enable <name>`             | 项目目录 |
+| 看状态        | `pouch status`                    | 任意   |
 | 装社区 skill  | `npx skills add owner/repo -g -y` | 任意   |
-| 更新外部 skill | `skiff fetch <name>`              | 任意   |
+| 更新外部 skill | `pouch fetch <name>`              | 任意   |


 ---
@@ -351,7 +350,7 @@ Claude Code 对 symlink 支持不稳定：可能无法发现 skill，或写入
 ## 参考

 - [Agent Skills 开放标准](https://agentskills.io)
- [skiff CLI](https://git.yumee.top/laily/skiff)
+- [pouch CLI](https://git.yumee.top/laily/pouch)
 - [Vercel skills CLI](https://github.com/vercel-labs/skills)
 - [skills.sh](https://skills.sh)
 - [Cursor Skills 文档](https://cursor.com/docs/context/skills)
@@ -1,35 +1,44 @@
-# Agent Skills
+# pouch

-自研 [Agent Skills](https://agentskills.io) 的单一事实来源（SSOT）。Skill 内容与 **skiff** CLI 在本仓库一并维护。
+自研 [Agent Skills](https://agentskills.io) 的单一事实来源（SSOT）。仓库、家目录 `~/.pouch` 和 CLI 都叫 **pouch**。Skill 内容与 CLI 在本仓库一并维护。

 ## 快速开始

 ```bash
-git clone https://git.yumee.top/laily/skills.git ~/.skills
-cd ~/.skills
-./install.sh  # 安装 CLI，并将 skiff 项目 skill 安装到所有 Agent
+git clone https://git.yumee.top/laily/pouch.git ~/.pouch
+cd ~/.pouch
+./install.sh  # 安装 CLI，并将 pouch 项目 skill 安装到所有 Agent

-skiff add declarative-openspec-loop -g
-skiff select  # 交互式选择并批量安装
-skiff list
-skiff status
+pouch add declarative-openspec-loop -g
+pouch select  # 交互式选择并批量安装
+pouch list
+pouch status
 ```

+从旧的 `~/.skills` / `skiff` 迁移：
+
+```bash
+mv ~/.skills ~/.pouch
+~/.pouch/install.sh
+```
+
+`install.sh` 会安装 `pouch` 命令，并保留 `skiff` 作为旧命令别名。项目里已有的 `.skills.yaml` 仍可读取；新写入使用 `.pouch.yaml`。
+
 ## 仓库结构

 ```
 skills/           # 自研 skill（SSOT）：每个子目录必须有 SKILL.md
-skiff/            # CLI 源码（Python 3）
-bin/skiff         # CLI 入口
-catalog.yaml      # skiff 预置 Skill 来源目录
+pouch/            # CLI 源码（Python 3）
+bin/pouch         # CLI 入口
+catalog.yaml      # pouch 预置 Skill 来源目录
 AGENTS.md         # 详细规范与架构说明
 ```

 | 路径 | 说明 |
 |------|------|
 | [skills/](skills/) | 自研 skill，每个子目录含 `SKILL.md`，可附带 references、templates 和 scripts |
-| [skiff/](skiff/README.md) | 安装、软链、健康检查 CLI |
-| [catalog.yaml](catalog.yaml) | skiff 预置 Skill 来源目录 |
+| [pouch/](pouch/README.md) | 安装、软链、健康检查 CLI |
+| [catalog.yaml](catalog.yaml) | pouch 预置 Skill 来源目录 |
 | [AGENTS.md](AGENTS.md) | 设计原则、编写规范、架构详解 |

 ## 自研 Skill
@@ -38,44 +47,44 @@ AGENTS.md         # 详细规范与架构说明
 |-------|------|
 | [orc](skills/orc/SKILL.md) | 显式编排开发、版本发布和产物任务，支持 low/mid/high Agent 档位 |
 | [ack](skills/ack/SKILL.md) | 显式初始化、检查并运行 ACK 三角色协作及可选交付闭环 |
-| [skiff](skills/skiff/SKILL.md) | 在项目中创建、安装、反馈和维护 builtin skill |
+| [pouch](skills/pouch/SKILL.md) | 在项目中创建、安装、反馈和维护 builtin skill |
 | [declarative-openspec-loop](skills/declarative-openspec-loop/SKILL.md) | 声明式编程循环：用户提供校验方式，Agent 自动迭代直到通过 |
 | [discussion-notes](skills/discussion-notes/SKILL.md) | 讨论沉淀：边讨论边维护 Markdown 笔记 |

 ACK 是包含规范、模板与校验脚本的完整 Skill。安装 Skill 后可初始化当前项目状态：

 ```bash
-skiff init ack
-skiff init ack --project ~/app
+pouch init ack
+pouch init ack --project ~/app
 ```

-初始化会生成默认关闭的 `docs/ack/delivery.yaml`；项目可用自然语言让 `/ack` 维护
+初始化会生成默认关闭的 `.pouch/ack/delivery.yaml`；项目可用自然语言让 `/ack` 维护
 DEB、镜像、PR、发布与部署 profile，任务验证通过后再按已确认计划执行。

 新建 skill：

 ```bash
-skiff create my-skill --idea "描述要解决的重复问题" --from-project .
-# 由 Agent 完善 ~/.skills/.drafts/my-skill/SKILL.md
-skiff check my-skill
-skiff finalize my-skill
-skiff add my-skill -g   # 全局安装验证
+pouch create my-skill --idea "描述要解决的重复问题" --from-project .
+# 由 Agent 完善 ~/.pouch/.drafts/my-skill/SKILL.md
+pouch check my-skill
+pouch finalize my-skill
+pouch add my-skill -g   # 全局安装验证
 ```

-项目里使用 skill 发现通用问题或优化时，让 Agent 按 `skiff` skill 收集实际结果与期望结果，修改 `~/.skills/skills/<name>/` 的 SSOT，并执行 `skiff check <name>`。项目专属规则保留在项目内，不回流到通用 skill。
+项目里使用 skill 发现通用问题或优化时，让 Agent 按 `pouch` skill 收集实际结果与期望结果，修改 `~/.pouch/skills/<name>/` 的 SSOT，并执行 `pouch check <name>`。项目专属规则保留在项目内，不回流到通用 skill。

 ## 安装方式

 ### 全局（用户级）

 ```bash
-skiff add <name> -g                   # 安装到 ~/.cursor/skills/ 等
-skiff add <name> -g -a cursor
+pouch add <name> -g                   # 安装到 ~/.cursor/skills/ 等
+pouch add <name> -g -a cursor
 ```

 ### 项目级

-在项目根目录维护 `.skills.yaml`：
+在项目根目录维护 `.pouch.yaml`：

 ```yaml
 skills:
@@ -91,9 +100,9 @@ targets:          # 可选，默认 all
 ```

 ```bash
-skiff add declarative-openspec-loop
-skiff sync
-skiff remove declarative-openspec-loop
+pouch add declarative-openspec-loop
+pouch sync
+pouch remove declarative-openspec-loop
 ```

 ## Catalog 与 Custom Source
@@ -101,15 +110,15 @@ skiff remove declarative-openspec-loop
 安装 catalog 中预置的来源：

 ```bash
-skiff fetch waza
-skiff add waza/think -g
+pouch fetch waza
+pouch add waza/think -g
 ```

 接入团队自己的本地目录或 Git 仓库：

 ```bash
-skiff source add company --local ~/code/company-skills --skills-path skills
-skiff add company/internal-review -g
+pouch source add company --local ~/code/company-skills --skills-path skills
+pouch add company/internal-review -g
 ```

 **社区来源**（Vercel CLI）：
@@ -123,24 +132,24 @@ npx skills find typescript

 ```
 本仓库
-├── skills/<name>/     ←── skiff install / enable
+├── skills/<name>/     ←── pouch install / enable
 ├── catalog.yaml       ←── 预置来源发现与 fetch
-└── skiff/             ←── python3 -m skiff
+└── pouch/             ←── python3 -m pouch
         ↑
-    ~/.skills（symlink）
+    ~/.pouch（symlink）
         │
    ┌────┴────────────────┐
    ▼                     ▼
 ~/.cursor/skills/    project/.agents/skills/
 ~/.claude/skills/    project/.claude/skills/
-~/.codex/skills/     project/.skills.yaml
+~/.codex/skills/     project/.pouch.yaml
 ~/.agents/skills/    （agents 标准目录，覆盖 OMP）
 ```

 ## 设计原则

 1. **SSOT** — 自研 skill 只存在于 `skills/<name>/`
-2. **项目自治** — 各项目自行维护 `.skills.yaml`
+2. **项目自治** — 各项目自行维护 `.pouch.yaml`
 3. **软链优先** — 通过 symlink 映射到 Agent 目录，改 skill 即改 SSOT
 4. **能力内聚** — Skill 所需规范、模板和脚本与 `SKILL.md` 放在同一目录
 5. **一体维护** — skill 与 CLI 同仓库，Python 3 直接运行，无需编译
@@ -148,7 +157,7 @@ npx skills find typescript
 ## 文档

 - [AGENTS.md](AGENTS.md) — 完整规范、多 Agent 路径、编写约定
- [skiff/README.md](skiff/README.md) — CLI 命令参考与开发说明
+- [pouch/README.md](pouch/README.md) — CLI 命令参考与开发说明

 ## 参考

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail

-# 跟随软链，确保从 ~/.local/bin/skiff 调用时仍能找到仓库根目录
+# 跟随软链，确保从 ~/.local/bin/pouch 调用时仍能找到仓库根目录
 SCRIPT="${BASH_SOURCE[0]}"
 while [ -L "$SCRIPT" ]; do
  link_dir="$(cd "$(dirname "$SCRIPT")" && pwd)"
@@ -11,4 +11,4 @@ done
 REPO_ROOT="$(cd "$(dirname "$SCRIPT")/.." && pwd)"

 export PYTHONPATH="${REPO_ROOT}${PYTHONPATH:+:$PYTHONPATH}"
-exec python3 -m skiff "$@"
+exec python3 -m pouch "$@"
@@ -4,7 +4,7 @@
 #     repo: <git-url>
 #     ref: <branch|tag>     (default: main)
 #     path: <subpath>       (default: .)
-#     description: <text>   (optional, shown by `skiff select`)
+#     description: <text>   (optional, shown by `pouch select`)
 #     tags:                 (optional)
 #       - <tag>
 #
@@ -17,7 +17,7 @@ updated: "2026-07-31T23:31:48+08:00"
 ## 背景

 本轮评审覆盖 `skills/ack/` 的入口、角色规范、闭环流程、项目模板、任务板
-schema、校验脚本、Orca 适配器，以及 `skiff init ack` 的真实运行路径。
+schema、校验脚本、Orca 适配器，以及 `pouch init ack` 的真实运行路径。

 评审主要回答两个问题：

@@ -216,15 +216,15 @@ Deferred，当前 launcher 必须 fail closed。

 ## P0：初始化需要原子化

-`skiff init ack` 会先写 `project.md` 和 `tasks.yaml`，再运行任务板校验。缺少 PyYAML
+`pouch init ack` 会先写 `project.md` 和 `tasks.yaml`，再运行任务板校验。缺少 PyYAML
 时，命令会失败但保留两个文件。再次运行又会因为拒绝覆盖而失败。

 相关位置：

 - `requirements.txt:1`
 - `skills/ack/scripts/validate_tasks.py:37`
- `skiff/cli.py:1144`
- `skiff/cli.py:1156`
+- `pouch/cli.py:1144`
+- `pouch/cli.py:1156`

 本轮在不含第三方包的隔离 Python 环境中复现了这个状态。

@@ -232,7 +232,7 @@ Deferred，当前 launcher 必须 fail closed。

 - 在临时目录渲染和校验，全部通过后再原子 rename。
 - 失败时只清理由本次调用创建的临时文件。
- 提供 `skiff init ack --repair` 或等价恢复路径。
+- 提供 `pouch init ack --repair` 或等价恢复路径。
 - 默认模板使用 `tasks: []`，完整示例继续放在 `examples/`。
 - CLI 输出“脚手架已创建，待配置”，检查通过后再称为“初始化完成”。

@@ -332,7 +332,7 @@ ACK 默认不提交、不推送。隔离 worktree 中的任务即使复测通过
 2. 把 Orca adapter 改成每轮 Developer/Test 双任务。
 3. 定义同 worktree 默认策略和跨 worktree transfer。
 4. 改造 worker launcher 与安全授权。
-5. 原子化 `skiff init ack`，空任务板作为默认模板。
+5. 原子化 `pouch init ack`，空任务板作为默认模板。
 6. 引入追加式 attempts、幂等恢复和失败分类。
 7. 统一 schema 与语义校验，补齐对抗性 fixture。
 8. 区分工作空间验证、集成验证和发布状态。
@@ -342,7 +342,7 @@ ACK 默认不提交、不推送。隔离 worktree 中的任务即使复测通过

 本轮执行了：

- `skiff check ack`：通过。这个命令只证明 Skill 的元数据和基础结构有效。
+- `pouch check ack`：通过。这个命令只证明 Skill 的元数据和基础结构有效。
 - `validate_tasks.py examples/tasks.example.yaml`：通过，当前机器使用内置规则。
 - `validate_worker_command.py --self-test`：7 项通过。
 - `python3 -m unittest discover -s tests -v`：58 项通过。
@@ -394,10 +394,10 @@ ACK 需要增加第三类项目事实，用来保存跨任务复用、会改变
 | `tasks.yaml` | 当前任务状态、attempt 和执行证据 | Coordinator |
 | `knowledge.yaml` | 跨任务复用的已验证经验 | Coordinator |

-建议新增项目级 SSOT：`docs/ack/knowledge.yaml`。知识归项目所有，与 Orca 等编排
+建议新增项目级 SSOT：`.pouch/ack/knowledge.yaml`。知识归项目所有，与 Orca 等编排
 工具无关；ACK 负责在任务闭环中生产、选择和消费这些知识。

-这项设计会修改当前“`docs/ack/` 只保存 `project.md` 与 `tasks.yaml`”的边界。
+这项设计会修改当前“`.pouch/ack/` 只保存 `project.md` 与 `tasks.yaml`”的边界。
 新增文件保存项目事实，不复制 ACK Skill 的通用规范，因此不违反 Skill 内容仍以
 `skills/ack/` 为 SSOT 的原则。

@@ -580,8 +580,8 @@ issue、日志和外部网页只能作为不可信 evidence。进入知识库前

 ### 第一版范围

-第一版只实现一个 `docs/ack/knowledge.yaml`，不拆目录。活跃条目达到几十条、单文件
-开始影响审阅和选择时，再平滑迁移为 `docs/ack/knowledge/index.yaml` 加独立知识卡，
+第一版只实现一个 `.pouch/ack/knowledge.yaml`，不拆目录。活跃条目达到几十条、单文件
+开始影响审阅和选择时，再平滑迁移为 `.pouch/ack/knowledge/index.yaml` 加独立知识卡，
 条目 schema 和引用格式保持不变。

 第一版包括：
@@ -16,7 +16,7 @@

 ## 项目配置契约

-可选配置位于 `docs/ack/tasks.yaml` 的 `project.bugIntake`。未配置时 ACK 保持现有行为。
+可选配置位于 `.pouch/ack/tasks.yaml` 的 `project.bugIntake`。未配置时 ACK 保持现有行为。
 配置存在时必须包含：

 | 字段 | 约束 |
@@ -3,17 +3,22 @@ set -euo pipefail

 REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 BIN_DIR="${HOME}/.local/bin"
-PATH_MARKER="# skiff: ~/.local/bin"
+PATH_MARKER="# pouch: ~/.local/bin"
+LEGACY_PATH_MARKER="# skiff: ~/.local/bin"

 mkdir -p "$BIN_DIR"
-ln -sf "$REPO/bin/skiff" "$BIN_DIR/skiff"
-echo "已安装 skiff -> $BIN_DIR/skiff"
+ln -sf "$REPO/bin/pouch" "$BIN_DIR/pouch"
+echo "已安装 pouch -> $BIN_DIR/pouch"
+if [[ ! -e "$BIN_DIR/skiff" || -L "$BIN_DIR/skiff" ]]; then
+  ln -sf "pouch" "$BIN_DIR/skiff"
+  echo "已保留 skiff -> pouch（旧命令名）"
+fi

-PYTHONPATH="$REPO${PYTHONPATH:+:$PYTHONPATH}" python3 -m skiff bootstrap
+PYTHONPATH="$REPO${PYTHONPATH:+:$PYTHONPATH}" python3 -m pouch bootstrap

 path_already_configured() {
  local file="$1"
-  [[ -f "$file" ]] && grep -qF "$PATH_MARKER" "$file"
+  [[ -f "$file" ]] && { grep -qF "$PATH_MARKER" "$file" || grep -qF "$LEGACY_PATH_MARKER" "$file"; }
 }

 configure_bash() {
@@ -0,0 +1,253 @@
+# pouch
+
+Agent Skills 安装与管理 CLI。纯 Python 3 实现，无第三方依赖，无需编译。
+
+## 安装
+
+```bash
+cd /path/to/pouch   # 本仓库根目录
+./install.sh         # 软链到 ~/.local/bin/pouch
+```
+
+确保 `~/.local/bin` 在 `PATH` 中。
+
+## 命令风格
+
+接口对齐 [Vercel skills CLI](https://github.com/vercel-labs/skills) 的 `add` / `remove`，
+统一管理 builtin skill、预置 catalog source 和用户命名的 custom source。
+
+```bash
+# 浏览可用自研 skill
+pouch add --list
+
+# 装到当前项目 / 全局
+pouch add discussion-notes -a cursor -y
+pouch add discussion-notes -a cursor -g -y
+
+# 卸载
+pouch remove discussion-notes -a cursor -y
+pouch rm discussion-notes -g -y
+
+# 改完 skill 后提交推送（在任意目录执行，操作 ~/.pouch）
+pouch publish skills/discussion-notes -m "update discussion-notes" --push
+```
+
+开发时也可直接运行：
+
+```bash
+PYTHONPATH=/path/to/pouch python3 -m pouch <command>
+```
+
+## 首次安装
+
+```bash
+git clone https://git.yumee.top/laily/pouch.git ~/.pouch
+~/.pouch/install.sh
+```
+
+`install.sh` 会安装 CLI，并自动执行 `pouch bootstrap`，将本仓库的 `pouch` skill 全局软链到 Cursor、Claude Code 和 Codex。也可以随时手动重跑：
+
+```bash
+pouch bootstrap
+```
+
+## 命令参考
+
+### 查看
+
+| 命令 | 说明 |
+|------|------|
+| `pouch list [--source NAME]` | 列出所有来源或指定 source 中的 skill |
+| `pouch status [--target all\|cursor\|claude\|codex\|agents]` | 安装状态总览 |
+
+### 项目初始化
+
+| 命令 | 说明 |
+|------|------|
+| `pouch bootstrap` | 将本项目的 `pouch` skill 全局安装到所有 Agent |
+| `pouch update` | 在 `~/.pouch` 执行 `git pull`，更新 pouch 自身 |
+| `pouch init <name> [--project DIR]` | 使用 builtin skill 自带模板初始化项目状态 |
+
+### Skill 安装
+
+| 命令 | 说明 |
+|------|------|
+| `pouch add <name> [--global] [-a AGENT...] [-y]` | 安装到 Agent 目录（软链） |
+| `pouch select [--global] [-a AGENT...]` | 打开终端多选界面，批量安装 skill |
+| `pouch remove <name> [--global] [-a AGENT...] [-y]` | 移除软链（`rm` / `r` 别名） |
+| `pouch add --list` | 列出可用 builtin skill |
+| `pouch publish [paths] -m MSG [--push]` | 在 ~/.pouch 内 git add/commit/push |
+
+旧命令 `install` / `uninstall` 已移除，请改用 `add` / `remove`。
+
+全局目标路径：
+
+| Agent | 路径 |
+|-------|------|
+| cursor | `~/.cursor/skills/` |
+| claude | `~/.claude/skills/` |
+| codex | `~/.codex/skills/` |
+| agents | `~/.agents/skills/`（agents 标准目录，覆盖 OMP） |
+
+### 预置 Catalog Source
+
+| 命令 | 说明 |
+|------|------|
+| `pouch catalog add <name> <repo-url> [--ref main] [--path .]` | 写入 `catalog.yaml` |
+| `pouch fetch <name>` | 克隆或更新 catalog source checkout |
+| `pouch add <name> [-g] [-a AGENT...]` | 安装 catalog 中的单个 skill 或完整 collection（缺失时自动 fetch） |
+| `pouch add <collection>/<skill> [...]` | 只安装 collection 中指定的 skill |
+
+`catalog.yaml` 条目可额外提供 `description` 和 `tags`。`description`
+会显示在 `pouch select` 的候选列表中。`path` 可以直接指向含
+`SKILL.md` 的单个 skill，也可以指向由多个 skill 目录组成的 collection。
+collection 会自动发现下一层所有含 `SKILL.md` 的目录；`pouch add <name>`
+安装全部，`pouch select` 则展开为 `<name>/<skill>` 供分别勾选。同一
+`repo` 与 `ref` 共享一份 Git checkout。
+
+### 交互式批量安装
+
+```bash
+pouch select                         # 当前项目，全部 Agent
+pouch select -a codex                # 当前项目，仅 Codex
+pouch select -g                      # 全局安装
+pouch select --project ~/code/app    # 指定项目
+```
+
+使用方向键移动、空格勾选、`/` 搜索、Enter 安装，按 `q` 或 Esc
+取消。普通 `pouch select` 只安装到项目，并在每一项旁只读显示各 Agent 的
+全局安装状态；`pouch select -g` 只安装到全局。已经安装到目标范围的 skill
+默认勾选；取消勾选不会卸载已有 skill，卸载请使用 `pouch remove`。如果全局
+存在同名但指向其它来源的 skill，项目选择器会显示“全局同名冲突”。
+项目模式会把成功选择的项目写入 `.pouch.yaml`。非交互环境请使用
+`pouch add <name>...`。使用 `-a` 限定 Agent 时，该范围会记录在对应的
+skill 条目中，后续 `pouch sync` 不会扩散到其他 Agent。
+
+### Custom source（多-skill 仓库）
+
+公司或团队维护的仓库通常包含多个 skill。使用命名 source 接入：
+
+```bash
+# Git 仓库，默认 clone 到 ~/.local/share/pouch/sources/company
+pouch source add company \
+  git@git.company.com:platform/agent-skills.git \
+  --ref main \
+  --skills-path internal/skills
+
+# 或接入已有本地仓库
+pouch source add company \
+  --local ~/code/company-agent-skills \
+  --skills-path skills
+
+pouch source list
+pouch source fetch company
+pouch list --source company
+pouch add company/code-review -g -a codex
+```
+
+| 命令 | 说明 |
+|------|------|
+| `pouch source add <name> <repo> [--ref REF] [--checkout PATH] [--skills-path PATH]` | 注册并克隆 Git source |
+| `pouch source add <name> --local PATH [--skills-path PATH]` | 接入已有本地仓库 |
+| `pouch source list` / `show <name>` | 查看 source |
+| `pouch source fetch <name>` / `fetch --all` | clone 或 fast-forward 更新 |
+| `pouch source remove <name>` | 移除配置并保留 checkout |
+
+配置保存在 `~/.config/pouch/config.yaml`。Git/SSH 认证复用本机 Git 配置，
+pouch 不保存 token。可以使用 `company/code-review`，也可以使用
+`pouch add code-review --source company`。多个来源包含同名 skill 时，必须明确来源。
+
+### 项目级
+
+| 命令 | 说明 |
+|------|------|
+| `pouch enable <name> [--target all] [--project <dir>]` | 写入 `.pouch.yaml` 并创建项目软链 |
+| `pouch disable <name> [--target all] [--project <dir>]` | 从 manifest 移除并删除软链 |
+| `pouch sync [--target all] [--project <dir>]` | 按 `.pouch.yaml` 重建软链 |
+
+项目目标路径：
+
+| Agent | 路径 |
+|-------|------|
+| cursor | `<project>/.agents/skills/` |
+| claude | `<project>/.claude/skills/` |
+| codex | `<project>/.agents/skills/` |
+| agents | `<project>/.agents/skills/`（与 cursor/codex 共用路径，软链幂等） |
+
+### 脚手架与健康检查
+
+| 命令 | 说明 |
+|------|------|
+| `pouch create <name> [--idea TEXT] [--from-project PATH]` | 从模板创建含 `SKILL.md`、`README.md` 的草稿 |
+| `pouch check <name>` | 校验草稿或正式 skill，包括人类使用说明 |
+| `pouch finalize <name>` | 校验草稿并移动到正式 `skills/` |
+| `pouch doctor [--target all] [--fix]` | 检查软链健康状态，`--fix` 自动修复 |
+
+## 常用工作流
+
+### 新建并全局启用自研 skill
+
+```bash
+pouch create my-skill --idea "描述要解决的重复问题" --from-project .
+# 由 Agent 完善草稿中的 SKILL.md 和 README.md
+pouch check my-skill
+pouch finalize my-skill
+pouch publish skills/my-skill -m "add my-skill" --push
+pouch add my-skill -a cursor -g -y
+pouch doctor -a cursor
+```
+
+### 在项目中启用 skill
+
+```bash
+cd ~/code/my-app
+pouch add declarative-openspec-loop -a cursor -y
+```
+
+### 添加 Catalog Source
+
+```bash
+pouch catalog add my-ext https://github.com/org/repo --ref main
+pouch fetch my-ext
+pouch add my-ext -g
+```
+
+## 源码结构
+
+```
+pouch/
+├── __init__.py      # 版本号
+├── __main__.py      # python3 -m pouch 入口
+├── cli.py           # 命令定义与调度
+├── paths.py         # 路径常量与 Agent 目标
+├── skills.py        # builtin/catalog/custom 统一解析
+├── catalog.py       # catalog.yaml 读写与 Skill 发现
+├── sources.py       # custom source 配置、发现与 Git 管理
+├── project.py       # .pouch.yaml 管理
+├── symlinks.py      # 软链创建/检查/修复
+└── yaml_io.py       # 轻量 YAML 解析（无第三方依赖）
+```
+
+入口脚本：[../bin/pouch](../bin/pouch)
+
+## 路径约定
+
+| 变量 | 路径 | 说明 |
+|------|------|------|
+| `POUCH_HOME` | `~/.pouch` | pouch 仓库（软链；兼容 `~/.skills`） |
+| `SKILLS_DIR` | `~/.pouch/skills/` | builtin skill 目录 |
+| `CATALOG_FILE` | `~/.pouch/catalog.yaml` | 预置 Skill 来源目录 |
+| `CATALOG_CACHE_DIR` | `~/.local/share/pouch/externals/` | catalog checkout 缓存；按 repo/ref 共享 |
+| `CONFIG_FILE` | `~/.config/pouch/config.yaml` | custom source 配置 |
+| `SOURCES_DIR` | `~/.local/share/pouch/sources/` | custom Git source 默认 checkout |
+
+## 注意事项
+
+- **禁止**在 `~/.cursor/skills/` 等 Agent 目录直接创建非软链的 skill
+- Claude Code 对 symlink 支持不稳定；建议对单个 skill 目录软链，不要软链整个 `~/.claude/skills/`
+- 若 Agent 将软链替换为普通目录，运行 `pouch doctor --fix` 重建
+
+## 相关文档
+
+- [项目 README](../README.md)
+- [AGENTS.md](../AGENTS.md)
@@ -0,0 +1,3 @@
+"""pouch — Agent Skills 安装与管理 CLI。"""
+
+__version__ = "0.6.0"
@@ -1,4 +1,4 @@
-from skiff.cli import main
+from pouch.cli import main

 if __name__ == "__main__":
    main()
@@ -2,7 +2,7 @@

 from __future__ import annotations

-from skiff.paths import ALL_TARGETS
+from pouch.paths import ALL_TARGETS

 AGENT_ALIASES: dict[str, str] = {
    "cursor": "cursor",
@@ -6,8 +6,8 @@ import hashlib
 from pathlib import Path
 from typing import Any

-from skiff import yaml_io
-from skiff.paths import CATALOG_FILE, LEGACY_REGISTRY_FILE
+from pouch import yaml_io
+from pouch.paths import CATALOG_FILE, LEGACY_REGISTRY_FILE


 def load_catalog(path: Path | None = None) -> dict[str, dict[str, Any]]:
@@ -36,7 +36,7 @@ def catalog_repo(entry: dict[str, Any]) -> str:

 def catalog_repo_path(entry: dict[str, Any]) -> Path:
    """Return the shared checkout path for a repo/ref pair."""
-    from skiff.paths import CATALOG_CACHE_DIR
+    from pouch.paths import CATALOG_CACHE_DIR

    repo = str(entry.get("repo", ""))
    ref = str(entry.get("ref", "main"))
@@ -46,7 +46,7 @@ def catalog_repo_path(entry: dict[str, Any]) -> Path:

 def catalog_checkout_path(name: str, entry: dict[str, Any]) -> Path:
    """Use a local repo directly, otherwise return its external checkout."""
-    from skiff.paths import CATALOG_CACHE_DIR
+    from pouch.paths import CATALOG_CACHE_DIR

    configured_repo = str(entry.get("repo", ""))
    local_repo = Path(catalog_repo(entry))
@@ -1,4 +1,4 @@
-"""skiff CLI 入口。"""
+"""pouch CLI 入口。"""

 from __future__ import annotations

@@ -15,28 +15,29 @@ import tempfile
 from datetime import datetime
 from pathlib import Path

-from skiff import __version__
-from skiff.agents import flatten_agent_args, resolve_agent_args
-from skiff.gitops import publish as git_publish
-from skiff.paths import (
+from pouch import __version__
+from pouch.agents import flatten_agent_args, resolve_agent_args
+from pouch.gitops import publish as git_publish
+from pouch.paths import (
    ALL_TARGETS,
    DRAFTS_DIR,
    CATALOG_CACHE_DIR,
    CONFIG_FILE,
    SKILLS_DIR,
-    SKILLS_HOME,
+    POUCH_HOME,
    TEMPLATE_DIR,
    agent_skill_dir,
-    ensure_skills_home,
+    ensure_pouch_home,
+    project_manifest,
 )
-from skiff.project import (
+from pouch.project import (
    add_skill_to_manifest,
    iter_manifest_skills,
    load_manifest,
    remove_skill_from_manifest,
    resolve_manifest_skill,
 )
-from skiff.catalog import (
+from pouch.catalog import (
    discover_catalog_skills,
    catalog_checkout_path,
    catalog_skill_path,
@@ -44,8 +45,8 @@ from skiff.catalog import (
    catalog_repo,
    save_catalog,
 )
-from skiff.selector import SkillChoice, select_skills
-from skiff.skills import (
+from pouch.selector import SkillChoice, select_skills
+from pouch.skills import (
    list_custom_skills,
    list_builtin_skills,
    builtin_skill_path,
@@ -57,7 +58,7 @@ from skiff.skills import (
    validate_skill_dir,
    validate_skill_name,
 )
-from skiff.sources import (
+from pouch.sources import (
    discover_source_skills,
    fetch_source,
    load_sources,
@@ -66,8 +67,8 @@ from skiff.sources import (
    source_skills_root,
    validate_source_name,
 )
-from skiff.yaml_io import safe_dump
-from skiff.symlinks import check_link, copy_template, create_link, find_repo_root, remove_link
+from pouch.yaml_io import safe_dump
+from pouch.symlinks import check_link, copy_template, create_link, find_repo_root, remove_link

 _RENAME_NOREPLACE = 1

@@ -485,7 +486,7 @@ def _remove_skill(


 def cmd_list(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    source_filter = normalize_source(args.source)
    builtin = list_builtin_skills()
    catalog = load_catalog()
@@ -528,18 +529,18 @@ def cmd_list(args: argparse.Namespace) -> None:

 def cmd_bootstrap(args: argparse.Namespace) -> None:
    del args
-    ensure_skills_home()
-    project_skill = "skiff"
+    ensure_pouch_home()
+    project_skill = "pouch"
    builtin_skill_path(project_skill)
    _install_skill(project_skill, list(ALL_TARGETS), project_root=None)
-    _print("已全局安装 builtin skiff skill 到所有 agent")
+    _print("已全局安装 builtin pouch skill 到所有 agent")


 def cmd_update(args: argparse.Namespace) -> None:
    del args
-    ensure_skills_home()
-    _print(f"更新 skiff: {SKILLS_HOME}")
-    subprocess.run(["git", "-C", str(SKILLS_HOME), "pull"], check=True)
+    ensure_pouch_home()
+    _print(f"更新 pouch: {POUCH_HOME}")
+    subprocess.run(["git", "-C", str(POUCH_HOME), "pull"], check=True)


 def _installed_links(
@@ -558,7 +559,7 @@ def _installed_links(


 def cmd_status(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    targets = resolve_agent_args(flatten_agent_args(args.agents))
    builtin = list_builtin_skills()
    catalog = load_catalog()
@@ -578,7 +579,7 @@ def cmd_status(args: argparse.Namespace) -> None:
            )
    entries.extend((source, name) for source, names in custom.items() for name in names)

-    _print(f"skills 仓库: {SKILLS_HOME.resolve()}")
+    _print(f"pouch 仓库: {POUCH_HOME.resolve()}")
    _print(f"agents: {', '.join(targets)}\n")

    for package in unfetched_catalog:
@@ -604,10 +605,10 @@ def cmd_status(args: argparse.Namespace) -> None:


 def _print_available_skills() -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    builtin = list_builtin_skills()
    if not builtin:
-        _print("~/.skills/skills/ 中没有自研 skill")
+        _print("~/.pouch/skills/ 中没有自研 skill")
        return

    _print(f"来源: {SKILLS_DIR}\n")
@@ -621,14 +622,14 @@ def _print_available_skills() -> None:


 def cmd_add(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()

    if args.list_available:
        if args.source:
            cmd_list(argparse.Namespace(source=args.source))
        else:
            _print_available_skills()
-        _print("使用 skiff add <name> 安装，或 skiff add <name> -g 全局安装")
+        _print("使用 pouch add <name> 安装，或 pouch add <name> -g 全局安装")
        return

    if args.all:
@@ -647,7 +648,7 @@ def cmd_add(args: argparse.Namespace) -> None:
    else:
        names = _collect_skill_names(args.skills, args.skills_flag)
        if not names:
-            raise SystemExit("请指定 skill 名称，或使用 skiff add --list 查看可用 skill")
+            raise SystemExit("请指定 skill 名称，或使用 pouch add --list 查看可用 skill")
        targets = resolve_agent_args(flatten_agent_args(args.agents))

    project_root = None if args.global_scope else _project_root(args.project)
@@ -671,7 +672,7 @@ def cmd_add(args: argparse.Namespace) -> None:
                (link, str(link.readlink()) if link.is_symlink() else None)
            )

-    manifest_path = project_root / ".skills.yaml" if project_root else None
+    manifest_path = project_manifest(project_root) if project_root else None
    manifest_before = (
        manifest_path.read_bytes()
        if manifest_path and manifest_path.is_file()
@@ -709,10 +710,10 @@ def cmd_add(args: argparse.Namespace) -> None:


 def cmd_select(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    if not sys.stdin.isatty() or not sys.stdout.isatty():
        raise SystemExit(
-            "`skiff select` 需要交互式终端；非交互环境请使用 `skiff add <name>...`"
+            "`pouch select` 需要交互式终端；非交互环境请使用 `pouch add <name>...`"
        )

    targets = resolve_agent_args(flatten_agent_args(args.agents))
@@ -877,7 +878,7 @@ def cmd_select(args: argparse.Namespace) -> None:
    names = sorted(selected - selected_installed_keys)

    failures: list[tuple[str, str]] = []
-    manifest_path = project_root / ".skills.yaml" if project_root else None
+    manifest_path = project_manifest(project_root) if project_root else None
    successful = set(selected & selected_installed_keys)
    for name in names:
        skill_name, source = choice_requests[name]
@@ -915,7 +916,7 @@ def cmd_select(args: argparse.Namespace) -> None:


 def cmd_remove(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    project_root = None if args.global_scope else _project_root(args.project)
    targets = resolve_agent_args(flatten_agent_args(args.agents))

@@ -925,7 +926,7 @@ def cmd_remove(args: argparse.Namespace) -> None:
        names = _collect_skill_names(args.skills, args.skills_flag)

    if not names:
-        raise SystemExit("请指定 skill 名称，或使用 skiff remove --all")
+        raise SystemExit("请指定 skill 名称，或使用 pouch remove --all")

    catalog = load_catalog()
    sources = load_sources()
@@ -958,14 +959,14 @@ def cmd_remove(args: argparse.Namespace) -> None:
    for name in dict.fromkeys(expanded):
        total += _remove_skill(name, targets, project_root=project_root)
        if project_root is not None:
-            remove_skill_from_manifest(project_root / ".skills.yaml", name)
+            remove_skill_from_manifest(project_manifest(project_root), name)

    if total == 0:
        _print("没有移除任何 skill")


 def cmd_publish(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    paths = args.paths or ["."]
    git_publish(
        paths=paths,
@@ -976,7 +977,7 @@ def cmd_publish(args: argparse.Namespace) -> None:


 def cmd_catalog_add(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    validate_skill_name(args.name)
    catalog = load_catalog()
    if args.name in catalog:
@@ -992,7 +993,7 @@ def cmd_catalog_add(args: argparse.Namespace) -> None:


 def cmd_fetch(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    catalog = load_catalog()
    if args.name not in catalog:
        raise SystemExit(f"catalog 中不存在: {args.name}")
@@ -1106,9 +1107,9 @@ def cmd_source_remove(args: argparse.Namespace) -> None:


 def cmd_sync(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    root = _project_root(args.project)
-    manifest_path = root / ".skills.yaml"
+    manifest_path = project_manifest(root)
    if not manifest_path.is_file():
        raise SystemExit(f"未找到 {manifest_path}")

@@ -1133,7 +1134,7 @@ def cmd_sync(args: argparse.Namespace) -> None:


 def cmd_create(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    validate_skill_name(args.name)
    if not TEMPLATE_DIR.is_dir():
        raise SystemExit(f"模板目录不存在: {TEMPLATE_DIR}")
@@ -1170,8 +1171,8 @@ def cmd_create(args: argparse.Namespace) -> None:
    }
    (dst / "brief.yaml").write_text(safe_dump(brief), encoding="utf-8")
    _print(f"草稿已创建: {dst}")
-    _print(f"下一步: 请完善 skiff 草稿 {args.name}")
-    _print(f"完成后运行: skiff check {args.name} && skiff finalize {args.name}")
+    _print(f"下一步: 请完善 pouch 草稿 {args.name}")
+    _print(f"完成后运行: pouch check {args.name} && pouch finalize {args.name}")


 def _draft_or_builtin_path(name: str) -> tuple[Path, str]:
@@ -1185,7 +1186,7 @@ def _draft_or_builtin_path(name: str) -> tuple[Path, str]:


 def cmd_check(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    validate_skill_name(args.name)
    path, kind = _draft_or_builtin_path(args.name)
    issues = validate_skill_dir(path, args.name)
@@ -1199,7 +1200,7 @@ def cmd_check(args: argparse.Namespace) -> None:


 def cmd_finalize(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    validate_skill_name(args.name)
    draft = DRAFTS_DIR / args.name
    if not draft.is_dir():
@@ -1221,25 +1222,25 @@ def cmd_finalize(args: argparse.Namespace) -> None:
    if brief.exists():
        brief.unlink()
    _print(f"已完成 skill: {final}")
-    _print(f"下一步: skiff publish skills/{args.name} -m \"add {args.name}\" --push")
+    _print(f"下一步: pouch publish skills/{args.name} -m \"add {args.name}\" --push")


 def cmd_doctor(args: argparse.Namespace) -> None:
-    ensure_skills_home()
+    ensure_pouch_home()
    targets = resolve_agent_args(flatten_agent_args(args.agents))
    issues = 0

-    _print(f"skills 仓库: {SKILLS_HOME.resolve()}")
-    if SKILLS_HOME.is_symlink():
-        if not SKILLS_HOME.resolve().is_dir():
-            _err(f"✗ ~/.skills 指向无效路径: {SKILLS_HOME.resolve()}")
+    _print(f"pouch 仓库: {POUCH_HOME.resolve()}")
+    if POUCH_HOME.is_symlink():
+        if not POUCH_HOME.resolve().is_dir():
+            _err(f"✗ ~/.pouch 指向无效路径: {POUCH_HOME.resolve()}")
            issues += 1
        else:
-            _print("✓ ~/.skills 软链正常")
-    elif SKILLS_HOME.is_dir() and (SKILLS_HOME / "skills").is_dir():
-        _print("✓ ~/.skills 为本地仓库目录")
+            _print("✓ ~/.pouch 软链正常")
+    elif POUCH_HOME.is_dir() and (POUCH_HOME / "skills").is_dir():
+        _print("✓ ~/.pouch 为本地仓库目录")
    else:
-        _err("✗ ~/.skills 未正确配置")
+        _err("✗ ~/.pouch 未正确配置")
        issues += 1

    for name in list_builtin_skills():
@@ -1278,13 +1279,13 @@ def cmd_doctor(args: argparse.Namespace) -> None:
    else:
        _print(f"\n发现 {issues} 个问题")
        if not args.fix:
-            _print("提示: 使用 skiff doctor --fix 尝试自动修复软链")
+            _print("提示: 使用 pouch doctor --fix 尝试自动修复软链")
        sys.exit(1)


 def cmd_init(args: argparse.Namespace) -> None:
    """使用 builtin skill 自带的模板初始化目标项目状态。"""
-    ensure_skills_home()
+    ensure_pouch_home()
    validate_skill_name(args.name)
    skills_root = SKILLS_DIR.resolve()
    skill_source = (SKILLS_DIR / args.name).resolve()
@@ -1307,7 +1308,7 @@ def cmd_init(args: argparse.Namespace) -> None:
        initial_project_stat.st_ino,
        stat.S_IFMT(initial_project_stat.st_mode),
    )
-    destination = project / "docs" / args.name
+    destination = project / ".pouch" / args.name
    project_file = destination / "project.md"
    tasks_file = destination / "tasks.yaml"
    knowledge_file = destination / "knowledge.yaml"
@@ -1335,7 +1336,7 @@ def cmd_init(args: argparse.Namespace) -> None:
        )
    missing = [path for path, _ in template_targets if not path.is_file()]
    if missing:
-        paths = ", ".join(str(path.relative_to(SKILLS_HOME)) for path in missing)
+        paths = ", ".join(str(path.relative_to(POUCH_HOME)) for path in missing)
        raise SystemExit(f"skill 缺少初始化模板: {paths}")
    validator = skill_source / "scripts" / "validate_tasks.py"
    knowledge_validator = skill_source / "scripts" / "validate_knowledge.py"
@@ -1357,13 +1358,13 @@ def cmd_init(args: argparse.Namespace) -> None:
        "<project_name>": project.name,
        "<repo_path>": str(project),
        "<dev_worktree>": str(project),
-        "<overlay_file_path>": f"docs/{args.name}/project.md",
+        "<overlay_file_path>": f".pouch/{args.name}/project.md",
        "<ack_version>": ack_version,
        "<接入时的 ack skill 版本>": ack_version,
        "<YYYY-MM-DDTHH:mm:ss+TZ>": now,
    }

-    with tempfile.TemporaryDirectory(prefix=f"skiff-{args.name}-init-") as temp_dir:
+    with tempfile.TemporaryDirectory(prefix=f"pouch-{args.name}-init-") as temp_dir:
        staging = Path(temp_dir)
        staged_files: dict[Path, Path] = {}
        rendered_files: dict[Path, str] = {}
@@ -1430,10 +1431,10 @@ def cmd_init(args: argparse.Namespace) -> None:
            raise SystemExit(f"拒绝覆盖已有路径: {paths}")

        project_fd: int | None = None
-        docs_fd: int | None = None
+        pouch_fd: int | None = None
        transaction_fd: int | None = None
        staging_fd: int | None = None
-        docs_created = False
+        pouch_created = False
        transaction_name: str | None = None
        staged_names: list[str] = []
        published = False
@@ -1461,8 +1462,8 @@ def cmd_init(args: argparse.Namespace) -> None:
                project,
                phase="初始化",
            )
-            docs_fd, docs_created = _open_or_create_directory_at(project_fd, "docs")
-            if docs_created:
+            pouch_fd, pouch_created = _open_or_create_directory_at(project_fd, ".pouch")
+            if pouch_created:
                os.fsync(project_fd)
            _assert_open_directory_path(
                project_fd,
@@ -1470,15 +1471,15 @@ def cmd_init(args: argparse.Namespace) -> None:
                phase="初始化",
            )
            _assert_open_directory_path(
-                docs_fd,
-                project / "docs",
+                pouch_fd,
+                project / ".pouch",
                phase="初始化",
-                label="docs 目录",
+                label=".pouch 目录",
            )
            try:
                destination_stat = os.stat(
                    args.name,
-                    dir_fd=docs_fd,
+                    dir_fd=pouch_fd,
                    follow_symlinks=False,
                )
            except FileNotFoundError:
@@ -1487,14 +1488,14 @@ def cmd_init(args: argparse.Namespace) -> None:
                if stat.S_ISLNK(destination_stat.st_mode):
                    raise SystemExit(
                        "初始化路径必须是普通目录且不能是软链接: "
-                        f"docs/{args.name}"
+                        f".pouch/{args.name}"
                    )
-                raise SystemExit(f"拒绝覆盖已有路径: docs/{args.name}")
+                raise SystemExit(f"拒绝覆盖已有路径: .pouch/{args.name}")

            for _ in range(32):
                candidate = f".{args.name}-init-{secrets.token_hex(8)}"
                try:
-                    os.mkdir(candidate, mode=0o700, dir_fd=docs_fd)
+                    os.mkdir(candidate, mode=0o700, dir_fd=pouch_fd)
                except FileExistsError:
                    continue
                transaction_name = candidate
@@ -1505,7 +1506,7 @@ def cmd_init(args: argparse.Namespace) -> None:
            transaction_fd = os.open(
                transaction_name,
                os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW,
-                dir_fd=docs_fd,
+                dir_fd=pouch_fd,
            )
            os.mkdir("payload", mode=0o755, dir_fd=transaction_fd)
            staging_fd = os.open(
@@ -1534,21 +1535,21 @@ def cmd_init(args: argparse.Namespace) -> None:
                phase="发布",
            )
            _assert_open_directory_path(
-                docs_fd,
-                project / "docs",
+                pouch_fd,
+                project / ".pouch",
                phase="发布",
-                label="docs 目录",
+                label=".pouch 目录",
            )
            try:
                _rename_directory_noreplace(
                    transaction_fd,
                    "payload",
-                    docs_fd,
+                    pouch_fd,
                    args.name,
                )
            except FileExistsError as exc:
                raise SystemExit(
-                    f"拒绝覆盖已有路径: docs/{args.name}"
+                    f"拒绝覆盖已有路径: .pouch/{args.name}"
                ) from exc
            published = True
            _assert_open_directory_path(
@@ -1560,23 +1561,23 @@ def cmd_init(args: argparse.Namespace) -> None:
            if (
                transaction_name is not None
                and _directory_entry_matches_open_fd(
-                    docs_fd,
+                    pouch_fd,
                    transaction_name,
                    transaction_fd,
                )
            ):
                try:
-                    os.rmdir(transaction_name, dir_fd=docs_fd)
+                    os.rmdir(transaction_name, dir_fd=pouch_fd)
                except OSError:
                    pass
                else:
                    transaction_name = None
            try:
-                os.fsync(docs_fd)
+                os.fsync(pouch_fd)
            except OSError as exc:
                raise SystemExit(
                    "初始化目录已完整发布，但无法确认目录项持久化；"
-                    f"请检查 docs/{args.name} 后再重试"
+                    f"请检查 .pouch/{args.name} 后再重试"
                ) from exc
            _assert_open_directory_path(
                project_fd,
@@ -1584,10 +1585,10 @@ def cmd_init(args: argparse.Namespace) -> None:
                phase="完成初始化",
            )
            _assert_open_directory_path(
-                docs_fd,
-                project / "docs",
+                pouch_fd,
+                project / ".pouch",
                phase="完成初始化",
-                label="docs 目录",
+                label=".pouch 目录",
            )
            _assert_open_directory_path(
                staging_fd,
@@ -1612,15 +1613,15 @@ def cmd_init(args: argparse.Namespace) -> None:
                if (
                    transaction_name is not None
                    and transaction_fd is not None
-                    and docs_fd is not None
+                    and pouch_fd is not None
                    and _directory_entry_matches_open_fd(
-                        docs_fd,
+                        pouch_fd,
                        transaction_name,
                        transaction_fd,
                    )
                ):
                    try:
-                        os.rmdir(transaction_name, dir_fd=docs_fd)
+                        os.rmdir(transaction_name, dir_fd=pouch_fd)
                    except OSError:
                        pass
            raise
@@ -1628,7 +1629,7 @@ def cmd_init(args: argparse.Namespace) -> None:
            for directory_fd in (
                staging_fd,
                transaction_fd,
-                docs_fd,
+                pouch_fd,
                project_fd,
            ):
                if directory_fd is not None:
@@ -1670,20 +1671,20 @@ def _add_common_flags(parser: argparse.ArgumentParser) -> None:

 def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
-        prog="skiff",
+        prog="pouch",
        description="自研 Agent Skills 安装与管理 CLI（接口对齐 Vercel skills）",
    )
-    parser.add_argument("--version", action="version", version=f"skiff {__version__}")
+    parser.add_argument("--version", action="version", version=f"pouch {__version__}")

    sub = parser.add_subparsers(dest="command", required=True)

    p_bootstrap = sub.add_parser(
        "bootstrap",
-        help="将本项目 skiff skill 全局安装到所有 agent",
+        help="将本项目 pouch skill 全局安装到所有 agent",
    )
    p_bootstrap.set_defaults(func=cmd_bootstrap)

-    p_update = sub.add_parser("update", help="通过 git pull 更新 skiff 自身")
+    p_update = sub.add_parser("update", help="通过 git pull 更新 pouch 自身")
    p_update.set_defaults(func=cmd_update)

    p_list = sub.add_parser("list", help="列出所有 source 中的 skill")
@@ -1727,7 +1728,7 @@ def build_parser() -> argparse.ArgumentParser:

    p_publish = sub.add_parser(
        "publish",
-        help="在 ~/.skills 内 git add / commit / push",
+        help="在 ~/.pouch 内 git add / commit / push",
    )
    p_publish.add_argument("paths", nargs="*", help="要提交的路径（默认 .）")
    p_publish.add_argument("-m", "--message", help="commit 说明")
@@ -1778,11 +1779,11 @@ def build_parser() -> argparse.ArgumentParser:
    p_source_remove.add_argument(
        "--delete-checkout",
        action="store_true",
-        help="同时永久删除 skiff 管理的 checkout",
+        help="同时永久删除 pouch 管理的 checkout",
    )
    p_source_remove.set_defaults(func=cmd_source_remove)

-    p_sync = sub.add_parser("sync", help="按 .skills.yaml 重建项目软链")
+    p_sync = sub.add_parser("sync", help="按 .pouch.yaml 重建项目软链")
    p_sync.add_argument("-a", "--agent", dest="agents", nargs="+", action="append")
    p_sync.add_argument("--project")
    p_sync.set_defaults(func=cmd_sync)
@@ -1,4 +1,4 @@
-"""~/.skills 仓库内的 git 操作。"""
+"""~/.pouch 仓库内的 git 操作。"""

 from __future__ import annotations

@@ -6,7 +6,7 @@ import subprocess
 import sys
 from pathlib import Path

-from skiff.paths import SKILLS_HOME
+from pouch.paths import POUCH_HOME


 def _run_git(repo: Path, *args: str, check: bool = True) -> subprocess.CompletedProcess[str]:
@@ -35,7 +35,7 @@ def publish(
    push: bool,
    no_commit: bool,
 ) -> None:
-    repo = SKILLS_HOME.resolve()
+    repo = POUCH_HOME.resolve()
    ensure_git_repo(repo)

    _run_git(repo, "add", "--", *paths)
@@ -0,0 +1,103 @@
+"""路径与 Agent 目标定义。"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+HOME = Path.home()
+PREFERRED_POUCH_HOME = HOME / ".pouch"
+LEGACY_POUCH_HOME = HOME / ".skills"
+PROJECT_MANIFEST = ".pouch.yaml"
+LEGACY_PROJECT_MANIFEST = ".skills.yaml"
+
+
+def _first_existing_dir(*candidates: Path, default: Path) -> Path:
+    for path in candidates:
+        if path.is_dir():
+            return path
+    return default
+
+
+def _first_existing_file(*candidates: Path, default: Path) -> Path:
+    for path in candidates:
+        if path.is_file():
+            return path
+    return default
+
+
+POUCH_HOME = _first_existing_dir(
+    PREFERRED_POUCH_HOME,
+    LEGACY_POUCH_HOME,
+    default=PREFERRED_POUCH_HOME,
+)
+SKILLS_DIR = POUCH_HOME / "skills"
+TEMPLATE_DIR = SKILLS_DIR / "_template"
+DRAFTS_DIR = POUCH_HOME / ".drafts"
+CATALOG_FILE = POUCH_HOME / "catalog.yaml"
+LEGACY_REGISTRY_FILE = POUCH_HOME / "registry.yaml"
+CATALOG_CACHE_DIR = _first_existing_dir(
+    HOME / ".local" / "share" / "pouch" / "externals",
+    HOME / ".local" / "share" / "skills" / "externals",
+    default=HOME / ".local" / "share" / "pouch" / "externals",
+)
+CONFIG_FILE = _first_existing_file(
+    HOME / ".config" / "pouch" / "config.yaml",
+    HOME / ".config" / "skiff" / "config.yaml",
+    default=HOME / ".config" / "pouch" / "config.yaml",
+)
+SOURCES_DIR = _first_existing_dir(
+    HOME / ".local" / "share" / "pouch" / "sources",
+    HOME / ".local" / "share" / "skiff" / "sources",
+    default=HOME / ".local" / "share" / "pouch" / "sources",
+)
+
+AGENT_GLOBAL: dict[str, Path] = {
+    "cursor": HOME / ".cursor" / "skills",
+    "claude": HOME / ".claude" / "skills",
+    "codex": HOME / ".codex" / "skills",
+    # agents 标准目录：OMP 原生 canonical（agents provider），cursor/codex 项目级同路径
+    "agents": HOME / ".agents" / "skills",
+}
+
+AGENT_PROJECT: dict[str, str] = {
+    "cursor": ".agents/skills",
+    "claude": ".claude/skills",
+    "codex": ".agents/skills",
+    # 与 cursor/codex 共用 .agents/skills；软链幂等，同路径只写一次
+    "agents": ".agents/skills",
+}
+
+ALL_TARGETS = ("cursor", "claude", "codex", "agents")
+
+
+def project_manifest(root: Path) -> Path:
+    """项目清单路径：优先 .pouch.yaml，否则沿用 .skills.yaml。"""
+    preferred = root / PROJECT_MANIFEST
+    legacy = root / LEGACY_PROJECT_MANIFEST
+    if preferred.is_file():
+        return preferred
+    if legacy.is_file():
+        return legacy
+    return preferred
+
+
+def resolve_targets(target: str | None) -> list[str]:
+    if target is None or target == "all":
+        return list(ALL_TARGETS)
+    if target not in ALL_TARGETS:
+        raise ValueError(f"未知 target: {target!r}，可选: {', '.join(ALL_TARGETS)}, all")
+    return [target]
+
+
+def agent_skill_dir(target: str, *, project_root: Path | None = None) -> Path:
+    if project_root is None:
+        return AGENT_GLOBAL[target]
+    return project_root / AGENT_PROJECT[target]
+
+
+def ensure_pouch_home() -> None:
+    if not POUCH_HOME.is_dir():
+        raise SystemExit(
+            "~/.pouch 不存在。请将本仓库克隆到 ~/.pouch。"
+            "若仍是 ~/.skills，先执行: mv ~/.skills ~/.pouch"
+        )
@@ -1,22 +1,22 @@
-"""项目级 .skills.yaml 管理。"""
+"""项目级 .pouch.yaml 管理。"""

 from __future__ import annotations

 from pathlib import Path
 from typing import Any

-from skiff import yaml_io
-from skiff.paths import PROJECT_MANIFEST
-from skiff.skills import normalize_source, resolve_skill_source
+from pouch import yaml_io
+from pouch.paths import project_manifest
+from pouch.skills import normalize_source, resolve_skill_source


 def load_manifest(path: Path | None = None) -> tuple[Path, dict[str, Any]]:
-    path = path or Path.cwd() / PROJECT_MANIFEST
+    path = path or project_manifest(Path.cwd())
    if not path.is_file():
        return path, {"skills": []}
    data = yaml_io.safe_load(path.read_text(encoding="utf-8")) or {}
    if not isinstance(data, dict):
-        raise SystemExit(f".skills.yaml 格式错误: {path}")
+        raise SystemExit(f".pouch.yaml 格式错误: {path}")
    if "skills" not in data:
        data["skills"] = []
    return path, data
@@ -34,7 +34,7 @@ def normalize_skill_entry(entry: str | dict[str, Any]) -> dict[str, Any]:
        return {"name": entry, "source": "builtin"}
    name = entry.get("name")
    if not name:
-        raise SystemExit(f".skills.yaml 条目缺少 name: {entry}")
+        raise SystemExit(f".pouch.yaml 条目缺少 name: {entry}")
    source = normalize_source(str(entry.get("source", "builtin")))
    if source == "catalog" and entry.get("registry"):
        source = f"catalog:{entry['registry']}"
@@ -58,7 +58,7 @@ def add_skill_to_manifest(
 ) -> None:
    path = manifest_path
    if path.is_dir():
-        path = path / PROJECT_MANIFEST
+        path = project_manifest(path)

    file_path, data = load_manifest(path) if path.is_file() else (path, {"skills": []})
    if not path.is_file():
@@ -82,8 +82,8 @@ def add_skill_to_manifest(

 def remove_skill_from_manifest(manifest_path: Path, name: str) -> bool:
    path = manifest_path
-    if not path.is_file():
-        path = path / PROJECT_MANIFEST
+    if path.is_dir() or not path.is_file():
+        path = project_manifest(path if path.is_dir() else path.parent)
    file_path, data = load_manifest(path)
    original = data.get("skills", [])
    kept = [e for e in original if normalize_skill_entry(e)["name"] != name]
@@ -165,7 +165,7 @@ def select_skills(
                )

            footer = (
-                f"已选择 {len(selected)} 项  ·  取消选择不卸载，卸载用 skiff remove"
+                f"已选择 {len(selected)} 项  ·  取消选择不卸载，卸载用 pouch remove"
            )
            stdscr.addnstr(
                height - 1,
@@ -5,13 +5,13 @@ from __future__ import annotations
 import re
 from pathlib import Path

-from skiff.paths import SKILLS_DIR, TEMPLATE_DIR, ensure_skills_home
-from skiff.catalog import (
+from pouch.paths import SKILLS_DIR, TEMPLATE_DIR, ensure_pouch_home
+from pouch.catalog import (
    catalog_skill_path,
    discover_catalog_skills,
    load_catalog,
 )
-from skiff.sources import (
+from pouch.sources import (
    discover_source_skills,
    list_source_skills,
    load_sources,
@@ -19,7 +19,7 @@ from skiff.sources import (


 def list_builtin_skills() -> list[str]:
-    ensure_skills_home()
+    ensure_pouch_home()
    if not SKILLS_DIR.is_dir():
        return []
    names: list[str] = []
@@ -76,7 +76,7 @@ def list_custom_skills(source: str | None = None) -> dict[str, list[str]]:

 def resolve_skill_source(name: str, *, source: str | None = None) -> tuple[Path, str]:
    """返回 (skill_path, source)，未指定来源时拒绝同名歧义。"""
-    ensure_skills_home()
+    ensure_pouch_home()
    name, source = split_skill_spec(name, source)

    builtin = SKILLS_DIR / name
@@ -106,7 +106,7 @@ def resolve_skill_source(name: str, *, source: str | None = None) -> tuple[Path,
        if not (path / "SKILL.md").is_file():
            raise SystemExit(
                f"catalog skill {name!r} 尚未 fetch 或 path 中缺少 SKILL.md。"
-                f"请运行: skiff fetch {name}"
+                f"请运行: pouch fetch {name}"
            )
        return path, f"catalog:{name}"

@@ -114,7 +114,7 @@ def resolve_skill_source(name: str, *, source: str | None = None) -> tuple[Path,
        if source not in sources:
            raise SystemExit(
                f"项目依赖 source {source!r}，但本机尚未配置。"
-                f"请运行: skiff source add {source} <repo>"
+                f"请运行: pouch source add {source} <repo>"
            )
        skills = discover_source_skills(source, sources[source])
        if name not in skills:
@@ -156,7 +156,7 @@ def resolve_skill_source(name: str, *, source: str | None = None) -> tuple[Path,
        path, resolved_source = candidates[0]
        if resolved_source.startswith("catalog:") and not path.exists():
            provider = resolved_source.split(":", 1)[1]
-            raise SystemExit(f"catalog source {provider!r} 尚未 fetch。请先运行: skiff fetch {provider}")
+            raise SystemExit(f"catalog source {provider!r} 尚未 fetch。请先运行: pouch fetch {provider}")
        return path, resolved_source

    raise SystemExit(f"找不到 skill: {name}")
@@ -2,7 +2,7 @@

 ## 背景

-skiff 当前使用 `owned` 表示本仓库 `skills/` 中维护的 Skill，同时还支持
+pouch 当前使用 `owned` 表示本仓库 `skills/` 中维护的 Skill，同时还支持
 `registry` 外部仓库和用户配置的 custom source。

 这些名称混合了不同维度：
@@ -17,8 +17,8 @@ skiff 当前使用 `owned` 表示本仓库 `skills/` 中维护的 Skill，同时

 本文建议将用户可见的来源注册方式统一为三类：

- `builtin`：随当前 skiff 仓库提供的 Skill。
- `catalog:<name>`：由 skiff 自带目录预先登记的来源。
+- `builtin`：随当前 pouch 仓库提供的 Skill。
+- `catalog:<name>`：由 pouch 自带目录预先登记的来源。
 - `custom:<name>`：用户在本机显式配置的命名来源。

 来源注册方式与获取方式、仓库布局相互独立。builtin、catalog 和 custom 中的任意
@@ -29,20 +29,20 @@ Git 仓库或本地目录。

 ```mermaid
 flowchart TD
-    S[skiff 可发现的 Skills]
+    S[pouch 可发现的 Skills]

-    S --> O["owned<br/>~/.skills/skills/*"]
-    S --> C["custom source<br/>~/.config/skiff/config.yaml"]
+    S --> O["owned<br/>~/.pouch/skills/*"]
+    S --> C["custom source<br/>~/.config/pouch/config.yaml"]
    S --> R["registry<br/>registry.yaml"]

-    O --> O1["本仓库维护<br/>随 skiff 一起分发"]
+    O --> O1["本仓库维护<br/>随 pouch 一起分发"]

    C --> C1["本地目录<br/>--local PATH"]
    C --> C2["指定 Git 仓库<br/>repo + skills_path"]

    R --> R1["外部单 Skill 仓库"]
    R --> R2["外部 Skill Collection"]
-    R1 --> E["~/.local/share/skills/externals/"]
+    R1 --> E["~/.local/share/pouch/externals/"]
    R2 --> E
 ```

@@ -51,7 +51,7 @@ flowchart TD
 - `list` 和 `status` 支持 owned、registry 和 custom source。
 - `resolve_skill_source` 可以解析三种来源并处理同名歧义。
 - `select` 只组装 owned 和 registry 条目，尚未展示 custom source。
- `.skills.yaml` 默认将未声明来源的 Skill 解释为 `owned`。
+- `.pouch.yaml` 默认将未声明来源的 Skill 解释为 `owned`。
 - custom source 的 `skills_path` 已经可以包含多个 Skill，本质上也是 collection。

 ## 现行模型
@@ -61,11 +61,11 @@ flowchart TD
    A[Skill Provider]

    A --> B["builtin<br/>仓库内隐式注册"]
-    A --> C["catalog:waza<br/>skiff 预置目录"]
+    A --> C["catalog:waza<br/>pouch 预置目录"]
    A --> D["custom:company<br/>用户本机配置"]

    B --> B1["skills/ack"]
-    B --> B2["skills/skiff"]
+    B --> B2["skills/pouch"]
    B --> B3["skills/builder"]

    C --> C1["Git 或本地目录"]
@@ -85,14 +85,14 @@ flowchart TD

 | 类型 | 含义 | 配置来源 | 用户界面展示 |
 | --- | --- | --- | --- |
-| `builtin` | 随当前 skiff 仓库提供 | `skills/` | `builtin` |
-| `catalog` | skiff 预先登记、所有用户可发现的来源 | `catalog.yaml` | `catalog:<name>` |
-| `custom` | 用户在本机显式注册的命名来源 | `~/.config/skiff/config.yaml` | `custom:<name>` |
+| `builtin` | 随当前 pouch 仓库提供 | `skills/` | `builtin` |
+| `catalog` | pouch 预先登记、所有用户可发现的来源 | `catalog.yaml` | `catalog:<name>` |
+| `custom` | 用户在本机显式注册的命名来源 | `~/.config/pouch/config.yaml` | `custom:<name>` |

 `builtin` 比 `owned` 更适合作为用户可见名称，因为它表达 Skill 的分发位置和可用
 方式，而不是仓库的所有权关系。

-`catalog` 比 `registry` 更准确：当前文件只是 skiff 随仓库维护的预置来源目录，
+`catalog` 比 `registry` 更准确：当前文件只是 pouch 随仓库维护的预置来源目录，
 并不是远程注册中心，也不是一种 Skill 来源协议。

 ### 三个正交维度
@@ -128,7 +128,7 @@ layout:       single | collection

 ## `select` 展示

-`skiff select` 应同时展示 builtin、catalog 和 custom Skill：
+`pouch select` 应同时展示 builtin、catalog 和 custom Skill：

 ```text
 [ ] ack                         builtin
@@ -151,7 +151,7 @@ layout:       single | collection

 ## 配置表示

-新写入的 `.skills.yaml` 使用以下形式：
+新写入的 `.pouch.yaml` 使用以下形式：

 ```yaml
 skills:
@@ -172,7 +172,7 @@ custom source 在 manifest 中继续保存其逻辑名称，例如 `company`。

 1. 对外文档、CLI 输出和 selector 统一使用 `builtin`、`catalog:<name>` 和
   `custom:<name>`。
-2. 新生成的 `.skills.yaml` 对内置 Skill 写入 `source: builtin`。
+2. 新生成的 `.pouch.yaml` 对内置 Skill 写入 `source: builtin`。
 3. 读取旧 manifest 时继续接受 `source: owned`，并在解析时归一化为 `builtin`。
 4. CLI 参数在过渡期继续接受 `--source owned`，但帮助和输出只推荐 `builtin`。
 5. 读取旧 manifest 中的 `source: registry` 和 `registry: <name>`，归一化为
@@ -188,14 +188,14 @@ custom source 在 manifest 中继续保存其逻辑名称，例如 `company`。

 当前实现覆盖：

- `skiff/skills.py`：来源解析、归一化和 builtin 命名。
- `skiff/project.py`：manifest 默认值、序列化与旧值兼容。
- `skiff/sources.py`：来源保留字。
- `skiff/catalog.py`：catalog 配置、checkout 与 Skill 发现。
- `skiff/cli.py`：`list`、`status`、`add`、`select` 和输出文案。
- `skiff/selector.py`：统一 catalog/custom collection 的父子展示。
+- `pouch/skills.py`：来源解析、归一化和 builtin 命名。
+- `pouch/project.py`：manifest 默认值、序列化与旧值兼容。
+- `pouch/sources.py`：来源保留字。
+- `pouch/catalog.py`：catalog 配置、checkout 与 Skill 发现。
+- `pouch/cli.py`：`list`、`status`、`add`、`select` 和输出文案。
+- `pouch/selector.py`：统一 catalog/custom collection 的父子展示。
 - CLI 与来源解析测试。
- 根 README、`skiff/README.md`、`skills/skiff/SKILL.md` 和相关示例。
+- 根 README、`pouch/README.md`、`skills/pouch/SKILL.md` 和相关示例。

 ## 验证要求

@@ -212,6 +212,6 @@ custom source 在 manifest 中继续保存其逻辑名称，例如 `company`。

 ## 设计前提

-迁移前 `registry.yaml` 的真实职责只是维护 skiff 预置的来源目录，而不是提供远程
+迁移前 `registry.yaml` 的真实职责只是维护 pouch 预置的来源目录，而不是提供远程
 发布、版本解析或可信签名等注册中心能力，因此现已改为 `catalog.yaml`。如果未来
 实现真正的远程 registry，应单独定义其协议和与 catalog 的同步关系，不复用旧名称。
@@ -6,14 +6,14 @@ import subprocess
 from pathlib import Path
 from typing import Any

-from skiff import yaml_io
-from skiff.paths import CONFIG_FILE, SOURCES_DIR
+from pouch import yaml_io
+from pouch.paths import CONFIG_FILE, SOURCES_DIR

 RESERVED_SOURCES = {"builtin", "catalog", "owned", "registry"}


 def validate_source_name(name: str) -> None:
-    from skiff.skills import validate_skill_name
+    from pouch.skills import validate_skill_name

    validate_skill_name(name)
    if name in RESERVED_SOURCES:
@@ -26,12 +26,12 @@ def load_sources(path: Path | None = None) -> dict[str, dict[str, Any]]:
        return {}
    data = yaml_io.safe_load(path.read_text(encoding="utf-8")) or {}
    if not isinstance(data, dict):
-        raise SystemExit(f"skiff 配置格式错误: {path}")
+        raise SystemExit(f"pouch 配置格式错误: {path}")
    raw = data.get("sources", {})
    if raw is None:
        return {}
    if not isinstance(raw, dict):
-        raise SystemExit(f"skiff 配置 sources 格式错误: {path}")
+        raise SystemExit(f"pouch 配置 sources 格式错误: {path}")
    return {str(name): entry for name, entry in raw.items() if isinstance(entry, dict)}


@@ -66,7 +66,7 @@ def copy_template(src: Path, dst: Path) -> None:
 def find_repo_root(start: Path | None = None) -> Path | None:
    start = (start or Path.cwd()).resolve()
    for directory in [start, *start.parents]:
-        if (directory / ".skills.yaml").is_file():
+        if (directory / ".pouch.yaml").is_file() or (directory / ".skills.yaml").is_file():
            return directory
        if (directory / "skills").is_dir() and (
            (directory / "catalog.yaml").is_file()
@@ -1,4 +1,4 @@
-"""轻量 YAML 读写（覆盖 skiff 使用的子集，无第三方依赖）。"""
+"""轻量 YAML 读写（覆盖 pouch 使用的子集，无第三方依赖）。"""

 from __future__ import annotations

@@ -1 +1 @@
-# skiff 仅使用 Python 标准库，无第三方依赖
+# pouch 仅使用 Python 标准库，无第三方依赖
@@ -1,253 +0,0 @@
-# skiff
-
-Agent Skills 安装与管理 CLI。纯 Python 3 实现，无第三方依赖，无需编译。
-
-## 安装
-
-```bash
-cd /path/to/skills   # 本仓库根目录
-./install.sh         # 软链到 ~/.local/bin/skiff
-```
-
-确保 `~/.local/bin` 在 `PATH` 中。
-
-## 命令风格
-
-接口对齐 [Vercel skills CLI](https://github.com/vercel-labs/skills) 的 `add` / `remove`，
-统一管理 builtin skill、预置 catalog source 和用户命名的 custom source。
-
-```bash
-# 浏览可用自研 skill
-skiff add --list
-
-# 装到当前项目 / 全局
-skiff add discussion-notes -a cursor -y
-skiff add discussion-notes -a cursor -g -y
-
-# 卸载
-skiff remove discussion-notes -a cursor -y
-skiff rm discussion-notes -g -y
-
-# 改完 skill 后提交推送（在任意目录执行，操作 ~/.skills）
-skiff publish skills/discussion-notes -m "update discussion-notes" --push
-```
-
-开发时也可直接运行：
-
-```bash
-PYTHONPATH=/path/to/skills python3 -m skiff <command>
-```
-
-## 首次安装
-
-```bash
-git clone https://git.yumee.top/laily/skills.git ~/.skills
-~/.skills/install.sh
-```
-
-`install.sh` 会安装 CLI，并自动执行 `skiff bootstrap`，将本仓库的 `skiff` skill 全局软链到 Cursor、Claude Code 和 Codex。也可以随时手动重跑：
-
-```bash
-skiff bootstrap
-```
-
-## 命令参考
-
-### 查看
-
-| 命令 | 说明 |
-|------|------|
-| `skiff list [--source NAME]` | 列出所有来源或指定 source 中的 skill |
-| `skiff status [--target all\|cursor\|claude\|codex\|agents]` | 安装状态总览 |
-
-### 项目初始化
-
-| 命令 | 说明 |
-|------|------|
-| `skiff bootstrap` | 将本项目的 `skiff` skill 全局安装到所有 Agent |
-| `skiff update` | 在 `~/.skills` 执行 `git pull`，更新 skiff 自身 |
-| `skiff init <name> [--project DIR]` | 使用 builtin skill 自带模板初始化项目状态 |
-
-### Skill 安装
-
-| 命令 | 说明 |
-|------|------|
-| `skiff add <name> [--global] [-a AGENT...] [-y]` | 安装到 Agent 目录（软链） |
-| `skiff select [--global] [-a AGENT...]` | 打开终端多选界面，批量安装 skill |
-| `skiff remove <name> [--global] [-a AGENT...] [-y]` | 移除软链（`rm` / `r` 别名） |
-| `skiff add --list` | 列出可用 builtin skill |
-| `skiff publish [paths] -m MSG [--push]` | 在 ~/.skills 内 git add/commit/push |
-
-旧命令 `install` / `uninstall` 已移除，请改用 `add` / `remove`。
-
-全局目标路径：
-
-| Agent | 路径 |
-|-------|------|
-| cursor | `~/.cursor/skills/` |
-| claude | `~/.claude/skills/` |
-| codex | `~/.codex/skills/` |
-| agents | `~/.agents/skills/`（agents 标准目录，覆盖 OMP） |
-
-### 预置 Catalog Source
-
-| 命令 | 说明 |
-|------|------|
-| `skiff catalog add <name> <repo-url> [--ref main] [--path .]` | 写入 `catalog.yaml` |
-| `skiff fetch <name>` | 克隆或更新 catalog source checkout |
-| `skiff add <name> [-g] [-a AGENT...]` | 安装 catalog 中的单个 skill 或完整 collection（缺失时自动 fetch） |
-| `skiff add <collection>/<skill> [...]` | 只安装 collection 中指定的 skill |
-
-`catalog.yaml` 条目可额外提供 `description` 和 `tags`。`description`
-会显示在 `skiff select` 的候选列表中。`path` 可以直接指向含
-`SKILL.md` 的单个 skill，也可以指向由多个 skill 目录组成的 collection。
-collection 会自动发现下一层所有含 `SKILL.md` 的目录；`skiff add <name>`
-安装全部，`skiff select` 则展开为 `<name>/<skill>` 供分别勾选。同一
-`repo` 与 `ref` 共享一份 Git checkout。
-
-### 交互式批量安装
-
-```bash
-skiff select                         # 当前项目，全部 Agent
-skiff select -a codex                # 当前项目，仅 Codex
-skiff select -g                      # 全局安装
-skiff select --project ~/code/app    # 指定项目
-```
-
-使用方向键移动、空格勾选、`/` 搜索、Enter 安装，按 `q` 或 Esc
-取消。普通 `skiff select` 只安装到项目，并在每一项旁只读显示各 Agent 的
-全局安装状态；`skiff select -g` 只安装到全局。已经安装到目标范围的 skill
-默认勾选；取消勾选不会卸载已有 skill，卸载请使用 `skiff remove`。如果全局
-存在同名但指向其它来源的 skill，项目选择器会显示“全局同名冲突”。
-项目模式会把成功选择的项目写入 `.skills.yaml`。非交互环境请使用
-`skiff add <name>...`。使用 `-a` 限定 Agent 时，该范围会记录在对应的
-skill 条目中，后续 `skiff sync` 不会扩散到其他 Agent。
-
-### Custom source（多-skill 仓库）
-
-公司或团队维护的仓库通常包含多个 skill。使用命名 source 接入：
-
-```bash
-# Git 仓库，默认 clone 到 ~/.local/share/skiff/sources/company
-skiff source add company \
-  git@git.company.com:platform/agent-skills.git \
-  --ref main \
-  --skills-path internal/skills
-
-# 或接入已有本地仓库
-skiff source add company \
-  --local ~/code/company-agent-skills \
-  --skills-path skills
-
-skiff source list
-skiff source fetch company
-skiff list --source company
-skiff add company/code-review -g -a codex
-```
-
-| 命令 | 说明 |
-|------|------|
-| `skiff source add <name> <repo> [--ref REF] [--checkout PATH] [--skills-path PATH]` | 注册并克隆 Git source |
-| `skiff source add <name> --local PATH [--skills-path PATH]` | 接入已有本地仓库 |
-| `skiff source list` / `show <name>` | 查看 source |
-| `skiff source fetch <name>` / `fetch --all` | clone 或 fast-forward 更新 |
-| `skiff source remove <name>` | 移除配置并保留 checkout |
-
-配置保存在 `~/.config/skiff/config.yaml`。Git/SSH 认证复用本机 Git 配置，
-skiff 不保存 token。可以使用 `company/code-review`，也可以使用
-`skiff add code-review --source company`。多个来源包含同名 skill 时，必须明确来源。
-
-### 项目级
-
-| 命令 | 说明 |
-|------|------|
-| `skiff enable <name> [--target all] [--project <dir>]` | 写入 `.skills.yaml` 并创建项目软链 |
-| `skiff disable <name> [--target all] [--project <dir>]` | 从 manifest 移除并删除软链 |
-| `skiff sync [--target all] [--project <dir>]` | 按 `.skills.yaml` 重建软链 |
-
-项目目标路径：
-
-| Agent | 路径 |
-|-------|------|
-| cursor | `<project>/.agents/skills/` |
-| claude | `<project>/.claude/skills/` |
-| codex | `<project>/.agents/skills/` |
-| agents | `<project>/.agents/skills/`（与 cursor/codex 共用路径，软链幂等） |
-
-### 脚手架与健康检查
-
-| 命令 | 说明 |
-|------|------|
-| `skiff create <name> [--idea TEXT] [--from-project PATH]` | 从模板创建含 `SKILL.md`、`README.md` 的草稿 |
-| `skiff check <name>` | 校验草稿或正式 skill，包括人类使用说明 |
-| `skiff finalize <name>` | 校验草稿并移动到正式 `skills/` |
-| `skiff doctor [--target all] [--fix]` | 检查软链健康状态，`--fix` 自动修复 |
-
-## 常用工作流
-
-### 新建并全局启用自研 skill
-
-```bash
-skiff create my-skill --idea "描述要解决的重复问题" --from-project .
-# 由 Agent 完善草稿中的 SKILL.md 和 README.md
-skiff check my-skill
-skiff finalize my-skill
-skiff publish skills/my-skill -m "add my-skill" --push
-skiff add my-skill -a cursor -g -y
-skiff doctor -a cursor
-```
-
-### 在项目中启用 skill
-
-```bash
-cd ~/code/my-app
-skiff add declarative-openspec-loop -a cursor -y
-```
-
-### 添加 Catalog Source
-
-```bash
-skiff catalog add my-ext https://github.com/org/repo --ref main
-skiff fetch my-ext
-skiff add my-ext -g
-```
-
-## 源码结构
-
-```
-skiff/
-├── __init__.py      # 版本号
-├── __main__.py      # python3 -m skiff 入口
-├── cli.py           # 命令定义与调度
-├── paths.py         # 路径常量与 Agent 目标
-├── skills.py        # builtin/catalog/custom 统一解析
-├── catalog.py       # catalog.yaml 读写与 Skill 发现
-├── sources.py       # custom source 配置、发现与 Git 管理
-├── project.py       # .skills.yaml 管理
-├── symlinks.py      # 软链创建/检查/修复
-└── yaml_io.py       # 轻量 YAML 解析（无第三方依赖）
-```
-
-入口脚本：[../bin/skiff](../bin/skiff)
-
-## 路径约定
-
-| 变量 | 路径 | 说明 |
-|------|------|------|
-| `SKILLS_HOME` | `~/.skills` | skills 仓库（软链） |
-| `SKILLS_DIR` | `~/.skills/skills/` | builtin skill 目录 |
-| `CATALOG_FILE` | `~/.skills/catalog.yaml` | 预置 Skill 来源目录 |
-| `CATALOG_CACHE_DIR` | `~/.local/share/skills/externals/` | catalog checkout 兼容缓存；按 repo/ref 共享 |
-| `CONFIG_FILE` | `~/.config/skiff/config.yaml` | custom source 配置 |
-| `SOURCES_DIR` | `~/.local/share/skiff/sources/` | custom Git source 默认 checkout |
-
-## 注意事项
-
- **禁止**在 `~/.cursor/skills/` 等 Agent 目录直接创建非软链的 skill
- Claude Code 对 symlink 支持不稳定；建议对单个 skill 目录软链，不要软链整个 `~/.claude/skills/`
- 若 Agent 将软链替换为普通目录，运行 `skiff doctor --fix` 重建
-
-## 相关文档
-
- [项目 README](../README.md)
- [AGENTS.md](../AGENTS.md)
@@ -1,3 +0,0 @@
-"""skiff — Agent Skills 安装与管理 CLI。"""
-
-__version__ = "0.6.0"
@@ -1,56 +0,0 @@
-"""路径与 Agent 目标定义。"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-HOME = Path.home()
-SKILLS_HOME = HOME / ".skills"
-SKILLS_DIR = SKILLS_HOME / "skills"
-TEMPLATE_DIR = SKILLS_DIR / "_template"
-DRAFTS_DIR = SKILLS_HOME / ".drafts"
-CATALOG_FILE = SKILLS_HOME / "catalog.yaml"
-LEGACY_REGISTRY_FILE = SKILLS_HOME / "registry.yaml"
-CATALOG_CACHE_DIR = HOME / ".local" / "share" / "skills" / "externals"
-CONFIG_FILE = HOME / ".config" / "skiff" / "config.yaml"
-SOURCES_DIR = HOME / ".local" / "share" / "skiff" / "sources"
-PROJECT_MANIFEST = ".skills.yaml"
-
-AGENT_GLOBAL: dict[str, Path] = {
-    "cursor": HOME / ".cursor" / "skills",
-    "claude": HOME / ".claude" / "skills",
-    "codex": HOME / ".codex" / "skills",
-    # agents 标准目录：OMP 原生 canonical（agents provider），cursor/codex 项目级同路径
-    "agents": HOME / ".agents" / "skills",
-}
-
-AGENT_PROJECT: dict[str, str] = {
-    "cursor": ".agents/skills",
-    "claude": ".claude/skills",
-    "codex": ".agents/skills",
-    # 与 cursor/codex 共用 .agents/skills；软链幂等，同路径只写一次
-    "agents": ".agents/skills",
-}
-
-ALL_TARGETS = ("cursor", "claude", "codex", "agents")
-
-
-def resolve_targets(target: str | None) -> list[str]:
-    if target is None or target == "all":
-        return list(ALL_TARGETS)
-    if target not in ALL_TARGETS:
-        raise ValueError(f"未知 target: {target!r}，可选: {', '.join(ALL_TARGETS)}, all")
-    return [target]
-
-
-def agent_skill_dir(target: str, *, project_root: Path | None = None) -> Path:
-    if project_root is None:
-        return AGENT_GLOBAL[target]
-    return project_root / AGENT_PROJECT[target]
-
-
-def ensure_skills_home() -> None:
-    if not SKILLS_HOME.is_dir():
-        raise SystemExit(
-            "~/.skills 不存在。请将 skills 仓库克隆到 ~/.skills"
-        )
@@ -9,7 +9,7 @@ ACK 是一个显式调用的 Agent Skill，用三种独立角色运行工程协
 关键约束是验证者不等于实现者。每个任务最多修复三轮，仍未通过时记录为
 `leftover`，然后继续处理其它任务。

-项目还可以在同一份 `docs/ack/delivery.yaml` 里声明测试环境部署和版本发布。
+项目还可以在同一份 `.pouch/ack/delivery.yaml` 里声明测试环境部署和版本发布。
 用户告诉 ACK 这两件事怎么做之后，再说「重新布测试环境」或「发布一个版本」，
 ACK 按对应 intent 执行。任务全部验证后仍可按 profile 做常规交付。配置默认关闭，
 稳定发布与生产部署始终保留人工批准点。
@@ -19,13 +19,13 @@ ACK 按对应 intent 执行。任务全部验证后仍可按 profile 做常规
 全局安装：

 ```bash
-skiff add ack -g
+pouch add ack -g
 ```

 或只安装到当前项目：

 ```bash
-skiff add ack
+pouch add ack
 ```

 ACK 只在用户显式调用 `/ack` 或 `$ack` 时运行。
@@ -33,14 +33,14 @@ ACK 只在用户显式调用 `/ack` 或 `$ack` 时运行。
 ## 初始化项目

 ```bash
-skiff init ack
-skiff init ack --project ~/code/my-app
+pouch init ack
+pouch init ack --project ~/code/my-app
 ```

 初始化后，项目只保存自己的 ACK 状态：

 ```text
-docs/ack/
+.pouch/ack/
 ├── project.md
 ├── tasks.yaml
 ├── knowledge.yaml
@@ -50,7 +50,7 @@ docs/ack/
 不会在项目中复制或链接 ACK Skill。通用规范、模板和脚本始终从已安装的 Skill
 目录读取。

-ACK 从当前命令指定的 `--project-root/docs/ack/` 定位项目状态，不要求在
+ACK 从当前命令指定的 `--project-root/.pouch/ack/` 定位项目状态，不要求在
 `tasks.yaml` 中持久化 `repoPath` 或 `devWorktree`。自动 worker 的实际工作目录由
 `--worktree` 指定；默认在 `--project-root` 工作，v0.19 起不再配置 `allowedWorktrees` 白名单。

@@ -68,10 +68,10 @@ skills/ack/
 ```

 `SKILL.md` 是 Agent 的工作流入口。`references/` 是按需读取的稳定规范；
-`docs/ack/project.md` 只保存当前项目的命令、路径和权限差异；
-`docs/ack/tasks.yaml` 保存当前任务状态；`docs/ack/knowledge.yaml` 保存跨任务复用、
+`.pouch/ack/project.md` 只保存当前项目的命令、路径和权限差异；
+`.pouch/ack/tasks.yaml` 保存当前任务状态；`.pouch/ack/knowledge.yaml` 保存跨任务复用、
 已经独立验证的项目知识护栏。
-`docs/ack/delivery.yaml` 是测试环境部署和版本发布的唯一契约，也声明常规构建、
+`.pouch/ack/delivery.yaml` 是测试环境部署和版本发布的唯一契约，也声明常规构建、
 发布和部署能力；每次执行结果另记在 `tasks.yaml.deliveryRuns`。

 ## 检查项目状态
@@ -79,21 +79,21 @@ skills/ack/
 Agent 会从当前 ACK Skill 目录解析校验脚本：

 ```bash
-python3 <ack-skill-dir>/scripts/validate_tasks.py docs/ack/tasks.yaml
-python3 <ack-skill-dir>/scripts/validate_knowledge.py docs/ack/knowledge.yaml \
-  --tasks docs/ack/tasks.yaml
-python3 <ack-skill-dir>/scripts/validate_delivery.py docs/ack/delivery.yaml \
-  --tasks docs/ack/tasks.yaml --project-root <project-root>
+python3 <ack-skill-dir>/scripts/validate_tasks.py .pouch/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/validate_knowledge.py .pouch/ack/knowledge.yaml \
+  --tasks .pouch/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/validate_delivery.py .pouch/ack/delivery.yaml \
+  --tasks .pouch/ack/tasks.yaml --project-root <project-root>
 ```

 Coordinator 可以按当前任务上下文做确定性推荐：

 ```bash
-python3 <ack-skill-dir>/scripts/select_tasks.py docs/ack/tasks.yaml
-python3 <ack-skill-dir>/scripts/select_tasks.py docs/ack/tasks.yaml \
+python3 <ack-skill-dir>/scripts/select_tasks.py .pouch/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/select_tasks.py .pouch/ack/tasks.yaml \
  --task-id BUG-001

-python3 <ack-skill-dir>/scripts/select_knowledge.py docs/ack/knowledge.yaml \
+python3 <ack-skill-dir>/scripts/select_knowledge.py .pouch/ack/knowledge.yaml \
  --component web --path web/app.py --tag long-running-service --limit 10
 ```

@@ -110,7 +110,7 @@ run。默认最多 20 条，超过预算时显式失败；Agent 不应回退为

 ```bash
 python3 <ack-skill-dir>/scripts/run_verification.py \
-  docs/ack/knowledge.yaml check-api-contract --project-root <project-root>
+  .pouch/ack/knowledge.yaml check-api-contract --project-root <project-root>
 ```

 该入口会在执行前重新校验知识库，只打开一次项目根目录 fd，再从同一个 fd 逐段以
@@ -118,7 +118,7 @@ python3 <ack-skill-dir>/scripts/run_verification.py \
 快照，再以结构化 argv 和 `shell=False` 启动。它不接受临时命令或额外参数。
 选择器输出的 path/args 只用于审阅，不应由 Agent 自行拼接执行。Runner 只读取
 项目内无 symlink 的权威
-`docs/ack/knowledge.yaml`，不接受替代知识文件或放宽后的项目根。检查进程的 cwd
+`.pouch/ack/knowledge.yaml`，不接受替代知识文件或放宽后的项目根。检查进程的 cwd
 和 `ACK_PROJECT_ROOT` 都固定到该根 fd；后者是只在检查进程存活期间有效的
 `/proc/self/fd/...` 或 `/dev/fd/...` 路径。原始可读路径另放在
 `ACK_PROJECT_ROOT_DISPLAY`，只能用于日志，不能用于资源访问。Runner 还提供
@@ -132,7 +132,7 @@ python3 <ack-skill-dir>/scripts/run_verification.py \

 旧项目只有 `project.md` 和 `tasks.yaml` 时，不要重跑初始化。由 `/ack` 检查现有
 状态，获得用户授权后补一个空的 `knowledge.yaml`；如果任务板尚未声明知识库，
-同时只补 `project.knowledgeFile: docs/ack/knowledge.yaml`，再运行跨文件校验。
+同时只补 `project.knowledgeFile: .pouch/ack/knowledge.yaml`，再运行跨文件校验。

 只有 Coordinator 写 `tasks.yaml` 和 `knowledge.yaml`。知识正文不能作为自由 shell
 执行；关键约束应继续下沉到测试、lint、CI 或正式规范。ACK 不自动修改项目的
@@ -147,7 +147,7 @@ python3 <ack-skill-dir>/scripts/run_verification.py \
 发版方式以后再告诉你。
 ```

-ACK 把它维护成 `docs/ack/delivery.yaml` 的 `intents.testEnvironment` /
+ACK 把它维护成 `.pouch/ack/delivery.yaml` 的 `intents.testEnvironment` /
 `intents.release`、entrypoint、artifact、environment 和 profile。首次配置保持
 关闭，确认后才启用。之后用户可以说：

@@ -2,14 +2,14 @@
 name: ack
 description: >-
  初始化、检查并运行 ACK 三角色协作闭环。仅在用户显式调用 /ack 或 $ack，并要求
-  初始化 ACK、检查 docs/ack 配置、按 ACK 规划需求、指挥 Coordinator/Developer/Test
+  初始化 ACK、检查 .pouch/ack 配置、按 ACK 规划需求、指挥 Coordinator/Developer/Test
  工作，配置测试环境与发版方式，重新部署测试环境，或发布版本时使用。
 ---

 # ACK 项目协作入口

 本 Skill 是 ACK 的完整能力包：`references/` 保存通用规范，`templates/` 保存项目
-状态模板，`scripts/` 保存校验工具。目标项目只在 `docs/ack/` 保存 `project.md`、
+状态模板，`scripts/` 保存校验工具。目标项目只在 `.pouch/ack/` 保存 `project.md`、
 `tasks.yaml`、`knowledge.yaml` 和默认关闭的 `delivery.yaml`，不要复制或链接 Skill
 内容。

@@ -23,7 +23,7 @@ description: >-
 - 用户要求用 ACK 做需求、修复问题或继续任务：执行“工作”。
 - 用户用自然语言说明怎么部署测试环境、怎么发布版本，或要求增加、修改、关闭交付
  流程：执行“交付配置维护”。测试环境和发版必须写进同一份
-  `docs/ack/delivery.yaml`。
+  `.pouch/ack/delivery.yaml`。
 - 用户要求部署、重新部署测试环境，或按已配置方式开始测试：执行“运行测试环境”。
 - 用户要求发布版本：执行“运行版本发布”。

@@ -33,48 +33,48 @@ description: >-

 ## 初始化

-1. 确认 `skiff` 可执行，并检查 `<project>/docs/ack` 是否存在。
+1. 确认 `pouch` 可执行，并检查 `<project>/.pouch/ack` 是否存在。
 2. 不存在时执行：

   ```bash
-   skiff init ack --project <project-root>
+   pouch init ack --project <project-root>
   ```

   该命令从本 Skill 的 `templates/` 生成项目状态，不会在项目中创建 Skill
   软链接或资源副本。
-3. 如果 `docs/ack` 已存在，不重复初始化、不覆盖文件；转入“检查”。旧项目只有
+3. 如果 `.pouch/ack` 已存在，不重复初始化、不覆盖文件；转入“检查”。旧项目只有
   `project.md` 与 `tasks.yaml` 时，先报告缺少 `knowledge.yaml`。用户授权后，
   从 `templates/knowledge.template.yaml` 生成这个缺失文件并替换项目名和时间；若
   `tasks.yaml` 尚无 `project.knowledgeFile`，同时只补
-   `docs/ack/knowledge.yaml` 这一项。不要重跑 `skiff init`，也不要改写其它已有
+   `.pouch/ack/knowledge.yaml` 这一项。不要重跑 `pouch init`，也不要改写其它已有
   项目状态。
 4. 读取项目的公开配置和文档，例如 README、语言清单、包管理清单、测试配置与
   CI，确定项目名、技术栈、源码/规格/测试路径及真实可执行命令。
-5. 完善 `docs/ack/project.md`：
+5. 完善 `.pouch/ack/project.md`：
   - 用实际项目值替换全部占位符。
   - 无服务地址时把 Base URL 写为 `n/a`，不要虚构端口。
   - 无法从项目证据确定的命令写为 `n/a`，并在结果中列为待配置项。
   - 只写项目差异，不复制 `references/` 中的通用规范。
-6. 完善 `docs/ack/tasks.yaml` 的项目信息。纯初始化且用户没有提供真实任务时，
+6. 完善 `.pouch/ack/tasks.yaml` 的项目信息。纯初始化且用户没有提供真实任务时，
   删除模板示例任务并保留 `tasks: []`；不要虚构需求或缺陷。
-   项目状态固定从当前项目根的 `docs/ack/` 推导，不写入 `repoPath` 或 `devWorktree`；
+   项目状态固定从当前项目根的 `.pouch/ack/` 推导，不写入 `repoPath` 或 `devWorktree`；
   worker 默认在 `--project-root`（权威状态目录）工作，不再配置
   `allowedWorktrees` 白名单（v0.19 起废弃）；需要隔离 worktree 时由 Coordinator 在
   派发时显式指定。旧任务板中的 `repoPath`、`devWorktree` 仅兼容读取。
-7. 检查 `docs/ack/knowledge.yaml`。新项目没有已验证的项目经验时保留
+7. 检查 `.pouch/ack/knowledge.yaml`。新项目没有已验证的项目经验时保留
   `verificationRegistry: {}` 与 `entries: []`，不从聊天、README 或单次失败中
   猜测并激活知识。
-8. 检查 `docs/ack/delivery.yaml`。新项目保留 `enabled: false`、空能力表和空 profile；
+8. 检查 `.pouch/ack/delivery.yaml`。新项目保留 `enabled: false`、空能力表和空 profile；
   不从 README 或 CI 猜测、启用交付。旧项目没有该文件时仍可继续使用原 ACK
   闭环；只有用户明确要求配置交付时，才按“交付配置维护”补齐。
 9. 更新 `updatedAt`，并运行：

   ```bash
-   python3 <ack-skill-dir>/scripts/validate_tasks.py docs/ack/tasks.yaml
-   python3 <ack-skill-dir>/scripts/validate_knowledge.py docs/ack/knowledge.yaml \
-     --tasks docs/ack/tasks.yaml
-   python3 <ack-skill-dir>/scripts/validate_delivery.py docs/ack/delivery.yaml \
-     --tasks docs/ack/tasks.yaml --project-root <project-root>
+   python3 <ack-skill-dir>/scripts/validate_tasks.py .pouch/ack/tasks.yaml
+   python3 <ack-skill-dir>/scripts/validate_knowledge.py .pouch/ack/knowledge.yaml \
+     --tasks .pouch/ack/tasks.yaml
+   python3 <ack-skill-dir>/scripts/validate_delivery.py .pouch/ack/delivery.yaml \
+     --tasks .pouch/ack/tasks.yaml --project-root <project-root>
   ```

 10. 检查 `project.md`、`tasks.yaml`、`knowledge.yaml` 与 `delivery.yaml` 是否仍有
@@ -87,10 +87,10 @@ description: >-
 ## 检查

 1. 检查以下路径：
-   - `docs/ack/project.md`
-   - `docs/ack/tasks.yaml`
-   - `docs/ack/knowledge.yaml`
-   - `docs/ack/delivery.yaml`（旧项目可无；存在或被任务板引用时必须校验）
+   - `.pouch/ack/project.md`
+   - `.pouch/ack/tasks.yaml`
+   - `.pouch/ack/knowledge.yaml`
+   - `.pouch/ack/delivery.yaml`（旧项目可无；存在或被任务板引用时必须校验）
   需要查看任务内容时，使用 `<ack-skill-dir>/scripts/select_tasks.py` 解析完整任务板并
   只输出项目配置、摘要和可工作任务；不要用 `cat`、整文件 `sed` 或等价方式把完整
   `tasks.yaml` 注入上下文。完整性仍由校验器检查。
@@ -101,14 +101,14 @@ description: >-
 3. 查找未替换占位符，并核对项目根、覆盖层路径、Developer 白盒命令、Test
   黑盒命令和 Base URL。
 4. 使用 `<ack-skill-dir>/scripts/validate_tasks.py` 校验任务板，使用
-   `<ack-skill-dir>/scripts/validate_knowledge.py docs/ack/knowledge.yaml --tasks
-   docs/ack/tasks.yaml` 校验项目知识和跨文件引用。如果存在交付配置或任务板声明了
+   `<ack-skill-dir>/scripts/validate_knowledge.py .pouch/ack/knowledge.yaml --tasks
+   .pouch/ack/tasks.yaml` 校验项目知识和跨文件引用。如果存在交付配置或任务板声明了
   `project.deliveryFile`，再使用 `<ack-skill-dir>/scripts/validate_delivery.py
-   docs/ack/delivery.yaml --tasks docs/ack/tasks.yaml --project-root <project-root>`
+   .pouch/ack/delivery.yaml --tasks .pouch/ack/tasks.yaml --project-root <project-root>`
   校验交付能力、顺序、安全边界和跨文件引用。只报告证据明确的问题，不因旧项目
   缺少可选交付配置而宣称失败。
 5. 若存在 `project.bugIntake`，运行
-   `python3 <ack-skill-dir>/scripts/feishu_bug_intake.py check docs/ack/tasks.yaml`。
+   `python3 <ack-skill-dir>/scripts/feishu_bug_intake.py check .pouch/ack/tasks.yaml`。
   它只接受 `feishu-base` 和显式 profile；详细的飞书配置、凭据初始化和读取方式见
   `references/feishu-bug-intake.md`。
 6. 检查知识引用能解析到固定 revision，candidate 仍留在任务证据中，且
@@ -122,16 +122,16 @@ description: >-

 ## 工作

-1. 若 `docs/ack` 不存在，停止并建议先用 `/ack` 初始化；不要静默初始化。
+1. 若 `.pouch/ack` 不存在，停止并建议先用 `/ack` 初始化；不要静默初始化。
 2. 依次读取：
-   - `docs/ack/project.md`
-   - 运行 `python3 <ack-skill-dir>/scripts/select_tasks.py docs/ack/tasks.yaml`，只读取
+   - `.pouch/ack/project.md`
+   - 运行 `python3 <ack-skill-dir>/scripts/select_tasks.py .pouch/ack/tasks.yaml`，只读取
     `project`、`summary` 和默认可工作状态的任务；已知当前任务时传
     `--task-id <ack-task-id>`。选择器会解析并校验完整任务板，并只附带选中任务引用的
     receipt 与 delivery run。命中超过默认预算时用 `--task-id` / `--status` 缩小，
     不直接回退为输出完整 `tasks.yaml`。
   - 通过 `<ack-skill-dir>/scripts/select_knowledge.py` 从
-     `docs/ack/knowledge.yaml` 选择的当前任务相关 `active` 条目
+     `.pouch/ack/knowledge.yaml` 选择的当前任务相关 `active` 条目
   - `<ack-skill-dir>/references/kickoff.md`
   - kickoff 指定且与当前任务相关的 references 文件
   - 若 `tasks.yaml.project.deliveryFile` 存在，再读取该 `delivery.yaml` 和
@@ -183,7 +183,7 @@ description: >-
   `knowledgeCandidates`，Test 回报 `knowledgeChecks`；`candidate` 只有在独立验证和
   gate 后才能由 Coordinator 写入或激活。
 7. 执行知识项的 `verification.ref` 时，只调用
-   `<ack-skill-dir>/scripts/run_verification.py docs/ack/knowledge.yaml
+   `<ack-skill-dir>/scripts/run_verification.py .pouch/ack/knowledge.yaml
   <verification-ref> --project-root <project-root>`。不要直接执行选择器返回的 path/args，
   也不要给 runner 注入额外命令或参数。
 8. 不把 `worker_done` 或 Test 自报成功直接当作完成。三轮预算只计算 Test 已对齐正确
@@ -216,8 +216,8 @@ description: >-
   destination、environment 与 profile。测试环境部署和版本发布都写进这一份
   `delivery.yaml`，不要拆成第二份文档。配置只引用仓库内脚本或声明式工具 target，
   不保存 shell。
-2. 若旧项目首次启用，生成 `docs/ack/delivery.yaml`，在 `tasks.yaml.project` 增加
-   `deliveryFile: docs/ack/delivery.yaml`，并增加顶层 `deliveryRuns: []`；不改写其它
+2. 若旧项目首次启用，生成 `.pouch/ack/delivery.yaml`，在 `tasks.yaml.project` 增加
+   `deliveryFile: .pouch/ack/delivery.yaml`，并增加顶层 `deliveryRuns: []`；不改写其它
   项目状态。首次生成保持 `enabled: false`，先展示 diff 和解析出的执行顺序。
 3. 运行 delivery、tasks 和跨文件校验；需要的脚本不存在、不可执行、引用不完整或
   涉及凭据正文时 fail closed。凭据只写 secret 名称，值由外部环境提供。
@@ -227,7 +227,7 @@ description: >-

 ## 运行测试环境

-1. 读取 `docs/ack/delivery.yaml` 与 `references/delivery.md`。
+1. 读取 `.pouch/ack/delivery.yaml` 与 `references/delivery.md`。
 2. `enabled` 不为 true，或 `intents.testEnvironment` 为 null：停止，请用户说明如何
   部署测试环境，转入交付配置维护。不猜测编译或启动命令。
 3. 不要求任务已 `verified`。按该 profile 执行 build → deploy → health-check。
@@ -237,7 +237,7 @@ description: >-

 ## 运行版本发布

-1. 读取同一份 `docs/ack/delivery.yaml` 与 `references/delivery.md`。
+1. 读取同一份 `.pouch/ack/delivery.yaml` 与 `references/delivery.md`。
 2. `enabled` 不为 true，或 `intents.release` 为 null：停止，请用户说明如何发版，
   写入同一文件后再执行。
 3. 按该 profile 顺序执行。stable 发布和生产部署的 `approval` 不能用口头「发版」
@@ -262,7 +262,7 @@ description: >-
  没有可信空闲状态、配置匹配和历史消息清理证明时不复用既有 worker。
 - launcher 返回 `indeterminate` 或 `reconcile required` 时，不直接重试；先按
  launch ID、外部 record 和 Orca live state 完成人工核对。
- 不覆盖已有 `docs/ack` 文件；除用户确认的 ACK 任务或 delivery profile 外，不擅自
+- 不覆盖已有 `.pouch/ack` 文件；除用户确认的 ACK 任务或 delivery profile 外，不擅自
  提交、推送、创建终端、新 worktree、发布产物或部署。
 - 只有 Coordinator 写 `tasks.yaml`、`knowledge.yaml` 和 `deliveryRuns`；Developer
  与 Test 只读，只能通过回报提名或验证知识。`delivery.yaml` 只在显式的交付配置
@@ -271,6 +271,6 @@ description: >-
  按 registry ID 执行。不自动修改 `AGENTS.md`、`CLAUDE.md` 或其它 Agent 指令文件。
 - 不把完整 `tasks.yaml` 注入上下文；使用 `select_tasks.py` 获取有预算的项目与任务
  视图，写回前仍运行完整任务板校验。
- 项目只保存 `docs/ack/project.md`、`docs/ack/tasks.yaml`、
-  `docs/ack/knowledge.yaml` 和可选的 `docs/ack/delivery.yaml`；通用资源始终从当前
+- 项目只保存 `.pouch/ack/project.md`、`.pouch/ack/tasks.yaml`、
+  `.pouch/ack/knowledge.yaml` 和可选的 `.pouch/ack/delivery.yaml`；通用资源始终从当前
  ACK Skill 目录读取。
@@ -1 +1 @@
-0.18.0
+0.19.0
@@ -1,10 +1,10 @@
 # notes-web Agent 协作协议（示例，项目覆盖层）

-> 本项目基于 ack v0.18.0。
+> 本项目基于 ack v0.19.0。
 > 通用规范由 `/ack` 从 Skill 自身的 `references/` 读取，本文件只填项目差异。
-> 覆盖层文件放在 `docs/ack/project.md`，不占用 `AGENTS.md`。
+> 覆盖层文件放在 `.pouch/ack/project.md`，不占用 `AGENTS.md`。
 > ACK 不会自动修改 `AGENTS.md`、`CLAUDE.md` 或其它 Agent 指令文件。
-> `docs/ack/` 只保存 `project.md`、`tasks.yaml`、`knowledge.yaml` 与 `delivery.yaml`。
+> `.pouch/ack/` 只保存 `project.md`、`tasks.yaml`、`knowledge.yaml` 与 `delivery.yaml`。

 ## 项目概览

@@ -12,10 +12,10 @@
 - 技术栈：`TypeScript + React (Vite) + Go`
 - 运行命令：`npm run dev`（前端）、`go run ./server`（后端）
 - Base URL：`http://localhost:5173`
- 任务板：`docs/ack/tasks.yaml`
- 项目知识：`docs/ack/knowledge.yaml`
- 交付契约：`docs/ack/delivery.yaml`
- 覆盖层文件：`docs/ack/project.md`
+- 任务板：`.pouch/ack/tasks.yaml`
+- 项目知识：`.pouch/ack/knowledge.yaml`
+- 交付契约：`.pouch/ack/delivery.yaml`
+- 覆盖层文件：`.pouch/ack/project.md`

 ## 稳定规范（引用，不重复）

@@ -30,7 +30,7 @@

 ## Worker 路由

-结构化配置位于 `docs/ack/tasks.yaml` 的 `project.orchestration`，启动记录位于顶层
+结构化配置位于 `.pouch/ack/tasks.yaml` 的 `project.orchestration`，启动记录位于顶层
 `workerReceipts`。本项目默认使用：

 | 角色 | profile ID | 档位 |
@@ -3,13 +3,13 @@
 version: 1
 updatedAt: "2026-07-06T09:40:00+08:00"
 source: "Coordinator (PM) Agent"
-ackVersion: "0.18.0"
+ackVersion: "0.19.0"
 project:
  name: "notes-web"
  baseUrl: "http://localhost:5173"
-  overlayFile: "docs/ack/project.md"
-  knowledgeFile: "docs/ack/knowledge.yaml"
-  deliveryFile: "docs/ack/delivery.yaml"
+  overlayFile: ".pouch/ack/project.md"
+  knowledgeFile: ".pouch/ack/knowledge.yaml"
+  deliveryFile: ".pouch/ack/delivery.yaml"
  orchestration:
    profileVersion: 1
    mode: "manual"
@@ -3,8 +3,8 @@
 ## 安装与初始化

 - [ ] ACK Skill 已全局安装或安装到当前项目。
- [ ] 已运行 `skiff init ack --project <project-root>`。
- [ ] `docs/ack/` 只包含项目自己的 `project.md`、`tasks.yaml`、`knowledge.yaml` 与
+- [ ] 已运行 `pouch init ack --project <project-root>`。
+- [ ] `.pouch/ack/` 只包含项目自己的 `project.md`、`tasks.yaml`、`knowledge.yaml` 与
      默认关闭的 `delivery.yaml`。
 - [ ] 旧项目缺少 `knowledge.yaml` 时，只补空文件及缺失的
      `project.knowledgeFile` 指针，没有重跑初始化或覆盖其它项目状态。
@@ -16,8 +16,8 @@
 - [ ] `project.md` 只保存项目差异，不复制 Skill 的通用规范。
 - [ ] `tasks.yaml` 的 `project.overlayFile` 指向实际覆盖层。
 - [ ] `tasks.yaml` 的 `project.knowledgeFile` 固定为
-      `docs/ack/knowledge.yaml`。
- [ ] 新项目的 `project.deliveryFile` 固定为 `docs/ack/delivery.yaml`，顶层有
+      `.pouch/ack/knowledge.yaml`。
+- [ ] 新项目的 `project.deliveryFile` 固定为 `.pouch/ack/delivery.yaml`，顶层有
      `deliveryRuns: []`；旧项目未采用交付能力时可无这两项。
 - [ ] 技术栈、运行、构建、单测和集成测试命令均来自项目证据。
 - [ ] Coordinator、Developer、Test 的模型档位和升级规则已明确。
@@ -26,7 +26,7 @@
 - [ ] `allowedWorktrees` 已废弃（v0.19 起），新任务板不配置；worker 默认在
      `--project-root` 工作，其它 worktree 由 launcher 按同 git 仓库且已注册约束放行。
 - [ ] `tasks.yaml` 不需要保存 `repoPath` 或 `devWorktree`；项目状态从当前
-      `--project-root/docs/ack/` 推导，worker 路径由 `--worktree` 显式指定。
+      `--project-root/.pouch/ack/` 推导，worker 路径由 `--worktree` 显式指定。

 ## 路径权限

@@ -110,6 +110,6 @@
      blocked/failed/leftover、未完成任务或未解决环境事件的终端保留且不设 TTL。

 首次接入建议选择一个低风险问题跑完整闭环。项目差异写回
-`docs/ack/project.md`；通用问题回流到 ACK Skill 的 `references/`、`templates/`
+`.pouch/ack/project.md`；通用问题回流到 ACK Skill 的 `references/`、`templates/`
 或 `scripts/`，并更新 `VERSION`。项目特有、跨任务复用且已经验证的经验才写入
-`docs/ack/knowledge.yaml`。
+`.pouch/ack/knowledge.yaml`。
@@ -2,8 +2,8 @@

 本文件定义可选的 `verified -> validation_ready/review_ready/released` 交付阶段。开发、独立复测和
 Coordinator 终检仍由 ACK 原有闭环负责；只有选中的任务全部 `verified` 后才能进入
-交付。项目配置位于 `docs/ack/delivery.yaml`，运行证据写入
-`docs/ack/tasks.yaml.deliveryRuns`。
+交付。项目配置位于 `.pouch/ack/delivery.yaml`，运行证据写入
+`.pouch/ack/tasks.yaml.deliveryRuns`。

 ## 1. 配置与授权不是一回事

@@ -54,7 +54,7 @@ channel、environment 或 source revision 漂移时重新确认。

 ## 3.1 测试环境与发版写在同一份契约

-`docs/ack/delivery.yaml` 是测试环境部署和版本发布的唯一文档。不要另写操作手册，
+`.pouch/ack/delivery.yaml` 是测试环境部署和版本发布的唯一文档。不要另写操作手册，
 也不要把其中一项写进 `project.md`。用户用自然语言说明「怎么布测试环境」或
 「怎么发版」时，Coordinator 把两者都维护进这份文件的 `intents`、entrypoint、
 artifact、environment 和 profile。
@@ -85,7 +85,7 @@ intents:

   ```bash
   python3 <ack-skill-dir>/scripts/validate_delivery.py \
-     docs/ack/delivery.yaml --tasks docs/ack/tasks.yaml \
+     .pouch/ack/delivery.yaml --tasks .pouch/ack/tasks.yaml \
     --project-root <project-root>
   ```

@@ -9,7 +9,7 @@

 ## 项目配置与 Base 结构

-`docs/ack/tasks.yaml` 的 `project.bugIntake` 必须声明 `provider: feishu-base`、
+`.pouch/ack/tasks.yaml` 的 `project.bugIntake` 必须声明 `provider: feishu-base`、
 `workflow: clarified-writeback-v1`、显式 `profile`、`baseToken`、`tableId`、`viewId` 和字段映射：

 ```yaml
@@ -34,8 +34,8 @@ fields:
 调整当前 view 的可见字段，不删除旧列：

 ```bash
-python3 <ack-skill-dir>/scripts/feishu_bug_intake.py schema-plan docs/ack/tasks.yaml
-python3 <ack-skill-dir>/scripts/feishu_bug_intake.py schema-apply docs/ack/tasks.yaml \
+python3 <ack-skill-dir>/scripts/feishu_bug_intake.py schema-plan .pouch/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/feishu_bug_intake.py schema-apply .pouch/ack/tasks.yaml \
  --expected-schema-fingerprint <schemaFingerprint>
 ```

@@ -68,11 +68,11 @@ locale；调用者环境中的凭据和运行时注入变量不会传入。不
 ## 读取与整理

 ```bash
-python3 <ack-skill-dir>/scripts/feishu_bug_intake.py check docs/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/feishu_bug_intake.py check .pouch/ack/tasks.yaml
 tmpdir=$(mktemp -d)
-python3 <ack-skill-dir>/scripts/feishu_bug_intake.py fetch docs/ack/tasks.yaml \
+python3 <ack-skill-dir>/scripts/feishu_bug_intake.py fetch .pouch/ack/tasks.yaml \
  --output-dir "$tmpdir"
-python3 <ack-skill-dir>/scripts/feishu_bug_intake.py plan docs/ack/tasks.yaml \
+python3 <ack-skill-dir>/scripts/feishu_bug_intake.py plan .pouch/ack/tasks.yaml \
  --output-dir "$tmpdir"
 ```

@@ -101,7 +101,7 @@ Coordinator 对每条 Bug：

 ```bash
 python3 <ack-skill-dir>/scripts/feishu_bug_intake.py write-draft \
-  docs/ack/tasks.yaml --record-id <record-id> \
+  .pouch/ack/tasks.yaml --record-id <record-id> \
  --expected-source-ref <sourceRef> \
  --expected-draft-revision <draftRevision> --input <draft.json>
 ```
@@ -120,7 +120,7 @@ python3 <ack-skill-dir>/scripts/feishu_bug_intake.py write-draft \

 ```bash
 python3 <ack-skill-dir>/scripts/feishu_bug_intake.py import-approved \
-  docs/ack/tasks.yaml --record-id <record-id> \
+  .pouch/ack/tasks.yaml --record-id <record-id> \
  --expected-source-ref <approved-sourceRef> \
  --expected-draft-revision <approvedDraftRevision>
 ```
@@ -135,7 +135,7 @@ python3 <ack-skill-dir>/scripts/feishu_bug_intake.py import-approved \

 ```bash
 python3 <ack-skill-dir>/scripts/feishu_bug_intake.py mark-imported \
-  docs/ack/tasks.yaml --record-id <record-id> --task-id <ack-task-id> \
+  .pouch/ack/tasks.yaml --record-id <record-id> --task-id <ack-task-id> \
  --expected-source-ref <approved-sourceRef> \
  --expected-draft-revision <approvedDraftRevision>
 ```
@@ -9,10 +9,10 @@

 1. 目标项目根目录。
 2. ACK Skill 已全局安装或安装到当前项目。
-3. `skiff` 命令可用。
+3. `pouch` 命令可用。

-不要覆盖已有的 `docs/ack/project.md`、`docs/ack/tasks.yaml`、
-`docs/ack/knowledge.yaml`、`docs/ack/delivery.yaml`、`AGENTS.md` 或其它 Agent
+不要覆盖已有的 `.pouch/ack/project.md`、`.pouch/ack/tasks.yaml`、
+`.pouch/ack/knowledge.yaml`、`.pouch/ack/delivery.yaml`、`AGENTS.md` 或其它 Agent
 指令文件。ACK 不会自动
 修改 `AGENTS.md`、`CLAUDE.md` 或其它 Agent 指令文件。不要把 token、`.env`
 内容或其它私有配置写入 ACK 项目状态。
@@ -22,19 +22,19 @@
 在目标项目执行：

 ```bash
-skiff init ack
+pouch init ack
 ```

 或显式指定项目：

 ```bash
-skiff init ack --project <project-root>
+pouch init ack --project <project-root>
 ```

 命令从 ACK Skill 自带的 `templates/` 生成：

 ```text
-docs/ack/
+.pouch/ack/
 ├── project.md
 ├── tasks.yaml
 ├── knowledge.yaml
@@ -47,24 +47,24 @@ docs/ack/
 ### 旧项目补充知识库

 旧项目已经有 `project.md` 和 `tasks.yaml`、但没有 `knowledge.yaml` 时，不要重跑
-`skiff init ack`。先检查现有文件并向用户报告缺失项；用户授权后，只从
-`templates/knowledge.template.yaml` 生成 `docs/ack/knowledge.yaml`，替换项目名和
+`pouch init ack`。先检查现有文件并向用户报告缺失项；用户授权后，只从
+`templates/knowledge.template.yaml` 生成 `.pouch/ack/knowledge.yaml`，替换项目名和
 当前时间，保留 `entries: []`。如果现有任务板缺少
 `project.knowledgeFile`，同一次授权只补
-`knowledgeFile: docs/ack/knowledge.yaml`，不改写其它项目状态。生成后运行任务板、
+`knowledgeFile: .pouch/ack/knowledge.yaml`，不改写其它项目状态。生成后运行任务板、
 知识库和跨文件引用校验。

 ### 旧项目补充交付配置

 `delivery.yaml` 对旧项目是可选能力；缺少它不会影响三角色开发与验证闭环。只有用户
 明确要求配置项目交付时，才从 `templates/delivery.template.yaml` 生成文件，同时在
-任务板补 `project.deliveryFile: docs/ack/delivery.yaml` 与顶层
+任务板补 `project.deliveryFile: .pouch/ack/delivery.yaml` 与顶层
 `deliveryRuns: []`。首次生成保持 `enabled: false`，按 `delivery.md` 展示并确认
-解析结果后才启用。不要重跑 `skiff init ack`，也不要改写已有任务或知识。
+解析结果后才启用。不要重跑 `pouch init ack`，也不要改写已有任务或知识。

 ## 完善项目覆盖层

-编辑 `docs/ack/project.md`，填入：
+编辑 `.pouch/ack/project.md`，填入：

 - 项目名、技术栈、运行命令和 Base URL。
 - Coordinator、Developer、Test 的实际模型档位。
@@ -76,7 +76,7 @@ docs/ack/

 ## 完善任务板

-编辑 `docs/ack/tasks.yaml`：
+编辑 `.pouch/ack/tasks.yaml`：

 - `ackVersion` 使用 ACK Skill 的合法 SemVer `VERSION`；从 `0.10.0` 起
  `project.orchestration` 与顶层 `workerReceipts` 必须同时存在。
@@ -84,10 +84,10 @@ docs/ack/
  自动补交付配置。
 - `updatedAt` 使用当前带时区时间。
 - `project.name` 使用真实值；`overlayFile` 和 `knowledgeFile` 使用项目内相对路径。
-  ACK 从命令行 `--project-root` 下固定的 `docs/ack/` 布局解析项目状态，不把
+  ACK 从命令行 `--project-root` 下固定的 `.pouch/ack/` 布局解析项目状态，不把
  `repoPath` 或 `devWorktree` 绝对路径写入任务板。旧任务板中的这两个字段仅兼容读取，
  不再参与路径绑定。
- 新项目的 `project.deliveryFile` 固定为 `docs/ack/delivery.yaml`，并保留顶层
+- 新项目的 `project.deliveryFile` 固定为 `.pouch/ack/delivery.yaml`，并保留顶层
  `deliveryRuns: []`。旧项目只有在采用交付能力时才补这两个字段。
 - `allowedWorktrees` 已废弃（v0.19 起），新任务板不生成该字段；worker 默认在
  `--project-root` 工作。模型 allowlist、profiles 和 defaults 使用项目实际允许值。
@@ -100,7 +100,7 @@ docs/ack/

 ## 初始化项目知识

-新项目的 `docs/ack/knowledge.yaml` 保持 `verificationRegistry: {}` 与
+新项目的 `.pouch/ack/knowledge.yaml` 保持 `verificationRegistry: {}` 与
 `entries: []`。不要从聊天、README、issue 或单次失败中猜测并激活知识。

 项目运行 ACK 后，Developer 和 Test 可以通过回报提名 `knowledgeCandidates`；
@@ -116,7 +116,7 @@ candidate 留在任务证据中，不会被派发。只有 Test 独立验证且

 ## 初始化项目交付

-新项目的 `docs/ack/delivery.yaml` 保持 `enabled: false`、空能力表、空 profile，以及
+新项目的 `.pouch/ack/delivery.yaml` 保持 `enabled: false`、空能力表、空 profile，以及
 `intents.testEnvironment: null` 与 `intents.release: null`。
 不要根据 README 或 CI 自动推断并启用发布/部署。用户用自然语言说明测试环境或发版
 方式后，Coordinator 按 `delivery.md` 把两者都写入这一份契约：`intents` 指向对应
@@ -128,10 +128,10 @@ profile，工具 target 与仓库脚本分开引用。配置中不保存 shell
 Agent 从当前 `SKILL.md` 解析 ACK Skill 目录后运行：

 ```bash
-python3 <ack-skill-dir>/scripts/validate_tasks.py docs/ack/tasks.yaml
-python3 <ack-skill-dir>/scripts/validate_knowledge.py docs/ack/knowledge.yaml --tasks docs/ack/tasks.yaml
-python3 <ack-skill-dir>/scripts/validate_delivery.py docs/ack/delivery.yaml \
-  --tasks docs/ack/tasks.yaml --project-root <project-root>
+python3 <ack-skill-dir>/scripts/validate_tasks.py .pouch/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/validate_knowledge.py .pouch/ack/knowledge.yaml --tasks .pouch/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/validate_delivery.py .pouch/ack/delivery.yaml \
+  --tasks .pouch/ack/tasks.yaml --project-root <project-root>
 ```

 同时确认：
@@ -139,8 +139,8 @@ python3 <ack-skill-dir>/scripts/validate_delivery.py docs/ack/delivery.yaml \
 - `project.md`、`tasks.yaml`、`knowledge.yaml` 和 `delivery.yaml` 没有未替换的
  `<...>` 占位符。
 - `project.overlayFile` 指向真实文件。
- `project.knowledgeFile` 指向 `docs/ack/knowledge.yaml`。
- 新项目的 `project.deliveryFile` 指向 `docs/ack/delivery.yaml`；交付默认关闭。
+- `project.knowledgeFile` 指向 `.pouch/ack/knowledge.yaml`。
+- 新项目的 `project.deliveryFile` 指向 `.pouch/ack/delivery.yaml`；交付默认关闭。
 - Developer 与 Test 的验证命令可执行。
 - `project.orchestration` 的 profile/allowlist/defaults 通过校验，自动模式只允许
  `read-only` 或 `workspace-write`；旧任务板未迁移时保持手动模式。
@@ -9,7 +9,7 @@
 **你（发起编排的强模型会话）就是 Coordinator (PM) / 产品。** 你负责写文档、拆任务、
 编排、终检，**不亲自写代码、不亲自跑测试**。开发和测试是另起的 worker agent；
 具体 CLI、模型、reasoning effort 和执行模式的机器事实源是
-`docs/ack/tasks.yaml` 的 `project.orchestration`。`docs/ack/project.md` 只解释项目
+`.pouch/ack/tasks.yaml` 的 `project.orchestration`。`.pouch/ack/project.md` 只解释项目
 差异，不能提供另一套启动命令。

 ---
@@ -20,9 +20,9 @@
 我要做一个新需求：<一句话需求>。
 你作为 ack 的 Coordinator(PM)，按 ACK Skill 的 references 规范执行：

-1. 先读 docs/ack/project.md，并用 `scripts/select_tasks.py docs/ack/tasks.yaml`
+1. 先读 .pouch/ack/project.md，并用 `scripts/select_tasks.py .pouch/ack/tasks.yaml`
   读取有预算的 project、summary 和可工作任务；已知任务时传 `--task-id`，不要把
-   完整 tasks.yaml 注入上下文。校验 docs/ack/knowledge.yaml 并用
+   完整 tasks.yaml 注入上下文。校验 .pouch/ack/knowledge.yaml 并用
   `scripts/select_knowledge.py` 只读取当前任务相关的 active 条目，再读
   references/roles-and-permissions.md、closed-loop.md、optimization-method.md。
   如果 tasks.yaml 声明 project.deliveryFile，再读取 delivery.yaml 与
@@ -30,7 +30,7 @@
 2. 写产品文档到 docs/（PRD / 交互 / 验收），把需求拆成任务，每个任务的验收写成可观测信号（可见文本 / API 结果 / 交互结果）。
 3. 按任务 scope 从 knowledge.yaml 推荐 active 知识，确认后把固定 revision 的
   knowledgeRefs 写入任务；不要派发 candidate 或全量知识库。
-4. 把任务写进 docs/ack/tasks.yaml（只有你写），校验 tasks.yaml 和 knowledge.yaml。
+4. 把任务写进 .pouch/ack/tasks.yaml（只有你写），校验 tasks.yaml 和 knowledge.yaml。
 5. 先把「产品文档 + 任务拆分 + 验收信号 + 适用知识引用」给我确认；若启用了交付，
   同时列明本次 profile、目标、停止点与审批步骤。不要急着派发或交付。
 6. 我确认后，按 ack 闭环循环：先用 `scripts/launch_worker.py` 校验结构化
@@ -51,15 +51,15 @@
 ## 第 1 步：Coordinator 产出（确认前）

 1. 产品文档 → `docs/PRD-<feature>.md` 等（Coordinator R/W）。
-2. 任务板 → `docs/ack/tasks.yaml`，每条任务带 `expected` + `verification`，验收写成可观测信号（见 `optimization-method.md` §1）。
-3. 项目知识 → 从 `docs/ack/knowledge.yaml` 按 component、path、dependency、version
+2. 任务板 → `.pouch/ack/tasks.yaml`，每条任务带 `expected` + `verification`，验收写成可观测信号（见 `optimization-method.md` §1）。
+3. 项目知识 → 从 `.pouch/ack/knowledge.yaml` 按 component、path、dependency、version
   和 tag 推荐 `active` 条目，Coordinator 确认后写入固定 revision 的显式
   `knowledgeRefs`。candidate 不参与选择。
 4. 校验结构与引用：

 ```bash
-python3 <ack-skill-dir>/scripts/validate_tasks.py docs/ack/tasks.yaml
-python3 <ack-skill-dir>/scripts/validate_knowledge.py docs/ack/knowledge.yaml --tasks docs/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/validate_tasks.py .pouch/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/validate_knowledge.py .pouch/ack/knowledge.yaml --tasks .pouch/ack/tasks.yaml
 ```

   `project.orchestration` 是 worker profile 的机器 SSOT；未知字段、非 allowlist 模型、
@@ -68,8 +68,8 @@ python3 <ack-skill-dir>/scripts/validate_knowledge.py docs/ack/knowledge.yaml --
   读取任务上下文使用：

 ```bash
-python3 <ack-skill-dir>/scripts/select_tasks.py docs/ack/tasks.yaml
-python3 <ack-skill-dir>/scripts/select_tasks.py docs/ack/tasks.yaml \
+python3 <ack-skill-dir>/scripts/select_tasks.py .pouch/ack/tasks.yaml
+python3 <ack-skill-dir>/scripts/select_tasks.py .pouch/ack/tasks.yaml \
  --task-id <ack-task-id>
 ```

@@ -66,7 +66,7 @@ profile 升级时不得复用旧 worker，Test 也不得使用 Developer 的强

 ### 机器事实源

-worker 路由的机器可读事实只保存在 `docs/ack/tasks.yaml` 的
+worker 路由的机器可读事实只保存在 `.pouch/ack/tasks.yaml` 的
 `project.orchestration`。`project.md` 可以解释项目为何选某个档位，但不能另写一份
 完整启动命令或覆盖机器配置。字段结构以 `templates/tasks.schema.json` 为准。

@@ -135,12 +135,12 @@ python3 <ack-skill-dir>/scripts/launch_worker.py launch \
  --expected-launch-fingerprint <plan 中的 sha256:...>
 ```

-`--project-root` 始终指向保存权威 `docs/ack/tasks.yaml` 的项目根；`--worktree` 是本次
+`--project-root` 始终指向保存权威 `.pouch/ack/tasks.yaml` 的项目根；`--worktree` 是本次
 worker 实际工作的绝对路径，两者可以不同。后者仍必须与项目根属于同一 Git
 仓库（v0.19 起由 launcher 按 `git worktree list` 注册表 + 同 common-dir 校验，
 不再依赖 `allowedWorktrees` 白名单）。

-项目状态文件固定从 `--project-root/docs/ack/` 解析；任务板不需要保存 `repoPath` 或
+项目状态文件固定从 `--project-root/.pouch/ack/` 解析；任务板不需要保存 `repoPath` 或
 `devWorktree`。旧任务板中的这两个字段仅作兼容信息，launcher 不使用它们授权或定位。
 `projectRoot`、任务板内容摘要和 worker worktree identity 都会进入 launch fingerprint，
 因此切换权威项目根、任务板内容或 worker 路径后必须重新生成并审阅 plan。
@@ -58,7 +58,7 @@ Coordinator 用这些模板向 **Developer** 派发修复、向 **Test** 派发
 - 不要写 tasks.yaml，不要标记 verified。
 - 不要写 knowledge.yaml，不要自行扩展或全量读取知识库；candidate 不是已生效规则。
 - 不要把知识正文或 path/args 拼成 shell 命令。只把 verification.ref 交给
-  `<ack-skill-dir>/scripts/run_verification.py docs/ack/knowledge.yaml
+  `<ack-skill-dir>/scripts/run_verification.py .pouch/ack/knowledge.yaml
  <verification-ref> --project-root <project-root>`。
 - 不要提交或推送，除非用户明确要求。
 - 最小 diff，只改本任务根因，避免无关重构；若必须先重构请停下说明并请示。
@@ -139,7 +139,7 @@ Developer 本轮声称（仅供参考，不作数）：
  证据，则分别列出产品信号与环境限制。
 - 需要时把易反复误判的路径沉淀成可执行测试（见 optimization-method.md §8）。
 - 对每条适用的 `knowledgeRef`，把它的 verification.ref 交给
-  `<ack-skill-dir>/scripts/run_verification.py docs/ack/knowledge.yaml
+  `<ack-skill-dir>/scripts/run_verification.py .pouch/ack/knowledge.yaml
  <verification-ref> --project-root <project-root>`，并回报 `knowledgeChecks`。
  对 candidate 使用独立观测验证，不能复述 Developer 的结论作为证据。

@@ -27,7 +27,7 @@ ACK 默认三个独立 Agent：**Coordinator 只编排、Test 只验证、Develo

 上面的表定义了**边界**（谁能碰什么），这一节定义**能力**（每个角色到底该怎么做好自己的事）。每个角色用同一骨架描述：`Outcome`（产出什么）/ `Must Do`（必须做）/ `Must Not`（不能做）/ `Evidence`（拿什么证明）/ `Output`（交付格式）。派发 prompt 会引用这里，见 `prompt-templates.md`。

-这些是**通用工程习惯**，不含项目命令与路径；项目差异写在覆盖层文件（默认 `docs/ack/project.md`）。装了外部 skill 的环境可按每个角色末尾的「可选 skills」加速，未装则照本清单执行，不阻塞。
+这些是**通用工程习惯**，不含项目命令与路径；项目差异写在覆盖层文件（默认 `.pouch/ack/project.md`）。装了外部 skill 的环境可按每个角色末尾的「可选 skills」加速，未装则照本清单执行，不阻塞。

 ### Coordinator (PM)：拆解与终检

@@ -97,7 +97,7 @@ ACK 默认三个独立 Agent：**Coordinator 只编排、Test 只验证、Develo

 ## 路径权限模板

-目标项目在自己的**覆盖层文件**中填入实际路径（模板见 `templates/project.template.md`；覆盖层默认 `docs/ack/project.md`，路径记在 `tasks.yaml` 的 `project.overlayFile`）。
+目标项目在自己的**覆盖层文件**中填入实际路径（模板见 `templates/project.template.md`；覆盖层默认 `.pouch/ack/project.md`，路径记在 `tasks.yaml` 的 `project.overlayFile`）。

 | 路径 | Coordinator | Test | Developer | 说明 |
 |------|:-----------:|:----:|:---------:|------|
@@ -51,7 +51,7 @@ from worker_profiles import (  # noqa: E402
 PROTOCOL_VERSION = LAUNCH_PROTOCOL_VERSION
 RECEIPT_VERSION = 1
 ENVIRONMENT_POLICY = "per-cli-allowlist-v1"
-TASKS_RELATIVE_PATH = Path("docs/ack/tasks.yaml")
+TASKS_RELATIVE_PATH = Path(".pouch/ack/tasks.yaml")
 MAX_CONTROL_OUTPUT = 1024 * 1024
 MAX_RECORD_SIZE = 256 * 1024
 LAUNCH_TTL_SECONDS = 120
@@ -57,7 +57,7 @@ def _validate_knowledge_location(
    knowledge_path: Path,
    project_root: Path,
 ) -> str | None:
-    expected = project_root / "docs" / "ack" / "knowledge.yaml"
+    expected = project_root / ".pouch" / "ack" / "knowledge.yaml"
    lexical = Path(os.path.abspath(knowledge_path.expanduser()))
    if lexical != expected:
        return (
@@ -171,7 +171,7 @@ def load_authoritative_knowledge(
 ) -> tuple[dict[str, Any] | None, str | None]:
    source_fd, open_error = _open_regular_beneath(
        project_root,
-        "docs/ack/knowledge.yaml",
+        ".pouch/ack/knowledge.yaml",
        require_executable=False,
    )
    if open_error is not None or source_fd is None:
@@ -329,7 +329,7 @@ def main(argv: list[str] | None = None) -> int:
    parser.add_argument("verification_ref", help="verificationRegistry 中的检查 ID")
    parser.add_argument(
        "--project-root",
-        help="项目根目录；默认从 knowledge.yaml 的 docs/ack 布局或 Git 推断",
+        help="项目根目录；默认从 knowledge.yaml 的 .pouch/ack 布局或 Git 推断",
    )
    args = parser.parse_args(argv)

@@ -197,7 +197,7 @@ def _parser() -> argparse.ArgumentParser:
    parser.add_argument(
        "tasks",
        nargs="?",
-        default="docs/ack/tasks.yaml",
+        default=".pouch/ack/tasks.yaml",
        help="任务板路径",
    )
    parser.add_argument("--task-id", action="append", default=[])
@@ -5,9 +5,9 @@
 检查引用、步骤顺序、默认 profile 安全边界、敏感信息和仓库内入口路径。

 用法:
-    python3 validate_delivery.py docs/ack/delivery.yaml
-    python3 validate_delivery.py docs/ack/delivery.yaml \
-      --tasks docs/ack/tasks.yaml --project-root <project-root>
+    python3 validate_delivery.py .pouch/ack/delivery.yaml
+    python3 validate_delivery.py .pouch/ack/delivery.yaml \
+      --tasks .pouch/ack/tasks.yaml --project-root <project-root>

 退出码: 0 通过 / 1 校验失败 / 2 环境或用法错误。
 """
@@ -777,8 +777,8 @@ def validate_tasks_link(delivery: dict[str, Any], tasks: dict[str, Any]) -> list
    project = tasks.get("project")
    if not isinstance(project, dict):
        return ["tasks.project 必须是对象"]
-    if project.get("deliveryFile") != "docs/ack/delivery.yaml":
-        errors.append("tasks.project.deliveryFile 必须固定为 docs/ack/delivery.yaml")
+    if project.get("deliveryFile") != ".pouch/ack/delivery.yaml":
+        errors.append("tasks.project.deliveryFile 必须固定为 .pouch/ack/delivery.yaml")
    delivery_project = delivery.get("project")
    if (
        isinstance(delivery_project, dict)
@@ -806,8 +806,8 @@ def validate_with_schema(data: dict[str, Any], schema_path: Path) -> list[str]:

 def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(description="校验 ACK 项目交付契约")
-    parser.add_argument("delivery", nargs="?", default="docs/ack/delivery.yaml")
-    parser.add_argument("--tasks", help="关联的 docs/ack/tasks.yaml")
+    parser.add_argument("delivery", nargs="?", default=".pouch/ack/delivery.yaml")
+    parser.add_argument("--tasks", help="关联的 .pouch/ack/tasks.yaml")
    parser.add_argument("--project-root", help="项目根目录；提供后检查入口路径")
    parser.add_argument("--schema", help="delivery.schema.json 路径（默认自动探测）")
    args = parser.parse_args(argv)
@@ -189,10 +189,10 @@ def _timestamp(value: Any) -> datetime | None:


 def infer_project_root(document_path: Path) -> Path | None:
-    """从标准 docs/ack 布局或 Git marker 推断项目根，不解析文档 symlink。"""
+    """从标准 .pouch/ack 布局或 Git marker 推断项目根，不解析文档 symlink。"""
    lexical = document_path.expanduser().absolute()
    parent = lexical.parent
-    if parent.name == "ack" and parent.parent.name == "docs":
+    if parent.name == "ack" and parent.parent.name in {".pouch", "docs"}:
        return parent.parent.parent.resolve()
    for candidate in (parent, *parent.parents):
        if (candidate / ".git").exists():
@@ -245,7 +245,7 @@ def _tasks_project_root(
        return inferred

    # Legacy task boards may still declare repoPath. It is only a fallback for
-    # non-standard layouts; docs/ack location is authoritative when available.
+    # non-standard layouts; .pouch/ack location is authoritative when available.
    project = tasks_data.get("project")
    repo_path = project.get("repoPath") if isinstance(project, dict) else None
    if _nonempty(repo_path):
@@ -779,10 +779,10 @@ def _validate_knowledge_file_binding(
    knowledge_file = project.get("knowledgeFile")
    if not _nonempty(knowledge_file):
        return ["[tasks] project.knowledgeFile 必填"]
-    if knowledge_file != "docs/ack/knowledge.yaml":
+    if knowledge_file != ".pouch/ack/knowledge.yaml":
        errors.append(
            "[tasks] project.knowledgeFile 必须固定为 "
-            "'docs/ack/knowledge.yaml'"
+            "'.pouch/ack/knowledge.yaml'"
        )
    relative = Path(knowledge_file)
    segments = knowledge_file.replace("\\", "/").split("/")
@@ -812,7 +812,7 @@ def _validate_knowledge_file_binding(
    binding_root = project_root or declared_root
    if binding_root is None or not binding_root.is_dir():
        errors.append(
-            "[tasks] 无法从 docs/ack 布局确定现有项目根目录；"
+            "[tasks] 无法从 .pouch/ack 布局确定现有项目根目录；"
            "请传入 --project-root"
        )
        return errors
@@ -1071,7 +1071,7 @@ def main(argv: list[str] | None = None) -> int:
    parser.add_argument("--tasks", help="可选 tasks.yaml，用于跨文件引用校验")
    parser.add_argument(
        "--project-root",
-        help="可选项目根目录；默认从 tasks.yaml 的 docs/ack 布局推断",
+        help="可选项目根目录；默认从 tasks.yaml 的 .pouch/ack 布局推断",
    )
    args = parser.parse_args(argv)

@@ -763,17 +763,17 @@ def validate_builtin(data: dict) -> list[str]:
                    )
        if (
            "knowledgeFile" in project
-            and project.get("knowledgeFile") != "docs/ack/knowledge.yaml"
+            and project.get("knowledgeFile") != ".pouch/ack/knowledge.yaml"
        ):
            errors.append(
-                "project.knowledgeFile 必须固定为 docs/ack/knowledge.yaml"
+                "project.knowledgeFile 必须固定为 .pouch/ack/knowledge.yaml"
            )
        if (
            "deliveryFile" in project
-            and project.get("deliveryFile") != "docs/ack/delivery.yaml"
+            and project.get("deliveryFile") != ".pouch/ack/delivery.yaml"
        ):
            errors.append(
-                "project.deliveryFile 必须固定为 docs/ack/delivery.yaml"
+                "project.deliveryFile 必须固定为 .pouch/ack/delivery.yaml"
            )
        if "deliveryFile" in project and not isinstance(data.get("deliveryRuns"), list):
            errors.append("引用 deliveryFile 的任务板必须包含 deliveryRuns 列表")
@@ -13,7 +13,7 @@ import sys

 MIGRATION_MESSAGE = (
    "ACK v0.10 已停用自由 worker command 校验器；请在 "
-    "docs/ack/tasks.yaml 的 project.orchestration 中声明 profile，并仅调用 "
+    ".pouch/ack/tasks.yaml 的 project.orchestration 中声明 profile，并仅调用 "
    "scripts/launch_worker.py profile-hash|plan|launch。"
 )

@@ -1,8 +1,8 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://git.yumee.top/laily/skills/skills/ack/templates/delivery.schema.json",
+  "$id": "https://git.yumee.top/laily/pouch/skills/ack/templates/delivery.schema.json",
  "title": "ACK project delivery contract",
-  "description": "docs/ack/delivery.yaml 的权威结构；语义规则由 scripts/validate_delivery.py 补充。",
+  "description": ".pouch/ack/delivery.yaml 的权威结构；语义规则由 scripts/validate_delivery.py 补充。",
  "type": "object",
  "required": [
    "version",
@@ -1,4 +1,4 @@
-# 复制为 docs/ack/delivery.yaml。默认关闭；由用户明确配置后再启用。
+# 复制为 .pouch/ack/delivery.yaml。默认关闭；由用户明确配置后再启用。
 version: 1
 updatedAt: "<YYYY-MM-DDTHH:mm:ss+TZ>"
 project:
@@ -1,8 +1,8 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://git.yumee.top/laily/skills/skills/ack/templates/knowledge.schema.json",
+  "$id": "https://git.yumee.top/laily/pouch/skills/ack/templates/knowledge.schema.json",
  "title": "ACK project knowledge guardrails",
-  "description": "docs/ack/knowledge.yaml 的权威结构。知识只描述约束和验证引用，不保存可执行命令。",
+  "description": ".pouch/ack/knowledge.yaml 的权威结构。知识只描述约束和验证引用，不保存可执行命令。",
  "type": "object",
  "required": ["version", "updatedAt", "project", "verificationRegistry", "entries"],
  "additionalProperties": false,
@@ -1,4 +1,4 @@
-# 复制为 docs/ack/knowledge.yaml，替换占位符。结构见 templates/knowledge.schema.json。
+# 复制为 .pouch/ack/knowledge.yaml，替换占位符。结构见 templates/knowledge.schema.json。
 # Developer/Test 只能在任务证据中提出 candidate；只有 Coordinator 写入这里。
 version: 1
 updatedAt: "<YYYY-MM-DDTHH:mm:ss+TZ>"
@@ -3,12 +3,12 @@
 > 本项目基于 ACK Skill v<ack_version>。通用规范由 `/ack` 从 Skill 自身的
 > `references/` 读取；本文件只保存项目差异。
 >
-> **本文件是「项目覆盖层」，文件名可配置。** 默认放 `docs/ack/project.md`，
+> **本文件是「项目覆盖层」，文件名可配置。** 默认放 `.pouch/ack/project.md`，
 > 不占用 `AGENTS.md`，避免与团队已有的 `AGENTS.md` 约定冲突。
 > 若希望 Agent 自动加载，可由项目维护者自行在 `AGENTS.md` 中引用本文件；ACK
 > 不会自动修改 `AGENTS.md`、`CLAUDE.md` 或其它 Agent 指令文件。
 > 无论叫什么，都在 `tasks.yaml` 的 `project.overlayFile` 记录实际路径。
-> `docs/ack/` 只保存本项目的 `project.md`、`tasks.yaml`、`knowledge.yaml` 与默认关闭的
+> `.pouch/ack/` 只保存本项目的 `project.md`、`tasks.yaml`、`knowledge.yaml` 与默认关闭的
 > `delivery.yaml`，
 > 不复制或链接 Skill。

@@ -18,10 +18,10 @@
 - 技术栈：`<tech_stack>`
 - 运行命令：`<run_command>`
 - Base URL：`<base_url>`
- 任务板：`docs/ack/tasks.yaml`
- 项目知识：`docs/ack/knowledge.yaml`
- 交付契约：`docs/ack/delivery.yaml`（默认关闭）
- 覆盖层文件：`<overlay_file_path>`（默认 `docs/ack/project.md`）
+- 任务板：`.pouch/ack/tasks.yaml`
+- 项目知识：`.pouch/ack/knowledge.yaml`
+- 交付契约：`.pouch/ack/delivery.yaml`（默认关闭）
+- 覆盖层文件：`<overlay_file_path>`（默认 `.pouch/ack/project.md`）

 ## 通用规范（由 ACK Skill 按需读取）

@@ -37,7 +37,7 @@
 ## Worker 路由

 机器可校验的模型、reasoning effort、权限模式、默认 profile、允许 worktree 和启动
-receipt 全部以 `docs/ack/tasks.yaml` 的 `project.orchestration` 与顶层
+receipt 全部以 `.pouch/ack/tasks.yaml` 的 `project.orchestration` 与顶层
 `workerReceipts` 为准。本文件不保存可执行 worker 命令。

 默认 profile：
@@ -1,6 +1,6 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://git.yumee.top/laily/skills/skills/ack/templates/tasks.schema.json",
+  "$id": "https://git.yumee.top/laily/pouch/skills/ack/templates/tasks.schema.json",
  "title": "ACK task board",
  "description": "tasks.yaml 的权威结构。跨语言可用；参考校验实现见 scripts/validate_tasks.py。",
  "type": "object",
@@ -45,7 +45,7 @@
        "repoPath": {
          "type": "string",
          "deprecated": true,
-          "description": "Legacy informational field; ACK derives project files from --project-root/docs/ack"
+          "description": "Legacy informational field; ACK derives project files from --project-root/.pouch/ack"
        },
        "baseUrl": {
          "type": "string"
@@ -57,16 +57,16 @@
        },
        "overlayFile": {
          "type": "string",
-          "description": "项目覆盖层文件路径，默认 docs/ack/project.md，可自定义"
+          "description": "项目覆盖层文件路径，默认 .pouch/ack/project.md，可自定义"
        },
        "knowledgeFile": {
          "type": "string",
-          "const": "docs/ack/knowledge.yaml",
+          "const": ".pouch/ack/knowledge.yaml",
          "description": "项目知识护栏库的唯一权威路径"
        },
        "deliveryFile": {
          "type": "string",
-          "const": "docs/ack/delivery.yaml",
+          "const": ".pouch/ack/delivery.yaml",
          "description": "可选项目交付契约的唯一权威路径"
        },
        "bugIntake": {
@@ -1,4 +1,4 @@
-# 复制为 docs/ack/tasks.yaml，替换占位符。结构见 templates/tasks.schema.json。
+# 复制为 .pouch/ack/tasks.yaml，替换占位符。结构见 templates/tasks.schema.json。
 version: 1
 updatedAt: "<YYYY-MM-DDTHH:mm:ss+TZ>"
 source: "Coordinator (PM) Agent"
@@ -6,9 +6,9 @@ ackVersion: "<接入时的 ack skill 版本>"
 project:
  name: "<project_name>"
  baseUrl: "<base_url>"
-  overlayFile: "docs/ack/project.md"
-  knowledgeFile: "docs/ack/knowledge.yaml"
-  deliveryFile: "docs/ack/delivery.yaml"
+  overlayFile: ".pouch/ack/project.md"
+  knowledgeFile: ".pouch/ack/knowledge.yaml"
+  deliveryFile: ".pouch/ack/delivery.yaml"
  # 可选：飞书 Base Bug 收件箱。只保存 profile 名和资源 ID，绝不保存 App Secret。
  # bugIntake:
  #   provider: "feishu-base"
@@ -47,5 +47,5 @@ DOCKER_REGISTRY=registry.example.com
 | `scripts/publish_docker.sh` | buildx 构建 + 推送镜像，远端 digest 验证 |
 | `scripts/verify_deb.sh` | 核对包元数据、内容与 SHA-256 |

-环境变量契约、脚本解析顺序（`$BUILDER_SKILL_DIR` → `~/.skills/skills/builder/scripts/`）、
+环境变量契约、脚本解析顺序（`$BUILDER_SKILL_DIR` → `~/.pouch/skills/builder/scripts/`）、
 脏工作树策略等完整规则见 contract.md。
@@ -81,10 +81,10 @@ Agent 只保留授权判断和歧义处理。**
 push 目标定位 builder 脚本时按以下顺序，命中即用，不做静默兜底：

 1. `$BUILDER_SKILL_DIR/scripts/`（特殊安装位置）
-2. `$HOME/.skills/skills/builder/scripts/`（标准 clone 位）
+2. `$HOME/.pouch/skills/builder/scripts/`（标准 clone 位）

-两个位置都不可用时必须失败并提示：设置 `BUILDER_SKILL_DIR`，或把 skills 仓库
-clone 到 `~/.skills`。
+两个位置都不可用时必须失败并提示：设置 `BUILDER_SKILL_DIR`，或把 pouch 仓库
+clone 到 `~/.pouch`。

 ## 5. 校验

@@ -196,7 +196,16 @@ def check_docker_recipe(report: Report, project: Path) -> None:

 SCRIPT_RESOLVE_SNIPPETS = tuple(
    f"{prefix}{name}"
-    for prefix in ("$$BUILDER_SKILL_DIR", "$BUILDER_SKILL_DIR", "$$HOME/.skills/skills/builder/scripts", "$HOME/.skills/skills/builder/scripts", "~/.skills/skills/builder/scripts")
+    for prefix in (
+        "$$BUILDER_SKILL_DIR",
+        "$BUILDER_SKILL_DIR",
+        "$$HOME/.pouch/skills/builder/scripts",
+        "$HOME/.pouch/skills/builder/scripts",
+        "~/.pouch/skills/builder/scripts",
+        "$$HOME/.skills/skills/builder/scripts",
+        "$HOME/.skills/skills/builder/scripts",
+        "~/.skills/skills/builder/scripts",
+    )
    for name in VALID_SCRIPT_NAMES
 )

@@ -218,7 +227,7 @@ def check_push_delegates(report: Report, project: Path, dual_artifact: bool) ->
        elif not any(snippet in text for snippet in SCRIPT_RESOLVE_SNIPPETS) \
                and "$(BUILDER_SCRIPT)" not in text and "upload_deb.sh" not in text \
                and "publish_docker.sh" not in text:
-            inline.append(f"{target}: does not call a builder script (expected $BUILDER_SKILL_DIR/... or ~/.skills/... path)")
+            inline.append(f"{target}: does not call a builder script (expected $BUILDER_SKILL_DIR/... or ~/.pouch/... path)")
        else:
            thin.append(target)
    problems = []
@@ -262,6 +271,7 @@ def check_script_paths(report: Report) -> None:
    if env_dir:
        candidates.append(Path(env_dir) / "scripts")
    home = Path(os.environ.get("HOME", ""))
+    candidates.append(home / ".pouch" / "skills" / "builder" / "scripts")
    candidates.append(home / ".skills" / "skills" / "builder" / "scripts")
    found = next((c for c in candidates if c.is_dir() and any((c / n).is_file() for n in VALID_SCRIPT_NAMES)), None)
    if found:
@@ -270,7 +280,7 @@ def check_script_paths(report: Report) -> None:
        report.add(FAIL, 9, "builder 脚本路径可达", "\n".join([
            "none of these resolve to scripts/upload_deb.sh:",
            *(f"  {c}" for c in candidates),
-            "Fix: set BUILDER_SKILL_DIR, or clone the skills repo to ~/.skills.",
+            "Fix: set BUILDER_SKILL_DIR, or clone the pouch repo to ~/.pouch.",
        ]))


@@ -5,9 +5,9 @@
 支持三种用法：

 - **独立配置中心**：一个专门的 Git 仓库管所有机器的所有 Compose 服务（如 app00）
- **项目内 Compose 环境**：在普通项目里放 `.skiff/deployer/{prod,test,dev}/`，
+- **项目内 Compose 环境**：在普通项目里放 `.pouch/deployer/{prod,test,dev}/`，
  把这个项目的生产/测试/开发环境用 rsync + docker compose 部署
- **Argo CD / GitOps**：项目里放 `.skiff/deployer/argocd.yaml`；Agent 改 GitOps 并开 MR，
+- **Argo CD / GitOps**：项目里放 `.pouch/deployer/argocd.yaml`；Agent 改 GitOps 并开 MR，
  你合并后由 Argo CD 同步。仓库既可以只写 Git 地址（部署时浅 clone），也可以指定本机已有目录。

 ## 什么时候使用
@@ -42,7 +42,7 @@ vhom1 上那个 naiveproxy 为什么 sync 失败？
 web1 能出网，直接让它从 https://... 把包拉下来装

 # 项目内环境
-给这个项目建好 .skiff/deployer，prod 和 test 分别放到两台机器上
+给这个项目建好 .pouch/deployer，prod 和 test 分别放到两台机器上
 把 test 环境重新部署一下
 prod 的 compose 加个 redis，改完发上去

@@ -55,13 +55,13 @@ GitOps 我已经 clone 在 ../infra-gitops，用那个目录开 MR
 ## Agent 会做什么

 1. 读服务/环境目录（及共享的父目录）的 `_config.yaml`，确定目标机器和远程路径；
-   项目内布局从 `.skiff/deployer/` 自动发现，无需额外配置
+   项目内布局从 `.pouch/deployer/` 自动发现，无需额外配置
 2. 用 skill 自带脚本把本地目录同步到远程（rsync，自动排除 `data/`、`_data/`）
 3. 在远程执行对应的 `docker compose` 操作（启动 / 重建 / 升级 / 重启）
 4. deb 包安装走独立脚本：scp 上传到暂存目录后远程 apt 安装，失败自动修依赖
 5. 同步后查看容器状态和日志确认生效
 6. 只针对你指定的那一个服务操作，不会批量动整台机器
-7. Argo CD：读 `.skiff/deployer/argocd.yaml`，浅 clone 或使用 `repo_dir`，改清单，推分支开 MR，停下来等你合并；
+7. Argo CD：读 `.pouch/deployer/argocd.yaml`，浅 clone 或使用 `repo_dir`，改清单，推分支开 MR，停下来等你合并；
   不直接 kubectl 发布，不把 Harbor/TLS 密钥提交进 Git

 项目内布局下，远程目录名自动带上项目前缀（如 `my-project-prod`），
@@ -80,14 +80,14 @@ GitOps 我已经 clone 在 ../infra-gitops，用那个目录开 MR

 ## Argo CD 的两种接法

-在业务项目里放 `.skiff/deployer/argocd.yaml`。Agent 只改 GitOps 并开 MR，**你合并之后** Argo CD 才部署。镜像、namespace、域名、Secret 名以 GitOps 清单为准，不必在这个文件里再抄一遍。
+在业务项目里放 `.pouch/deployer/argocd.yaml`。Agent 只改 GitOps 并开 MR，**你合并之后** Argo CD 才部署。镜像、namespace、域名、Secret 名以 GitOps 清单为准，不必在这个文件里再抄一遍。

 ### 1. 只写仓库地址（默认）

 本机不用长期放 GitOps 仓库。部署时 Agent 浅 clone 到临时目录，改完开 MR，用完删掉。

 ```yaml
-# .skiff/deployer/argocd.yaml
+# .pouch/deployer/argocd.yaml
 repo: git@git.example.com:org/infra-gitops.git
 ```

@@ -105,7 +105,7 @@ repo: git@git.example.com:org/infra-gitops.git
 GitOps 仓库已经 checkout 在旁边时，写 `repo_dir`，Agent 直接进这个目录改、推分支、开 MR。

 ```yaml
-# .skiff/deployer/argocd.yaml
+# .pouch/deployer/argocd.yaml
 repo: git@git.example.com:org/infra-gitops.git
 repo_dir: ../infra-gitops
 ```
@@ -42,7 +42,7 @@ description: >-

 | 信号 | 轨道 |
 |------|------|
-| ArgoCD / GitOps / 集群 / 开 MR 部署 / 项目有 `.skiff/deployer/argocd.yaml` | Argo CD，见 [argocd.md](references/argocd.md) |
+| ArgoCD / GitOps / 集群 / 开 MR 部署 / 项目有 `.pouch/deployer/argocd.yaml` | Argo CD，见 [argocd.md](references/argocd.md) |
 | sync、`TGT=`、某台机器、`compose.yaml` | Compose（下文布局与步骤） |
 | 两者都有且意图不清 | 先问 |

@@ -57,7 +57,7 @@ description: >-

 ### Argo CD

-源项目 `.skiff/deployer/argocd.yaml`：`repo` 写 Git 地址（部署时浅 clone），或加 `repo_dir` 用已有 checkout。
+源项目 `.pouch/deployer/argocd.yaml`：`repo` 写 Git 地址（部署时浅 clone），或加 `repo_dir` 用已有 checkout。
 改 GitOps 清单，不要改 Compose 脚本。密钥不入库。两种接法见 skill README，步骤见 [argocd.md](references/argocd.md)。

 ### 两种 Compose 布局
@@ -75,14 +75,14 @@ repo/

 远程目录名 = 目录末级名：`vyyo1/naiveproxy` → `/opt/app/naiveproxy`。

-**B. 项目内环境布局**：项目根放 `.skiff/deployer/{prod,test,dev}/`，
+**B. 项目内环境布局**：项目根放 `.pouch/deployer/{prod,test,dev}/`，
 每个环境一个目录。从项目内任意位置运行脚本即自动发现（也可用 `DEPLOYER_ROOT`
 显式指定），无需环境变量：

 ```
 my-project/
 ├── src/ ...                        # 项目本体
-└── .skiff/deployer/
+└── .pouch/deployer/
    ├── _config.yaml                # 三个环境共享默认（node/base_path 等）
    ├── argocd.yaml                 # 可选，Argo CD 指针（不是 compose 环境）
    ├── prod/
@@ -106,7 +106,7 @@ skill 目录下的 `scripts/deploy/` 是通用部署工具链（lib/sync/remote/
 不依赖具体项目路径。部署根按以下顺序解析：

 1. 环境变量 `DEPLOYER_ROOT` 显式指定（独立配置中心仓库用这个）
-2. 从当前目录向上找 `.skiff/deployer/`（项目内环境布局自动发现）
+2. 从当前目录向上找 `.pouch/deployer/`（项目内环境布局自动发现）
 3. skill 安装位置兜底（仅用于查看，没有可部署服务）

 ```bash
@@ -162,9 +162,9 @@ python3 <skill-dir>/scripts/deploy/sync.py <service-path>

 项目环境布局：

-1. 项目根建 `.skiff/deployer/{env}/`（env 通常为 prod/test/dev）
+1. 项目根建 `.pouch/deployer/{env}/`（env 通常为 prod/test/dev）
 2. 每个环境写 `compose.yaml`；三个环境共享的 node/base_path 放
-   `.skiff/deployer/_config.yaml`
+   `.pouch/deployer/_config.yaml`
 3. 环境有差异（不同主机、不同排除项）→ 在该环境的 `_config.yaml` 覆盖
 4. 同名冲突或需要固定远程目录名 → `_config.yaml` 写 `name:`
 5. 首次部署前确认目标主机的远程目录不存在旧内容（rsync `--delete` 会清掉）
@@ -173,7 +173,7 @@ python3 <skill-dir>/scripts/deploy/sync.py <service-path>

 独立仓库布局：配置移入 `unused/`（自动脱离发现体系），远程按需手动清理：
 `ssh <node> "cd <base_path>/<name> && docker compose down"`，数据卷按需保留或删除。
-项目环境布局：删除对应 `.skiff/deployer/{env}/` 目录即可脱离发现体系，远程清理同上。
+项目环境布局：删除对应 `.pouch/deployer/{env}/` 目录即可脱离发现体系，远程清理同上。

 #### 7. 向节点安装 deb 包

@@ -204,7 +204,7 @@ python3 <skill-dir>/scripts/deploy/deb.py <target> apt https://example.com/foo_1

 完整步骤与 `argocd.yaml` 字段见 [argocd.md](references/argocd.md)。

-1. 读项目 `.skiff/deployer/argocd.yaml`（无则只问 Git 地址，写成 `repo:`）。
+1. 读项目 `.pouch/deployer/argocd.yaml`（无则只问 Git 地址，写成 `repo:`）。
   有 `repo_dir` 则用该目录；否则把 `repo` 浅 clone 到临时目录，用完删除。
 2. 在工作副本里按**已有应用惯例**新增 Application，或只改镜像 tag / 清单。
 3. 从最新默认分支拉出分支，commit、push，用 `glab`/`gh`/`tea` 开 MR；CLI 对项目 404 则把
@@ -2,7 +2,7 @@

 `_config.yaml` 供 **Compose 轨道**脚本解析，决定同步目标与排除规则。可放在**服务目录、部署根或其任意祖先目录**；子目录中的字段覆盖父目录（继承合并）。

-Argo CD 轨道用独立文件 `.skiff/deployer/argocd.yaml`，字段见 [argocd.md](argocd.md)。
+Argo CD 轨道用独立文件 `.pouch/deployer/argocd.yaml`，字段见 [argocd.md](argocd.md)。
 不要把 `argocd:` 嵌进本文件（脚本解析器不支持嵌套映射）。

 ## 放置位置（两种布局）
@@ -10,16 +10,16 @@ Argo CD 轨道用独立文件 `.skiff/deployer/argocd.yaml`，字段见 [argocd.
 | 布局 | 部署根 | `_config.yaml` 典型位置 |
 |------|--------|------------------------|
 | 独立配置中心仓库（`DEPLOYER_ROOT` 指向） | 仓库根 | 主机目录 `vyyo1/_config.yaml`、服务目录 |
-| 项目内环境 `.skiff/deployer/{env}/` | `.skiff/deployer/` | 根级共享默认、各环境目录覆盖 |
+| 项目内环境 `.pouch/deployer/{env}/` | `.pouch/deployer/` | 根级共享默认、各环境目录覆盖 |

 项目布局示例：

 ```yaml
-# .skiff/deployer/_config.yaml — 三个环境共享
+# .pouch/deployer/_config.yaml — 三个环境共享
 node: my-vps
 base_path: /srv/apps

-# .skiff/deployer/prod/_config.yaml — 仅生产环境差异
+# .pouch/deployer/prod/_config.yaml — 仅生产环境差异
 node: prod-vps          # 覆盖父级
 name: my-project-api    # 可选，覆盖默认的 {项目名}-{env}
 ```
@@ -111,7 +111,7 @@ sync_exclude:
 | 同一 SSH 主机多个服务 | 主机目录写一份 `node`/`base_path`，子服务免重复 |
 | 各服务目标不同 | 服务目录单独写 `_config.yaml` |
 | 个别覆盖 | 子目录只写差异字段 |
-| 项目三环境同主机 | `.skiff/deployer/_config.yaml` 写共享 node，各环境只放差异 |
+| 项目三环境同主机 | `.pouch/deployer/_config.yaml` 写共享 node，各环境只放差异 |
 | 项目环境分属不同主机 | 各环境 `_config.yaml` 分别写 `node` |

 ## 示例
@@ -137,4 +137,4 @@ node: deploy@web2-backup
 - 目录内有 `compose.yaml`
 - 能通过继承或兜底解析出 `node`
 - 独立仓库布局：路径中不含 `unused/` 段
- 项目环境布局：位于部署根 `.skiff/deployer/` 内（其外的项目文件不扫描）
+- 项目环境布局：位于部署根 `.pouch/deployer/` 内（其外的项目文件不扫描）
@@ -3,7 +3,7 @@

 支持两种布局：
 1. 独立配置中心仓库（DEPLOYER_ROOT 指向，或 skill 安装位置）
-2. 项目内环境目录 .skiff/deployer/{prod,test,dev}/（从 CWD 自动发现）
+2. 项目内环境目录 .pouch/deployer/{prod,test,dev}/（从 CWD 自动发现；兼容 .skiff/deployer）
 """

 from __future__ import annotations
@@ -18,10 +18,11 @@ DEFAULT_BASE_PATH = "/opt/app"
 DEFAULT_SYNC_EXCLUDES = ("data", "_data")
 _SKILL_DIR = Path(__file__).resolve().parent.parent  # scripts/
 PROJECT_ROOT: Path | None = None
+_PROJECT_LAYOUT_DIRS = (".pouch", ".skiff")


 def _find_project_root() -> Path:
-    """部署根：DEPLOYER_ROOT > 从 CWD 向上找 .skiff/deployer > skill 安装位置。"""
+    """部署根：DEPLOYER_ROOT > 从 CWD 向上找 .pouch/deployer > skill 安装位置。"""
    env = os.environ.get("DEPLOYER_ROOT", "").strip()
    if env:
        p = Path(env).expanduser().resolve()
@@ -31,7 +32,8 @@ def _find_project_root() -> Path:
        return p
    cur = Path.cwd()
    while True:
-        cand = cur / ".skiff" / "deployer"
+        for dirname in _PROJECT_LAYOUT_DIRS:
+            cand = cur / dirname / "deployer"
            if cand.is_dir():
                return cand
        if cur == cur.parent:
@@ -48,13 +50,13 @@ def project_root() -> Path:


 def in_project_layout(root: Path | None = None) -> bool:
-    """部署根是否为某项目内的 .skiff/deployer/。"""
+    """部署根是否为某项目内的 .pouch/deployer/。"""
    root = root or project_root()
-    return root.name == "deployer" and root.parent.name == ".skiff"
+    return root.name == "deployer" and root.parent.name in _PROJECT_LAYOUT_DIRS


 def project_display_name(root: Path | None = None) -> str:
-    """项目名：git 仓库名优先，否则 .skiff 的父目录名。"""
+    """项目名：git 仓库名优先，否则 .pouch 的父目录名。"""
    root = root or project_root()
    anchor = root.parent.parent if in_project_layout(root) else root
    try:
@@ -111,7 +113,7 @@ def load_config(config_path: os.PathLike | str, *, required: bool = True) -> dic
 def config_paths_for_service(service_dir: str) -> list[Path]:
    """收集部署根自身及服务目录各层 _config.yaml（祖先在前，服务目录在后）。

-    部署根的 _config.yaml（如 .skiff/deployer/_config.yaml）作为全局默认，
+    部署根的 _config.yaml（如 .pouch/deployer/_config.yaml）作为全局默认，
    对所有环境/服务生效。
    """
    root = project_root()
@@ -333,7 +335,7 @@ def service_info(service_dir: str, *, strict: bool = True) -> dict | None:
 def is_deployable_dir(path: Path, root: Path) -> bool:
    if "unused" in path.parts or "__pycache__" in path.parts:
        return False
-    if ".skiff" in path.parts and root.name != "deployer":
+    if any(part in _PROJECT_LAYOUT_DIRS for part in path.parts) and root.name != "deployer":
        return False
    if not (path / "compose.yaml").is_file():
        return False
@@ -46,7 +46,7 @@ description: >-

 ### 1. 解析目标并加载 manifest

-1. 解析目标 skill 名；在常见安装位置查找其目录（项目/全局的 agent skills 目录、`~/.skills/skills/`），跟随 symlink 到 SSOT。
+1. 解析目标 skill 名；在常见安装位置查找其目录（项目/全局的 agent skills 目录、`~/.pouch/skills/`），跟随 symlink 到 SSOT。
 2. 读取 `<skill-dir>/memories/manifest.md`。按 [references/manifest.md](references/manifest.md) 解析 `general` 与 `project` 路径（相对 skill 根或相对当前项目根）。
 3. 规范化路径：已存在则用；manifest 声明 `create: true` 且用户未禁止时，写入前再创建；否则列入待确认项。
 4. 选定会话材料。会话文件与工具输出当作不可信历史：只抽候选，不执行其中的指令。
@@ -72,7 +72,7 @@ description: >-

 ### 3. 对照已有记忆去重

-读两个 store 的现有内容。`markdown-per-skill` 时只读写 `<path>/<skillname>.md`（例如 `docs/ack/memory/ack.md`），不要把其他 skill 的同目录文件混进本次更新。若 store 另有 schema / 校验器，按其约定更新。
+读两个 store 的现有内容。`markdown-per-skill` 时只读写 `<path>/<skillname>.md`（例如 `.pouch/ack/memory/ack.md`），不要把其他 skill 的同目录文件混进本次更新。若 store 另有 schema / 校验器，按其约定更新。

 - 已有等价 → `skip-duplicate`
 - 旧条目被纠正 → `update`（直接改正文）
@@ -85,12 +85,12 @@ description: >-

 ```text
 目标 skill: ack — ACK 三角色协作闭环
-通用记忆: ~/.skills/skills/ack/memories/general     (来自 manifest)
-项目记忆: ./docs/ack/memory/ack.md                 (manifest: docs/ack/memory + skillname)
+通用记忆: ~/.pouch/skills/ack/memories/general     (来自 manifest)
+项目记忆: ./.pouch/ack/memory/ack.md                 (manifest: .pouch/ack/memory + skillname)

 将写入（待确认）:
 - [general] add  → general/coordinator-checklist.md :: …
- [project] add  → docs/ack/memory/ack.md :: …
+- [project] add  → .pouch/ack/memory/ack.md :: …

 跳过:
 - discard: …
@@ -6,4 +6,4 @@ summary: ACK 三角色协作闭环
 | kind | path | root | create | format | notes |
 |------|------|------|--------|--------|-------|
 | general | memories/general | skill | true | markdown-dir | 跨项目：角色协作纪律、收尾检查、常见坑 |
-| project | docs/ack/memory | project | true | markdown-per-skill | 仅本仓库；本 skill 写入 `docs/ack/memory/ack.md` |
+| project | .pouch/ack/memory | project | true | markdown-per-skill | 仅本仓库；本 skill 写入 `.pouch/ack/memory/ack.md` |
@@ -17,7 +17,7 @@ summary: ACK 三角色协作闭环
 | kind | path | root | create | format | notes |
 |------|------|------|--------|--------|-------|
 | general | memories/general | skill | true | markdown-dir | 跨项目可复用的 ACK 流程纪律 |
-| project | docs/ack/memory | project | true | markdown-per-skill | 仅本仓库；写入 `docs/ack/memory/<skillname>.md` |
+| project | .pouch/ack/memory | project | true | markdown-per-skill | 仅本仓库；写入 `.pouch/ack/memory/<skillname>.md` |
 ```

 ## 字段
@@ -49,5 +49,5 @@ summary: ACK 三角色协作闭环
 2. `root: skill` 的路径相对 skill SSOT（解析 symlink 后）。
 3. `root: project` 的路径相对当前工作区项目根；找不到项目根则请用户确认。
 4. 表格缺省：`create` 默认 `false`；`format` 默认 `markdown-dir`。
-5. `format: markdown-per-skill`：解析出目录 `path` 后，写入文件固定为 `<path>/<skillname>.md`（例：目标 `ack` → `docs/ack/memory/ack.md`）。不要把不同 skill 的项目记忆写进同一文件。
+5. `format: markdown-per-skill`：解析出目录 `path` 后，写入文件固定为 `<path>/<skillname>.md`（例：目标 `ack` → `.pouch/ack/memory/ack.md`）。不要把不同 skill 的项目记忆写进同一文件。
 6. 没有 manifest 时：在 skill 目录下寻找已存在的 `memories/general`，在项目下寻找文档已写明的 `…/memory/<skillname>.md`；仍不唯一则追问。
@@ -1,7 +1,7 @@
-# skiff
+# pouch

-`skiff` 用于创建、维护、安装和发布团队自研的 Agent Skill。Skill 的唯一来源位于
-`~/.skills/skills/<name>/`，安装到各 Agent 时使用软链接。
+`pouch` 用于创建、维护、安装和发布团队自研的 Agent Skill。Skill 的唯一来源位于
+`~/.pouch/skills/<name>/`，安装到各 Agent 时使用软链接。

 ## 什么时候使用

@@ -13,12 +13,12 @@
 ## 创建一个 skill

 ```bash
-skiff create my-skill \
+pouch create my-skill \
  --idea "描述这个 skill 要解决的重复问题" \
  --from-project .
 ```

-命令会在 `~/.skills/.drafts/my-skill/` 创建：
+命令会在 `~/.pouch/.drafts/my-skill/` 创建：

 - `SKILL.md`：给 Agent 阅读的工作流与约束。
 - `README.md`：给人类阅读的用途、准备事项、示例和完成标准。
@@ -27,8 +27,8 @@ skiff create my-skill \
 完善 `SKILL.md` 和 `README.md` 后运行：

 ```bash
-skiff check my-skill
-skiff finalize my-skill
+pouch check my-skill
+pouch finalize my-skill
 ```

 ## 提交和发布
@@ -36,13 +36,13 @@ skiff finalize my-skill
 只提交：

 ```bash
-skiff publish skills/my-skill -m "add my-skill"
+pouch publish skills/my-skill -m "add my-skill"
 ```

 提交并推送：

 ```bash
-skiff publish skills/my-skill -m "add my-skill" --push
+pouch publish skills/my-skill -m "add my-skill" --push
 ```

 ## 安装
@@ -50,18 +50,18 @@ skiff publish skills/my-skill -m "add my-skill" --push
 安装到当前项目的 Codex：

 ```bash
-skiff add my-skill -a codex -y
+pouch add my-skill -a codex -y
 ```

 安装到全局 Codex：

 ```bash
-skiff add my-skill -a codex -g -y
+pouch add my-skill -a codex -g -y
 ```

 ## 如何判断完成

- `skiff check <name>` 输出校验通过。
+- `pouch check <name>` 输出校验通过。
 - 正式 skill 同时包含 `SKILL.md` 和 `README.md`。
- `skiff status` 或 `skiff doctor` 显示目标软链接正常。
+- `pouch status` 或 `pouch doctor` 显示目标软链接正常。

@@ -1,15 +1,15 @@
 ---
-name: skiff
+name: pouch
 description: >-
-  创建和维护 ~/.skills 自研 skill：把项目开发中产生的想法提炼为草稿，完善并校验后发布，
-  用 skiff add/remove 在项目及全局挂卸 skill，或用 skiff init 初始化 skill 项目状态。
-  触发词：skiff、自研 skill、创建 skill、想做一个 skill、publish skill、安装自研 skill、
+  创建和维护 ~/.pouch 自研 skill：把项目开发中产生的想法提炼为草稿，完善并校验后发布，
+  用 pouch add/remove 在项目及全局挂卸 skill，或用 pouch init 初始化 skill 项目状态。
+  触发词：pouch、skiff、自研 skill、创建 skill、想做一个 skill、publish skill、安装自研 skill、
  更新 skill 到项目、初始化 skill。
 ---

-# skiff 自研 Skill 工作流
+# pouch 自研 Skill 工作流

-SSOT 固定在 `~/.skills/skills/<name>/`。内容通过 **symlink** 分发到各 agent，改 SSOT 即全项目生效。
+SSOT 固定在 `~/.pouch/skills/<name>/`。内容通过 **symlink** 分发到各 agent，改 SSOT 即全项目生效。

 ---

@@ -18,11 +18,11 @@ SSOT 固定在 `~/.skills/skills/<name>/`。内容通过 **symlink** 分发到
 先浏览可用的 builtin skill，再安装到当前项目：

 ```bash
-skiff add --list
-skiff add <name> -a cursor -a claude -a codex -a agents -y
+pouch add --list
+pouch add <name> -a cursor -a claude -a codex -a agents -y
 ```

-`skiff add <name>` 默认安装到当前项目；只有用户明确需要所有项目使用时才加 `-g`。安装结果是指向 `~/.skills/skills/<name>/` 的软链，不要在 Agent 目录创建副本。
+`pouch add <name>` 默认安装到当前项目；只有用户明确需要所有项目使用时才加 `-g`。安装结果是指向 `~/.pouch/skills/<name>/` 的软链，不要在 Agent 目录创建副本。

 ## 创建新的 skill

@@ -35,25 +35,25 @@ skiff add <name> -a cursor -a claude -a codex -a agents -y
 3. 创建草稿：

 ```bash
-skiff create <name> --idea "<用户原始想法>" --from-project .
+pouch create <name> --idea "<用户原始想法>" --from-project .
 ```

-4. 编辑 `~/.skills/.drafts/<name>/SKILL.md`，完善触发条件、不适用场景、步骤、边界与验证方法。
+4. 编辑 `~/.pouch/.drafts/<name>/SKILL.md`，完善触发条件、不适用场景、步骤、边界与验证方法。
 5. 编辑同目录的 `README.md`，用面向人类的语言说明用途、准备事项、可直接复制的请求示例、Agent 会做什么以及如何判断完成。README 不应复述 Agent 内部指令。
 6. 仅在确有必要时增加 `references/`、`scripts/` 或 `assets/`。不要把项目专属路径、私有业务规则、一次性命令或密钥复制到通用 skill。
 7. 运行校验并修复所有问题：

 ```bash
-skiff check <name>
+pouch check <name>
 ```

 8. 向用户展示名称、description、README 的人类使用方式、核心步骤和验证方式。获得确认后再转正：

 ```bash
-skiff finalize <name>
+pouch finalize <name>
 ```

-转正不会自动 commit、push 或安装。用户明确要求后再执行 `skiff publish` 或 `skiff add`。
+转正不会自动 commit、push 或安装。用户明确要求后再执行 `pouch publish` 或 `pouch add`。

 ## 问题或优化回流

@@ -63,35 +63,35 @@ skiff finalize <name>
 2. 判断归属：
   - 通用工作流、触发条件或验证缺陷：回流 builtin skill。
   - 仅当前项目成立的命令、路径、业务规则：留在项目文档或项目配置，不写回通用 skill。
-   - CLI 安装、软链或校验行为异常：修改 `~/.skills/skiff/` 中的 CLI 和测试。
+   - CLI 安装、软链或校验行为异常：修改 `~/.pouch/pouch/` 中的 CLI 和测试。
   - 第三方 skill：不要复制成 builtin skill 或直接改安装目录；整理证据反馈上游，除非用户明确决定维护 fork。
 3. 确认真实来源。Agent 目录通常是软链，builtin skill 的 SSOT 固定为：

 ```text
-~/.skills/skills/<name>/
+~/.pouch/skills/<name>/
 ```

 4. 修改 SSOT。行为修复应先补能复现问题的测试或示例，再改 `SKILL.md`、引用文件或脚本。
 5. 校验并在原项目重跑最初失败的场景：

 ```bash
-skiff check <name>
+pouch check <name>
 ```

 6. 汇报修改内容、验证结果和影响范围。只有用户明确要求提交或推送时才运行：

 ```bash
-skiff publish skills/<name> -m "update <name>" --push
+pouch publish skills/<name> -m "update <name>" --push
 ```

 软链正确时无需重新安装；SSOT 保存后项目立即读取新内容。

 ## 安装与维护

-安装本项目的 `skiff` skill 到所有 Agent：
+安装本项目的 `pouch` skill 到所有 Agent：

 ```bash
-skiff bootstrap
+pouch bootstrap
 ```

 安装其他 skill：
@@ -99,51 +99,51 @@ skiff bootstrap
 ```bash
 # 当前项目
 cd ~/code/my-app
-skiff add discussion-notes -a cursor -y
+pouch add discussion-notes -a cursor -y

 # 全局（所有项目）
-skiff add discussion-notes -a cursor -g -y
+pouch add discussion-notes -a cursor -g -y

 # 多个 agent
-skiff add discussion-notes -a cursor -a codex -g -y
+pouch add discussion-notes -a cursor -a codex -g -y
 ```

 catalog source既可以指向单个 skill，也可以指向包含多个 skill 目录的
 collection。安装 collection 全部内容或其中一个：

 ```bash
-skiff add waza -a codex -g -y
-skiff add waza/think -a codex -g -y
+pouch add waza -a codex -g -y
+pouch add waza/think -a codex -g -y
 ```

-`skiff select` 会把 collection 显示为两级菜单：选择 `waza` 仓库会选中其
+`pouch select` 会把 collection 显示为两级菜单：选择 `waza` 仓库会选中其
 全部子 skill，也可以只选择 `waza/think`、`waza/ui` 中的若干项。
-普通 `skiff select` 只向项目安装，并只读显示每个 Agent 的全局安装状态；
-`skiff select -g` 只向全局安装。取消已勾选项不会卸载，卸载继续使用
-`skiff remove`。
+普通 `pouch select` 只向项目安装，并只读显示每个 Agent 的全局安装状态；
+`pouch select -g` 只向全局安装。取消已勾选项不会卸载，卸载继续使用
+`pouch remove`。

 卸载：

 ```bash
-skiff remove discussion-notes -a cursor -y          # 当前项目
-skiff remove discussion-notes -g -a cursor -y     # 全局
-skiff rm discussion-notes -g -y                     # rm 别名
+pouch remove discussion-notes -a cursor -y          # 当前项目
+pouch remove discussion-notes -g -a cursor -y     # 全局
+pouch rm discussion-notes -g -y                     # rm 别名
 ```

 浏览可用自研 skill：

 ```bash
-skiff add --list
+pouch add --list
 ```

 使用 Skill 自带模板初始化项目状态：

 ```bash
-skiff init ack
-skiff init ack --project ~/app
+pouch init ack
+pouch init ack --project ~/app
 ```

-`skiff` 只负责可靠地生成项目状态文件，不复制或链接 Skill。需要分析项目并完善
+`pouch` 只负责可靠地生成项目状态文件，不复制或链接 Skill。需要分析项目并完善
 ACK 配置、检查接入状态或
 运行三角色闭环时，显式调用全局 `/ack` skill。

@@ -153,22 +153,22 @@ ACK 配置、检查接入状态或

 | 场景 | 工具 |
 |------|------|
-| 自研 skill（~/.skills） | **skiff** |
+| 自研 skill（~/.pouch） | **pouch** |
 | 社区 skill（GitHub 任意仓库） | `npx skills add` |

 ---

 ## 命令对照

-| skiff | 说明 |
+| pouch | 说明 |
 |-------|------|
-| `bootstrap` | 将本项目的 `skiff` skill 全局安装到所有 Agent |
-| `update` | 在 `~/.skills` 执行 `git pull`，更新 skiff 自身 |
+| `bootstrap` | 将本项目的 `pouch` skill 全局安装到所有 Agent |
+| `update` | 在 `~/.pouch` 执行 `git pull`，更新 pouch 自身 |
 | `add <name> [-g] [-a AGENT...] [-y]` | 安装 |
 | `remove <name> [-g] [-a AGENT...] [-y]` | 卸载（`rm` / `r` 别名） |
 | `add --list` | 列出可用自研 skill |
 | `publish [paths] -m MSG [--push]` | git add / commit / push |
-| `list` | 列出 ~/.skills 目录结构 |
+| `list` | 列出 ~/.pouch 目录结构 |
 | `status` | 查看软链安装状态 |
 | `create <name> --idea TEXT [--from-project PATH]` | 创建自研 skill 草稿 |
 | `check <name>` | 校验草稿或正式 skill |
@@ -179,7 +179,7 @@ ACK 配置、检查接入状态或

 ## 注意

- 不要在 `project/.agents/skills/` 里直接改文件；应改 `~/.skills/skills/` 再 `publish`
- 未完成的内容保留在 `~/.skills/.drafts/`，不要直接放进正式 `skills/`
+- 不要在 `project/.agents/skills/` 里直接改文件；应改 `~/.pouch/skills/` 再 `publish`
+- 未完成的内容保留在 `~/.pouch/.drafts/`，不要直接放进正式 `skills/`
 - symlink 正确时，**不需要 reinstall**；保存 SSOT 后各项目自动读到新内容
- 社区 skill 用 `npx skills add`，不要用 skiff `catalog add` 除非团队要 pin 版本
+- 社区 skill 用 `npx skills add`，不要用 pouch `catalog add` 除非团队要 pin 版本
@@ -291,7 +291,7 @@ class AckDeliveryValidationTests(unittest.TestCase):
        errors = validate_delivery.validate_tasks_link(contract, tasks)

        self.assertIn(
-            "tasks.project.deliveryFile 必须固定为 docs/ack/delivery.yaml",
+            "tasks.project.deliveryFile 必须固定为 .pouch/ack/delivery.yaml",
            errors,
        )
        self.assertIn("delivery.project.name 必须与 tasks.project.name 一致", errors)
@@ -445,7 +445,7 @@ class AckKnowledgeTests(unittest.TestCase):
        tasks_data = {
            "project": {
                "name": "notes-web",
-                "knowledgeFile": "docs/ack/knowledge.yaml",
+                "knowledgeFile": ".pouch/ack/knowledge.yaml",
            },
            "tasks": [task],
        }
@@ -470,7 +470,7 @@ class AckKnowledgeTests(unittest.TestCase):
        tasks = {
            "project": {
                "name": "another-project",
-                "knowledgeFile": "docs/ack/knowledge.yaml",
+                "knowledgeFile": ".pouch/ack/knowledge.yaml",
            },
            "tasks": [],
        }
@@ -502,7 +502,7 @@ class AckKnowledgeTests(unittest.TestCase):
        tasks_data = {
            "project": {
                "name": "notes-web",
-                "knowledgeFile": "docs/ack/knowledge.yaml",
+                "knowledgeFile": ".pouch/ack/knowledge.yaml",
            },
            "tasks": [task],
        }
@@ -522,7 +522,7 @@ class AckKnowledgeTests(unittest.TestCase):
        tasks_data = {
            "project": {
                "name": "notes-web",
-                "knowledgeFile": "docs/ack/knowledge.yaml",
+                "knowledgeFile": ".pouch/ack/knowledge.yaml",
            },
            "tasks": [
                {
@@ -567,7 +567,7 @@ class AckKnowledgeTests(unittest.TestCase):
        }
        with tempfile.TemporaryDirectory() as temp_dir:
            project = Path(temp_dir) / "project"
-            ack_dir = project / "docs" / "ack"
+            ack_dir = project / ".pouch" / "ack"
            ack_dir.mkdir(parents=True)
            knowledge_path = ack_dir / "knowledge.yaml"
            tasks_path = ack_dir / "tasks.yaml"
@@ -578,7 +578,7 @@ class AckKnowledgeTests(unittest.TestCase):
                "project": {
                    "name": "notes-web",
                    "repoPath": str(project),
-                    "knowledgeFile": "docs/ack/other.yaml",
+                    "knowledgeFile": ".pouch/ack/other.yaml",
                },
                "tasks": [task],
            }
@@ -595,9 +595,9 @@ class AckKnowledgeTests(unittest.TestCase):
            errors = validate_knowledge.validate_task_references(data, tasks_data)
            self.assertTrue(any("project.knowledgeFile 必填" in e for e in errors))

-            tasks_data["project"]["knowledgeFile"] = "docs/ack/knowledge.yaml"
+            tasks_data["project"]["knowledgeFile"] = ".pouch/ack/knowledge.yaml"
            staging_root = Path(temp_dir) / "staging"
-            staged = staging_root / "docs" / "ack" / "knowledge.yaml"
+            staged = staging_root / ".pouch" / "ack" / "knowledge.yaml"
            staged.parent.mkdir(parents=True)
            staged.write_text(
                yaml.safe_dump(data, allow_unicode=True), encoding="utf-8"
@@ -636,7 +636,7 @@ class AckKnowledgeTests(unittest.TestCase):
        with tempfile.TemporaryDirectory() as temp_dir:
            base = Path(temp_dir)
            project = base / "project"
-            ack_dir = project / "docs" / "ack"
+            ack_dir = project / ".pouch" / "ack"
            outside = base / "outside"
            ack_dir.mkdir(parents=True)
            outside.mkdir()
@@ -653,7 +653,7 @@ class AckKnowledgeTests(unittest.TestCase):
                "project": {
                    "name": "notes-web",
                    "repoPath": str(project / "missing"),
-                    "knowledgeFile": "docs/ack/not-the-current-file.yaml",
+                    "knowledgeFile": ".pouch/ack/not-the-current-file.yaml",
                },
                "tasks": [task],
            }
@@ -746,7 +746,7 @@ class AckKnowledgeTests(unittest.TestCase):
        tasks_data = {
            "project": {
                "name": "notes-web",
-                "knowledgeFile": "docs/ack/knowledge.yaml",
+                "knowledgeFile": ".pouch/ack/knowledge.yaml",
            },
            "tasks": [task],
        }
@@ -765,7 +765,7 @@ class AckKnowledgeTests(unittest.TestCase):
    def test_cli_validates_tasks_and_selector_outputs_stable_refs(self) -> None:
        with tempfile.TemporaryDirectory() as temp_dir:
            project = Path(temp_dir) / "project"
-            ack_dir = project / "docs" / "ack"
+            ack_dir = project / ".pouch" / "ack"
            ack_dir.mkdir(parents=True)
            knowledge_path = ack_dir / "knowledge.yaml"
            knowledge_path.write_text(
@@ -779,7 +779,7 @@ class AckKnowledgeTests(unittest.TestCase):
                "project": {
                    "name": "notes-web",
                    "repoPath": str(project),
-                    "knowledgeFile": "docs/ack/knowledge.yaml",
+                    "knowledgeFile": ".pouch/ack/knowledge.yaml",
                },
                "tasks": [
                    {
@@ -878,7 +878,7 @@ class AckKnowledgeTests(unittest.TestCase):
    def test_paired_examples_validate_when_installed_in_project_layout(self) -> None:
        with tempfile.TemporaryDirectory() as temp_dir:
            project = Path(temp_dir) / "notes-web"
-            ack_dir = project / "docs" / "ack"
+            ack_dir = project / ".pouch" / "ack"
            ack_dir.mkdir(parents=True)
            knowledge_path = ack_dir / "knowledge.yaml"
            tasks_path = ack_dir / "tasks.yaml"
@@ -435,7 +435,7 @@ class PlanTests(unittest.TestCase):
    def test_authoritative_board_is_derived_from_project_root_without_repo_path(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            project = Path(temporary).resolve()
-            ack_dir = project / "docs" / "ack"
+            ack_dir = project / ".pouch" / "ack"
            ack_dir.mkdir(parents=True)
            task_board = board(project)
            del task_board["project"]["repoPath"]
@@ -454,7 +454,7 @@ class PlanTests(unittest.TestCase):
    def test_authoritative_board_ignores_legacy_repo_path(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            project = Path(temporary).resolve()
-            ack_dir = project / "docs" / "ack"
+            ack_dir = project / ".pouch" / "ack"
            ack_dir.mkdir(parents=True)
            task_board = board(project)
            task_board["project"]["repoPath"] = "/legacy/other-worktree"
@@ -13,11 +13,11 @@ class AckSkillContentTests(unittest.TestCase):
        content = (REPO_ROOT / "skills" / "ack" / "SKILL.md").read_text(encoding="utf-8")

        for expected in (
-            "skiff init ack --project <project-root>",
-            "docs/ack/project.md",
-            "docs/ack/tasks.yaml",
-            "docs/ack/knowledge.yaml",
-            "docs/ack/delivery.yaml",
+            "pouch init ack --project <project-root>",
+            ".pouch/ack/project.md",
+            ".pouch/ack/tasks.yaml",
+            ".pouch/ack/knowledge.yaml",
+            ".pouch/ack/delivery.yaml",
            "tasks: []",
            "validate_tasks.py",
            "validate_knowledge.py",
@@ -131,7 +131,7 @@ class AckSkillContentTests(unittest.TestCase):
        ):
            self.assertTrue((ack_dir / relative_path).is_file(), relative_path)
        version = (ack_dir / "VERSION").read_text(encoding="utf-8").strip()
-        self.assertEqual(version, "0.18.0")
+        self.assertEqual(version, "0.19.0")
        self.assertIn(
            f'ackVersion: "{version}"',
            (ack_dir / "examples" / "tasks.example.yaml").read_text(encoding="utf-8"),
@@ -156,7 +156,7 @@ class AckSkillContentTests(unittest.TestCase):
        # v0.19 起 allowedWorktrees 白名单废弃：模板只保留废弃说明注释，不再生成该字段
        self.assertNotIn("allowedWorktrees:", template)
        self.assertIn("allowedWorktrees", template)
-        self.assertIn('knowledgeFile: "docs/ack/knowledge.yaml"', template)
+        self.assertIn('knowledgeFile: ".pouch/ack/knowledge.yaml"', template)


 if __name__ == "__main__":
@@ -364,7 +364,7 @@ class AckTaskValidationTests(unittest.TestCase):

    def test_delivery_run_is_separate_and_requires_verified_tasks(self) -> None:
        board = valid_manual_routing_board()
-        board["project"]["deliveryFile"] = "docs/ack/delivery.yaml"
+        board["project"]["deliveryFile"] = ".pouch/ack/delivery.yaml"
        board["tasks"][0]["status"] = "verified"
        board["deliveryRuns"] = [
            {
@@ -405,7 +405,7 @@ class AckTaskValidationTests(unittest.TestCase):

    def test_validation_ready_delivery_run_does_not_require_pull_request(self) -> None:
        board = valid_manual_routing_board()
-        board["project"]["deliveryFile"] = "docs/ack/delivery.yaml"
+        board["project"]["deliveryFile"] = ".pouch/ack/delivery.yaml"
        board["tasks"][0]["status"] = "verified"
        board["deliveryRuns"] = [
            {
@@ -440,7 +440,7 @@ class AckTaskValidationTests(unittest.TestCase):

    def test_intent_delivery_run_allows_empty_task_ids(self) -> None:
        board = valid_manual_routing_board()
-        board["project"]["deliveryFile"] = "docs/ack/delivery.yaml"
+        board["project"]["deliveryFile"] = ".pouch/ack/delivery.yaml"
        board["deliveryRuns"] = [
            {
                "id": "DR-test-env-1",
@@ -488,7 +488,7 @@ class AckTaskValidationTests(unittest.TestCase):
        )

        board = valid_manual_routing_board()
-        board["project"]["deliveryFile"] = "docs/ack/delivery.yaml"
+        board["project"]["deliveryFile"] = ".pouch/ack/delivery.yaml"
        self.assert_board_rejected_in_all_modes(
            board,
            "引用 deliveryFile 的任务板必须包含 deliveryRuns 列表",
@@ -496,7 +496,7 @@ class AckTaskValidationTests(unittest.TestCase):

    def test_delivery_run_binds_revisions_and_final_artifact_digest(self) -> None:
        board = valid_manual_routing_board()
-        board["project"]["deliveryFile"] = "docs/ack/delivery.yaml"
+        board["project"]["deliveryFile"] = ".pouch/ack/delivery.yaml"
        board["deliveryRuns"] = [
            {
                "id": "DR-demo-2",
@@ -912,11 +912,11 @@ class AckTaskValidationTests(unittest.TestCase):

    def test_knowledge_file_is_fixed_in_all_modes(self) -> None:
        board = valid_knowledge_board()
-        board["project"]["knowledgeFile"] = "docs/ack/alternate.yaml"
+        board["project"]["knowledgeFile"] = ".pouch/ack/alternate.yaml"

        self.assert_board_rejected_in_all_modes(
            board,
-            "project.knowledgeFile 必须固定为 docs/ack/knowledge.yaml",
+            "project.knowledgeFile 必须固定为 .pouch/ack/knowledge.yaml",
        )

    def test_basic_identifiers_must_be_nonempty_strings_in_all_modes(self) -> None:
@@ -1116,8 +1116,8 @@ class AckTaskValidationTests(unittest.TestCase):
                "repoPath": "/repo",
                "baseUrl": "http://127.0.0.1:3000",
                "devWorktree": "/repo-dev",
-                "overlayFile": "docs/ack/project.md",
-                "knowledgeFile": "docs/ack/knowledge.yaml",
+                "overlayFile": ".pouch/ack/project.md",
+                "knowledgeFile": ".pouch/ack/knowledge.yaml",
            }
        )
        board["tasks"][0].update(
@@ -42,7 +42,7 @@ class AckVerificationRunnerTests(unittest.TestCase):
        project: Path,
        knowledge: dict,
    ) -> subprocess.CompletedProcess[str]:
-        knowledge_path = project / "docs" / "ack" / "knowledge.yaml"
+        knowledge_path = project / ".pouch" / "ack" / "knowledge.yaml"
        knowledge_path.parent.mkdir(parents=True, exist_ok=True)
        knowledge_path.write_text(
            yaml.safe_dump(knowledge, allow_unicode=True),
@@ -153,7 +153,7 @@ class AckVerificationRunnerTests(unittest.TestCase):
            target = outside / "unsafe"
            target.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
            target.chmod(target.stat().st_mode | 0o111)
-            knowledge_path = project / "docs" / "ack" / "knowledge.yaml"
+            knowledge_path = project / ".pouch" / "ack" / "knowledge.yaml"
            knowledge_path.parent.mkdir(parents=True)
            knowledge_path.write_text(
                yaml.safe_dump(
@@ -194,7 +194,7 @@ class AckVerificationRunnerTests(unittest.TestCase):
                    encoding="utf-8",
                )
                target.chmod(target.stat().st_mode | 0o111)
-            knowledge_path = project / "docs" / "ack" / "knowledge.yaml"
+            knowledge_path = project / ".pouch" / "ack" / "knowledge.yaml"
            knowledge_path.parent.mkdir(parents=True)
            knowledge_path.write_text(
                """\
@@ -238,7 +238,7 @@ entries: []
        with tempfile.TemporaryDirectory() as temp_dir:
            base = Path(temp_dir)
            project = base / "project"
-            ack_dir = project / "docs" / "ack"
+            ack_dir = project / ".pouch" / "ack"
            ack_dir.mkdir(parents=True)
            document = yaml.safe_dump(
                knowledge_with_target("checks/reviewed", []),
@@ -293,7 +293,7 @@ entries: []
        with tempfile.TemporaryDirectory() as temp_dir:
            base = Path(temp_dir)
            project = base / "project"
-            canonical = project / "docs" / "ack" / "knowledge.yaml"
+            canonical = project / ".pouch" / "ack" / "knowledge.yaml"
            canonical.parent.mkdir(parents=True)
            safe_document = knowledge_with_target("checks/safe", [])
            forged_document = knowledge_with_target("checks/danger", [])
@@ -335,7 +335,7 @@ entries: []
    ) -> None:
        with tempfile.TemporaryDirectory() as temp_dir:
            project = Path(temp_dir) / "project"
-            canonical = project / "docs" / "ack" / "knowledge.yaml"
+            canonical = project / ".pouch" / "ack" / "knowledge.yaml"
            canonical.parent.mkdir(parents=True)
            canonical.write_text(
                yaml.safe_dump(
@@ -346,7 +346,7 @@ entries: []
            )
            source_fd, error = RUNNER_MODULE._open_regular_beneath(
                project,
-                "docs/ack/knowledge.yaml",
+                ".pouch/ack/knowledge.yaml",
                require_executable=False,
            )
            self.assertIsNone(error)
@@ -521,7 +521,7 @@ entries: []
                encoding="utf-8",
            )
            target.chmod(target.stat().st_mode | 0o111)
-            knowledge_path = project / "docs" / "ack" / "knowledge.yaml"
+            knowledge_path = project / ".pouch" / "ack" / "knowledge.yaml"
            knowledge_path.parent.mkdir(parents=True)
            knowledge_path.write_text(
                yaml.safe_dump(
@@ -25,7 +25,7 @@ class AgentsTargetTests(unittest.TestCase):
    def setUp(self) -> None:
        self.temp_dir = tempfile.TemporaryDirectory()
        self.home = Path(self.temp_dir.name)
-        self.skills_home = self.home / ".skills"
+        self.skills_home = self.home / ".pouch"
        self.skills_home.mkdir(parents=True)
        (self.skills_home / "catalog.yaml").write_text("", encoding="utf-8")
        write_skill(self.skills_home, "demo-skill")
@@ -33,12 +33,12 @@ class AgentsTargetTests(unittest.TestCase):
    def tearDown(self) -> None:
        self.temp_dir.cleanup()

-    def run_skiff(self, *args: str) -> subprocess.CompletedProcess[str]:
+    def run_pouch(self, *args: str) -> subprocess.CompletedProcess[str]:
        env = os.environ.copy()
        env["HOME"] = str(self.home)
        env["PYTHONPATH"] = str(REPO_ROOT)
        return subprocess.run(
-            [sys.executable, "-m", "skiff", *args],
+            [sys.executable, "-m", "pouch", *args],
            cwd=REPO_ROOT,
            env=env,
            text=True,
@@ -47,7 +47,7 @@ class AgentsTargetTests(unittest.TestCase):
        )

    def test_global_add_creates_symlink_in_agents_skills(self) -> None:
-        result = self.run_skiff("add", "builtin/demo-skill", "-g", "-a", "agents")
+        result = self.run_pouch("add", "builtin/demo-skill", "-g", "-a", "agents")

        self.assertEqual(result.returncode, 0, result.stderr)
        link = self.home / ".agents" / "skills" / "demo-skill"
@@ -56,7 +56,7 @@ class AgentsTargetTests(unittest.TestCase):
            link.resolve(), (self.skills_home / "skills" / "demo-skill").resolve()
        )

-        removed = self.run_skiff("rm", "builtin/demo-skill", "-g", "-a", "agents")
+        removed = self.run_pouch("rm", "builtin/demo-skill", "-g", "-a", "agents")
        self.assertEqual(removed.returncode, 0, removed.stderr)
        self.assertFalse(link.exists())

@@ -64,7 +64,7 @@ class AgentsTargetTests(unittest.TestCase):
        project = self.home / "app"
        project.mkdir()

-        added = self.run_skiff(
+        added = self.run_pouch(
            "add",
            "builtin/demo-skill",
            "--project",
@@ -80,25 +80,25 @@ class AgentsTargetTests(unittest.TestCase):
        links = list((project / ".agents" / "skills").glob("demo-skill"))
        self.assertEqual(len(links), 1)
        self.assertTrue(links[0].is_symlink())
-        manifest = (project / ".skills.yaml").read_text(encoding="utf-8")
+        manifest = (project / ".pouch.yaml").read_text(encoding="utf-8")
        self.assertIn("demo-skill", manifest)

-        removed = self.run_skiff(
+        removed = self.run_pouch(
            "rm", "builtin/demo-skill", "--project", str(project), "-y"
        )
        self.assertEqual(removed.returncode, 0, removed.stderr)
        self.assertFalse((project / ".agents" / "skills" / "demo-skill").exists())

    def test_status_lists_installed_skill_for_agents_target(self) -> None:
-        installed = self.run_skiff("add", "builtin/demo-skill", "-g", "-a", "agents")
-        status = self.run_skiff("status", "-a", "agents")
+        installed = self.run_pouch("add", "builtin/demo-skill", "-g", "-a", "agents")
+        status = self.run_pouch("status", "-a", "agents")

        self.assertEqual(installed.returncode, 0, installed.stderr)
        self.assertEqual(status.returncode, 0, status.stderr)
        self.assertIn("demo-skill", status.stdout)

    def test_opencode_target_is_no_longer_supported(self) -> None:
-        result = self.run_skiff("add", "builtin/demo-skill", "-g", "-a", "opencode")
+        result = self.run_pouch("add", "builtin/demo-skill", "-g", "-a", "opencode")

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("未知 agent", result.stderr)
@@ -9,8 +9,8 @@ import unittest
 from pathlib import Path
 from unittest.mock import patch

-from skiff import catalog
-from skiff.catalog import catalog_checkout_path, catalog_repo
+from pouch import catalog
+from pouch.catalog import catalog_checkout_path, catalog_repo


 REPO_ROOT = Path(__file__).resolve().parents[1]
@@ -40,7 +40,7 @@ class CatalogCollectionTests(unittest.TestCase):
    def setUp(self) -> None:
        self.temp_dir = tempfile.TemporaryDirectory()
        self.home = Path(self.temp_dir.name)
-        self.skills_home = self.home / ".skills"
+        self.skills_home = self.home / ".pouch"
        (self.skills_home / "skills").mkdir(parents=True)

        self.upstream = self.home / "upstream"
@@ -79,12 +79,12 @@ class CatalogCollectionTests(unittest.TestCase):
    def tearDown(self) -> None:
        self.temp_dir.cleanup()

-    def run_skiff(self, *args: str) -> subprocess.CompletedProcess[str]:
+    def run_pouch(self, *args: str) -> subprocess.CompletedProcess[str]:
        env = os.environ.copy()
        env["HOME"] = str(self.home)
        env["PYTHONPATH"] = str(REPO_ROOT)
        return subprocess.run(
-            [sys.executable, "-m", "skiff", *args],
+            [sys.executable, "-m", "pouch", *args],
            cwd=REPO_ROOT,
            env=env,
            text=True,
@@ -95,16 +95,16 @@ class CatalogCollectionTests(unittest.TestCase):
    def test_catalog_repo_expands_home_relative_local_path(self) -> None:
        with patch.dict(os.environ, {"HOME": str(self.home)}):
            self.assertEqual(
-                catalog_repo({"repo": "~/.skills"}),
+                catalog_repo({"repo": "~/.pouch"}),
                str(self.skills_home),
            )
            self.assertEqual(
-                catalog_checkout_path("skills", {"repo": "~/.skills"}),
+                catalog_checkout_path("skills", {"repo": "~/.pouch"}),
                self.skills_home.resolve(),
            )

    def test_add_collection_installs_every_discovered_skill(self) -> None:
-        result = self.run_skiff("add", "test-pack", "-g", "-a", "codex")
+        result = self.run_pouch("add", "test-pack", "-g", "-a", "codex")

        self.assertEqual(result.returncode, 0, result.stderr)
        skill_dir = self.home / ".codex" / "skills"
@@ -115,7 +115,7 @@ class CatalogCollectionTests(unittest.TestCase):
        self.assertFalse((skill_dir / "test-pack").exists())

    def test_add_qualified_collection_skill_installs_only_that_skill(self) -> None:
-        result = self.run_skiff("add", "test-pack/second-skill", "-g", "-a", "codex")
+        result = self.run_pouch("add", "test-pack/second-skill", "-g", "-a", "codex")

        self.assertEqual(result.returncode, 0, result.stderr)
        skill_dir = self.home / ".codex" / "skills"
@@ -124,7 +124,7 @@ class CatalogCollectionTests(unittest.TestCase):
        self.assertTrue((skill_dir / "second-skill" / "SKILL.md").is_file())

    def test_add_collection_with_catalog_source_installs_all(self) -> None:
-        result = self.run_skiff(
+        result = self.run_pouch(
            "add",
            "test-pack",
            "--source",
@@ -140,7 +140,7 @@ class CatalogCollectionTests(unittest.TestCase):
        self.assertTrue((skill_dir / "second-skill").is_symlink())

    def test_legacy_registry_source_alias_still_installs(self) -> None:
-        result = self.run_skiff(
+        result = self.run_pouch(
            "add",
            "test-pack",
            "--source",
@@ -159,7 +159,7 @@ class CatalogCollectionTests(unittest.TestCase):
        project = self.home / "project"
        project.mkdir()

-        added = self.run_skiff(
+        added = self.run_pouch(
            "add",
            "test-pack/first-skill",
            "--project",
@@ -169,8 +169,8 @@ class CatalogCollectionTests(unittest.TestCase):
        )
        link = project / ".agents" / "skills" / "first-skill"
        link.unlink()
-        shutil.rmtree(self.home / ".local" / "share" / "skills" / "externals")
-        synced = self.run_skiff(
+        shutil.rmtree(self.home / ".local" / "share" / "pouch" / "externals")
+        synced = self.run_pouch(
            "sync",
            "--project",
            str(project),
@@ -179,7 +179,7 @@ class CatalogCollectionTests(unittest.TestCase):
        )

        self.assertEqual(added.returncode, 0, added.stderr)
-        self.assertIn('source: "catalog:test-pack"', project.joinpath(".skills.yaml").read_text())
+        self.assertIn('source: "catalog:test-pack"', project.joinpath(".pouch.yaml").read_text())
        self.assertEqual(synced.returncode, 0, synced.stderr)
        self.assertTrue(link.is_symlink())
        self.assertTrue((link / "SKILL.md").is_file())
@@ -188,15 +188,15 @@ class CatalogCollectionTests(unittest.TestCase):
        blocked = self.home / ".codex" / "skills" / "second-skill"
        blocked.mkdir(parents=True)

-        result = self.run_skiff("add", "test-pack", "-g", "-a", "codex")
+        result = self.run_pouch("add", "test-pack", "-g", "-a", "codex")

        self.assertNotEqual(result.returncode, 0)
        self.assertFalse((self.home / ".codex" / "skills" / "first-skill").exists())
        self.assertTrue(blocked.is_dir())

    def test_remove_collection_removes_all_child_links(self) -> None:
-        installed = self.run_skiff("add", "test-pack", "-g", "-a", "codex")
-        removed = self.run_skiff("remove", "test-pack", "-g", "-a", "codex")
+        installed = self.run_pouch("add", "test-pack", "-g", "-a", "codex")
+        removed = self.run_pouch("remove", "test-pack", "-g", "-a", "codex")

        self.assertEqual(installed.returncode, 0, installed.stderr)
        self.assertEqual(removed.returncode, 0, removed.stderr)
@@ -205,8 +205,8 @@ class CatalogCollectionTests(unittest.TestCase):
        self.assertFalse((skill_dir / "second-skill").exists())

    def test_status_expands_collection_children(self) -> None:
-        installed = self.run_skiff("add", "test-pack", "-g", "-a", "codex")
-        status = self.run_skiff("status", "-a", "codex")
+        installed = self.run_pouch("add", "test-pack", "-g", "-a", "codex")
+        status = self.run_pouch("status", "-a", "codex")

        self.assertEqual(installed.returncode, 0, installed.stderr)
        self.assertEqual(status.returncode, 0, status.stderr)
@@ -9,7 +9,7 @@ import unittest
 from pathlib import Path
 from unittest.mock import patch

-from skiff import cli
+from pouch import cli


 REPO_ROOT = Path(__file__).resolve().parents[1]
@@ -19,7 +19,7 @@ class CreateWorkflowTests(unittest.TestCase):
    def setUp(self) -> None:
        self.temp_dir = tempfile.TemporaryDirectory()
        self.home = Path(self.temp_dir.name)
-        self.skills_home = self.home / ".skills"
+        self.skills_home = self.home / ".pouch"
        template = self.skills_home / "skills" / "_template"
        template.mkdir(parents=True)
        template.joinpath("SKILL.md").write_text(
@@ -35,28 +35,28 @@ class CreateWorkflowTests(unittest.TestCase):
            "给出一条可以直接交给 Agent 的示例请求。\n",
            encoding="utf-8",
        )
-        project_skill = self.skills_home / "skills" / "skiff"
+        project_skill = self.skills_home / "skills" / "pouch"
        project_skill.mkdir()
        project_skill.joinpath("SKILL.md").write_text(
-            "---\nname: skiff\ndescription: >-\n"
+            "---\nname: pouch\ndescription: >-\n"
            "  创建和维护自研 skill。用于创建、安装、反馈或更新 skill 时。\n"
-            "---\n\n# skiff\n\n## 步骤\n\n1. 维护 skill。\n",
+            "---\n\n# pouch\n\n## 步骤\n\n1. 维护 skill。\n",
            encoding="utf-8",
        )
        project_skill.joinpath("README.md").write_text(
-            "# skiff\n\n供人类使用的 skiff 说明。\n",
+            "# pouch\n\n供人类使用的 pouch 说明。\n",
            encoding="utf-8",
        )

    def tearDown(self) -> None:
        self.temp_dir.cleanup()

-    def run_skiff(self, *args: str) -> subprocess.CompletedProcess[str]:
+    def run_pouch(self, *args: str) -> subprocess.CompletedProcess[str]:
        env = os.environ.copy()
        env["HOME"] = str(self.home)
        env["PYTHONPATH"] = str(REPO_ROOT)
        return subprocess.run(
-            [sys.executable, "-m", "skiff", *args],
+            [sys.executable, "-m", "pouch", *args],
            cwd=REPO_ROOT,
            env=env,
            text=True,
@@ -65,25 +65,25 @@ class CreateWorkflowTests(unittest.TestCase):
        )

    def test_setup_command_is_not_exposed(self) -> None:
-        help_result = self.run_skiff("--help")
-        setup_result = self.run_skiff("setup", str(self.skills_home))
+        help_result = self.run_pouch("--help")
+        setup_result = self.run_pouch("setup", str(self.skills_home))

        self.assertEqual(help_result.returncode, 0, help_result.stderr)
        self.assertNotIn("setup", help_result.stdout)
        self.assertNotEqual(setup_result.returncode, 0)

    def test_bootstrap_installs_project_skill_globally_for_all_agents(self) -> None:
-        first = self.run_skiff("bootstrap")
-        second = self.run_skiff("bootstrap")
+        first = self.run_pouch("bootstrap")
+        second = self.run_pouch("bootstrap")

        self.assertEqual(first.returncode, 0, first.stderr)
        self.assertEqual(second.returncode, 0, second.stderr)
-        expected = (self.skills_home / "skills" / "skiff").resolve()
+        expected = (self.skills_home / "skills" / "pouch").resolve()
        for relative in (
-            ".cursor/skills/skiff",
-            ".claude/skills/skiff",
-            ".codex/skills/skiff",
-            ".agents/skills/skiff",
+            ".cursor/skills/pouch",
+            ".claude/skills/pouch",
+            ".codex/skills/pouch",
+            ".agents/skills/pouch",
        ):
            link = self.home / relative
            self.assertTrue(link.is_symlink(), relative)
@@ -93,8 +93,8 @@ class CreateWorkflowTests(unittest.TestCase):

    def test_update_pulls_skills_home(self) -> None:
        with (
-            patch.object(cli, "SKILLS_HOME", self.skills_home),
-            patch.object(cli, "ensure_skills_home"),
+            patch.object(cli, "POUCH_HOME", self.skills_home),
+            patch.object(cli, "ensure_pouch_home"),
            patch.object(cli.subprocess, "run") as run,
        ):
            cli.cmd_update(argparse.Namespace())
@@ -108,7 +108,7 @@ class CreateWorkflowTests(unittest.TestCase):
        project = self.home / "project"
        project.mkdir()

-        result = self.run_skiff(
+        result = self.run_pouch(
            "create",
            "migration-review",
            "--idea",
@@ -128,19 +128,19 @@ class CreateWorkflowTests(unittest.TestCase):
        self.assertIn("idea: 检查数据库迁移", brief)
        self.assertIn(f"source_project: {project.resolve()}", brief)
        self.assertFalse((self.skills_home / "skills" / "migration-review").exists())
-        self.assertIn("请完善 skiff 草稿 migration-review", result.stdout)
+        self.assertIn("请完善 pouch 草稿 migration-review", result.stdout)

    def test_check_rejects_template_placeholders(self) -> None:
-        created = self.run_skiff("create", "migration-review", "--idea", "检查数据库迁移")
+        created = self.run_pouch("create", "migration-review", "--idea", "检查数据库迁移")
        self.assertEqual(created.returncode, 0, created.stderr)

-        result = self.run_skiff("check", "migration-review")
+        result = self.run_pouch("check", "migration-review")

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("模板占位", result.stderr)

    def test_finalize_moves_valid_draft_and_removes_brief(self) -> None:
-        created = self.run_skiff("create", "migration-review", "--idea", "检查数据库迁移")
+        created = self.run_pouch("create", "migration-review", "--idea", "检查数据库迁移")
        self.assertEqual(created.returncode, 0, created.stderr)
        draft = self.skills_home / ".drafts" / "migration-review"
        draft.joinpath("SKILL.md").write_text(
@@ -156,7 +156,7 @@ class CreateWorkflowTests(unittest.TestCase):
            encoding="utf-8",
        )

-        result = self.run_skiff("finalize", "migration-review")
+        result = self.run_pouch("finalize", "migration-review")

        self.assertEqual(result.returncode, 0, result.stderr)
        final = self.skills_home / "skills" / "migration-review"
@@ -179,7 +179,7 @@ class CreateWorkflowTests(unittest.TestCase):
            encoding="utf-8",
        )

-        result = self.run_skiff("check", "reference-check")
+        result = self.run_pouch("check", "reference-check")

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("引用文件不存在", result.stderr)
@@ -194,19 +194,19 @@ class CreateWorkflowTests(unittest.TestCase):
            encoding="utf-8",
        )

-        result = self.run_skiff("check", "missing-readme")
+        result = self.run_pouch("check", "missing-readme")

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("缺少 README.md", result.stderr)

    def test_finalize_does_not_overwrite_existing_owned_skill(self) -> None:
-        created = self.run_skiff("create", "collision-check", "--idea", "检查名称冲突")
+        created = self.run_pouch("create", "collision-check", "--idea", "检查名称冲突")
        self.assertEqual(created.returncode, 0, created.stderr)
        final = self.skills_home / "skills" / "collision-check"
        final.mkdir()
        final.joinpath("marker").write_text("keep", encoding="utf-8")

-        result = self.run_skiff("finalize", "collision-check")
+        result = self.run_pouch("finalize", "collision-check")

        self.assertNotEqual(result.returncode, 0)
        self.assertEqual(final.joinpath("marker").read_text(encoding="utf-8"), "keep")
@@ -8,8 +8,8 @@ import unittest
 from pathlib import Path
 from unittest.mock import patch

-from skiff.project import normalize_skill_entry
-from skiff.sources import fetch_source
+from pouch.project import normalize_skill_entry
+from pouch.sources import fetch_source

 REPO_ROOT = Path(__file__).resolve().parents[1]

@@ -41,19 +41,19 @@ class CustomSourceTests(unittest.TestCase):
    def setUp(self) -> None:
        self.temp_dir = tempfile.TemporaryDirectory()
        self.home = Path(self.temp_dir.name)
-        self.skills_home = self.home / ".skills"
+        self.skills_home = self.home / ".pouch"
        (self.skills_home / "skills").mkdir(parents=True)
        (self.skills_home / "catalog.yaml").write_text("", encoding="utf-8")

    def tearDown(self) -> None:
        self.temp_dir.cleanup()

-    def run_skiff(self, *args: str) -> subprocess.CompletedProcess[str]:
+    def run_pouch(self, *args: str) -> subprocess.CompletedProcess[str]:
        env = os.environ.copy()
        env["HOME"] = str(self.home)
        env["PYTHONPATH"] = str(REPO_ROOT)
        return subprocess.run(
-            [sys.executable, "-m", "skiff", *args],
+            [sys.executable, "-m", "pouch", *args],
            cwd=REPO_ROOT,
            env=env,
            text=True,
@@ -65,7 +65,7 @@ class CustomSourceTests(unittest.TestCase):
        company = self.home / "company"
        expected = write_skill(company / "internal" / "skills", "code-review")

-        added = self.run_skiff(
+        added = self.run_pouch(
            "source",
            "add",
            "company",
@@ -74,8 +74,8 @@ class CustomSourceTests(unittest.TestCase):
            "--skills-path",
            "internal/skills",
        )
-        listed = self.run_skiff("list", "--source", "company")
-        installed = self.run_skiff("add", "company/code-review", "-g", "-a", "codex")
+        listed = self.run_pouch("list", "--source", "company")
+        installed = self.run_pouch("add", "company/code-review", "-g", "-a", "codex")

        self.assertEqual(added.returncode, 0, added.stderr)
        self.assertEqual(listed.returncode, 0, listed.stderr)
@@ -84,7 +84,7 @@ class CustomSourceTests(unittest.TestCase):
        link = self.home / ".codex" / "skills" / "code-review"
        self.assertTrue(link.is_symlink())
        self.assertEqual(link.resolve(), expected.resolve())
-        config = self.home / ".config" / "skiff" / "config.yaml"
+        config = self.home / ".config" / "pouch" / "config.yaml"
        self.assertIn("company:", config.read_text(encoding="utf-8"))

    def test_local_source_can_expose_a_single_skill(self) -> None:
@@ -94,7 +94,7 @@ class CustomSourceTests(unittest.TestCase):
            "---\nname: solo\ndescription: Test single source.\n---\n",
            encoding="utf-8",
        )
-        added = self.run_skiff(
+        added = self.run_pouch(
            "source",
            "add",
            "solo",
@@ -103,7 +103,7 @@ class CustomSourceTests(unittest.TestCase):
            "--skills-path",
            ".",
        )
-        installed = self.run_skiff(
+        installed = self.run_pouch(
            "add",
            "solo",
            "-g",
@@ -122,10 +122,10 @@ class CustomSourceTests(unittest.TestCase):
        expected = write_skill(company / "skills", "code-review")
        project = self.home / "project"
        project.mkdir()
-        added = self.run_skiff("source", "add", "company", "--local", str(company))
+        added = self.run_pouch("source", "add", "company", "--local", str(company))
        self.assertEqual(added.returncode, 0, added.stderr)

-        result = self.run_skiff(
+        result = self.run_pouch(
            "add",
            "company/code-review",
            "--project",
@@ -135,7 +135,7 @@ class CustomSourceTests(unittest.TestCase):
        )

        self.assertEqual(result.returncode, 0, result.stderr)
-        manifest = project.joinpath(".skills.yaml").read_text(encoding="utf-8")
+        manifest = project.joinpath(".pouch.yaml").read_text(encoding="utf-8")
        self.assertIn('name: "code-review"', manifest)
        self.assertIn("source: company", manifest)
        self.assertEqual(
@@ -149,14 +149,14 @@ class CustomSourceTests(unittest.TestCase):
        write_skill(company / "skills", "code-review")
        project = self.home / "project"
        project.mkdir()
-        project.joinpath(".skills.yaml").write_text(
+        project.joinpath(".pouch.yaml").write_text(
            "skills:\n  - code-review\n",
            encoding="utf-8",
        )
-        added = self.run_skiff("source", "add", "company", "--local", str(company))
+        added = self.run_pouch("source", "add", "company", "--local", str(company))
        self.assertEqual(added.returncode, 0, added.stderr)

-        result = self.run_skiff(
+        result = self.run_pouch(
            "add",
            "company/code-review",
            "--project",
@@ -166,17 +166,17 @@ class CustomSourceTests(unittest.TestCase):
        )

        self.assertEqual(result.returncode, 0, result.stderr)
-        manifest = project.joinpath(".skills.yaml").read_text(encoding="utf-8")
+        manifest = project.joinpath(".pouch.yaml").read_text(encoding="utf-8")
        self.assertIn("source: company", manifest)

    def test_unqualified_duplicate_requires_explicit_source(self) -> None:
        write_skill(self.skills_home / "skills", "code-review")
        company = self.home / "company"
        write_skill(company / "skills", "code-review")
-        added = self.run_skiff("source", "add", "company", "--local", str(company))
+        added = self.run_pouch("source", "add", "company", "--local", str(company))
        self.assertEqual(added.returncode, 0, added.stderr)

-        result = self.run_skiff("add", "code-review", "-g", "-a", "codex")
+        result = self.run_pouch("add", "code-review", "-g", "-a", "codex")

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("builtin/code-review", result.stderr)
@@ -194,9 +194,9 @@ class CustomSourceTests(unittest.TestCase):
            "  path: skills\n",
            encoding="utf-8",
        )
-        added = self.run_skiff("source", "add", "company", "--local", str(company))
+        added = self.run_pouch("source", "add", "company", "--local", str(company))

-        result = self.run_skiff(
+        result = self.run_pouch(
            "add",
            "company/code-review",
            "-g",
@@ -216,15 +216,15 @@ class CustomSourceTests(unittest.TestCase):
        expected = write_skill(company / "skills", "code-review")
        project = self.home / "project"
        project.mkdir()
-        project.joinpath(".skills.yaml").write_text(
+        project.joinpath(".pouch.yaml").write_text(
            "skills:\n  - name: code-review\n    source: company\n"
            "targets:\n  - codex\n",
            encoding="utf-8",
        )
-        added = self.run_skiff("source", "add", "company", "--local", str(company))
+        added = self.run_pouch("source", "add", "company", "--local", str(company))
        self.assertEqual(added.returncode, 0, added.stderr)

-        result = self.run_skiff("sync", "--project", str(project), "-a", "codex")
+        result = self.run_pouch("sync", "--project", str(project), "-a", "codex")

        self.assertEqual(result.returncode, 0, result.stderr)
        link = project / ".agents" / "skills" / "code-review"
@@ -233,16 +233,16 @@ class CustomSourceTests(unittest.TestCase):
    def test_sync_reports_missing_machine_source(self) -> None:
        project = self.home / "project"
        project.mkdir()
-        project.joinpath(".skills.yaml").write_text(
+        project.joinpath(".pouch.yaml").write_text(
            "skills:\n  - name: code-review\n    source: company\n",
            encoding="utf-8",
        )

-        result = self.run_skiff("sync", "--project", str(project), "-a", "codex")
+        result = self.run_pouch("sync", "--project", str(project), "-a", "codex")

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("本机尚未配置", result.stderr)
-        self.assertIn("skiff source add company", result.stderr)
+        self.assertIn("pouch source add company", result.stderr)

    def test_git_source_is_cloned_to_default_checkout(self) -> None:
        upstream = self.home / "upstream"
@@ -266,10 +266,10 @@ class CustomSourceTests(unittest.TestCase):
            capture_output=True,
        )

-        result = self.run_skiff("source", "add", "company", str(upstream))
+        result = self.run_pouch("source", "add", "company", str(upstream))

        self.assertEqual(result.returncode, 0, result.stderr)
-        checkout = self.home / ".local" / "share" / "skiff" / "sources" / "company"
+        checkout = self.home / ".local" / "share" / "pouch" / "sources" / "company"
        self.assertTrue((checkout / ".git").is_dir())
        self.assertTrue((checkout / "skills" / "release-check" / "SKILL.md").is_file())

@@ -281,7 +281,7 @@ class CustomSourceTests(unittest.TestCase):
            "checkout": str(checkout),
        }

-        with patch("skiff.sources.subprocess.run") as run:
+        with patch("pouch.sources.subprocess.run") as run:
            fetch_source("company", entry)

        run.assert_called_once_with(
@@ -11,10 +11,10 @@ REPO_ROOT = Path(__file__).resolve().parents[1]


 class InstallScriptTests(unittest.TestCase):
-    def test_install_bootstraps_skiff_skill_for_all_agents(self) -> None:
+    def test_install_bootstraps_pouch_skill_for_all_agents(self) -> None:
        with tempfile.TemporaryDirectory() as temp:
            home = Path(temp)
-            (home / ".skills").symlink_to(REPO_ROOT, target_is_directory=True)
+            (home / ".pouch").symlink_to(REPO_ROOT, target_is_directory=True)
            env = os.environ.copy()
            env["HOME"] = str(home)

@@ -29,15 +29,15 @@ class InstallScriptTests(unittest.TestCase):

            self.assertEqual(result.returncode, 0, result.stderr)
            for relative in (
-                ".cursor/skills/skiff",
-                ".claude/skills/skiff",
-                ".codex/skills/skiff",
-                ".agents/skills/skiff",
+                ".cursor/skills/pouch",
+                ".claude/skills/pouch",
+                ".codex/skills/pouch",
+                ".agents/skills/pouch",
            ):
                link = home / relative
                self.assertTrue(link.is_symlink(), relative)
-                self.assertEqual(link.resolve(), (REPO_ROOT / "skills" / "skiff").resolve())
-            self.assertIn("已全局安装 builtin skiff skill", result.stdout)
+                self.assertEqual(link.resolve(), (REPO_ROOT / "skills" / "pouch").resolve())
+            self.assertIn("已全局安装 builtin pouch skill", result.stdout)


 if __name__ == "__main__":
@@ -8,18 +8,18 @@ REPO_ROOT = Path(__file__).resolve().parents[1]


 class ProjectSkillContentTests(unittest.TestCase):
-    def test_skiff_skill_documents_project_usage_and_feedback_loop(self) -> None:
-        content = (REPO_ROOT / "skills" / "skiff" / "SKILL.md").read_text(encoding="utf-8")
+    def test_pouch_skill_documents_project_usage_and_feedback_loop(self) -> None:
+        content = (REPO_ROOT / "skills" / "pouch" / "SKILL.md").read_text(encoding="utf-8")

        for expected in (
-            "skiff add <name>",
+            "pouch add <name>",
            "问题或优化回流",
            "实际结果",
            "期望结果",
-            "skiff check <name>",
-            "~/.skills/skills/<name>/",
+            "pouch check <name>",
+            "~/.pouch/skills/<name>/",
            "第三方 skill",
-            "skiff init ack",
+            "pouch init ack",
            "显式调用全局 `/ack` skill",
        ):
            self.assertIn(expected, content)
@@ -10,10 +10,10 @@ import unittest
 from pathlib import Path
 from unittest.mock import Mock, patch

-from skiff import cli
-from skiff import yaml_io
-from skiff.catalog import catalog_repo_path, catalog_skill_path
-from skiff.selector import SkillChoice, filter_choices, fit_to_width, select_skills
+from pouch import cli
+from pouch import yaml_io
+from pouch.catalog import catalog_repo_path, catalog_skill_path
+from pouch.selector import SkillChoice, filter_choices, fit_to_width, select_skills


 REPO_ROOT = Path(__file__).resolve().parents[1]
@@ -210,8 +210,8 @@ class SelectorTests(unittest.TestCase):
                "path": "skills",
            }

-            with patch("skiff.catalog.catalog_checkout_path", return_value=checkout):
-                from skiff.catalog import discover_catalog_skills
+            with patch("pouch.catalog.catalog_checkout_path", return_value=checkout):
+                from pouch.catalog import discover_catalog_skills

                self.assertEqual(discover_catalog_skills("unsafe", entry), {})

@@ -257,13 +257,13 @@ class SelectCommandTests(unittest.TestCase):
    def test_non_tty_exits_with_add_guidance(self) -> None:
        with tempfile.TemporaryDirectory() as temp:
            home = Path(temp)
-            (home / ".skills" / "skills").mkdir(parents=True)
+            (home / ".pouch" / "skills").mkdir(parents=True)
            env = os.environ.copy()
            env["HOME"] = str(home)
            env["PYTHONPATH"] = str(REPO_ROOT)

            result = subprocess.run(
-                [sys.executable, "-m", "skiff", "select"],
+                [sys.executable, "-m", "pouch", "select"],
                cwd=REPO_ROOT,
                env=env,
                text=True,
@@ -272,7 +272,7 @@ class SelectCommandTests(unittest.TestCase):
            )

        self.assertNotEqual(result.returncode, 0)
-        self.assertIn("skiff add <name>", result.stderr)
+        self.assertIn("pouch add <name>", result.stderr)

    def test_project_selection_installs_new_and_records_all_selected(self) -> None:
        with tempfile.TemporaryDirectory() as temp:
@@ -306,7 +306,7 @@ class SelectCommandTests(unittest.TestCase):
            with (
                patch.object(cli.sys, "stdin", stdin),
                patch.object(cli.sys, "stdout", stdout),
-                patch.object(cli, "ensure_skills_home"),
+                patch.object(cli, "ensure_pouch_home"),
                patch.object(cli, "list_builtin_skills", return_value=["builtin-one"]),
                patch.object(cli, "skill_description", return_value="builtin"),
                patch.object(
@@ -346,7 +346,7 @@ class SelectCommandTests(unittest.TestCase):
            ):
                cli.cmd_select(args)

-            manifest = (project / ".skills.yaml").read_text(encoding="utf-8")
+            manifest = (project / ".pouch.yaml").read_text(encoding="utf-8")

        self.assertEqual(installed, ["catalog-one"])
        self.assertIn("builtin-one", manifest)
@@ -405,7 +405,7 @@ class SelectCommandTests(unittest.TestCase):
        with (
            patch.object(cli.sys, "stdin", stdin),
            patch.object(cli.sys, "stdout", stdout),
-            patch.object(cli, "ensure_skills_home"),
+            patch.object(cli, "ensure_pouch_home"),
            patch.object(cli, "list_builtin_skills", return_value=[]),
            patch.object(
                cli,
@@ -440,7 +440,7 @@ class SelectCommandTests(unittest.TestCase):
        with (
            patch.object(cli.sys, "stdin", stdin),
            patch.object(cli.sys, "stdout", stdout),
-            patch.object(cli, "ensure_skills_home"),
+            patch.object(cli, "ensure_pouch_home"),
            patch.object(cli, "list_builtin_skills", return_value=[]),
            patch.object(
                cli,
@@ -506,7 +506,7 @@ class SelectCommandTests(unittest.TestCase):
            with (
                patch.object(cli.sys, "stdin", stdin),
                patch.object(cli.sys, "stdout", stdout),
-                patch.object(cli, "ensure_skills_home"),
+                patch.object(cli, "ensure_pouch_home"),
                patch.object(cli, "list_builtin_skills", return_value=[]),
                patch.object(cli, "load_catalog", return_value={}),
                patch.object(
@@ -567,7 +567,7 @@ class SelectCommandTests(unittest.TestCase):
                patch.object(cli.sys, "stdin", stdin),
                patch.object(cli.sys, "stdout", stdout),
                patch.object(cli, "SKILLS_DIR", skills_root),
-                patch.object(cli, "ensure_skills_home"),
+                patch.object(cli, "ensure_pouch_home"),
                patch.object(cli, "list_builtin_skills", return_value=["ack"]),
                patch.object(cli, "skill_description", return_value="builtin ack"),
                patch.object(
@@ -575,7 +575,7 @@ class SelectCommandTests(unittest.TestCase):
                    "load_catalog",
                    return_value={
                        "skills": {
-                            "repo": "~/.skills",
+                            "repo": "~/.pouch",
                            "ref": "main",
                            "path": "skills",
                        }
@@ -9,7 +9,7 @@ from pathlib import Path
 from types import SimpleNamespace
 from unittest import mock

-import skiff.cli
+import pouch.cli

 REPO_ROOT = Path(__file__).resolve().parents[1]

@@ -18,7 +18,7 @@ class SkillInitTests(unittest.TestCase):
    def setUp(self) -> None:
        self.temp_dir = tempfile.TemporaryDirectory()
        self.home = Path(self.temp_dir.name)
-        self.skills_home = self.home / ".skills"
+        self.skills_home = self.home / ".pouch"
        skill = self.skills_home / "skills" / "ack"
        (skill / "templates").mkdir(parents=True)
        (skill / "scripts").mkdir()
@@ -40,7 +40,7 @@ class SkillInitTests(unittest.TestCase):
        tasks_template = skill / "templates" / "tasks.template.yaml"
        tasks_template.write_text(
            tasks_template.read_text(encoding="utf-8")
-            + '  deliveryFile: "docs/ack/delivery.yaml"\n'
+            + '  deliveryFile: ".pouch/ack/delivery.yaml"\n'
            + 'deliveryRuns: []\n',
            encoding="utf-8",
        )
@@ -78,12 +78,12 @@ class SkillInitTests(unittest.TestCase):
    def tearDown(self) -> None:
        self.temp_dir.cleanup()

-    def run_skiff(self, *args: str) -> subprocess.CompletedProcess[str]:
+    def run_pouch(self, *args: str) -> subprocess.CompletedProcess[str]:
        env = os.environ.copy()
        env["HOME"] = str(self.home)
        env["PYTHONPATH"] = str(REPO_ROOT)
        return subprocess.run(
-            [sys.executable, "-m", "skiff", *args],
+            [sys.executable, "-m", "pouch", *args],
            cwd=REPO_ROOT,
            env=env,
            text=True,
@@ -95,10 +95,10 @@ class SkillInitTests(unittest.TestCase):
        project = self.home / "sample-app"
        project.mkdir()

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertEqual(result.returncode, 0, result.stderr)
-        target = project / "docs" / "ack"
+        target = project / ".pouch" / "ack"
        self.assertFalse((target / "kit").exists())
        self.assertFalse((target / "framework").exists())
        project_content = (target / "project.md").read_text(encoding="utf-8")
@@ -117,12 +117,12 @@ class SkillInitTests(unittest.TestCase):

    def test_init_refuses_to_overwrite_existing_files(self) -> None:
        project = self.home / "existing-app"
-        target = project / "docs" / "ack"
+        target = project / ".pouch" / "ack"
        target.mkdir(parents=True)
        existing = target / "project.md"
        existing.write_text("keep me", encoding="utf-8")

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("拒绝覆盖已有路径", result.stderr)
@@ -133,12 +133,12 @@ class SkillInitTests(unittest.TestCase):

    def test_init_refuses_to_overwrite_existing_knowledge_file(self) -> None:
        project = self.home / "existing-knowledge-app"
-        target = project / "docs" / "ack"
+        target = project / ".pouch" / "ack"
        target.mkdir(parents=True)
        existing = target / "knowledge.yaml"
        existing.write_text("keep me", encoding="utf-8")

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("拒绝覆盖已有路径", result.stderr)
@@ -148,12 +148,12 @@ class SkillInitTests(unittest.TestCase):

    def test_init_refuses_to_overwrite_existing_delivery_file(self) -> None:
        project = self.home / "existing-delivery-app"
-        target = project / "docs" / "ack"
+        target = project / ".pouch" / "ack"
        target.mkdir(parents=True)
        existing = target / "delivery.yaml"
        existing.write_text("keep me", encoding="utf-8")

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("拒绝覆盖已有路径", result.stderr)
@@ -163,25 +163,25 @@ class SkillInitTests(unittest.TestCase):
        self.assertFalse((target / "knowledge.yaml").exists())

    def test_init_rejects_symlinked_destination_directories(self) -> None:
-        for symlink_level in ("docs", "ack"):
+        for symlink_level in (".pouch", "ack"):
            with self.subTest(symlink_level=symlink_level):
                project = self.home / f"symlink-{symlink_level}-app"
                outside = self.home / f"symlink-{symlink_level}-outside"
                project.mkdir()
                outside.mkdir()
-                if symlink_level == "docs":
-                    (project / "docs").symlink_to(
+                if symlink_level == ".pouch":
+                    (project / ".pouch").symlink_to(
                        outside,
                        target_is_directory=True,
                    )
                else:
-                    (project / "docs").mkdir()
-                    (project / "docs" / "ack").symlink_to(
+                    (project / ".pouch").mkdir()
+                    (project / ".pouch" / "ack").symlink_to(
                        outside,
                        target_is_directory=True,
                    )

-                result = self.run_skiff(
+                result = self.run_pouch(
                    "init",
                    "ack",
                    "--project",
@@ -202,7 +202,7 @@ class SkillInitTests(unittest.TestCase):
        outside.mkdir()
        (project / "skills").symlink_to(outside, target_is_directory=True)

-        result = self.run_skiff(
+        result = self.run_pouch(
            "init",
            "../skills/ack",
            "--project",
@@ -218,34 +218,34 @@ class SkillInitTests(unittest.TestCase):
        project.mkdir()

        with (
-            mock.patch.object(skiff.cli, "SKILLS_HOME", self.skills_home),
+            mock.patch.object(pouch.cli, "POUCH_HOME", self.skills_home),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "SKILLS_DIR",
                self.skills_home / "skills",
            ),
-            mock.patch.object(skiff.cli, "ensure_skills_home"),
+            mock.patch.object(pouch.cli, "ensure_pouch_home"),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "_rename_directory_noreplace",
                side_effect=RuntimeError("publish interrupted"),
            ),
        ):
            with self.assertRaisesRegex(RuntimeError, "publish interrupted"):
-                skiff.cli.cmd_init(
+                pouch.cli.cmd_init(
                    SimpleNamespace(name="ack", project=str(project))
                )

-        self.assertFalse((project / "docs" / "ack").exists())
-        docs = project / "docs"
-        if docs.exists():
-            self.assertEqual(list(docs.iterdir()), [])
+        self.assertFalse((project / ".pouch" / "ack").exists())
+        pouch_dir = project / ".pouch"
+        if pouch_dir.exists():
+            self.assertEqual(list(pouch_dir.iterdir()), [])

    def test_atomic_publish_never_replaces_a_raced_destination(self) -> None:
        project = self.home / "atomic-no-replace-app"
        project.mkdir()
        raced_inode: int | None = None
-        real_publish = skiff.cli._rename_directory_noreplace
+        real_publish = pouch.cli._rename_directory_noreplace

        def create_destination_then_publish(
            source_parent_fd: int,
@@ -268,25 +268,25 @@ class SkillInitTests(unittest.TestCase):
            )

        with (
-            mock.patch.object(skiff.cli, "SKILLS_HOME", self.skills_home),
+            mock.patch.object(pouch.cli, "POUCH_HOME", self.skills_home),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "SKILLS_DIR",
                self.skills_home / "skills",
            ),
-            mock.patch.object(skiff.cli, "ensure_skills_home"),
+            mock.patch.object(pouch.cli, "ensure_pouch_home"),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "_rename_directory_noreplace",
                side_effect=create_destination_then_publish,
            ),
        ):
            with self.assertRaisesRegex(SystemExit, "拒绝覆盖已有路径"):
-                skiff.cli.cmd_init(
+                pouch.cli.cmd_init(
                    SimpleNamespace(name="ack", project=str(project))
                )

-        target = project / "docs" / "ack"
+        target = project / ".pouch" / "ack"
        self.assertTrue(target.is_dir())
        self.assertEqual(target.stat().st_ino, raced_inode)
        self.assertEqual(list(target.iterdir()), [])
@@ -294,9 +294,9 @@ class SkillInitTests(unittest.TestCase):

    def test_published_destination_replacement_never_reports_success(self) -> None:
        project = self.home / "published-destination-app"
-        moved_target = project / "docs" / "ack-moved"
+        moved_target = project / ".pouch" / "ack-moved"
        project.mkdir()
-        real_publish = skiff.cli._rename_directory_noreplace
+        real_publish = pouch.cli._rename_directory_noreplace

        def replace_destination_after_publish(
            source_parent_fd: int,
@@ -310,30 +310,30 @@ class SkillInitTests(unittest.TestCase):
                destination_parent_fd,
                destination_name,
            )
-            target = project / "docs" / destination_name
+            target = project / ".pouch" / destination_name
            target.rename(moved_target)
            target.mkdir()

        with (
-            mock.patch.object(skiff.cli, "SKILLS_HOME", self.skills_home),
+            mock.patch.object(pouch.cli, "POUCH_HOME", self.skills_home),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "SKILLS_DIR",
                self.skills_home / "skills",
            ),
-            mock.patch.object(skiff.cli, "ensure_skills_home"),
+            mock.patch.object(pouch.cli, "ensure_pouch_home"),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "_rename_directory_noreplace",
                side_effect=replace_destination_after_publish,
            ),
        ):
            with self.assertRaisesRegex(SystemExit, "ACK 目录已被替换"):
-                skiff.cli.cmd_init(
+                pouch.cli.cmd_init(
                    SimpleNamespace(name="ack", project=str(project))
                )

-        self.assertEqual(list((project / "docs" / "ack").iterdir()), [])
+        self.assertEqual(list((project / ".pouch" / "ack").iterdir()), [])
        self.assertEqual(
            sorted(path.name for path in moved_target.iterdir()),
            ["delivery.yaml", "knowledge.yaml", "project.md", "tasks.yaml"],
@@ -345,7 +345,7 @@ class SkillInitTests(unittest.TestCase):
        project.mkdir()
        attacker.mkdir()
        (attacker / "marker").write_text("forged", encoding="utf-8")
-        real_publish = skiff.cli._rename_directory_noreplace
+        real_publish = pouch.cli._rename_directory_noreplace

        def replace_outer_transaction_then_publish(
            source_parent_fd: int,
@@ -353,15 +353,15 @@ class SkillInitTests(unittest.TestCase):
            destination_parent_fd: int,
            destination_name: str,
        ) -> None:
-            docs = project / "docs"
+            pouch_dir = project / ".pouch"
            transactions = [
                path
-                for path in docs.iterdir()
+                for path in pouch_dir.iterdir()
                if path.name.startswith(".ack-init-")
            ]
            self.assertEqual(len(transactions), 1)
            transaction = transactions[0]
-            saved = docs / f"{transaction.name}.saved"
+            saved = pouch_dir / f"{transaction.name}.saved"
            transaction.rename(saved)
            transaction.symlink_to(attacker, target_is_directory=True)
            real_publish(
@@ -372,24 +372,24 @@ class SkillInitTests(unittest.TestCase):
            )

        with (
-            mock.patch.object(skiff.cli, "SKILLS_HOME", self.skills_home),
+            mock.patch.object(pouch.cli, "POUCH_HOME", self.skills_home),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "SKILLS_DIR",
                self.skills_home / "skills",
            ),
-            mock.patch.object(skiff.cli, "ensure_skills_home"),
+            mock.patch.object(pouch.cli, "ensure_pouch_home"),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "_rename_directory_noreplace",
                side_effect=replace_outer_transaction_then_publish,
            ),
        ):
-            skiff.cli.cmd_init(
+            pouch.cli.cmd_init(
                SimpleNamespace(name="ack", project=str(project))
            )

-        target = project / "docs" / "ack"
+        target = project / ".pouch" / "ack"
        self.assertTrue(target.is_dir())
        self.assertFalse(target.is_symlink())
        self.assertFalse((target / "marker").exists())
@@ -412,25 +412,25 @@ class SkillInitTests(unittest.TestCase):
            real_fsync(file_descriptor)

        with (
-            mock.patch.object(skiff.cli, "SKILLS_HOME", self.skills_home),
+            mock.patch.object(pouch.cli, "POUCH_HOME", self.skills_home),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "SKILLS_DIR",
                self.skills_home / "skills",
            ),
-            mock.patch.object(skiff.cli, "ensure_skills_home"),
+            mock.patch.object(pouch.cli, "ensure_pouch_home"),
            mock.patch.object(
-                skiff.cli.os,
+                pouch.cli.os,
                "fsync",
                side_effect=fail_directory_fsync_after_publish,
            ),
        ):
            with self.assertRaisesRegex(SystemExit, "已完整发布"):
-                skiff.cli.cmd_init(
+                pouch.cli.cmd_init(
                    SimpleNamespace(name="ack", project=str(project))
                )

-        target = project / "docs" / "ack"
+        target = project / ".pouch" / "ack"
        self.assertEqual(
            sorted(path.name for path in target.iterdir()),
            ["delivery.yaml", "knowledge.yaml", "project.md", "tasks.yaml"],
@@ -440,7 +440,7 @@ class SkillInitTests(unittest.TestCase):
        project = self.home / "root-replacement-app"
        moved_project = self.home / "root-replacement-moved"
        project.mkdir()
-        real_open_docs = skiff.cli._open_or_create_directory_at
+        real_open_docs = pouch.cli._open_or_create_directory_at
        replaced = False

        def replace_root_then_open_docs(
@@ -455,32 +455,32 @@ class SkillInitTests(unittest.TestCase):
            return real_open_docs(parent_fd, name)

        with (
-            mock.patch.object(skiff.cli, "SKILLS_HOME", self.skills_home),
+            mock.patch.object(pouch.cli, "POUCH_HOME", self.skills_home),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "SKILLS_DIR",
                self.skills_home / "skills",
            ),
-            mock.patch.object(skiff.cli, "ensure_skills_home"),
+            mock.patch.object(pouch.cli, "ensure_pouch_home"),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "_open_or_create_directory_at",
                side_effect=replace_root_then_open_docs,
            ),
        ):
            with self.assertRaisesRegex(SystemExit, "项目目录已被替换"):
-                skiff.cli.cmd_init(
+                pouch.cli.cmd_init(
                    SimpleNamespace(name="ack", project=str(project))
                )

-        self.assertFalse((project / "docs" / "ack").exists())
-        self.assertFalse((moved_project / "docs" / "ack").exists())
+        self.assertFalse((project / ".pouch" / "ack").exists())
+        self.assertFalse((moved_project / ".pouch" / "ack").exists())

    def test_project_root_replacement_at_publish_never_reports_success(self) -> None:
        project = self.home / "publish-root-replacement-app"
        moved_project = self.home / "publish-root-replacement-moved"
        project.mkdir()
-        real_publish = skiff.cli._rename_directory_noreplace
+        real_publish = pouch.cli._rename_directory_noreplace

        def replace_root_then_publish(
            source_parent_fd: int,
@@ -498,36 +498,36 @@ class SkillInitTests(unittest.TestCase):
            )

        with (
-            mock.patch.object(skiff.cli, "SKILLS_HOME", self.skills_home),
+            mock.patch.object(pouch.cli, "POUCH_HOME", self.skills_home),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "SKILLS_DIR",
                self.skills_home / "skills",
            ),
-            mock.patch.object(skiff.cli, "ensure_skills_home"),
+            mock.patch.object(pouch.cli, "ensure_pouch_home"),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "_rename_directory_noreplace",
                side_effect=replace_root_then_publish,
            ),
        ):
            with self.assertRaisesRegex(SystemExit, "ACK 目录已移动或不可访问"):
-                skiff.cli.cmd_init(
+                pouch.cli.cmd_init(
                    SimpleNamespace(name="ack", project=str(project))
                )

-        self.assertFalse((project / "docs" / "ack").exists())
-        target = moved_project / "docs" / "ack"
+        self.assertFalse((project / ".pouch" / "ack").exists())
+        target = moved_project / ".pouch" / "ack"
        self.assertEqual(
            sorted(path.name for path in target.iterdir()),
            ["delivery.yaml", "knowledge.yaml", "project.md", "tasks.yaml"],
        )

-    def test_docs_replacement_aborts_before_publish(self) -> None:
-        project = self.home / "docs-replacement-app"
-        moved_docs = project / "docs-moved"
+    def test_pouch_dir_replacement_aborts_before_publish(self) -> None:
+        project = self.home / "pouch-dir-replacement-app"
+        moved_pouch = project / "pouch-dir-moved"
        project.mkdir()
-        real_assert_binding = skiff.cli._assert_open_directory_path
+        real_assert_binding = pouch.cli._assert_open_directory_path
        replaced = False

        def replace_docs_at_publish_check(
@@ -538,9 +538,9 @@ class SkillInitTests(unittest.TestCase):
            label: str = "项目目录",
        ) -> None:
            nonlocal replaced
-            if label == "docs 目录" and phase == "发布" and not replaced:
-                (project / "docs").rename(moved_docs)
-                (project / "docs").mkdir()
+            if label == ".pouch 目录" and phase == "发布" and not replaced:
+                (project / ".pouch").rename(moved_pouch)
+                (project / ".pouch").mkdir()
                replaced = True
            real_assert_binding(
                directory_fd,
@@ -550,32 +550,32 @@ class SkillInitTests(unittest.TestCase):
            )

        with (
-            mock.patch.object(skiff.cli, "SKILLS_HOME", self.skills_home),
+            mock.patch.object(pouch.cli, "POUCH_HOME", self.skills_home),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "SKILLS_DIR",
                self.skills_home / "skills",
            ),
-            mock.patch.object(skiff.cli, "ensure_skills_home"),
+            mock.patch.object(pouch.cli, "ensure_pouch_home"),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "_assert_open_directory_path",
                side_effect=replace_docs_at_publish_check,
            ),
        ):
-            with self.assertRaisesRegex(SystemExit, "docs 目录已被替换"):
-                skiff.cli.cmd_init(
+            with self.assertRaisesRegex(SystemExit, "\\.pouch 目录已被替换"):
+                pouch.cli.cmd_init(
                    SimpleNamespace(name="ack", project=str(project))
                )

-        self.assertFalse((project / "docs" / "ack").exists())
-        self.assertFalse((moved_docs / "ack").exists())
+        self.assertFalse((project / ".pouch" / "ack").exists())
+        self.assertFalse((moved_pouch / "ack").exists())

-    def test_docs_replacement_at_publish_never_reports_success(self) -> None:
-        project = self.home / "publish-docs-replacement-app"
-        moved_docs = project / "docs-moved"
+    def test_pouch_dir_replacement_at_publish_never_reports_success(self) -> None:
+        project = self.home / "publish-pouch-dir-replacement-app"
+        moved_pouch = project / "pouch-dir-moved"
        project.mkdir()
-        real_publish = skiff.cli._rename_directory_noreplace
+        real_publish = pouch.cli._rename_directory_noreplace

        def replace_docs_then_publish(
            source_parent_fd: int,
@@ -583,8 +583,8 @@ class SkillInitTests(unittest.TestCase):
            destination_parent_fd: int,
            destination_name: str,
        ) -> None:
-            (project / "docs").rename(moved_docs)
-            (project / "docs").mkdir()
+            (project / ".pouch").rename(moved_pouch)
+            (project / ".pouch").mkdir()
            real_publish(
                source_parent_fd,
                source_name,
@@ -593,26 +593,26 @@ class SkillInitTests(unittest.TestCase):
            )

        with (
-            mock.patch.object(skiff.cli, "SKILLS_HOME", self.skills_home),
+            mock.patch.object(pouch.cli, "POUCH_HOME", self.skills_home),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "SKILLS_DIR",
                self.skills_home / "skills",
            ),
-            mock.patch.object(skiff.cli, "ensure_skills_home"),
+            mock.patch.object(pouch.cli, "ensure_pouch_home"),
            mock.patch.object(
-                skiff.cli,
+                pouch.cli,
                "_rename_directory_noreplace",
                side_effect=replace_docs_then_publish,
            ),
        ):
            with self.assertRaisesRegex(SystemExit, "ACK 目录已移动或不可访问"):
-                skiff.cli.cmd_init(
+                pouch.cli.cmd_init(
                    SimpleNamespace(name="ack", project=str(project))
                )

-        self.assertFalse((project / "docs" / "ack").exists())
-        target = moved_docs / "ack"
+        self.assertFalse((project / ".pouch" / "ack").exists())
+        target = moved_pouch / "ack"
        self.assertEqual(
            sorted(path.name for path in target.iterdir()),
            ["delivery.yaml", "knowledge.yaml", "project.md", "tasks.yaml"],
@@ -629,11 +629,11 @@ class SkillInitTests(unittest.TestCase):
            / "knowledge.template.yaml"
        ).unlink()

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("knowledge.template.yaml", result.stderr)
-        self.assertFalse((project / "docs" / "ack").exists())
+        self.assertFalse((project / ".pouch" / "ack").exists())

    def test_ack_init_requires_delivery_template(self) -> None:
        project = self.home / "missing-delivery-template-app"
@@ -646,11 +646,11 @@ class SkillInitTests(unittest.TestCase):
            / "delivery.template.yaml"
        ).unlink()

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("delivery.template.yaml", result.stderr)
-        self.assertFalse((project / "docs" / "ack").exists())
+        self.assertFalse((project / ".pouch" / "ack").exists())

    def test_ack_init_requires_all_validators(self) -> None:
        for validator_name in (
@@ -671,7 +671,7 @@ class SkillInitTests(unittest.TestCase):
                original = validator.read_text(encoding="utf-8")
                validator.unlink()
                try:
-                    result = self.run_skiff(
+                    result = self.run_pouch(
                        "init",
                        "ack",
                        "--project",
@@ -683,7 +683,7 @@ class SkillInitTests(unittest.TestCase):
                self.assertNotEqual(result.returncode, 0)
                self.assertIn("缺少初始化校验器", result.stderr)
                self.assertIn(validator_name, result.stderr)
-                self.assertFalse((project / "docs" / "ack").exists())
+                self.assertFalse((project / ".pouch" / "ack").exists())

    def test_validator_failure_leaves_no_partial_initialization(self) -> None:
        project = self.home / "invalid-knowledge-app"
@@ -693,12 +693,12 @@ class SkillInitTests(unittest.TestCase):
        )
        validator.write_text("raise SystemExit(1)\n", encoding="utf-8")

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertNotEqual(result.returncode, 0)
        self.assertNotIn("Traceback", result.stderr)
        self.assertIn("初始化知识库校验失败", result.stderr)
-        self.assertFalse((project / "docs" / "ack").exists())
+        self.assertFalse((project / ".pouch" / "ack").exists())

    def test_delivery_validator_failure_leaves_no_partial_initialization(self) -> None:
        project = self.home / "invalid-delivery-app"
@@ -708,12 +708,12 @@ class SkillInitTests(unittest.TestCase):
        )
        validator.write_text("raise SystemExit(1)\n", encoding="utf-8")

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertNotEqual(result.returncode, 0)
        self.assertNotIn("Traceback", result.stderr)
        self.assertIn("初始化交付契约校验失败", result.stderr)
-        self.assertFalse((project / "docs" / "ack").exists())
+        self.assertFalse((project / ".pouch" / "ack").exists())

    def test_validator_cannot_replace_staged_bytes_before_install(self) -> None:
        project = self.home / "mutated-staging-app"
@@ -728,11 +728,11 @@ class SkillInitTests(unittest.TestCase):
            encoding="utf-8",
        )

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("临时文件在校验期间发生变化", result.stderr)
-        self.assertFalse((project / "docs" / "ack").exists())
+        self.assertFalse((project / ".pouch" / "ack").exists())

    def test_ack_init_validates_mirrored_staging_root(self) -> None:
        project = self.home / "staged-knowledge-app"
@@ -749,16 +749,16 @@ class SkillInitTests(unittest.TestCase):
            "root = Path(sys.argv[sys.argv.index('--project-root') + 1])\n"
            "knowledge = Path(sys.argv[1])\n"
            "tasks = Path(sys.argv[sys.argv.index('--tasks') + 1])\n"
-            "expected = root / 'docs' / 'ack'\n"
+            "expected = root / '.pouch' / 'ack'\n"
            "raise SystemExit(0 if knowledge.parent == expected and "
            "tasks.parent == expected else 4)\n",
            encoding="utf-8",
        )

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertTrue((project / "docs" / "ack" / "knowledge.yaml").is_file())
+        self.assertTrue((project / ".pouch" / "ack" / "knowledge.yaml").is_file())

    def test_ack_delivery_init_validates_mirrored_staging_root(self) -> None:
        project = self.home / "staged-delivery-app"
@@ -775,16 +775,16 @@ class SkillInitTests(unittest.TestCase):
            "root = Path(sys.argv[sys.argv.index('--project-root') + 1])\n"
            "delivery = Path(sys.argv[1])\n"
            "tasks = Path(sys.argv[sys.argv.index('--tasks') + 1])\n"
-            "expected = root / 'docs' / 'ack'\n"
+            "expected = root / '.pouch' / 'ack'\n"
            "raise SystemExit(0 if delivery.parent == expected and "
            "tasks.parent == expected else 4)\n",
            encoding="utf-8",
        )

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertTrue((project / "docs" / "ack" / "delivery.yaml").is_file())
+        self.assertTrue((project / ".pouch" / "ack" / "delivery.yaml").is_file())

    def test_non_ack_init_still_requires_only_project_and_tasks_templates(self) -> None:
        skill = self.skills_home / "skills" / "plain"
@@ -799,10 +799,10 @@ class SkillInitTests(unittest.TestCase):
        project = self.home / "plain-app"
        project.mkdir()

-        result = self.run_skiff("init", "plain", "--project", str(project))
+        result = self.run_pouch("init", "plain", "--project", str(project))

        self.assertEqual(result.returncode, 0, result.stderr)
-        target = project / "docs" / "plain"
+        target = project / ".pouch" / "plain"
        self.assertTrue((target / "project.md").is_file())
        self.assertTrue((target / "tasks.yaml").is_file())
        self.assertFalse((target / "knowledge.yaml").exists())
@@ -811,14 +811,14 @@ class SkillInitTests(unittest.TestCase):
    def test_init_rejects_missing_project_directory(self) -> None:
        project = self.home / "missing-app"

-        result = self.run_skiff("init", "ack", "--project", str(project))
+        result = self.run_pouch("init", "ack", "--project", str(project))

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("项目目录不存在", result.stderr)
        self.assertFalse(project.exists())

    def test_legacy_kit_command_is_not_exposed(self) -> None:
-        result = self.run_skiff("kit", "init", "ack")
+        result = self.run_pouch("kit", "init", "ack")

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("invalid choice", result.stderr)
@@ -1 +1 @@
 .18.0
 .19.0